1 /*- 2 * Machine and OS Independent (well, as best as possible) 3 * code for the Qlogic ISP SCSI adapters. 4 * 5 * Copyright (c) 1997-2006 by Matthew Jacob 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice immediately at the beginning of the file, without modification, 13 * this list of conditions, and the following disclaimer. 14 * 2. The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 21 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 /* 31 * Inspiration and ideas about this driver are from Erik Moe's Linux driver 32 * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some 33 * ideas dredged from the Solaris driver. 34 */ 35 36 /* 37 * Include header file appropriate for platform we're building on. 38 */ 39 40 #ifdef __NetBSD__ 41 #include <dev/ic/isp_netbsd.h> 42 #endif 43 #ifdef __FreeBSD__ 44 #include <sys/cdefs.h> 45 __FBSDID("$FreeBSD$"); 46 #include <dev/isp/isp_freebsd.h> 47 #endif 48 #ifdef __OpenBSD__ 49 #include <dev/ic/isp_openbsd.h> 50 #endif 51 #ifdef __linux__ 52 #include "isp_linux.h" 53 #endif 54 #ifdef __svr4__ 55 #include "isp_solaris.h" 56 #endif 57 58 /* 59 * General defines 60 */ 61 62 #define MBOX_DELAY_COUNT 1000000 / 100 63 64 /* 65 * Local static data 66 */ 67 static const char portshift[] = 68 "Target %d Loop ID 0x%x (Port 0x%x) => Loop 0x%x (Port 0x%x)"; 69 static const char portdup[] = 70 "Target %d duplicates Target %d- killing off both"; 71 static const char retained[] = 72 "Retaining Loop ID 0x%x for Target %d (Port 0x%x)"; 73 static const char lretained[] = 74 "Retained login of Target %d (Loop ID 0x%x) Port 0x%x"; 75 static const char plogout[] = 76 "Logging out Target %d at Loop ID 0x%x (Port 0x%x)"; 77 static const char plogierr[] = 78 "Command Error in PLOGI for Port 0x%x (0x%x)"; 79 static const char nopdb[] = 80 "Could not get PDB for Device @ Port 0x%x"; 81 static const char pdbmfail1[] = 82 "PDB Loop ID info for Device @ Port 0x%x does not match up (0x%x)"; 83 static const char pdbmfail2[] = 84 "PDB Port info for Device @ Port 0x%x does not match up (0x%x)"; 85 static const char ldumped[] = 86 "Target %d (Loop ID 0x%x) Port 0x%x dumped after login info mismatch"; 87 static const char notresp[] = 88 "Not RESPONSE in RESPONSE Queue (type 0x%x) @ idx %d (next %d) nlooked %d"; 89 static const char xact1[] = 90 "HBA attempted queued transaction with disconnect not set for %d.%d.%d"; 91 static const char xact2[] = 92 "HBA attempted queued transaction to target routine %d on target %d bus %d"; 93 static const char xact3[] = 94 "HBA attempted queued cmd for %d.%d.%d when queueing disabled"; 95 static const char pskip[] = 96 "SCSI phase skipped for target %d.%d.%d"; 97 static const char topology[] = 98 "Loop ID %d, Port ID 0x%x, Loop State 0x%x, Topology '%s'"; 99 static const char swrej[] = 100 "Fabric Nameserver rejected %s (Reason=0x%x Expl=0x%x) for Port ID 0x%x"; 101 static const char finmsg[] = 102 "(%d.%d.%d): FIN dl%d resid %d STS 0x%x SKEY %c XS_ERR=0x%x"; 103 static const char sc0[] = 104 "%s CHAN %d FTHRSH %d IID %d RESETD %d RETRYC %d RETRYD %d ASD 0x%x"; 105 static const char sc1[] = 106 "%s RAAN 0x%x DLAN 0x%x DDMAB 0x%x CDMAB 0x%x SELTIME %d MQD %d"; 107 static const char sc2[] = "%s CHAN %d TGT %d FLAGS 0x%x 0x%x/0x%x"; 108 static const char sc3[] = "Generated"; 109 static const char sc4[] = "NVRAM"; 110 static const char bun[] = 111 "bad underrun for %d.%d (count %d, resid %d, status %s)"; 112 113 /* 114 * Local function prototypes. 115 */ 116 static int isp_parse_async(struct ispsoftc *, u_int16_t); 117 static int isp_handle_other_response(struct ispsoftc *, int, isphdr_t *, 118 u_int16_t *); 119 static void 120 isp_parse_status(struct ispsoftc *, ispstatusreq_t *, XS_T *); 121 static void isp_fastpost_complete(struct ispsoftc *, u_int16_t); 122 static int isp_mbox_continue(struct ispsoftc *); 123 static void isp_scsi_init(struct ispsoftc *); 124 static void isp_scsi_channel_init(struct ispsoftc *, int); 125 static void isp_fibre_init(struct ispsoftc *); 126 static void isp_mark_getpdb_all(struct ispsoftc *); 127 static int isp_getmap(struct ispsoftc *, fcpos_map_t *); 128 static int isp_getpdb(struct ispsoftc *, int, isp_pdb_t *); 129 static u_int64_t isp_get_portname(struct ispsoftc *, int, int); 130 static int isp_fclink_test(struct ispsoftc *, int); 131 static char *isp2100_fw_statename(int); 132 static int isp_pdb_sync(struct ispsoftc *); 133 static int isp_scan_loop(struct ispsoftc *); 134 static int isp_fabric_mbox_cmd(struct ispsoftc *, mbreg_t *); 135 static int isp_scan_fabric(struct ispsoftc *, int); 136 static void isp_register_fc4_type(struct ispsoftc *); 137 static void isp_fw_state(struct ispsoftc *); 138 static void isp_mboxcmd_qnw(struct ispsoftc *, mbreg_t *, int); 139 static void isp_mboxcmd(struct ispsoftc *, mbreg_t *, int); 140 141 static void isp_update(struct ispsoftc *); 142 static void isp_update_bus(struct ispsoftc *, int); 143 static void isp_setdfltparm(struct ispsoftc *, int); 144 static int isp_read_nvram(struct ispsoftc *); 145 static void isp_rdnvram_word(struct ispsoftc *, int, u_int16_t *); 146 static void isp_parse_nvram_1020(struct ispsoftc *, u_int8_t *); 147 static void isp_parse_nvram_1080(struct ispsoftc *, int, u_int8_t *); 148 static void isp_parse_nvram_12160(struct ispsoftc *, int, u_int8_t *); 149 static void isp_parse_nvram_2100(struct ispsoftc *, u_int8_t *); 150 151 /* 152 * Reset Hardware. 153 * 154 * Hit the chip over the head, download new f/w if available and set it running. 155 * 156 * Locking done elsewhere. 157 */ 158 159 void 160 isp_reset(struct ispsoftc *isp) 161 { 162 mbreg_t mbs; 163 u_int16_t code_org; 164 int loops, i, dodnld = 1; 165 char *btype = "????"; 166 167 isp->isp_state = ISP_NILSTATE; 168 MEMZERO(&mbs, sizeof (mbs)); 169 170 /* 171 * Basic types (SCSI, FibreChannel and PCI or SBus) 172 * have been set in the MD code. We figure out more 173 * here. Possibly more refined types based upon PCI 174 * identification. Chip revision has been gathered. 175 * 176 * After we've fired this chip up, zero out the conf1 register 177 * for SCSI adapters and do other settings for the 2100. 178 */ 179 180 /* 181 * Get the current running firmware revision out of the 182 * chip before we hit it over the head (if this is our 183 * first time through). Note that we store this as the 184 * 'ROM' firmware revision- which it may not be. In any 185 * case, we don't really use this yet, but we may in 186 * the future. 187 */ 188 if (isp->isp_touched == 0) { 189 /* 190 * First see whether or not we're sitting in the ISP PROM. 191 * If we've just been reset, we'll have the string "ISP " 192 * spread through outgoing mailbox registers 1-3. We do 193 * this for PCI cards because otherwise we really don't 194 * know what state the card is in and we could hang if 195 * we try this command otherwise. 196 * 197 * For SBus cards, we just do this because they almost 198 * certainly will be running firmware by now. 199 */ 200 if (ISP_READ(isp, OUTMAILBOX1) != 0x4953 || 201 ISP_READ(isp, OUTMAILBOX2) != 0x5020 || 202 ISP_READ(isp, OUTMAILBOX3) != 0x2020) { 203 /* 204 * Just in case it was paused... 205 */ 206 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); 207 mbs.param[0] = MBOX_ABOUT_FIRMWARE; 208 isp_mboxcmd(isp, &mbs, MBLOGNONE); 209 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 210 isp->isp_romfw_rev[0] = mbs.param[1]; 211 isp->isp_romfw_rev[1] = mbs.param[2]; 212 isp->isp_romfw_rev[2] = mbs.param[3]; 213 } 214 } 215 isp->isp_touched = 1; 216 } 217 218 DISABLE_INTS(isp); 219 220 /* 221 * Set up default request/response queue in-pointer/out-pointer 222 * register indices. 223 */ 224 if (IS_23XX(isp)) { 225 isp->isp_rqstinrp = BIU_REQINP; 226 isp->isp_rqstoutrp = BIU_REQOUTP; 227 isp->isp_respinrp = BIU_RSPINP; 228 isp->isp_respoutrp = BIU_RSPOUTP; 229 } else { 230 isp->isp_rqstinrp = INMAILBOX4; 231 isp->isp_rqstoutrp = OUTMAILBOX4; 232 isp->isp_respinrp = OUTMAILBOX5; 233 isp->isp_respoutrp = INMAILBOX5; 234 } 235 236 /* 237 * Put the board into PAUSE mode (so we can read the SXP registers 238 * or write FPM/FBM registers). 239 */ 240 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE); 241 242 if (IS_FC(isp)) { 243 switch (isp->isp_type) { 244 case ISP_HA_FC_2100: 245 btype = "2100"; 246 break; 247 case ISP_HA_FC_2200: 248 btype = "2200"; 249 break; 250 case ISP_HA_FC_2300: 251 btype = "2300"; 252 break; 253 case ISP_HA_FC_2312: 254 btype = "2312"; 255 break; 256 case ISP_HA_FC_2322: 257 btype = "2322"; 258 break; 259 case ISP_HA_FC_2422: 260 btype = "2422"; 261 break; 262 default: 263 break; 264 } 265 /* 266 * While we're paused, reset the FPM module and FBM fifos. 267 */ 268 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS); 269 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET); 270 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS); 271 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL); 272 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS); 273 } else if (IS_1240(isp)) { 274 sdparam *sdp = isp->isp_param; 275 btype = "1240"; 276 isp->isp_clock = 60; 277 sdp->isp_ultramode = 1; 278 sdp++; 279 sdp->isp_ultramode = 1; 280 /* 281 * XXX: Should probably do some bus sensing. 282 */ 283 } else if (IS_ULTRA2(isp)) { 284 static const char m[] = "bus %d is in %s Mode"; 285 u_int16_t l; 286 sdparam *sdp = isp->isp_param; 287 288 isp->isp_clock = 100; 289 290 if (IS_1280(isp)) 291 btype = "1280"; 292 else if (IS_1080(isp)) 293 btype = "1080"; 294 else if (IS_10160(isp)) 295 btype = "10160"; 296 else if (IS_12160(isp)) 297 btype = "12160"; 298 else 299 btype = "<UNKLVD>"; 300 301 l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK; 302 switch (l) { 303 case ISP1080_LVD_MODE: 304 sdp->isp_lvdmode = 1; 305 isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD"); 306 break; 307 case ISP1080_HVD_MODE: 308 sdp->isp_diffmode = 1; 309 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential"); 310 break; 311 case ISP1080_SE_MODE: 312 sdp->isp_ultramode = 1; 313 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended"); 314 break; 315 default: 316 isp_prt(isp, ISP_LOGERR, 317 "unknown mode on bus %d (0x%x)", 0, l); 318 break; 319 } 320 321 if (IS_DUALBUS(isp)) { 322 sdp++; 323 l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT); 324 l &= ISP1080_MODE_MASK; 325 switch(l) { 326 case ISP1080_LVD_MODE: 327 sdp->isp_lvdmode = 1; 328 isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD"); 329 break; 330 case ISP1080_HVD_MODE: 331 sdp->isp_diffmode = 1; 332 isp_prt(isp, ISP_LOGCONFIG, 333 m, 1, "Differential"); 334 break; 335 case ISP1080_SE_MODE: 336 sdp->isp_ultramode = 1; 337 isp_prt(isp, ISP_LOGCONFIG, 338 m, 1, "Single-Ended"); 339 break; 340 default: 341 isp_prt(isp, ISP_LOGERR, 342 "unknown mode on bus %d (0x%x)", 1, l); 343 break; 344 } 345 } 346 } else { 347 sdparam *sdp = isp->isp_param; 348 i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK; 349 switch (i) { 350 default: 351 isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i); 352 /* FALLTHROUGH */ 353 case 1: 354 btype = "1020"; 355 isp->isp_type = ISP_HA_SCSI_1020; 356 isp->isp_clock = 40; 357 break; 358 case 2: 359 /* 360 * Some 1020A chips are Ultra Capable, but don't 361 * run the clock rate up for that unless told to 362 * do so by the Ultra Capable bits being set. 363 */ 364 btype = "1020A"; 365 isp->isp_type = ISP_HA_SCSI_1020A; 366 isp->isp_clock = 40; 367 break; 368 case 3: 369 btype = "1040"; 370 isp->isp_type = ISP_HA_SCSI_1040; 371 isp->isp_clock = 60; 372 break; 373 case 4: 374 btype = "1040A"; 375 isp->isp_type = ISP_HA_SCSI_1040A; 376 isp->isp_clock = 60; 377 break; 378 case 5: 379 btype = "1040B"; 380 isp->isp_type = ISP_HA_SCSI_1040B; 381 isp->isp_clock = 60; 382 break; 383 case 6: 384 btype = "1040C"; 385 isp->isp_type = ISP_HA_SCSI_1040C; 386 isp->isp_clock = 60; 387 break; 388 } 389 /* 390 * Now, while we're at it, gather info about ultra 391 * and/or differential mode. 392 */ 393 if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) { 394 isp_prt(isp, ISP_LOGCONFIG, "Differential Mode"); 395 sdp->isp_diffmode = 1; 396 } else { 397 sdp->isp_diffmode = 0; 398 } 399 i = ISP_READ(isp, RISC_PSR); 400 if (isp->isp_bustype == ISP_BT_SBUS) { 401 i &= RISC_PSR_SBUS_ULTRA; 402 } else { 403 i &= RISC_PSR_PCI_ULTRA; 404 } 405 if (i != 0) { 406 isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable"); 407 sdp->isp_ultramode = 1; 408 /* 409 * If we're in Ultra Mode, we have to be 60MHz clock- 410 * even for the SBus version. 411 */ 412 isp->isp_clock = 60; 413 } else { 414 sdp->isp_ultramode = 0; 415 /* 416 * Clock is known. Gronk. 417 */ 418 } 419 420 /* 421 * Machine dependent clock (if set) overrides 422 * our generic determinations. 423 */ 424 if (isp->isp_mdvec->dv_clock) { 425 if (isp->isp_mdvec->dv_clock < isp->isp_clock) { 426 isp->isp_clock = isp->isp_mdvec->dv_clock; 427 } 428 } 429 430 } 431 432 /* 433 * Clear instrumentation 434 */ 435 isp->isp_intcnt = isp->isp_intbogus = 0; 436 437 /* 438 * Do MD specific pre initialization 439 */ 440 ISP_RESET0(isp); 441 442 again: 443 444 /* 445 * Hit the chip over the head with hammer, 446 * and give the ISP a chance to recover. 447 */ 448 449 if (IS_SCSI(isp)) { 450 ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET); 451 /* 452 * A slight delay... 453 */ 454 USEC_DELAY(100); 455 456 /* 457 * Clear data && control DMA engines. 458 */ 459 ISP_WRITE(isp, CDMA_CONTROL, 460 DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT); 461 ISP_WRITE(isp, DDMA_CONTROL, 462 DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT); 463 464 465 } else { 466 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET); 467 /* 468 * A slight delay... 469 */ 470 USEC_DELAY(100); 471 472 /* 473 * Clear data && control DMA engines. 474 */ 475 ISP_WRITE(isp, CDMA2100_CONTROL, 476 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT); 477 ISP_WRITE(isp, TDMA2100_CONTROL, 478 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT); 479 ISP_WRITE(isp, RDMA2100_CONTROL, 480 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT); 481 } 482 483 /* 484 * Wait for ISP to be ready to go... 485 */ 486 loops = MBOX_DELAY_COUNT; 487 for (;;) { 488 if (IS_SCSI(isp)) { 489 if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) 490 break; 491 } else { 492 if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET)) 493 break; 494 } 495 USEC_DELAY(100); 496 if (--loops < 0) { 497 ISP_DUMPREGS(isp, "chip reset timed out"); 498 return; 499 } 500 } 501 502 /* 503 * After we've fired this chip up, zero out the conf1 register 504 * for SCSI adapters and other settings for the 2100. 505 */ 506 507 if (IS_SCSI(isp)) { 508 ISP_WRITE(isp, BIU_CONF1, 0); 509 } else { 510 ISP_WRITE(isp, BIU2100_CSR, 0); 511 } 512 513 /* 514 * Reset RISC Processor 515 */ 516 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET); 517 USEC_DELAY(100); 518 /* Clear semaphore register (just to be sure) */ 519 ISP_WRITE(isp, BIU_SEMA, 0); 520 521 /* 522 * Establish some initial burst rate stuff. 523 * (only for the 1XX0 boards). This really should 524 * be done later after fetching from NVRAM. 525 */ 526 if (IS_SCSI(isp)) { 527 u_int16_t tmp = isp->isp_mdvec->dv_conf1; 528 /* 529 * Busted FIFO. Turn off all but burst enables. 530 */ 531 if (isp->isp_type == ISP_HA_SCSI_1040A) { 532 tmp &= BIU_BURST_ENABLE; 533 } 534 ISP_SETBITS(isp, BIU_CONF1, tmp); 535 if (tmp & BIU_BURST_ENABLE) { 536 ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST); 537 ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST); 538 } 539 #ifdef PTI_CARDS 540 if (((sdparam *) isp->isp_param)->isp_ultramode) { 541 while (ISP_READ(isp, RISC_MTR) != 0x1313) { 542 ISP_WRITE(isp, RISC_MTR, 0x1313); 543 ISP_WRITE(isp, HCCR, HCCR_CMD_STEP); 544 } 545 } else { 546 ISP_WRITE(isp, RISC_MTR, 0x1212); 547 } 548 /* 549 * PTI specific register 550 */ 551 ISP_WRITE(isp, RISC_EMB, DUAL_BANK) 552 #else 553 ISP_WRITE(isp, RISC_MTR, 0x1212); 554 #endif 555 } else { 556 ISP_WRITE(isp, RISC_MTR2100, 0x1212); 557 if (IS_2200(isp) || IS_23XX(isp)) { 558 ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE); 559 } 560 } 561 562 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */ 563 564 /* 565 * Do MD specific post initialization 566 */ 567 ISP_RESET1(isp); 568 569 /* 570 * Wait for everything to finish firing up. 571 * 572 * Avoid doing this on the 2312 because you can generate a PCI 573 * parity error (chip breakage). 574 */ 575 if (IS_23XX(isp)) { 576 USEC_DELAY(5); 577 } else { 578 loops = MBOX_DELAY_COUNT; 579 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) { 580 USEC_DELAY(100); 581 if (--loops < 0) { 582 isp_prt(isp, ISP_LOGERR, 583 "MBOX_BUSY never cleared on reset"); 584 return; 585 } 586 } 587 } 588 589 /* 590 * Up until this point we've done everything by just reading or 591 * setting registers. From this point on we rely on at least *some* 592 * kind of firmware running in the card. 593 */ 594 595 /* 596 * Do some sanity checking. 597 */ 598 mbs.param[0] = MBOX_NO_OP; 599 isp_mboxcmd(isp, &mbs, MBLOGALL); 600 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 601 return; 602 } 603 604 if (IS_SCSI(isp)) { 605 mbs.param[0] = MBOX_MAILBOX_REG_TEST; 606 mbs.param[1] = 0xdead; 607 mbs.param[2] = 0xbeef; 608 mbs.param[3] = 0xffff; 609 mbs.param[4] = 0x1111; 610 mbs.param[5] = 0xa5a5; 611 isp_mboxcmd(isp, &mbs, MBLOGALL); 612 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 613 return; 614 } 615 if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef || 616 mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 || 617 mbs.param[5] != 0xa5a5) { 618 isp_prt(isp, ISP_LOGERR, 619 "Register Test Failed (0x%x 0x%x 0x%x 0x%x 0x%x)", 620 mbs.param[1], mbs.param[2], mbs.param[3], 621 mbs.param[4], mbs.param[5]); 622 return; 623 } 624 625 } 626 627 /* 628 * Download new Firmware, unless requested not to do so. 629 * This is made slightly trickier in some cases where the 630 * firmware of the ROM revision is newer than the revision 631 * compiled into the driver. So, where we used to compare 632 * versions of our f/w and the ROM f/w, now we just see 633 * whether we have f/w at all and whether a config flag 634 * has disabled our download. 635 */ 636 if ((isp->isp_mdvec->dv_ispfw == NULL) || 637 (isp->isp_confopts & ISP_CFG_NORELOAD)) { 638 dodnld = 0; 639 } 640 641 if (IS_23XX(isp)) 642 code_org = ISP_CODE_ORG_2300; 643 else 644 code_org = ISP_CODE_ORG; 645 646 if (dodnld) { 647 isp->isp_mbxworkp = (void *) &isp->isp_mdvec->dv_ispfw[1]; 648 isp->isp_mbxwrk0 = isp->isp_mdvec->dv_ispfw[3] - 1; 649 isp->isp_mbxwrk1 = code_org + 1; 650 mbs.param[0] = MBOX_WRITE_RAM_WORD; 651 mbs.param[1] = code_org; 652 mbs.param[2] = isp->isp_mdvec->dv_ispfw[0]; 653 isp_mboxcmd(isp, &mbs, MBLOGNONE); 654 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 655 isp_prt(isp, ISP_LOGERR, 656 "F/W download failed at word %d", 657 isp->isp_mbxwrk1 - code_org); 658 dodnld = 0; 659 goto again; 660 } 661 /* 662 * Verify that it downloaded correctly. 663 */ 664 mbs.param[0] = MBOX_VERIFY_CHECKSUM; 665 mbs.param[1] = code_org; 666 isp_mboxcmd(isp, &mbs, MBLOGNONE); 667 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 668 isp_prt(isp, ISP_LOGERR, "Ram Checksum Failure"); 669 return; 670 } 671 isp->isp_loaded_fw = 1; 672 } else { 673 isp->isp_loaded_fw = 0; 674 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download"); 675 } 676 677 /* 678 * Now start it rolling. 679 * 680 * If we didn't actually download f/w, 681 * we still need to (re)start it. 682 */ 683 684 685 mbs.param[0] = MBOX_EXEC_FIRMWARE; 686 mbs.param[1] = code_org; 687 if (IS_2322(isp) || IS_24XX(isp)) { 688 if (isp->isp_loaded_fw) { 689 mbs.param[2] = 1; 690 } else { 691 mbs.param[2] = 0; 692 } 693 mbs.obits |= 2; 694 } 695 696 isp_mboxcmd(isp, &mbs, MBLOGNONE); 697 /* 698 * Give it a chance to start. 699 */ 700 USEC_DELAY(500); 701 702 if (IS_SCSI(isp)) { 703 /* 704 * Set CLOCK RATE, but only if asked to. 705 */ 706 if (isp->isp_clock) { 707 mbs.param[0] = MBOX_SET_CLOCK_RATE; 708 mbs.param[1] = isp->isp_clock; 709 isp_mboxcmd(isp, &mbs, MBLOGALL); 710 /* we will try not to care if this fails */ 711 } 712 } 713 714 mbs.param[0] = MBOX_ABOUT_FIRMWARE; 715 isp_mboxcmd(isp, &mbs, MBLOGALL); 716 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 717 return; 718 } 719 720 /* 721 * The SBus firmware that we are using apparently does not return 722 * major, minor, micro revisions in the mailbox registers, which 723 * is really, really, annoying. 724 */ 725 if (ISP_SBUS_SUPPORTED && isp->isp_bustype == ISP_BT_SBUS) { 726 if (dodnld) { 727 #ifdef ISP_TARGET_MODE 728 isp->isp_fwrev[0] = 7; 729 isp->isp_fwrev[1] = 55; 730 #else 731 isp->isp_fwrev[0] = 1; 732 isp->isp_fwrev[1] = 37; 733 #endif 734 isp->isp_fwrev[2] = 0; 735 } 736 } else { 737 isp->isp_fwrev[0] = mbs.param[1]; 738 isp->isp_fwrev[1] = mbs.param[2]; 739 isp->isp_fwrev[2] = mbs.param[3]; 740 } 741 isp_prt(isp, ISP_LOGCONFIG, 742 "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d", 743 btype, isp->isp_revision, dodnld? "loaded" : "resident", 744 isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]); 745 746 if (IS_FC(isp)) { 747 /* 748 * We do not believe firmware attributes for 2100 code less 749 * than 1.17.0, unless it's the firmware we specifically 750 * are loading. 751 * 752 * Note that all 22XX and 23XX f/w is greater than 1.X.0. 753 */ 754 if (!(ISP_FW_NEWER_THAN(isp, 1, 17, 0))) { 755 #ifdef USE_SMALLER_2100_FIRMWARE 756 FCPARAM(isp)->isp_fwattr = ISP_FW_ATTR_SCCLUN; 757 #else 758 FCPARAM(isp)->isp_fwattr = 0; 759 #endif 760 } else { 761 FCPARAM(isp)->isp_fwattr = mbs.param[6]; 762 isp_prt(isp, ISP_LOGDEBUG0, 763 "Firmware Attributes = 0x%x", mbs.param[6]); 764 } 765 if (IS_2KLOGIN(isp)) { 766 isp_prt(isp, ISP_LOGCONFIG, "2K Logins Supported"); 767 } 768 } 769 770 if (isp->isp_romfw_rev[0] || isp->isp_romfw_rev[1] || 771 isp->isp_romfw_rev[2]) { 772 isp_prt(isp, ISP_LOGCONFIG, "Last F/W revision was %d.%d.%d", 773 isp->isp_romfw_rev[0], isp->isp_romfw_rev[1], 774 isp->isp_romfw_rev[2]); 775 } 776 777 mbs.param[0] = MBOX_GET_FIRMWARE_STATUS; 778 isp_mboxcmd(isp, &mbs, MBLOGALL); 779 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 780 return; 781 } 782 isp->isp_maxcmds = mbs.param[2]; 783 isp_prt(isp, ISP_LOGINFO, 784 "%d max I/O commands supported", mbs.param[2]); 785 isp_fw_state(isp); 786 787 /* 788 * Set up DMA for the request and result mailboxes. 789 */ 790 if (ISP_MBOXDMASETUP(isp) != 0) { 791 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA"); 792 return; 793 } 794 isp->isp_state = ISP_RESETSTATE; 795 796 /* 797 * Okay- now that we have new firmware running, we now (re)set our 798 * notion of how many luns we support. This is somewhat tricky because 799 * if we haven't loaded firmware, we sometimes do not have an easy way 800 * of knowing how many luns we support. 801 * 802 * Expanded lun firmware gives you 32 luns for SCSI cards and 803 * 16384 luns for Fibre Channel cards. 804 * 805 * It turns out that even for QLogic 2100s with ROM 1.10 and above 806 * we do get a firmware attributes word returned in mailbox register 6. 807 * 808 * Because the lun is in a different position in the Request Queue 809 * Entry structure for Fibre Channel with expanded lun firmware, we 810 * can only support one lun (lun zero) when we don't know what kind 811 * of firmware we're running. 812 */ 813 if (IS_SCSI(isp)) { 814 if (dodnld) { 815 if (IS_ULTRA2(isp) || IS_ULTRA3(isp)) { 816 isp->isp_maxluns = 32; 817 } else { 818 isp->isp_maxluns = 8; 819 } 820 } else { 821 isp->isp_maxluns = 8; 822 } 823 } else { 824 if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) { 825 isp->isp_maxluns = 16384; 826 } else { 827 isp->isp_maxluns = 16; 828 } 829 } 830 } 831 832 /* 833 * Initialize Parameters of Hardware to a known state. 834 * 835 * Locks are held before coming here. 836 */ 837 838 void 839 isp_init(struct ispsoftc *isp) 840 { 841 /* 842 * Must do this first to get defaults established. 843 */ 844 isp_setdfltparm(isp, 0); 845 if (IS_DUALBUS(isp)) { 846 isp_setdfltparm(isp, 1); 847 } 848 if (IS_FC(isp)) { 849 isp_fibre_init(isp); 850 } else { 851 isp_scsi_init(isp); 852 } 853 } 854 855 static void 856 isp_scsi_init(struct ispsoftc *isp) 857 { 858 sdparam *sdp_chan0, *sdp_chan1; 859 mbreg_t mbs; 860 861 sdp_chan0 = isp->isp_param; 862 sdp_chan1 = sdp_chan0; 863 if (IS_DUALBUS(isp)) { 864 sdp_chan1++; 865 } 866 867 /* 868 * If we have no role (neither target nor initiator), return. 869 */ 870 if (isp->isp_role == ISP_ROLE_NONE) { 871 return; 872 } 873 874 /* First do overall per-card settings. */ 875 876 /* 877 * If we have fast memory timing enabled, turn it on. 878 */ 879 if (sdp_chan0->isp_fast_mttr) { 880 ISP_WRITE(isp, RISC_MTR, 0x1313); 881 } 882 883 /* 884 * Set Retry Delay and Count. 885 * You set both channels at the same time. 886 */ 887 MEMZERO(&mbs, sizeof (mbs)); 888 mbs.param[0] = MBOX_SET_RETRY_COUNT; 889 mbs.param[1] = sdp_chan0->isp_retry_count; 890 mbs.param[2] = sdp_chan0->isp_retry_delay; 891 mbs.param[6] = sdp_chan1->isp_retry_count; 892 mbs.param[7] = sdp_chan1->isp_retry_delay; 893 894 isp_mboxcmd(isp, &mbs, MBLOGALL); 895 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 896 return; 897 } 898 899 /* 900 * Set ASYNC DATA SETUP time. This is very important. 901 */ 902 mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME; 903 mbs.param[1] = sdp_chan0->isp_async_data_setup; 904 mbs.param[2] = sdp_chan1->isp_async_data_setup; 905 isp_mboxcmd(isp, &mbs, MBLOGALL); 906 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 907 return; 908 } 909 910 /* 911 * Set ACTIVE Negation State. 912 */ 913 mbs.param[0] = MBOX_SET_ACT_NEG_STATE; 914 mbs.param[1] = 915 (sdp_chan0->isp_req_ack_active_neg << 4) | 916 (sdp_chan0->isp_data_line_active_neg << 5); 917 mbs.param[2] = 918 (sdp_chan1->isp_req_ack_active_neg << 4) | 919 (sdp_chan1->isp_data_line_active_neg << 5); 920 921 isp_mboxcmd(isp, &mbs, MBLOGNONE); 922 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 923 isp_prt(isp, ISP_LOGERR, 924 "failed to set active negation state (%d,%d), (%d,%d)", 925 sdp_chan0->isp_req_ack_active_neg, 926 sdp_chan0->isp_data_line_active_neg, 927 sdp_chan1->isp_req_ack_active_neg, 928 sdp_chan1->isp_data_line_active_neg); 929 /* 930 * But don't return. 931 */ 932 } 933 934 /* 935 * Set the Tag Aging limit 936 */ 937 mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT; 938 mbs.param[1] = sdp_chan0->isp_tag_aging; 939 mbs.param[2] = sdp_chan1->isp_tag_aging; 940 isp_mboxcmd(isp, &mbs, MBLOGALL); 941 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 942 isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)", 943 sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging); 944 return; 945 } 946 947 /* 948 * Set selection timeout. 949 */ 950 mbs.param[0] = MBOX_SET_SELECT_TIMEOUT; 951 mbs.param[1] = sdp_chan0->isp_selection_timeout; 952 mbs.param[2] = sdp_chan1->isp_selection_timeout; 953 isp_mboxcmd(isp, &mbs, MBLOGALL); 954 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 955 return; 956 } 957 958 /* now do per-channel settings */ 959 isp_scsi_channel_init(isp, 0); 960 if (IS_DUALBUS(isp)) 961 isp_scsi_channel_init(isp, 1); 962 963 /* 964 * Now enable request/response queues 965 */ 966 967 if (IS_ULTRA2(isp) || IS_1240(isp)) { 968 mbs.param[0] = MBOX_INIT_RES_QUEUE_A64; 969 mbs.param[1] = RESULT_QUEUE_LEN(isp); 970 mbs.param[2] = DMA_WD1(isp->isp_result_dma); 971 mbs.param[3] = DMA_WD0(isp->isp_result_dma); 972 mbs.param[4] = 0; 973 mbs.param[6] = DMA_WD3(isp->isp_result_dma); 974 mbs.param[7] = DMA_WD2(isp->isp_result_dma); 975 isp_mboxcmd(isp, &mbs, MBLOGALL); 976 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 977 return; 978 } 979 isp->isp_residx = mbs.param[5]; 980 981 mbs.param[0] = MBOX_INIT_REQ_QUEUE_A64; 982 mbs.param[1] = RQUEST_QUEUE_LEN(isp); 983 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma); 984 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma); 985 mbs.param[5] = 0; 986 mbs.param[6] = DMA_WD3(isp->isp_result_dma); 987 mbs.param[7] = DMA_WD2(isp->isp_result_dma); 988 isp_mboxcmd(isp, &mbs, MBLOGALL); 989 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 990 return; 991 } 992 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4]; 993 } else { 994 mbs.param[0] = MBOX_INIT_RES_QUEUE; 995 mbs.param[1] = RESULT_QUEUE_LEN(isp); 996 mbs.param[2] = DMA_WD1(isp->isp_result_dma); 997 mbs.param[3] = DMA_WD0(isp->isp_result_dma); 998 mbs.param[4] = 0; 999 isp_mboxcmd(isp, &mbs, MBLOGALL); 1000 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1001 return; 1002 } 1003 isp->isp_residx = mbs.param[5]; 1004 1005 mbs.param[0] = MBOX_INIT_REQ_QUEUE; 1006 mbs.param[1] = RQUEST_QUEUE_LEN(isp); 1007 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma); 1008 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma); 1009 mbs.param[5] = 0; 1010 isp_mboxcmd(isp, &mbs, MBLOGALL); 1011 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1012 return; 1013 } 1014 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4]; 1015 } 1016 1017 /* 1018 * Turn on Fast Posting, LVD transitions 1019 * 1020 * Ultra2 F/W always has had fast posting (and LVD transitions) 1021 * 1022 * Ultra and older (i.e., SBus) cards may not. It's just safer 1023 * to assume not for them. 1024 */ 1025 1026 mbs.param[0] = MBOX_SET_FW_FEATURES; 1027 mbs.param[1] = 0; 1028 if (IS_ULTRA2(isp)) 1029 mbs.param[1] |= FW_FEATURE_LVD_NOTIFY; 1030 #ifndef ISP_NO_RIO 1031 if (IS_ULTRA2(isp) || IS_1240(isp)) 1032 mbs.param[1] |= FW_FEATURE_RIO_16BIT; 1033 #else 1034 #ifndef ISP_NO_FASTPOST 1035 if (IS_ULTRA2(isp) || IS_1240(isp)) 1036 mbs.param[1] |= FW_FEATURE_FAST_POST; 1037 #endif 1038 #endif 1039 if (mbs.param[1] != 0) { 1040 u_int16_t sfeat = mbs.param[1]; 1041 isp_mboxcmd(isp, &mbs, MBLOGALL); 1042 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 1043 isp_prt(isp, ISP_LOGINFO, 1044 "Enabled FW features (0x%x)", sfeat); 1045 } 1046 } 1047 1048 /* 1049 * Let the outer layers decide whether to issue a SCSI bus reset. 1050 */ 1051 isp->isp_state = ISP_INITSTATE; 1052 } 1053 1054 static void 1055 isp_scsi_channel_init(struct ispsoftc *isp, int channel) 1056 { 1057 sdparam *sdp; 1058 mbreg_t mbs; 1059 int tgt; 1060 1061 sdp = isp->isp_param; 1062 sdp += channel; 1063 1064 /* 1065 * Set (possibly new) Initiator ID. 1066 */ 1067 MEMZERO(&mbs, sizeof (mbs)); 1068 mbs.param[0] = MBOX_SET_INIT_SCSI_ID; 1069 mbs.param[1] = (channel << 7) | sdp->isp_initiator_id; 1070 isp_mboxcmd(isp, &mbs, MBLOGALL); 1071 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1072 return; 1073 } 1074 isp_prt(isp, ISP_LOGINFO, "Initiator ID is %d on Channel %d", 1075 sdp->isp_initiator_id, channel); 1076 1077 1078 /* 1079 * Set current per-target parameters to an initial safe minimum. 1080 */ 1081 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 1082 int lun; 1083 u_int16_t sdf; 1084 1085 if (sdp->isp_devparam[tgt].dev_enable == 0) { 1086 continue; 1087 } 1088 #ifndef ISP_TARGET_MODE 1089 sdf = sdp->isp_devparam[tgt].goal_flags; 1090 sdf &= DPARM_SAFE_DFLT; 1091 /* 1092 * It is not quite clear when this changed over so that 1093 * we could force narrow and async for 1000/1020 cards, 1094 * but assume that this is only the case for loaded 1095 * firmware. 1096 */ 1097 if (isp->isp_loaded_fw) { 1098 sdf |= DPARM_NARROW | DPARM_ASYNC; 1099 } 1100 #else 1101 /* 1102 * The !$*!)$!$)* f/w uses the same index into some 1103 * internal table to decide how to respond to negotiations, 1104 * so if we've said "let's be safe" for ID X, and ID X 1105 * selects *us*, the negotiations will back to 'safe' 1106 * (as in narrow/async). What the f/w *should* do is 1107 * use the initiator id settings to decide how to respond. 1108 */ 1109 sdp->isp_devparam[tgt].goal_flags = sdf = DPARM_DEFAULT; 1110 #endif 1111 mbs.param[0] = MBOX_SET_TARGET_PARAMS; 1112 mbs.param[1] = (channel << 15) | (tgt << 8); 1113 mbs.param[2] = sdf; 1114 if ((sdf & DPARM_SYNC) == 0) { 1115 mbs.param[3] = 0; 1116 } else { 1117 mbs.param[3] = 1118 (sdp->isp_devparam[tgt].goal_offset << 8) | 1119 (sdp->isp_devparam[tgt].goal_period); 1120 } 1121 isp_prt(isp, ISP_LOGDEBUG0, 1122 "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x", 1123 channel, tgt, mbs.param[2], mbs.param[3] >> 8, 1124 mbs.param[3] & 0xff); 1125 isp_mboxcmd(isp, &mbs, MBLOGNONE); 1126 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1127 sdf = DPARM_SAFE_DFLT; 1128 mbs.param[0] = MBOX_SET_TARGET_PARAMS; 1129 mbs.param[1] = (tgt << 8) | (channel << 15); 1130 mbs.param[2] = sdf; 1131 mbs.param[3] = 0; 1132 isp_mboxcmd(isp, &mbs, MBLOGALL); 1133 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1134 continue; 1135 } 1136 } 1137 1138 /* 1139 * We don't update any information directly from the f/w 1140 * because we need to run at least one command to cause a 1141 * new state to be latched up. So, we just assume that we 1142 * converge to the values we just had set. 1143 * 1144 * Ensure that we don't believe tagged queuing is enabled yet. 1145 * It turns out that sometimes the ISP just ignores our 1146 * attempts to set parameters for devices that it hasn't 1147 * seen yet. 1148 */ 1149 sdp->isp_devparam[tgt].actv_flags = sdf & ~DPARM_TQING; 1150 for (lun = 0; lun < (int) isp->isp_maxluns; lun++) { 1151 mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS; 1152 mbs.param[1] = (channel << 15) | (tgt << 8) | lun; 1153 mbs.param[2] = sdp->isp_max_queue_depth; 1154 mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle; 1155 isp_mboxcmd(isp, &mbs, MBLOGALL); 1156 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1157 break; 1158 } 1159 } 1160 } 1161 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 1162 if (sdp->isp_devparam[tgt].dev_refresh) { 1163 isp->isp_sendmarker |= (1 << channel); 1164 isp->isp_update |= (1 << channel); 1165 break; 1166 } 1167 } 1168 } 1169 1170 /* 1171 * Fibre Channel specific initialization. 1172 * 1173 * Locks are held before coming here. 1174 */ 1175 static void 1176 isp_fibre_init(struct ispsoftc *isp) 1177 { 1178 fcparam *fcp; 1179 isp_icb_t local, *icbp = &local; 1180 mbreg_t mbs; 1181 int loopid; 1182 u_int64_t nwwn, pwwn; 1183 1184 fcp = isp->isp_param; 1185 1186 /* 1187 * Do this *before* initializing the firmware. 1188 */ 1189 isp_mark_getpdb_all(isp); 1190 fcp->isp_fwstate = FW_CONFIG_WAIT; 1191 fcp->isp_loopstate = LOOP_NIL; 1192 1193 /* 1194 * If we have no role (neither target nor initiator), return. 1195 */ 1196 if (isp->isp_role == ISP_ROLE_NONE) { 1197 return; 1198 } 1199 1200 loopid = fcp->isp_loopid; 1201 MEMZERO(icbp, sizeof (*icbp)); 1202 icbp->icb_version = ICB_VERSION1; 1203 1204 /* 1205 * Firmware Options are either retrieved from NVRAM or 1206 * are patched elsewhere. We check them for sanity here 1207 * and make changes based on board revision, but otherwise 1208 * let others decide policy. 1209 */ 1210 1211 /* 1212 * If this is a 2100 < revision 5, we have to turn off FAIRNESS. 1213 */ 1214 if ((isp->isp_type == ISP_HA_FC_2100) && isp->isp_revision < 5) { 1215 fcp->isp_fwoptions &= ~ICBOPT_FAIRNESS; 1216 } 1217 1218 /* 1219 * We have to use FULL LOGIN even though it resets the loop too much 1220 * because otherwise port database entries don't get updated after 1221 * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0. 1222 */ 1223 if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) { 1224 fcp->isp_fwoptions |= ICBOPT_FULL_LOGIN; 1225 } 1226 1227 /* 1228 * Insist on Port Database Update Async notifications 1229 */ 1230 fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE; 1231 1232 /* 1233 * Make sure that target role reflects into fwoptions. 1234 */ 1235 if (isp->isp_role & ISP_ROLE_TARGET) { 1236 fcp->isp_fwoptions |= ICBOPT_TGT_ENABLE; 1237 } else { 1238 fcp->isp_fwoptions &= ~ICBOPT_TGT_ENABLE; 1239 } 1240 1241 if (isp->isp_role & ISP_ROLE_INITIATOR) { 1242 fcp->isp_fwoptions &= ~ICBOPT_INI_DISABLE; 1243 } else { 1244 fcp->isp_fwoptions |= ICBOPT_INI_DISABLE; 1245 } 1246 1247 /* 1248 * Propagate all of this into the ICB structure. 1249 */ 1250 icbp->icb_fwoptions = fcp->isp_fwoptions; 1251 icbp->icb_maxfrmlen = fcp->isp_maxfrmlen; 1252 if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN || 1253 icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) { 1254 isp_prt(isp, ISP_LOGERR, 1255 "bad frame length (%d) from NVRAM- using %d", 1256 fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN); 1257 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN; 1258 } 1259 icbp->icb_maxalloc = fcp->isp_maxalloc; 1260 if (icbp->icb_maxalloc < 1) { 1261 isp_prt(isp, ISP_LOGERR, 1262 "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc); 1263 icbp->icb_maxalloc = 16; 1264 } 1265 icbp->icb_execthrottle = fcp->isp_execthrottle; 1266 if (icbp->icb_execthrottle < 1) { 1267 isp_prt(isp, ISP_LOGERR, 1268 "bad execution throttle of %d- using 16", 1269 fcp->isp_execthrottle); 1270 icbp->icb_execthrottle = ICB_DFLT_THROTTLE; 1271 } 1272 icbp->icb_retry_delay = fcp->isp_retry_delay; 1273 icbp->icb_retry_count = fcp->isp_retry_count; 1274 icbp->icb_hardaddr = loopid; 1275 if (icbp->icb_hardaddr >= 125) { 1276 /* 1277 * We end up with these Loop IDs for F-Port topologies 1278 */ 1279 if (icbp->icb_hardaddr != 0xff || icbp->icb_hardaddr != 0x800) { 1280 isp_prt(isp, ISP_LOGERR, 1281 "bad hard address %u- resetting to zero", 1282 icbp->icb_hardaddr); 1283 } 1284 icbp->icb_hardaddr = 0; 1285 } 1286 /* 1287 * Right now we just set extended options to prefer point-to-point 1288 * over loop based upon some soft config options. 1289 * 1290 * NB: for the 2300, ICBOPT_EXTENDED is required. 1291 */ 1292 if (IS_2200(isp) || IS_23XX(isp)) { 1293 icbp->icb_fwoptions |= ICBOPT_EXTENDED; 1294 /* 1295 * Prefer or force Point-To-Point instead Loop? 1296 */ 1297 switch(isp->isp_confopts & ISP_CFG_PORT_PREF) { 1298 case ISP_CFG_NPORT: 1299 icbp->icb_xfwoptions |= ICBXOPT_PTP_2_LOOP; 1300 break; 1301 case ISP_CFG_NPORT_ONLY: 1302 icbp->icb_xfwoptions |= ICBXOPT_PTP_ONLY; 1303 break; 1304 case ISP_CFG_LPORT_ONLY: 1305 icbp->icb_xfwoptions |= ICBXOPT_LOOP_ONLY; 1306 break; 1307 default: 1308 icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP; 1309 break; 1310 } 1311 if (IS_23XX(isp)) { 1312 /* 1313 * QLogic recommends that FAST Posting be turned 1314 * off for 23XX cards and instead allow the HBA 1315 * to write response queue entries and interrupt 1316 * after a delay (ZIO). 1317 * 1318 * If we set ZIO, it will disable fast posting, 1319 * so we don't need to clear it in fwoptions. 1320 * 1321 * Depending on the role we're selecting, we 1322 * chose fast posting or not as it still is 1323 * a win for target mode. 1324 */ 1325 #ifndef ISP_NO_ZIO 1326 if (isp->isp_role == ISP_ROLE_TARGET) { 1327 icbp->icb_fwoptions |= ICBOPT_FAST_POST; 1328 } else { 1329 icbp->icb_xfwoptions |= ICBXOPT_ZIO; 1330 } 1331 #else 1332 icbp->icb_fwoptions |= ICBOPT_FAST_POST; 1333 #endif 1334 #if 0 1335 /* 1336 * Values, in 100us increments. The default 1337 * is 2 (200us) if a value 0 (default) is 1338 * selected. 1339 */ 1340 icbp->icb_idelaytimer = 2; 1341 #endif 1342 1343 if (isp->isp_confopts & ISP_CFG_ONEGB) { 1344 icbp->icb_zfwoptions |= ICBZOPT_RATE_ONEGB; 1345 } else if (isp->isp_confopts & ISP_CFG_TWOGB) { 1346 icbp->icb_zfwoptions |= ICBZOPT_RATE_TWOGB; 1347 } else { 1348 icbp->icb_zfwoptions |= ICBZOPT_RATE_AUTO; 1349 } 1350 } 1351 } 1352 1353 #ifndef ISP_NO_RIO_FC 1354 /* 1355 * RIO seems to be enabled in 2100s for fw >= 1.17.0. 1356 * 1357 * I've had some questionable problems with RIO on 2200. 1358 * More specifically, on a 2204 I had problems with RIO 1359 * on a Linux system where I was dropping commands right 1360 * and left. It's not clear to me what the actual problem 1361 * was. 1362 * 1363 * 23XX Cards do not support RIO. Instead they support ZIO. 1364 */ 1365 #if 0 1366 if (!IS_23XX(isp) && ISP_FW_NEWER_THAN(isp, 1, 17, 0)) { 1367 icbp->icb_xfwoptions |= ICBXOPT_RIO_16BIT; 1368 icbp->icb_racctimer = 4; 1369 icbp->icb_idelaytimer = 8; 1370 } 1371 #endif 1372 #endif 1373 1374 MEMZERO(&mbs, sizeof (mbs)); 1375 1376 /* 1377 * For 22XX > 2.1.26 && 23XX, set some options. 1378 * XXX: Probably okay for newer 2100 f/w too. 1379 */ 1380 if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) { 1381 /* 1382 * Turn on LIP F8 async event (1) 1383 * Turn on generate AE 8013 on all LIP Resets (2) 1384 * Disable LIP F7 switching (8) 1385 */ 1386 mbs.param[0] = MBOX_SET_FIRMWARE_OPTIONS; 1387 mbs.param[1] = 0xb; 1388 mbs.param[2] = 0; 1389 mbs.param[3] = 0; 1390 isp_mboxcmd(isp, &mbs, MBLOGALL); 1391 } 1392 icbp->icb_logintime = 30; /* 30 second login timeout */ 1393 1394 if (IS_23XX(isp)) { 1395 ISP_WRITE(isp, isp->isp_rqstinrp, 0); 1396 ISP_WRITE(isp, isp->isp_rqstoutrp, 0); 1397 ISP_WRITE(isp, isp->isp_respinrp, 0); 1398 ISP_WRITE(isp, isp->isp_respoutrp, 0); 1399 } 1400 1401 nwwn = ISP_NODEWWN(isp); 1402 pwwn = ISP_PORTWWN(isp); 1403 if (nwwn && pwwn) { 1404 icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS; 1405 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, nwwn); 1406 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn); 1407 isp_prt(isp, ISP_LOGDEBUG1, 1408 "Setting ICB Node 0x%08x%08x Port 0x%08x%08x", 1409 ((u_int32_t) (nwwn >> 32)), 1410 ((u_int32_t) (nwwn & 0xffffffff)), 1411 ((u_int32_t) (pwwn >> 32)), 1412 ((u_int32_t) (pwwn & 0xffffffff))); 1413 } else { 1414 isp_prt(isp, ISP_LOGDEBUG1, "Not using any WWNs"); 1415 icbp->icb_fwoptions &= ~(ICBOPT_BOTH_WWNS|ICBOPT_FULL_LOGIN); 1416 } 1417 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp); 1418 if (icbp->icb_rqstqlen < 1) { 1419 isp_prt(isp, ISP_LOGERR, "bad request queue length"); 1420 } 1421 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp); 1422 if (icbp->icb_rsltqlen < 1) { 1423 isp_prt(isp, ISP_LOGERR, "bad result queue length"); 1424 } 1425 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma); 1426 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma); 1427 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma); 1428 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma); 1429 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma); 1430 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma); 1431 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma); 1432 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma); 1433 isp_prt(isp, ISP_LOGDEBUG0, 1434 "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x", 1435 icbp->icb_fwoptions, icbp->icb_xfwoptions, icbp->icb_zfwoptions); 1436 1437 FC_SCRATCH_ACQUIRE(isp); 1438 isp_put_icb(isp, icbp, (isp_icb_t *)fcp->isp_scratch); 1439 1440 /* 1441 * Init the firmware 1442 */ 1443 mbs.param[0] = MBOX_INIT_FIRMWARE; 1444 mbs.param[1] = 0; 1445 mbs.param[2] = DMA_WD1(fcp->isp_scdma); 1446 mbs.param[3] = DMA_WD0(fcp->isp_scdma); 1447 mbs.param[4] = 0; 1448 mbs.param[5] = 0; 1449 mbs.param[6] = DMA_WD3(fcp->isp_scdma); 1450 mbs.param[7] = DMA_WD2(fcp->isp_scdma); 1451 isp_mboxcmd(isp, &mbs, MBLOGALL); 1452 FC_SCRATCH_RELEASE(isp); 1453 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1454 return; 1455 } 1456 isp->isp_reqidx = isp->isp_reqodx = 0; 1457 isp->isp_residx = 0; 1458 isp->isp_sendmarker = 1; 1459 1460 /* 1461 * Whatever happens, we're now committed to being here. 1462 */ 1463 isp->isp_state = ISP_INITSTATE; 1464 } 1465 1466 /* 1467 * Fibre Channel Support- get the port database for the id. 1468 * 1469 * Locks are held before coming here. Return 0 if success, 1470 * else failure. 1471 */ 1472 1473 static int 1474 isp_getmap(struct ispsoftc *isp, fcpos_map_t *map) 1475 { 1476 fcparam *fcp = (fcparam *) isp->isp_param; 1477 mbreg_t mbs; 1478 1479 MEMZERO(&mbs, sizeof (mbs)); 1480 mbs.param[0] = MBOX_GET_FC_AL_POSITION_MAP; 1481 mbs.param[1] = 0; 1482 mbs.param[2] = DMA_WD1(fcp->isp_scdma); 1483 mbs.param[3] = DMA_WD0(fcp->isp_scdma); 1484 /* 1485 * Unneeded. For the 2100, except for initializing f/w, registers 1486 * 4/5 have to not be written to. 1487 * mbs.param[4] = 0; 1488 * mbs.param[5] = 0; 1489 * 1490 */ 1491 mbs.param[6] = 0; 1492 mbs.param[7] = 0; 1493 FC_SCRATCH_ACQUIRE(isp); 1494 isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR); 1495 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 1496 MEMCPY(map, fcp->isp_scratch, sizeof (fcpos_map_t)); 1497 map->fwmap = mbs.param[1] != 0; 1498 FC_SCRATCH_RELEASE(isp); 1499 return (0); 1500 } 1501 FC_SCRATCH_RELEASE(isp); 1502 return (-1); 1503 } 1504 1505 static void 1506 isp_mark_getpdb_all(struct ispsoftc *isp) 1507 { 1508 fcparam *fcp = (fcparam *) isp->isp_param; 1509 int i; 1510 for (i = 0; i < MAX_FC_TARG; i++) { 1511 fcp->portdb[i].valid = fcp->portdb[i].fabric_dev = 0; 1512 } 1513 } 1514 1515 static int 1516 isp_getpdb(struct ispsoftc *isp, int id, isp_pdb_t *pdbp) 1517 { 1518 fcparam *fcp = (fcparam *) isp->isp_param; 1519 mbreg_t mbs; 1520 1521 MEMZERO(&mbs, sizeof (mbs)); 1522 mbs.param[0] = MBOX_GET_PORT_DB; 1523 if (IS_2KLOGIN(isp)) { 1524 mbs.param[1] = id; 1525 mbs.obits |= (1 << 10); 1526 } else { 1527 mbs.param[1] = id << 8; 1528 } 1529 mbs.param[2] = DMA_WD1(fcp->isp_scdma); 1530 mbs.param[3] = DMA_WD0(fcp->isp_scdma); 1531 /* 1532 * Unneeded. For the 2100, except for initializing f/w, registers 1533 * 4/5 have to not be written to. 1534 * mbs.param[4] = 0; 1535 * mbs.param[5] = 0; 1536 * 1537 */ 1538 mbs.param[6] = DMA_WD3(fcp->isp_scdma); 1539 mbs.param[7] = DMA_WD2(fcp->isp_scdma); 1540 FC_SCRATCH_ACQUIRE(isp); 1541 isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR); 1542 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 1543 isp_get_pdb(isp, (isp_pdb_t *)fcp->isp_scratch, pdbp); 1544 FC_SCRATCH_RELEASE(isp); 1545 return (0); 1546 } 1547 FC_SCRATCH_RELEASE(isp); 1548 return (-1); 1549 } 1550 1551 static u_int64_t 1552 isp_get_portname(struct ispsoftc *isp, int loopid, int nodename) 1553 { 1554 u_int64_t wwn = 0; 1555 mbreg_t mbs; 1556 1557 MEMZERO(&mbs, sizeof (mbs)); 1558 mbs.param[0] = MBOX_GET_PORT_NAME; 1559 if (IS_2KLOGIN(isp)) { 1560 mbs.param[1] = loopid; 1561 if (nodename) 1562 mbs.param[10] = 1; 1563 mbs.obits |= (1 << 10); 1564 } else { 1565 mbs.param[1] = loopid << 8; 1566 if (nodename) 1567 mbs.param[1] |= 1; 1568 } 1569 isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR); 1570 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 1571 wwn = 1572 (((u_int64_t)(mbs.param[2] & 0xff)) << 56) | 1573 (((u_int64_t)(mbs.param[2] >> 8)) << 48) | 1574 (((u_int64_t)(mbs.param[3] & 0xff)) << 40) | 1575 (((u_int64_t)(mbs.param[3] >> 8)) << 32) | 1576 (((u_int64_t)(mbs.param[6] & 0xff)) << 24) | 1577 (((u_int64_t)(mbs.param[6] >> 8)) << 16) | 1578 (((u_int64_t)(mbs.param[7] & 0xff)) << 8) | 1579 (((u_int64_t)(mbs.param[7] >> 8))); 1580 } 1581 return (wwn); 1582 } 1583 1584 /* 1585 * Make sure we have good FC link and know our Loop ID. 1586 */ 1587 1588 static int 1589 isp_fclink_test(struct ispsoftc *isp, int usdelay) 1590 { 1591 static char *toponames[] = { 1592 "Private Loop", 1593 "FL Port", 1594 "N-Port to N-Port", 1595 "F Port", 1596 "F Port (no FLOGI_ACC response)" 1597 }; 1598 mbreg_t mbs; 1599 int count, check_for_fabric; 1600 u_int8_t lwfs; 1601 fcparam *fcp; 1602 struct lportdb *lp; 1603 isp_pdb_t pdb; 1604 1605 fcp = isp->isp_param; 1606 1607 /* 1608 * XXX: Here is where we would start a 'loop dead' timeout 1609 */ 1610 1611 /* 1612 * Wait up to N microseconds for F/W to go to a ready state. 1613 */ 1614 lwfs = FW_CONFIG_WAIT; 1615 count = 0; 1616 while (count < usdelay) { 1617 u_int64_t enano; 1618 u_int32_t wrk; 1619 NANOTIME_T hra, hrb; 1620 1621 GET_NANOTIME(&hra); 1622 isp_fw_state(isp); 1623 if (lwfs != fcp->isp_fwstate) { 1624 isp_prt(isp, ISP_LOGINFO, "Firmware State <%s->%s>", 1625 isp2100_fw_statename((int)lwfs), 1626 isp2100_fw_statename((int)fcp->isp_fwstate)); 1627 lwfs = fcp->isp_fwstate; 1628 } 1629 if (fcp->isp_fwstate == FW_READY) { 1630 break; 1631 } 1632 GET_NANOTIME(&hrb); 1633 1634 /* 1635 * Get the elapsed time in nanoseconds. 1636 * Always guaranteed to be non-zero. 1637 */ 1638 enano = NANOTIME_SUB(&hrb, &hra); 1639 1640 isp_prt(isp, ISP_LOGDEBUG1, 1641 "usec%d: 0x%lx->0x%lx enano 0x%x%08x", 1642 count, (long) GET_NANOSEC(&hra), (long) GET_NANOSEC(&hrb), 1643 (u_int32_t)(enano >> 32), (u_int32_t)(enano & 0xffffffff)); 1644 1645 /* 1646 * If the elapsed time is less than 1 millisecond, 1647 * delay a period of time up to that millisecond of 1648 * waiting. 1649 * 1650 * This peculiar code is an attempt to try and avoid 1651 * invoking u_int64_t math support functions for some 1652 * platforms where linkage is a problem. 1653 */ 1654 if (enano < (1000 * 1000)) { 1655 count += 1000; 1656 enano = (1000 * 1000) - enano; 1657 while (enano > (u_int64_t) 4000000000U) { 1658 USEC_SLEEP(isp, 4000000); 1659 enano -= (u_int64_t) 4000000000U; 1660 } 1661 wrk = enano; 1662 wrk /= 1000; 1663 USEC_SLEEP(isp, wrk); 1664 } else { 1665 while (enano > (u_int64_t) 4000000000U) { 1666 count += 4000000; 1667 enano -= (u_int64_t) 4000000000U; 1668 } 1669 wrk = enano; 1670 count += (wrk / 1000); 1671 } 1672 } 1673 1674 /* 1675 * If we haven't gone to 'ready' state, return. 1676 */ 1677 if (fcp->isp_fwstate != FW_READY) { 1678 return (-1); 1679 } 1680 1681 /* 1682 * Get our Loop ID (if possible). We really need to have it. 1683 */ 1684 MEMZERO(&mbs, sizeof (mbs)); 1685 mbs.param[0] = MBOX_GET_LOOP_ID; 1686 isp_mboxcmd(isp, &mbs, MBLOGALL); 1687 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1688 return (-1); 1689 } 1690 fcp->isp_loopid = mbs.param[1]; 1691 if (fcp->isp_loopid == 0xffff) { /* happens with 2k login f/w */ 1692 fcp->isp_loopid = MAX_FC_TARG-1; 1693 } else if (fcp->isp_loopid >= MAX_FC_TARG) { 1694 isp_prt(isp, ISP_LOGWARN, "bad initiator loopid (0x%x)", fcp->isp_loopid); 1695 fcp->isp_loopid = MAX_FC_TARG-1; 1696 } 1697 if (IS_2200(isp) || IS_23XX(isp)) { 1698 int topo = (int) mbs.param[6]; 1699 if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB) 1700 topo = TOPO_PTP_STUB; 1701 fcp->isp_topo = topo; 1702 } else { 1703 fcp->isp_topo = TOPO_NL_PORT; 1704 } 1705 /* 1706 * Get the port id. 1707 */ 1708 fcp->isp_portid = mbs.param[2] | (mbs.param[3] << 16); 1709 1710 /* 1711 * Check to see if we're on a fabric by trying to see if we 1712 * can talk to the fabric name server. This can be a bit 1713 * tricky because if we're a 2100, we should check always 1714 * (in case we're connected to a server doing aliasing). 1715 */ 1716 fcp->isp_onfabric = 0; 1717 1718 if (IS_2100(isp)) { 1719 /* 1720 * Don't bother with fabric if we are using really old 1721 * 2100 firmware. It's just not worth it. 1722 */ 1723 if (ISP_FW_NEWER_THAN(isp, 1, 15, 37)) { 1724 check_for_fabric = 1; 1725 } else { 1726 check_for_fabric = 0; 1727 } 1728 } else if (fcp->isp_topo == TOPO_FL_PORT || 1729 fcp->isp_topo == TOPO_F_PORT) { 1730 check_for_fabric = 1; 1731 } else 1732 check_for_fabric = 0; 1733 1734 if (check_for_fabric && isp_getpdb(isp, FL_PORT_ID, &pdb) == 0) { 1735 int loopid = FL_PORT_ID; 1736 if (IS_2100(isp)) { 1737 fcp->isp_topo = TOPO_FL_PORT; 1738 } 1739 1740 if (BITS2WORD(pdb.pdb_portid_bits) == 0) { 1741 /* 1742 * Crock. 1743 */ 1744 fcp->isp_topo = TOPO_NL_PORT; 1745 goto not_on_fabric; 1746 } 1747 fcp->isp_portid = mbs.param[2] | ((int) mbs.param[3] << 16); 1748 1749 /* 1750 * Save the Fabric controller's port database entry. 1751 */ 1752 lp = &fcp->portdb[loopid]; 1753 lp->node_wwn = 1754 (((u_int64_t)pdb.pdb_nodename[0]) << 56) | 1755 (((u_int64_t)pdb.pdb_nodename[1]) << 48) | 1756 (((u_int64_t)pdb.pdb_nodename[2]) << 40) | 1757 (((u_int64_t)pdb.pdb_nodename[3]) << 32) | 1758 (((u_int64_t)pdb.pdb_nodename[4]) << 24) | 1759 (((u_int64_t)pdb.pdb_nodename[5]) << 16) | 1760 (((u_int64_t)pdb.pdb_nodename[6]) << 8) | 1761 (((u_int64_t)pdb.pdb_nodename[7])); 1762 lp->port_wwn = 1763 (((u_int64_t)pdb.pdb_portname[0]) << 56) | 1764 (((u_int64_t)pdb.pdb_portname[1]) << 48) | 1765 (((u_int64_t)pdb.pdb_portname[2]) << 40) | 1766 (((u_int64_t)pdb.pdb_portname[3]) << 32) | 1767 (((u_int64_t)pdb.pdb_portname[4]) << 24) | 1768 (((u_int64_t)pdb.pdb_portname[5]) << 16) | 1769 (((u_int64_t)pdb.pdb_portname[6]) << 8) | 1770 (((u_int64_t)pdb.pdb_portname[7])); 1771 lp->roles = 1772 (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT; 1773 lp->portid = BITS2WORD(pdb.pdb_portid_bits); 1774 lp->loopid = pdb.pdb_loopid; 1775 lp->loggedin = lp->valid = 1; 1776 fcp->isp_onfabric = 1; 1777 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid); 1778 isp_register_fc4_type(isp); 1779 } else { 1780 not_on_fabric: 1781 fcp->isp_onfabric = 0; 1782 fcp->portdb[FL_PORT_ID].valid = 0; 1783 } 1784 1785 fcp->isp_gbspeed = 1; 1786 if (IS_23XX(isp)) { 1787 mbs.param[0] = MBOX_GET_SET_DATA_RATE; 1788 mbs.param[1] = MBGSD_GET_RATE; 1789 /* mbs.param[2] undefined if we're just getting rate */ 1790 isp_mboxcmd(isp, &mbs, MBLOGALL); 1791 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 1792 if (mbs.param[1] == MBGSD_TWOGB) { 1793 isp_prt(isp, ISP_LOGINFO, "2Gb link speed/s"); 1794 fcp->isp_gbspeed = 2; 1795 } 1796 } 1797 } 1798 1799 isp_prt(isp, ISP_LOGCONFIG, topology, fcp->isp_loopid, 1800 fcp->isp_portid, fcp->isp_loopstate, toponames[fcp->isp_topo]); 1801 1802 /* 1803 * Announce ourselves, too. This involves synthesizing an entry. 1804 */ 1805 if (fcp->isp_iid_set == 0) { 1806 fcp->isp_iid_set = 1; 1807 fcp->isp_iid = fcp->isp_loopid; 1808 lp = &fcp->portdb[fcp->isp_iid]; 1809 } else { 1810 lp = &fcp->portdb[fcp->isp_iid]; 1811 if (fcp->isp_portid != lp->portid || 1812 fcp->isp_loopid != lp->loopid || 1813 fcp->isp_nodewwn != ISP_NODEWWN(isp) || 1814 fcp->isp_portwwn != ISP_PORTWWN(isp)) { 1815 lp->valid = 0; 1816 count = fcp->isp_iid; 1817 (void) isp_async(isp, ISPASYNC_PROMENADE, &count); 1818 } 1819 } 1820 lp->loopid = fcp->isp_loopid; 1821 lp->portid = fcp->isp_portid; 1822 lp->node_wwn = ISP_NODEWWN(isp); 1823 lp->port_wwn = ISP_PORTWWN(isp); 1824 switch (isp->isp_role) { 1825 case ISP_ROLE_NONE: 1826 lp->roles = 0; 1827 break; 1828 case ISP_ROLE_TARGET: 1829 lp->roles = SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT; 1830 break; 1831 case ISP_ROLE_INITIATOR: 1832 lp->roles = SVC3_INI_ROLE >> SVC3_ROLE_SHIFT; 1833 break; 1834 case ISP_ROLE_BOTH: 1835 lp->roles = (SVC3_INI_ROLE|SVC3_TGT_ROLE) >> SVC3_ROLE_SHIFT; 1836 break; 1837 } 1838 lp->loggedin = lp->valid = 1; 1839 count = fcp->isp_iid; 1840 (void) isp_async(isp, ISPASYNC_PROMENADE, &count); 1841 return (0); 1842 } 1843 1844 static char * 1845 isp2100_fw_statename(int state) 1846 { 1847 switch(state) { 1848 case FW_CONFIG_WAIT: return "Config Wait"; 1849 case FW_WAIT_AL_PA: return "Waiting for AL_PA"; 1850 case FW_WAIT_LOGIN: return "Wait Login"; 1851 case FW_READY: return "Ready"; 1852 case FW_LOSS_OF_SYNC: return "Loss Of Sync"; 1853 case FW_ERROR: return "Error"; 1854 case FW_REINIT: return "Re-Init"; 1855 case FW_NON_PART: return "Nonparticipating"; 1856 default: return "?????"; 1857 } 1858 } 1859 1860 /* 1861 * Synchronize our soft copy of the port database with what the f/w thinks 1862 * (with a view toward possibly for a specific target....) 1863 */ 1864 1865 static int 1866 isp_pdb_sync(struct ispsoftc *isp) 1867 { 1868 struct lportdb *lp; 1869 fcparam *fcp = isp->isp_param; 1870 isp_pdb_t pdb; 1871 int loopid, base, lim; 1872 1873 /* 1874 * Make sure we're okay for doing this right now. 1875 */ 1876 if (fcp->isp_loopstate != LOOP_PDB_RCVD && 1877 fcp->isp_loopstate != LOOP_FSCAN_DONE && 1878 fcp->isp_loopstate != LOOP_LSCAN_DONE) { 1879 return (-1); 1880 } 1881 1882 if (fcp->isp_topo == TOPO_FL_PORT || fcp->isp_topo == TOPO_NL_PORT || 1883 fcp->isp_topo == TOPO_N_PORT) { 1884 if (fcp->isp_loopstate < LOOP_LSCAN_DONE) { 1885 if (isp_scan_loop(isp) != 0) { 1886 return (-1); 1887 } 1888 } 1889 } 1890 fcp->isp_loopstate = LOOP_SYNCING_PDB; 1891 1892 /* 1893 * If we get this far, we've settled our differences with the f/w 1894 * (for local loop device) and we can say that the loop state is ready. 1895 */ 1896 1897 if (fcp->isp_topo == TOPO_NL_PORT) { 1898 fcp->loop_seen_once = 1; 1899 fcp->isp_loopstate = LOOP_READY; 1900 return (0); 1901 } 1902 1903 /* 1904 * Find all Fabric Entities that didn't make it from one scan to the 1905 * next and let the world know they went away. Scan the whole database. 1906 */ 1907 for (lp = &fcp->portdb[0]; lp < &fcp->portdb[MAX_FC_TARG]; lp++) { 1908 if (lp->was_fabric_dev && lp->fabric_dev == 0) { 1909 loopid = lp - fcp->portdb; 1910 lp->valid = 0; /* should already be set */ 1911 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid); 1912 MEMZERO((void *) lp, sizeof (*lp)); 1913 continue; 1914 } 1915 lp->was_fabric_dev = lp->fabric_dev; 1916 } 1917 1918 if (fcp->isp_topo == TOPO_FL_PORT) 1919 base = FC_SNS_ID+1; 1920 else 1921 base = 0; 1922 1923 if (fcp->isp_topo == TOPO_N_PORT) 1924 lim = 1; 1925 else 1926 lim = MAX_FC_TARG; 1927 1928 /* 1929 * Now log in any fabric devices that the outer layer has 1930 * left for us to see. This seems the most sane policy 1931 * for the moment. 1932 */ 1933 for (lp = &fcp->portdb[base]; lp < &fcp->portdb[lim]; lp++) { 1934 u_int32_t portid; 1935 mbreg_t mbs; 1936 1937 loopid = lp - fcp->portdb; 1938 if (loopid >= FL_PORT_ID && loopid <= FC_SNS_ID) { 1939 continue; 1940 } 1941 1942 /* 1943 * Anything here? 1944 */ 1945 if (lp->port_wwn == 0) { 1946 continue; 1947 } 1948 1949 /* 1950 * Don't try to log into yourself. 1951 */ 1952 if ((portid = lp->portid) == fcp->isp_portid) { 1953 continue; 1954 } 1955 1956 1957 /* 1958 * If we'd been logged in- see if we still are and we haven't 1959 * changed. If so, no need to log ourselves out, etc.. 1960 * 1961 * Unfortunately, our charming Qlogic f/w has decided to 1962 * return a valid port database entry for a fabric device 1963 * that has, in fact, gone away. And it hangs trying to 1964 * log it out. 1965 */ 1966 if (lp->loggedin && lp->force_logout == 0 && 1967 isp_getpdb(isp, lp->loopid, &pdb) == 0) { 1968 int nrole; 1969 u_int64_t nwwnn, nwwpn; 1970 nwwnn = 1971 (((u_int64_t)pdb.pdb_nodename[0]) << 56) | 1972 (((u_int64_t)pdb.pdb_nodename[1]) << 48) | 1973 (((u_int64_t)pdb.pdb_nodename[2]) << 40) | 1974 (((u_int64_t)pdb.pdb_nodename[3]) << 32) | 1975 (((u_int64_t)pdb.pdb_nodename[4]) << 24) | 1976 (((u_int64_t)pdb.pdb_nodename[5]) << 16) | 1977 (((u_int64_t)pdb.pdb_nodename[6]) << 8) | 1978 (((u_int64_t)pdb.pdb_nodename[7])); 1979 nwwpn = 1980 (((u_int64_t)pdb.pdb_portname[0]) << 56) | 1981 (((u_int64_t)pdb.pdb_portname[1]) << 48) | 1982 (((u_int64_t)pdb.pdb_portname[2]) << 40) | 1983 (((u_int64_t)pdb.pdb_portname[3]) << 32) | 1984 (((u_int64_t)pdb.pdb_portname[4]) << 24) | 1985 (((u_int64_t)pdb.pdb_portname[5]) << 16) | 1986 (((u_int64_t)pdb.pdb_portname[6]) << 8) | 1987 (((u_int64_t)pdb.pdb_portname[7])); 1988 nrole = (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> 1989 SVC3_ROLE_SHIFT; 1990 if (pdb.pdb_loopid == lp->loopid && lp->portid == 1991 (u_int32_t) BITS2WORD(pdb.pdb_portid_bits) && 1992 nwwnn == lp->node_wwn && nwwpn == lp->port_wwn && 1993 lp->roles == nrole && lp->force_logout == 0) { 1994 lp->loggedin = lp->valid = 1; 1995 isp_prt(isp, ISP_LOGCONFIG, lretained, 1996 (int) (lp - fcp->portdb), 1997 (int) lp->loopid, lp->portid); 1998 continue; 1999 } 2000 } 2001 2002 if (fcp->isp_fwstate != FW_READY || 2003 fcp->isp_loopstate != LOOP_SYNCING_PDB) { 2004 return (-1); 2005 } 2006 2007 /* 2008 * Force a logout if we were logged in. 2009 */ 2010 if (lp->loggedin) { 2011 if (lp->force_logout || 2012 isp_getpdb(isp, lp->loopid, &pdb) == 0) { 2013 MEMZERO(&mbs, sizeof (mbs)); 2014 mbs.param[0] = MBOX_FABRIC_LOGOUT; 2015 if (IS_2KLOGIN(isp)) { 2016 mbs.param[1] = lp->loopid; 2017 mbs.obits |= (1 << 10); 2018 } else { 2019 mbs.param[1] = lp->loopid << 8; 2020 } 2021 mbs.param[2] = 0; 2022 mbs.param[3] = 0; 2023 isp_mboxcmd(isp, &mbs, MBLOGNONE); 2024 isp_prt(isp, ISP_LOGINFO, plogout, 2025 (int) (lp - fcp->portdb), lp->loopid, 2026 lp->portid); 2027 } 2028 lp->force_logout = lp->loggedin = 0; 2029 if (fcp->isp_fwstate != FW_READY || 2030 fcp->isp_loopstate != LOOP_SYNCING_PDB) { 2031 return (-1); 2032 } 2033 } 2034 2035 /* 2036 * And log in.... 2037 */ 2038 loopid = lp - fcp->portdb; 2039 lp->loopid = FL_PORT_ID; 2040 do { 2041 MEMZERO(&mbs, sizeof (mbs)); 2042 mbs.param[0] = MBOX_FABRIC_LOGIN; 2043 if (IS_2KLOGIN(isp)) { 2044 mbs.param[1] = loopid; 2045 mbs.obits |= (1 << 10); 2046 } else { 2047 mbs.param[1] = loopid << 8; 2048 } 2049 mbs.param[2] = portid >> 16; 2050 mbs.param[3] = portid & 0xffff; 2051 isp_mboxcmd(isp, &mbs, MBLOGALL & ~(MBOX_LOOP_ID_USED | 2052 MBOX_PORT_ID_USED | MBOX_COMMAND_ERROR)); 2053 if (fcp->isp_fwstate != FW_READY || 2054 fcp->isp_loopstate != LOOP_SYNCING_PDB) { 2055 return (-1); 2056 } 2057 switch (mbs.param[0]) { 2058 case MBOX_LOOP_ID_USED: 2059 /* 2060 * Try the next available loop id. 2061 */ 2062 loopid++; 2063 break; 2064 case MBOX_PORT_ID_USED: 2065 /* 2066 * This port is already logged in. 2067 * Snaffle the loop id it's using if it's 2068 * nonzero, otherwise we're hosed. 2069 */ 2070 if (mbs.param[1] != 0) { 2071 loopid = mbs.param[1]; 2072 if (loopid >= MAX_FC_TARG) { 2073 loopid = MAX_FC_TARG; 2074 break; 2075 } 2076 isp_prt(isp, ISP_LOGINFO, retained, 2077 loopid, (int) (lp - fcp->portdb), 2078 lp->portid); 2079 } else { 2080 loopid = MAX_FC_TARG; 2081 break; 2082 } 2083 /* FALLTHROUGH */ 2084 case MBOX_COMMAND_COMPLETE: 2085 lp->loggedin = 1; 2086 lp->loopid = loopid; 2087 break; 2088 case MBOX_COMMAND_ERROR: 2089 isp_prt(isp, ISP_LOGINFO, plogierr, 2090 portid, mbs.param[1]); 2091 /* FALLTHROUGH */ 2092 case MBOX_ALL_IDS_USED: /* We're outta IDs */ 2093 default: 2094 loopid = MAX_FC_TARG; 2095 break; 2096 } 2097 } while (lp->loopid == FL_PORT_ID && loopid < MAX_FC_TARG); 2098 2099 /* 2100 * If we get here and we haven't set a Loop ID, 2101 * we failed to log into this device. 2102 */ 2103 2104 if (lp->loopid == FL_PORT_ID) { 2105 lp->loopid = 0; 2106 continue; 2107 } 2108 2109 /* 2110 * Make sure we can get the approriate port information. 2111 */ 2112 if (isp_getpdb(isp, lp->loopid, &pdb) != 0) { 2113 isp_prt(isp, ISP_LOGWARN, nopdb, lp->portid); 2114 goto dump_em; 2115 } 2116 2117 if (fcp->isp_fwstate != FW_READY || 2118 fcp->isp_loopstate != LOOP_SYNCING_PDB) { 2119 return (-1); 2120 } 2121 2122 if (pdb.pdb_loopid != lp->loopid) { 2123 isp_prt(isp, ISP_LOGWARN, pdbmfail1, 2124 lp->portid, pdb.pdb_loopid); 2125 goto dump_em; 2126 } 2127 2128 if (lp->portid != (u_int32_t) BITS2WORD(pdb.pdb_portid_bits)) { 2129 isp_prt(isp, ISP_LOGWARN, pdbmfail2, 2130 lp->portid, BITS2WORD(pdb.pdb_portid_bits)); 2131 goto dump_em; 2132 } 2133 2134 lp->roles = 2135 (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT; 2136 lp->node_wwn = 2137 (((u_int64_t)pdb.pdb_nodename[0]) << 56) | 2138 (((u_int64_t)pdb.pdb_nodename[1]) << 48) | 2139 (((u_int64_t)pdb.pdb_nodename[2]) << 40) | 2140 (((u_int64_t)pdb.pdb_nodename[3]) << 32) | 2141 (((u_int64_t)pdb.pdb_nodename[4]) << 24) | 2142 (((u_int64_t)pdb.pdb_nodename[5]) << 16) | 2143 (((u_int64_t)pdb.pdb_nodename[6]) << 8) | 2144 (((u_int64_t)pdb.pdb_nodename[7])); 2145 lp->port_wwn = 2146 (((u_int64_t)pdb.pdb_portname[0]) << 56) | 2147 (((u_int64_t)pdb.pdb_portname[1]) << 48) | 2148 (((u_int64_t)pdb.pdb_portname[2]) << 40) | 2149 (((u_int64_t)pdb.pdb_portname[3]) << 32) | 2150 (((u_int64_t)pdb.pdb_portname[4]) << 24) | 2151 (((u_int64_t)pdb.pdb_portname[5]) << 16) | 2152 (((u_int64_t)pdb.pdb_portname[6]) << 8) | 2153 (((u_int64_t)pdb.pdb_portname[7])); 2154 /* 2155 * Check to make sure this all makes sense. 2156 */ 2157 if (lp->node_wwn && lp->port_wwn) { 2158 lp->valid = 1; 2159 loopid = lp - fcp->portdb; 2160 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid); 2161 continue; 2162 } 2163 dump_em: 2164 lp->valid = 0; 2165 isp_prt(isp, ISP_LOGINFO, 2166 ldumped, loopid, lp->loopid, lp->portid); 2167 MEMZERO(&mbs, sizeof (mbs)); 2168 mbs.param[0] = MBOX_FABRIC_LOGOUT; 2169 if (IS_2KLOGIN(isp)) { 2170 mbs.param[1] = lp->loopid; 2171 mbs.obits |= (1 << 10); 2172 } else { 2173 mbs.param[1] = lp->loopid << 8; 2174 } 2175 isp_mboxcmd(isp, &mbs, MBLOGNONE); 2176 if (fcp->isp_fwstate != FW_READY || 2177 fcp->isp_loopstate != LOOP_SYNCING_PDB) { 2178 return (-1); 2179 } 2180 } 2181 /* 2182 * If we get here, we've for sure seen not only a valid loop 2183 * but know what is or isn't on it, so mark this for usage 2184 * in isp_start. 2185 */ 2186 fcp->loop_seen_once = 1; 2187 fcp->isp_loopstate = LOOP_READY; 2188 return (0); 2189 } 2190 2191 static int 2192 isp_scan_loop(struct ispsoftc *isp) 2193 { 2194 struct lportdb *lp; 2195 fcparam *fcp = isp->isp_param; 2196 isp_pdb_t pdb; 2197 int loopid, lim, hival; 2198 2199 switch (fcp->isp_topo) { 2200 case TOPO_NL_PORT: 2201 hival = FL_PORT_ID; 2202 break; 2203 case TOPO_N_PORT: 2204 hival = 2; 2205 break; 2206 case TOPO_FL_PORT: 2207 hival = FC_PORT_ID; 2208 break; 2209 default: 2210 fcp->isp_loopstate = LOOP_LSCAN_DONE; 2211 return (0); 2212 } 2213 fcp->isp_loopstate = LOOP_SCANNING_LOOP; 2214 2215 /* 2216 * make sure the temp port database is clean... 2217 */ 2218 MEMZERO((void *)fcp->tport, sizeof (fcp->tport)); 2219 2220 /* 2221 * Run through the local loop ports and get port database info 2222 * for each loop ID. 2223 * 2224 * There's a somewhat unexplained situation where the f/w passes back 2225 * the wrong database entity- if that happens, just restart (up to 2226 * FL_PORT_ID times). 2227 */ 2228 for (lim = loopid = 0; loopid < hival; loopid++) { 2229 lp = &fcp->tport[loopid]; 2230 2231 /* 2232 * Don't even try for ourselves... 2233 */ 2234 if (loopid == fcp->isp_loopid) 2235 continue; 2236 2237 lp->node_wwn = isp_get_portname(isp, loopid, 1); 2238 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) 2239 return (-1); 2240 if (lp->node_wwn == 0) 2241 continue; 2242 lp->port_wwn = isp_get_portname(isp, loopid, 0); 2243 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) 2244 return (-1); 2245 if (lp->port_wwn == 0) { 2246 lp->node_wwn = 0; 2247 continue; 2248 } 2249 2250 /* 2251 * Get an entry.... 2252 */ 2253 if (isp_getpdb(isp, loopid, &pdb) != 0) { 2254 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) 2255 return (-1); 2256 continue; 2257 } 2258 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) { 2259 return (-1); 2260 } 2261 2262 /* 2263 * If the returned database element doesn't match what we 2264 * asked for, restart the process entirely (up to a point...). 2265 */ 2266 if (pdb.pdb_loopid != loopid) { 2267 loopid = 0; 2268 if (lim++ < hival) { 2269 continue; 2270 } 2271 isp_prt(isp, ISP_LOGWARN, 2272 "giving up on synchronizing the port database"); 2273 return (-1); 2274 } 2275 2276 /* 2277 * Save the pertinent info locally. 2278 */ 2279 lp->node_wwn = 2280 (((u_int64_t)pdb.pdb_nodename[0]) << 56) | 2281 (((u_int64_t)pdb.pdb_nodename[1]) << 48) | 2282 (((u_int64_t)pdb.pdb_nodename[2]) << 40) | 2283 (((u_int64_t)pdb.pdb_nodename[3]) << 32) | 2284 (((u_int64_t)pdb.pdb_nodename[4]) << 24) | 2285 (((u_int64_t)pdb.pdb_nodename[5]) << 16) | 2286 (((u_int64_t)pdb.pdb_nodename[6]) << 8) | 2287 (((u_int64_t)pdb.pdb_nodename[7])); 2288 lp->port_wwn = 2289 (((u_int64_t)pdb.pdb_portname[0]) << 56) | 2290 (((u_int64_t)pdb.pdb_portname[1]) << 48) | 2291 (((u_int64_t)pdb.pdb_portname[2]) << 40) | 2292 (((u_int64_t)pdb.pdb_portname[3]) << 32) | 2293 (((u_int64_t)pdb.pdb_portname[4]) << 24) | 2294 (((u_int64_t)pdb.pdb_portname[5]) << 16) | 2295 (((u_int64_t)pdb.pdb_portname[6]) << 8) | 2296 (((u_int64_t)pdb.pdb_portname[7])); 2297 lp->roles = 2298 (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT; 2299 lp->portid = BITS2WORD(pdb.pdb_portid_bits); 2300 lp->loopid = pdb.pdb_loopid; 2301 } 2302 2303 /* 2304 * Mark all of the permanent local loop database entries as invalid 2305 * (except our own entry). 2306 */ 2307 for (loopid = 0; loopid < hival; loopid++) { 2308 if (loopid == fcp->isp_iid) { 2309 fcp->portdb[loopid].valid = 1; 2310 fcp->portdb[loopid].loopid = fcp->isp_loopid; 2311 continue; 2312 } 2313 fcp->portdb[loopid].valid = 0; 2314 } 2315 2316 /* 2317 * Now merge our local copy of the port database into our saved copy. 2318 * Notify the outer layers of new devices arriving. 2319 */ 2320 for (loopid = 0; loopid < hival; loopid++) { 2321 int i; 2322 2323 /* 2324 * If we don't have a non-zero Port WWN, we're not here. 2325 */ 2326 if (fcp->tport[loopid].port_wwn == 0) { 2327 continue; 2328 } 2329 2330 /* 2331 * Skip ourselves. 2332 */ 2333 if (loopid == fcp->isp_iid) { 2334 continue; 2335 } 2336 2337 /* 2338 * For the purposes of deciding whether this is the 2339 * 'same' device or not, we only search for an identical 2340 * Port WWN. Node WWNs may or may not be the same as 2341 * the Port WWN, and there may be multiple different 2342 * Port WWNs with the same Node WWN. It would be chaos 2343 * to have multiple identical Port WWNs, so we don't 2344 * allow that. 2345 */ 2346 2347 for (i = 0; i < hival; i++) { 2348 int j; 2349 if (fcp->portdb[i].port_wwn == 0) 2350 continue; 2351 if (fcp->portdb[i].port_wwn != 2352 fcp->tport[loopid].port_wwn) 2353 continue; 2354 /* 2355 * We found this WWN elsewhere- it's changed 2356 * loopids then. We don't change it's actual 2357 * position in our cached port database- we 2358 * just change the actual loop ID we'd use. 2359 */ 2360 if (fcp->portdb[i].loopid != loopid) { 2361 isp_prt(isp, ISP_LOGINFO, portshift, i, 2362 fcp->portdb[i].loopid, 2363 fcp->portdb[i].portid, loopid, 2364 fcp->tport[loopid].portid); 2365 } 2366 fcp->portdb[i].portid = fcp->tport[loopid].portid; 2367 fcp->portdb[i].loopid = loopid; 2368 fcp->portdb[i].valid = 1; 2369 fcp->portdb[i].roles = fcp->tport[loopid].roles; 2370 2371 /* 2372 * Now make sure this Port WWN doesn't exist elsewhere 2373 * in the port database. 2374 */ 2375 for (j = i+1; j < hival; j++) { 2376 if (fcp->portdb[i].port_wwn != 2377 fcp->portdb[j].port_wwn) { 2378 continue; 2379 } 2380 isp_prt(isp, ISP_LOGWARN, portdup, j, i); 2381 /* 2382 * Invalidate the 'old' *and* 'new' ones. 2383 * This is really harsh and not quite right, 2384 * but if this happens, we really don't know 2385 * who is what at this point. 2386 */ 2387 fcp->portdb[i].valid = 0; 2388 fcp->portdb[j].valid = 0; 2389 } 2390 break; 2391 } 2392 2393 /* 2394 * If we didn't traverse the entire port database, 2395 * then we found (and remapped) an existing entry. 2396 * No need to notify anyone- go for the next one. 2397 */ 2398 if (i < hival) { 2399 isp_prt(isp, ISP_LOGINFO, retained, 2400 fcp->portdb[i].loopid, i, fcp->portdb[i].portid); 2401 continue; 2402 } 2403 2404 /* 2405 * We've not found this Port WWN anywhere. It's a new entry. 2406 * See if we can leave it where it is (with target == loopid). 2407 */ 2408 if (fcp->portdb[loopid].port_wwn != 0) { 2409 for (lim = 0; lim < hival; lim++) { 2410 if (fcp->portdb[lim].port_wwn == 0) 2411 break; 2412 } 2413 /* "Cannot Happen" */ 2414 if (lim == hival) { 2415 isp_prt(isp, ISP_LOGWARN, "Remap Overflow"); 2416 continue; 2417 } 2418 i = lim; 2419 } else { 2420 i = loopid; 2421 } 2422 2423 /* 2424 * NB: The actual loopid we use here is loopid- we may 2425 * in fact be at a completely different index (target). 2426 */ 2427 fcp->portdb[i].loopid = loopid; 2428 fcp->portdb[i].port_wwn = fcp->tport[loopid].port_wwn; 2429 fcp->portdb[i].node_wwn = fcp->tport[loopid].node_wwn; 2430 fcp->portdb[i].roles = fcp->tport[loopid].roles; 2431 fcp->portdb[i].portid = fcp->tport[loopid].portid; 2432 fcp->portdb[i].valid = 1; 2433 2434 /* 2435 * Tell the outside world we've arrived. 2436 */ 2437 (void) isp_async(isp, ISPASYNC_PROMENADE, &i); 2438 } 2439 2440 /* 2441 * Now find all previously used targets that are now invalid and 2442 * notify the outer layers that they're gone. 2443 */ 2444 for (lp = &fcp->portdb[0]; lp < &fcp->portdb[hival]; lp++) { 2445 if (lp->valid || lp->port_wwn == 0) { 2446 continue; 2447 } 2448 2449 /* 2450 * Tell the outside world we've gone 2451 * away and erase our pdb entry. 2452 * 2453 */ 2454 loopid = lp - fcp->portdb; 2455 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid); 2456 MEMZERO((void *) lp, sizeof (*lp)); 2457 } 2458 fcp->isp_loopstate = LOOP_LSCAN_DONE; 2459 return (0); 2460 } 2461 2462 2463 static int 2464 isp_fabric_mbox_cmd(struct ispsoftc *isp, mbreg_t *mbp) 2465 { 2466 isp_mboxcmd(isp, mbp, MBLOGNONE); 2467 if (mbp->param[0] != MBOX_COMMAND_COMPLETE) { 2468 if (FCPARAM(isp)->isp_loopstate == LOOP_SCANNING_FABRIC) { 2469 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD; 2470 } 2471 if (mbp->param[0] == MBOX_COMMAND_ERROR) { 2472 char tbuf[16]; 2473 char *m; 2474 switch (mbp->param[1]) { 2475 case 1: 2476 m = "No Loop"; 2477 break; 2478 case 2: 2479 m = "Failed to allocate IOCB buffer"; 2480 break; 2481 case 3: 2482 m = "Failed to allocate XCB buffer"; 2483 break; 2484 case 4: 2485 m = "timeout or transmit failed"; 2486 break; 2487 case 5: 2488 m = "no fabric loop"; 2489 break; 2490 case 6: 2491 m = "remote device not a target"; 2492 break; 2493 default: 2494 SNPRINTF(tbuf, sizeof tbuf, "%x", 2495 mbp->param[1]); 2496 m = tbuf; 2497 break; 2498 } 2499 isp_prt(isp, ISP_LOGERR, "SNS Failed- %s", m); 2500 } 2501 return (-1); 2502 } 2503 2504 if (FCPARAM(isp)->isp_fwstate != FW_READY || 2505 FCPARAM(isp)->isp_loopstate < LOOP_SCANNING_FABRIC) { 2506 return (-1); 2507 } 2508 return(0); 2509 } 2510 2511 #ifdef ISP_USE_GA_NXT 2512 static int 2513 isp_scan_fabric(struct ispsoftc *isp, int ftype) 2514 { 2515 fcparam *fcp = isp->isp_param; 2516 u_int32_t portid, first_portid, last_portid; 2517 int hicap, last_port_same; 2518 2519 if (fcp->isp_onfabric == 0) { 2520 fcp->isp_loopstate = LOOP_FSCAN_DONE; 2521 return (0); 2522 } 2523 2524 FC_SCRATCH_ACQUIRE(isp); 2525 2526 /* 2527 * Since Port IDs are 24 bits, we can check against having seen 2528 * anything yet with this value. 2529 */ 2530 last_port_same = 0; 2531 last_portid = 0xffffffff; /* not a port */ 2532 first_portid = portid = fcp->isp_portid; 2533 fcp->isp_loopstate = LOOP_SCANNING_FABRIC; 2534 2535 for (hicap = 0; hicap < GA_NXT_MAX; hicap++) { 2536 mbreg_t mbs; 2537 sns_screq_t *rq; 2538 sns_ga_nxt_rsp_t *rs0, *rs1; 2539 struct lportdb lcl; 2540 u_int8_t sc[SNS_GA_NXT_RESP_SIZE]; 2541 2542 rq = (sns_screq_t *)sc; 2543 MEMZERO((void *) rq, SNS_GA_NXT_REQ_SIZE); 2544 rq->snscb_rblen = SNS_GA_NXT_RESP_SIZE >> 1; 2545 rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+0x100); 2546 rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+0x100); 2547 rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+0x100); 2548 rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+0x100); 2549 rq->snscb_sblen = 6; 2550 rq->snscb_data[0] = SNS_GA_NXT; 2551 rq->snscb_data[4] = portid & 0xffff; 2552 rq->snscb_data[5] = (portid >> 16) & 0xff; 2553 isp_put_sns_request(isp, rq, (sns_screq_t *) fcp->isp_scratch); 2554 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GA_NXT_REQ_SIZE); 2555 MEMZERO(&mbs, sizeof (mbs)); 2556 mbs.param[0] = MBOX_SEND_SNS; 2557 mbs.param[1] = SNS_GA_NXT_REQ_SIZE >> 1; 2558 mbs.param[2] = DMA_WD1(fcp->isp_scdma); 2559 mbs.param[3] = DMA_WD0(fcp->isp_scdma); 2560 /* 2561 * Leave 4 and 5 alone 2562 */ 2563 mbs.param[6] = DMA_WD3(fcp->isp_scdma); 2564 mbs.param[7] = DMA_WD2(fcp->isp_scdma); 2565 if (isp_fabric_mbox_cmd(isp, &mbs)) { 2566 if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) { 2567 fcp->isp_loopstate = LOOP_PDB_RCVD; 2568 } 2569 FC_SCRATCH_RELEASE(isp); 2570 return (-1); 2571 } 2572 MEMORYBARRIER(isp, SYNC_SFORCPU, 0x100, SNS_GA_NXT_RESP_SIZE); 2573 rs1 = (sns_ga_nxt_rsp_t *) sc; 2574 rs0 = (sns_ga_nxt_rsp_t *) ((u_int8_t *)fcp->isp_scratch+0x100); 2575 isp_get_ga_nxt_response(isp, rs0, rs1); 2576 if (rs1->snscb_cthdr.ct_response != FS_ACC) { 2577 int level; 2578 if (rs1->snscb_cthdr.ct_reason == 9 && 2579 rs1->snscb_cthdr.ct_explanation == 7) 2580 level = ISP_LOGDEBUG0; 2581 else 2582 level = ISP_LOGWARN; 2583 isp_prt(isp, level, swrej, "GA_NXT", 2584 rs1->snscb_cthdr.ct_reason, 2585 rs1->snscb_cthdr.ct_explanation, portid); 2586 FC_SCRATCH_RELEASE(isp); 2587 fcp->isp_loopstate = LOOP_FSCAN_DONE; 2588 return (0); 2589 } 2590 portid = 2591 (((u_int32_t) rs1->snscb_port_id[0]) << 16) | 2592 (((u_int32_t) rs1->snscb_port_id[1]) << 8) | 2593 (((u_int32_t) rs1->snscb_port_id[2])); 2594 2595 /* 2596 * XXX: We should check to make sure that this entry 2597 * XXX: supports the type(s) we are interested in. 2598 */ 2599 /* 2600 * Okay, we now have information about a fabric object. 2601 * If it is the type we're interested in, tell the outer layers 2602 * about it. The outer layer needs to know: Port ID, WWNN, 2603 * WWPN, FC4 type, and port type. 2604 * 2605 * The lportdb structure is adequate for this. 2606 */ 2607 MEMZERO(&lcl, sizeof (lcl)); 2608 lcl.port_type = rs1->snscb_port_type; 2609 lcl.fc4_type = ftype; 2610 lcl.portid = portid; 2611 lcl.node_wwn = 2612 (((u_int64_t)rs1->snscb_nodename[0]) << 56) | 2613 (((u_int64_t)rs1->snscb_nodename[1]) << 48) | 2614 (((u_int64_t)rs1->snscb_nodename[2]) << 40) | 2615 (((u_int64_t)rs1->snscb_nodename[3]) << 32) | 2616 (((u_int64_t)rs1->snscb_nodename[4]) << 24) | 2617 (((u_int64_t)rs1->snscb_nodename[5]) << 16) | 2618 (((u_int64_t)rs1->snscb_nodename[6]) << 8) | 2619 (((u_int64_t)rs1->snscb_nodename[7])); 2620 lcl.port_wwn = 2621 (((u_int64_t)rs1->snscb_portname[0]) << 56) | 2622 (((u_int64_t)rs1->snscb_portname[1]) << 48) | 2623 (((u_int64_t)rs1->snscb_portname[2]) << 40) | 2624 (((u_int64_t)rs1->snscb_portname[3]) << 32) | 2625 (((u_int64_t)rs1->snscb_portname[4]) << 24) | 2626 (((u_int64_t)rs1->snscb_portname[5]) << 16) | 2627 (((u_int64_t)rs1->snscb_portname[6]) << 8) | 2628 (((u_int64_t)rs1->snscb_portname[7])); 2629 2630 /* 2631 * Does this fabric object support the type we want? 2632 * If not, skip it. 2633 */ 2634 if (rs1->snscb_fc4_types[ftype >> 5] & (1 << (ftype & 0x1f))) { 2635 if (first_portid == portid) { 2636 lcl.last_fabric_dev = 1; 2637 } else { 2638 lcl.last_fabric_dev = 0; 2639 } 2640 (void) isp_async(isp, ISPASYNC_FABRIC_DEV, &lcl); 2641 } else { 2642 isp_prt(isp, ISP_LOGDEBUG0, 2643 "PortID 0x%x doesn't support FC4 type 0x%x", 2644 portid, ftype); 2645 } 2646 if (first_portid == portid) { 2647 fcp->isp_loopstate = LOOP_FSCAN_DONE; 2648 FC_SCRATCH_RELEASE(isp); 2649 return (0); 2650 } 2651 if (portid == last_portid) { 2652 if (last_port_same++ > 20) { 2653 isp_prt(isp, ISP_LOGWARN, 2654 "tangled fabric database detected"); 2655 break; 2656 } 2657 } else { 2658 last_port_same = 0 ; 2659 last_portid = portid; 2660 } 2661 } 2662 FC_SCRATCH_RELEASE(isp); 2663 if (hicap >= GA_NXT_MAX) { 2664 isp_prt(isp, ISP_LOGWARN, "fabric too big (> %d)", GA_NXT_MAX); 2665 } 2666 fcp->isp_loopstate = LOOP_FSCAN_DONE; 2667 return (0); 2668 } 2669 #else 2670 #define GIDLEN ((ISP2100_SCRLEN >> 1) + 16) 2671 #define NGENT ((GIDLEN - 16) >> 2) 2672 2673 #define IGPOFF (ISP2100_SCRLEN - GIDLEN) 2674 #define GXOFF (256) 2675 2676 static int 2677 isp_scan_fabric(struct ispsoftc *isp, int ftype) 2678 { 2679 fcparam *fcp = FCPARAM(isp); 2680 mbreg_t mbs; 2681 int i; 2682 sns_gid_ft_req_t *rq; 2683 sns_gid_ft_rsp_t *rs0, *rs1; 2684 2685 if (fcp->isp_onfabric == 0) { 2686 fcp->isp_loopstate = LOOP_FSCAN_DONE; 2687 return (0); 2688 } 2689 2690 FC_SCRATCH_ACQUIRE(isp); 2691 fcp->isp_loopstate = LOOP_SCANNING_FABRIC; 2692 2693 rq = (sns_gid_ft_req_t *)fcp->tport; 2694 MEMZERO((void *) rq, SNS_GID_FT_REQ_SIZE); 2695 rq->snscb_rblen = GIDLEN >> 1; 2696 rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+IGPOFF); 2697 rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+IGPOFF); 2698 rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+IGPOFF); 2699 rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+IGPOFF); 2700 rq->snscb_sblen = 6; 2701 rq->snscb_cmd = SNS_GID_FT; 2702 rq->snscb_mword_div_2 = NGENT; 2703 rq->snscb_fc4_type = ftype; 2704 isp_put_gid_ft_request(isp, rq, (sns_gid_ft_req_t *) fcp->isp_scratch); 2705 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GID_FT_REQ_SIZE); 2706 MEMZERO(&mbs, sizeof (mbs)); 2707 mbs.param[0] = MBOX_SEND_SNS; 2708 mbs.param[1] = SNS_GID_FT_REQ_SIZE >> 1; 2709 mbs.param[2] = DMA_WD1(fcp->isp_scdma); 2710 mbs.param[3] = DMA_WD0(fcp->isp_scdma); 2711 2712 /* 2713 * Leave 4 and 5 alone 2714 */ 2715 mbs.param[6] = DMA_WD3(fcp->isp_scdma); 2716 mbs.param[7] = DMA_WD2(fcp->isp_scdma); 2717 if (isp_fabric_mbox_cmd(isp, &mbs)) { 2718 if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) { 2719 fcp->isp_loopstate = LOOP_PDB_RCVD; 2720 } 2721 FC_SCRATCH_RELEASE(isp); 2722 return (-1); 2723 } 2724 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) { 2725 FC_SCRATCH_RELEASE(isp); 2726 return (-1); 2727 } 2728 MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN); 2729 rs1 = (sns_gid_ft_rsp_t *) fcp->tport; 2730 rs0 = (sns_gid_ft_rsp_t *) ((u_int8_t *)fcp->isp_scratch+IGPOFF); 2731 isp_get_gid_ft_response(isp, rs0, rs1, NGENT); 2732 if (rs1->snscb_cthdr.ct_response != FS_ACC) { 2733 int level; 2734 if (rs1->snscb_cthdr.ct_reason == 9 && 2735 rs1->snscb_cthdr.ct_explanation == 7) 2736 level = ISP_LOGDEBUG0; 2737 else 2738 level = ISP_LOGWARN; 2739 isp_prt(isp, level, swrej, "GID_FT", 2740 rs1->snscb_cthdr.ct_reason, 2741 rs1->snscb_cthdr.ct_explanation, 0); 2742 FC_SCRATCH_RELEASE(isp); 2743 fcp->isp_loopstate = LOOP_FSCAN_DONE; 2744 return (0); 2745 } 2746 2747 /* 2748 * Okay, we now have a list of Port IDs for this class of device. 2749 * Go through the list and for each one get the WWPN/WWNN for it 2750 * and tell the outer layers about it. The outer layer needs to 2751 * know: Port ID, WWNN, WWPN, FC4 type, and (possibly) port type. 2752 * 2753 * The lportdb structure is adequate for this. 2754 */ 2755 i = -1; 2756 do { 2757 sns_gxn_id_req_t grqbuf, *gq = &grqbuf; 2758 sns_gxn_id_rsp_t *gs0, grsbuf, *gs1 = &grsbuf; 2759 struct lportdb lcl; 2760 #if 0 2761 sns_gff_id_rsp_t *fs0, ffsbuf, *fs1 = &ffsbuf; 2762 #endif 2763 2764 i++; 2765 MEMZERO(&lcl, sizeof (lcl)); 2766 lcl.fc4_type = ftype; 2767 lcl.portid = 2768 (((u_int32_t) rs1->snscb_ports[i].portid[0]) << 16) | 2769 (((u_int32_t) rs1->snscb_ports[i].portid[1]) << 8) | 2770 (((u_int32_t) rs1->snscb_ports[i].portid[2])); 2771 2772 MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t)); 2773 gq->snscb_rblen = SNS_GXN_ID_RESP_SIZE >> 1; 2774 gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF); 2775 gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF); 2776 gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF); 2777 gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF); 2778 gq->snscb_sblen = 6; 2779 gq->snscb_cmd = SNS_GPN_ID; 2780 gq->snscb_portid = lcl.portid; 2781 isp_put_gxn_id_request(isp, gq, 2782 (sns_gxn_id_req_t *) fcp->isp_scratch); 2783 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE); 2784 MEMZERO(&mbs, sizeof (mbs)); 2785 mbs.param[0] = MBOX_SEND_SNS; 2786 mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1; 2787 mbs.param[2] = DMA_WD1(fcp->isp_scdma); 2788 mbs.param[3] = DMA_WD0(fcp->isp_scdma); 2789 /* 2790 * Leave 4 and 5 alone 2791 */ 2792 mbs.param[6] = DMA_WD3(fcp->isp_scdma); 2793 mbs.param[7] = DMA_WD2(fcp->isp_scdma); 2794 if (isp_fabric_mbox_cmd(isp, &mbs)) { 2795 if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) { 2796 fcp->isp_loopstate = LOOP_PDB_RCVD; 2797 } 2798 FC_SCRATCH_RELEASE(isp); 2799 return (-1); 2800 } 2801 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) { 2802 FC_SCRATCH_RELEASE(isp); 2803 return (-1); 2804 } 2805 MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GXN_ID_RESP_SIZE); 2806 gs0 = (sns_gxn_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF); 2807 isp_get_gxn_id_response(isp, gs0, gs1); 2808 if (gs1->snscb_cthdr.ct_response != FS_ACC) { 2809 isp_prt(isp, ISP_LOGWARN, swrej, "GPN_ID", 2810 gs1->snscb_cthdr.ct_reason, 2811 gs1->snscb_cthdr.ct_explanation, lcl.portid); 2812 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) { 2813 FC_SCRATCH_RELEASE(isp); 2814 return (-1); 2815 } 2816 continue; 2817 } 2818 lcl.port_wwn = 2819 (((u_int64_t)gs1->snscb_wwn[0]) << 56) | 2820 (((u_int64_t)gs1->snscb_wwn[1]) << 48) | 2821 (((u_int64_t)gs1->snscb_wwn[2]) << 40) | 2822 (((u_int64_t)gs1->snscb_wwn[3]) << 32) | 2823 (((u_int64_t)gs1->snscb_wwn[4]) << 24) | 2824 (((u_int64_t)gs1->snscb_wwn[5]) << 16) | 2825 (((u_int64_t)gs1->snscb_wwn[6]) << 8) | 2826 (((u_int64_t)gs1->snscb_wwn[7])); 2827 2828 MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t)); 2829 gq->snscb_rblen = SNS_GXN_ID_RESP_SIZE >> 1; 2830 gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF); 2831 gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF); 2832 gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF); 2833 gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF); 2834 gq->snscb_sblen = 6; 2835 gq->snscb_cmd = SNS_GNN_ID; 2836 gq->snscb_portid = lcl.portid; 2837 isp_put_gxn_id_request(isp, gq, 2838 (sns_gxn_id_req_t *) fcp->isp_scratch); 2839 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE); 2840 MEMZERO(&mbs, sizeof (mbs)); 2841 mbs.param[0] = MBOX_SEND_SNS; 2842 mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1; 2843 mbs.param[2] = DMA_WD1(fcp->isp_scdma); 2844 mbs.param[3] = DMA_WD0(fcp->isp_scdma); 2845 /* 2846 * Leave 4 and 5 alone 2847 */ 2848 mbs.param[6] = DMA_WD3(fcp->isp_scdma); 2849 mbs.param[7] = DMA_WD2(fcp->isp_scdma); 2850 if (isp_fabric_mbox_cmd(isp, &mbs)) { 2851 if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) { 2852 fcp->isp_loopstate = LOOP_PDB_RCVD; 2853 } 2854 FC_SCRATCH_RELEASE(isp); 2855 return (-1); 2856 } 2857 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) { 2858 FC_SCRATCH_RELEASE(isp); 2859 return (-1); 2860 } 2861 MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GXN_ID_RESP_SIZE); 2862 gs0 = (sns_gxn_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF); 2863 isp_get_gxn_id_response(isp, gs0, gs1); 2864 if (gs1->snscb_cthdr.ct_response != FS_ACC) { 2865 isp_prt(isp, ISP_LOGWARN, swrej, "GNN_ID", 2866 gs1->snscb_cthdr.ct_reason, 2867 gs1->snscb_cthdr.ct_explanation, lcl.portid); 2868 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) { 2869 FC_SCRATCH_RELEASE(isp); 2870 return (-1); 2871 } 2872 continue; 2873 } 2874 lcl.node_wwn = 2875 (((u_int64_t)gs1->snscb_wwn[0]) << 56) | 2876 (((u_int64_t)gs1->snscb_wwn[1]) << 48) | 2877 (((u_int64_t)gs1->snscb_wwn[2]) << 40) | 2878 (((u_int64_t)gs1->snscb_wwn[3]) << 32) | 2879 (((u_int64_t)gs1->snscb_wwn[4]) << 24) | 2880 (((u_int64_t)gs1->snscb_wwn[5]) << 16) | 2881 (((u_int64_t)gs1->snscb_wwn[6]) << 8) | 2882 (((u_int64_t)gs1->snscb_wwn[7])); 2883 2884 /* 2885 * The QLogic f/w is bouncing this with a parameter error. 2886 */ 2887 #if 0 2888 /* 2889 * Try and get FC4 Features (FC-GS-3 only). 2890 * We can use the sns_gxn_id_req_t for this request. 2891 */ 2892 MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t)); 2893 gq->snscb_rblen = SNS_GFF_ID_RESP_SIZE >> 1; 2894 gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF); 2895 gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF); 2896 gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF); 2897 gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF); 2898 gq->snscb_sblen = 6; 2899 gq->snscb_cmd = SNS_GFF_ID; 2900 gq->snscb_portid = lcl.portid; 2901 isp_put_gxn_id_request(isp, gq, 2902 (sns_gxn_id_req_t *) fcp->isp_scratch); 2903 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE); 2904 MEMZERO(&mbs, sizeof (mbs)); 2905 mbs.param[0] = MBOX_SEND_SNS; 2906 mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1; 2907 mbs.param[2] = DMA_WD1(fcp->isp_scdma); 2908 mbs.param[3] = DMA_WD0(fcp->isp_scdma); 2909 /* 2910 * Leave 4 and 5 alone 2911 */ 2912 mbs.param[6] = DMA_WD3(fcp->isp_scdma); 2913 mbs.param[7] = DMA_WD2(fcp->isp_scdma); 2914 if (isp_fabric_mbox_cmd(isp, &mbs)) { 2915 if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) { 2916 fcp->isp_loopstate = LOOP_PDB_RCVD; 2917 } 2918 FC_SCRATCH_RELEASE(isp); 2919 return (-1); 2920 } 2921 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) { 2922 FC_SCRATCH_RELEASE(isp); 2923 return (-1); 2924 } 2925 MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GFF_ID_RESP_SIZE); 2926 fs0 = (sns_gff_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF); 2927 isp_get_gff_id_response(isp, fs0, fs1); 2928 if (fs1->snscb_cthdr.ct_response != FS_ACC) { 2929 isp_prt(isp, /* ISP_LOGDEBUG0 */ ISP_LOGWARN, 2930 swrej, "GFF_ID", 2931 fs1->snscb_cthdr.ct_reason, 2932 fs1->snscb_cthdr.ct_explanation, lcl.portid); 2933 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) { 2934 FC_SCRATCH_RELEASE(isp); 2935 return (-1); 2936 } 2937 } else { 2938 int index = (ftype >> 3); 2939 int bshft = (ftype & 0x7) * 4; 2940 int fc4_fval = 2941 (fs1->snscb_fc4_features[index] >> bshft) & 0xf; 2942 if (fc4_fval & 0x1) { 2943 lcl.roles |= 2944 (SVC3_INI_ROLE >> SVC3_ROLE_SHIFT); 2945 } 2946 if (fc4_fval & 0x2) { 2947 lcl.roles |= 2948 (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT); 2949 } 2950 } 2951 #endif 2952 2953 /* 2954 * If we really want to know what kind of port type this is, 2955 * we have to run another CT command. Otherwise, we'll leave 2956 * it as undefined. 2957 * 2958 lcl.port_type = 0; 2959 */ 2960 if (rs1->snscb_ports[i].control & 0x80) { 2961 lcl.last_fabric_dev = 1; 2962 } else { 2963 lcl.last_fabric_dev = 0; 2964 } 2965 (void) isp_async(isp, ISPASYNC_FABRIC_DEV, &lcl); 2966 2967 } while ((rs1->snscb_ports[i].control & 0x80) == 0 && i < NGENT-1); 2968 2969 /* 2970 * If we're not at the last entry, our list isn't big enough. 2971 */ 2972 if ((rs1->snscb_ports[i].control & 0x80) == 0) { 2973 isp_prt(isp, ISP_LOGWARN, "fabric too big for scratch area"); 2974 } 2975 2976 FC_SCRATCH_RELEASE(isp); 2977 fcp->isp_loopstate = LOOP_FSCAN_DONE; 2978 return (0); 2979 } 2980 #endif 2981 2982 static void 2983 isp_register_fc4_type(struct ispsoftc *isp) 2984 { 2985 fcparam *fcp = isp->isp_param; 2986 u_int8_t local[SNS_RFT_ID_REQ_SIZE]; 2987 sns_screq_t *reqp = (sns_screq_t *) local; 2988 mbreg_t mbs; 2989 2990 MEMZERO((void *) reqp, SNS_RFT_ID_REQ_SIZE); 2991 reqp->snscb_rblen = SNS_RFT_ID_RESP_SIZE >> 1; 2992 reqp->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma + 0x100); 2993 reqp->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma + 0x100); 2994 reqp->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma + 0x100); 2995 reqp->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma + 0x100); 2996 reqp->snscb_sblen = 22; 2997 reqp->snscb_data[0] = SNS_RFT_ID; 2998 reqp->snscb_data[4] = fcp->isp_portid & 0xffff; 2999 reqp->snscb_data[5] = (fcp->isp_portid >> 16) & 0xff; 3000 reqp->snscb_data[6] = (1 << FC4_SCSI); 3001 #if 0 3002 reqp->snscb_data[6] |= (1 << FC4_IP); /* ISO/IEC 8802-2 LLC/SNAP */ 3003 #endif 3004 FC_SCRATCH_ACQUIRE(isp); 3005 isp_put_sns_request(isp, reqp, (sns_screq_t *) fcp->isp_scratch); 3006 MEMZERO(&mbs, sizeof (mbs)); 3007 mbs.param[0] = MBOX_SEND_SNS; 3008 mbs.param[1] = SNS_RFT_ID_REQ_SIZE >> 1; 3009 mbs.param[2] = DMA_WD1(fcp->isp_scdma); 3010 mbs.param[3] = DMA_WD0(fcp->isp_scdma); 3011 /* 3012 * Leave 4 and 5 alone 3013 */ 3014 mbs.param[6] = DMA_WD3(fcp->isp_scdma); 3015 mbs.param[7] = DMA_WD2(fcp->isp_scdma); 3016 isp_mboxcmd(isp, &mbs, MBLOGALL); 3017 FC_SCRATCH_RELEASE(isp); 3018 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 3019 isp_prt(isp, ISP_LOGDEBUG0, "Register FC4 types succeeded"); 3020 } 3021 } 3022 3023 /* 3024 * Start a command. Locking is assumed done in the caller. 3025 */ 3026 3027 int 3028 isp_start(XS_T *xs) 3029 { 3030 struct ispsoftc *isp; 3031 u_int16_t nxti, optr, handle; 3032 u_int8_t local[QENTRY_LEN]; 3033 ispreq_t *reqp, *qep; 3034 int target, i; 3035 3036 XS_INITERR(xs); 3037 isp = XS_ISP(xs); 3038 3039 /* 3040 * Check to make sure we're supporting initiator role. 3041 */ 3042 if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) { 3043 XS_SETERR(xs, HBA_SELTIMEOUT); 3044 return (CMD_COMPLETE); 3045 } 3046 3047 /* 3048 * Now make sure we're running. 3049 */ 3050 3051 if (isp->isp_state != ISP_RUNSTATE) { 3052 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE"); 3053 XS_SETERR(xs, HBA_BOTCH); 3054 return (CMD_COMPLETE); 3055 } 3056 3057 /* 3058 * Check command CDB length, etc.. We really are limited to 16 bytes 3059 * for Fibre Channel, but can do up to 44 bytes in parallel SCSI, 3060 * but probably only if we're running fairly new firmware (we'll 3061 * let the old f/w choke on an extended command queue entry). 3062 */ 3063 3064 if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) { 3065 isp_prt(isp, ISP_LOGERR, 3066 "unsupported cdb length (%d, CDB[0]=0x%x)", 3067 XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff); 3068 XS_SETERR(xs, HBA_BOTCH); 3069 return (CMD_COMPLETE); 3070 } 3071 3072 /* 3073 * Check to see whether we have good firmware state still or 3074 * need to refresh our port database for this target. 3075 */ 3076 target = XS_TGT(xs); 3077 if (IS_FC(isp)) { 3078 fcparam *fcp = isp->isp_param; 3079 struct lportdb *lp; 3080 #ifdef HANDLE_LOOPSTATE_IN_OUTER_LAYERS 3081 if (fcp->isp_fwstate != FW_READY || 3082 fcp->isp_loopstate != LOOP_READY) { 3083 return (CMD_RQLATER); 3084 } 3085 3086 /* 3087 * If we're not on a Fabric, we can't have a target 3088 * above FL_PORT_ID-1. 3089 * 3090 * If we're on a fabric and *not* connected as an F-port, 3091 * we can't have a target less than FC_SNS_ID+1. This 3092 * keeps us from having to sort out the difference between 3093 * local public loop devices and those which we might get 3094 * from a switch's database. 3095 */ 3096 if (fcp->isp_onfabric == 0) { 3097 if (target >= FL_PORT_ID) { 3098 XS_SETERR(xs, HBA_SELTIMEOUT); 3099 return (CMD_COMPLETE); 3100 } 3101 } else { 3102 if (target >= FL_PORT_ID && target <= FC_SNS_ID) { 3103 XS_SETERR(xs, HBA_SELTIMEOUT); 3104 return (CMD_COMPLETE); 3105 } 3106 /* 3107 * We used to exclude having local loop ports 3108 * at the same time that we have fabric ports. 3109 * That is, we used to exclude having ports 3110 * at < FL_PORT_ID if we're FL-port. 3111 * 3112 * That's wrong. The only thing that could be 3113 * dicey is if the switch you're connected to 3114 * has these local loop ports appear on the 3115 * fabric and we somehow attach them twice. 3116 */ 3117 } 3118 #else 3119 /* 3120 * Check for f/w being in ready state. If the f/w 3121 * isn't in ready state, then we don't know our 3122 * loop ID and the f/w hasn't completed logging 3123 * into all targets on the loop. If this is the 3124 * case, then bounce the command. We pretend this is 3125 * a SELECTION TIMEOUT error if we've never gone to 3126 * FW_READY state at all- in this case we may not 3127 * be hooked to a loop at all and we shouldn't hang 3128 * the machine for this. Otherwise, defer this command 3129 * until later. 3130 */ 3131 if (fcp->isp_fwstate != FW_READY) { 3132 /* 3133 * Give ourselves at most a 250ms delay. 3134 */ 3135 if (isp_fclink_test(isp, 250000)) { 3136 XS_SETERR(xs, HBA_SELTIMEOUT); 3137 if (fcp->loop_seen_once) { 3138 return (CMD_RQLATER); 3139 } else { 3140 return (CMD_COMPLETE); 3141 } 3142 } 3143 } 3144 3145 /* 3146 * If we're not on a Fabric, we can't have a target 3147 * above FL_PORT_ID-1. 3148 * 3149 * If we're on a fabric and *not* connected as an F-port, 3150 * we can't have a target less than FC_SNS_ID+1. This 3151 * keeps us from having to sort out the difference between 3152 * local public loop devices and those which we might get 3153 * from a switch's database. 3154 */ 3155 if (fcp->isp_onfabric == 0) { 3156 if (target >= FL_PORT_ID) { 3157 XS_SETERR(xs, HBA_SELTIMEOUT); 3158 return (CMD_COMPLETE); 3159 } 3160 } else { 3161 if (target >= FL_PORT_ID && target <= FC_SNS_ID) { 3162 XS_SETERR(xs, HBA_SELTIMEOUT); 3163 return (CMD_COMPLETE); 3164 } 3165 if (fcp->isp_topo != TOPO_F_PORT && 3166 target < FL_PORT_ID) { 3167 XS_SETERR(xs, HBA_SELTIMEOUT); 3168 return (CMD_COMPLETE); 3169 } 3170 } 3171 3172 /* 3173 * If our loop state is such that we haven't yet received 3174 * a "Port Database Changed" notification (after a LIP or 3175 * a Loop Reset or firmware initialization), then defer 3176 * sending commands for a little while, but only if we've 3177 * seen a valid loop at one point (otherwise we can get 3178 * stuck at initialization time). 3179 */ 3180 if (fcp->isp_loopstate < LOOP_PDB_RCVD) { 3181 XS_SETERR(xs, HBA_SELTIMEOUT); 3182 if (fcp->loop_seen_once) { 3183 return (CMD_RQLATER); 3184 } else { 3185 return (CMD_COMPLETE); 3186 } 3187 } 3188 3189 /* 3190 * If we're in the middle of loop or fabric scanning 3191 * or merging the port databases, retry this command later. 3192 */ 3193 if (fcp->isp_loopstate == LOOP_SCANNING_FABRIC || 3194 fcp->isp_loopstate == LOOP_SCANNING_LOOP || 3195 fcp->isp_loopstate == LOOP_SYNCING_PDB) { 3196 return (CMD_RQLATER); 3197 } 3198 3199 /* 3200 * If our loop state is now such that we've just now 3201 * received a Port Database Change notification, then 3202 * we have to go off and (re)scan the fabric. We back 3203 * out and try again later if this doesn't work. 3204 */ 3205 if (fcp->isp_loopstate == LOOP_PDB_RCVD && fcp->isp_onfabric) { 3206 if (isp_scan_fabric(isp, FC4_SCSI)) { 3207 return (CMD_RQLATER); 3208 } 3209 if (fcp->isp_fwstate != FW_READY || 3210 fcp->isp_loopstate < LOOP_FSCAN_DONE) { 3211 return (CMD_RQLATER); 3212 } 3213 } 3214 3215 /* 3216 * If our loop state is now such that we've just now 3217 * received a Port Database Change notification, then 3218 * we have to go off and (re)synchronize our port 3219 * database. 3220 */ 3221 if (fcp->isp_loopstate < LOOP_READY) { 3222 if (isp_pdb_sync(isp)) { 3223 return (CMD_RQLATER); 3224 } 3225 if (fcp->isp_fwstate != FW_READY || 3226 fcp->isp_loopstate != LOOP_READY) { 3227 return (CMD_RQLATER); 3228 } 3229 } 3230 3231 /* 3232 * XXX: Here's were we would cancel any loop_dead flag 3233 * XXX: also cancel in dead_loop timeout that's running 3234 */ 3235 #endif 3236 3237 /* 3238 * Now check whether we should even think about pursuing this. 3239 */ 3240 lp = &fcp->portdb[target]; 3241 if (lp->valid == 0) { 3242 XS_SETERR(xs, HBA_SELTIMEOUT); 3243 return (CMD_COMPLETE); 3244 } 3245 if ((lp->roles & (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT)) == 0) { 3246 isp_prt(isp, ISP_LOGDEBUG2, 3247 "Target %d does not have target service", target); 3248 XS_SETERR(xs, HBA_SELTIMEOUT); 3249 return (CMD_COMPLETE); 3250 } 3251 /* 3252 * Now turn target into what the actual Loop ID is. 3253 */ 3254 target = lp->loopid; 3255 } 3256 3257 /* 3258 * Next check to see if any HBA or Device 3259 * parameters need to be updated. 3260 */ 3261 if (isp->isp_update != 0) { 3262 isp_update(isp); 3263 } 3264 3265 if (isp_getrqentry(isp, &nxti, &optr, (void *)&qep)) { 3266 isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow"); 3267 XS_SETERR(xs, HBA_BOTCH); 3268 return (CMD_EAGAIN); 3269 } 3270 3271 /* 3272 * Now see if we need to synchronize the ISP with respect to anything. 3273 * We do dual duty here (cough) for synchronizing for busses other 3274 * than which we got here to send a command to. 3275 */ 3276 reqp = (ispreq_t *) local; 3277 if (isp->isp_sendmarker) { 3278 u_int8_t n = (IS_DUALBUS(isp)? 2: 1); 3279 /* 3280 * Check ports to send markers for... 3281 */ 3282 for (i = 0; i < n; i++) { 3283 if ((isp->isp_sendmarker & (1 << i)) == 0) { 3284 continue; 3285 } 3286 MEMZERO((void *) reqp, QENTRY_LEN); 3287 reqp->req_header.rqs_entry_count = 1; 3288 reqp->req_header.rqs_entry_type = RQSTYPE_MARKER; 3289 reqp->req_modifier = SYNC_ALL; 3290 reqp->req_target = i << 7; /* insert bus number */ 3291 isp_put_request(isp, reqp, qep); 3292 ISP_ADD_REQUEST(isp, nxti); 3293 isp->isp_sendmarker &= ~(1 << i); 3294 if (isp_getrqentry(isp, &nxti, &optr, (void *) &qep)) { 3295 isp_prt(isp, ISP_LOGDEBUG0, 3296 "Request Queue Overflow+"); 3297 XS_SETERR(xs, HBA_BOTCH); 3298 return (CMD_EAGAIN); 3299 } 3300 } 3301 } 3302 3303 MEMZERO((void *)reqp, QENTRY_LEN); 3304 reqp->req_header.rqs_entry_count = 1; 3305 if (IS_FC(isp)) { 3306 reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS; 3307 } else { 3308 if (XS_CDBLEN(xs) > 12) 3309 reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY; 3310 else 3311 reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST; 3312 } 3313 /* reqp->req_header.rqs_flags = 0; */ 3314 /* reqp->req_header.rqs_seqno = 0; */ 3315 if (IS_FC(isp)) { 3316 /* 3317 * See comment in isp_intr 3318 */ 3319 /* XS_RESID(xs) = 0; */ 3320 3321 /* 3322 * Fibre Channel always requires some kind of tag. 3323 * The Qlogic drivers seem be happy not to use a tag, 3324 * but this breaks for some devices (IBM drives). 3325 */ 3326 if (XS_TAG_P(xs)) { 3327 ((ispreqt2_t *)reqp)->req_flags = XS_TAG_TYPE(xs); 3328 } else { 3329 /* 3330 * If we don't know what tag to use, use HEAD OF QUEUE 3331 * for Request Sense or Simple. 3332 */ 3333 if (XS_CDBP(xs)[0] == 0x3) /* REQUEST SENSE */ 3334 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_HTAG; 3335 else 3336 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_STAG; 3337 } 3338 } else { 3339 sdparam *sdp = (sdparam *)isp->isp_param; 3340 sdp += XS_CHANNEL(xs); 3341 if ((sdp->isp_devparam[target].actv_flags & DPARM_TQING) && 3342 XS_TAG_P(xs)) { 3343 reqp->req_flags = XS_TAG_TYPE(xs); 3344 } 3345 } 3346 if (IS_SCSI(isp)) { 3347 reqp->req_target = target | (XS_CHANNEL(xs) << 7); 3348 reqp->req_lun_trn = XS_LUN(xs); 3349 reqp->req_cdblen = XS_CDBLEN(xs); 3350 } else if (IS_2KLOGIN(isp)) { 3351 ((ispreqt2e_t *)reqp)->req_target = target; 3352 ((ispreqt2e_t *)reqp)->req_scclun = XS_LUN(xs); 3353 } else if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) { 3354 ((ispreqt2_t *)reqp)->req_target = target; 3355 ((ispreqt2_t *)reqp)->req_scclun = XS_LUN(xs); 3356 } else { 3357 ((ispreqt2_t *)reqp)->req_target = target; 3358 ((ispreqt2_t *)reqp)->req_lun_trn = XS_LUN(xs); 3359 } 3360 MEMCPY(reqp->req_cdb, XS_CDBP(xs), XS_CDBLEN(xs)); 3361 3362 reqp->req_time = XS_TIME(xs) / 1000; 3363 if (reqp->req_time == 0 && XS_TIME(xs)) { 3364 reqp->req_time = 1; 3365 } 3366 3367 if (isp_save_xs(isp, xs, &handle)) { 3368 isp_prt(isp, ISP_LOGDEBUG0, "out of xflist pointers"); 3369 XS_SETERR(xs, HBA_BOTCH); 3370 return (CMD_EAGAIN); 3371 } 3372 reqp->req_handle = handle; 3373 3374 /* 3375 * Set up DMA and/or do any bus swizzling of the request entry 3376 * so that the Qlogic F/W understands what is being asked of it. 3377 */ 3378 i = ISP_DMASETUP(isp, xs, reqp, &nxti, optr); 3379 if (i != CMD_QUEUED) { 3380 isp_destroy_handle(isp, handle); 3381 /* 3382 * dmasetup sets actual error in packet, and 3383 * return what we were given to return. 3384 */ 3385 return (i); 3386 } 3387 XS_SETERR(xs, HBA_NOERROR); 3388 isp_prt(isp, ISP_LOGDEBUG2, 3389 "START cmd for %d.%d.%d cmd 0x%x datalen %ld", 3390 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), XS_CDBP(xs)[0], 3391 (long) XS_XFRLEN(xs)); 3392 ISP_ADD_REQUEST(isp, nxti); 3393 isp->isp_nactive++; 3394 return (CMD_QUEUED); 3395 } 3396 3397 /* 3398 * isp control 3399 * Locks (ints blocked) assumed held. 3400 */ 3401 3402 int 3403 isp_control(struct ispsoftc *isp, ispctl_t ctl, void *arg) 3404 { 3405 XS_T *xs; 3406 mbreg_t mbs; 3407 int bus, tgt; 3408 u_int16_t handle; 3409 3410 MEMZERO(&mbs, sizeof (mbs)); 3411 3412 switch (ctl) { 3413 default: 3414 isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl); 3415 break; 3416 3417 case ISPCTL_RESET_BUS: 3418 /* 3419 * Issue a bus reset. 3420 */ 3421 mbs.param[0] = MBOX_BUS_RESET; 3422 mbs.param[2] = 0; 3423 if (IS_SCSI(isp)) { 3424 mbs.param[1] = 3425 ((sdparam *) isp->isp_param)->isp_bus_reset_delay; 3426 if (mbs.param[1] < 2) 3427 mbs.param[1] = 2; 3428 bus = *((int *) arg); 3429 if (IS_DUALBUS(isp)) 3430 mbs.param[2] = bus; 3431 } else { 3432 mbs.param[1] = 10; 3433 bus = 0; 3434 } 3435 isp->isp_sendmarker |= (1 << bus); 3436 isp_mboxcmd(isp, &mbs, MBLOGALL); 3437 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 3438 break; 3439 } 3440 isp_prt(isp, ISP_LOGINFO, 3441 "driver initiated bus reset of bus %d", bus); 3442 return (0); 3443 3444 case ISPCTL_RESET_DEV: 3445 tgt = (*((int *) arg)) & 0xffff; 3446 bus = (*((int *) arg)) >> 16; 3447 mbs.param[0] = MBOX_ABORT_TARGET; 3448 if (IS_SCSI(isp)) { 3449 mbs.param[1] = (tgt << 8) | (bus << 15); 3450 } else { 3451 if (IS_2KLOGIN(isp)) { 3452 mbs.param[1] = tgt; 3453 mbs.obits |= (1 << 10); 3454 } else { 3455 mbs.param[1] = (tgt << 8); 3456 } 3457 } 3458 mbs.param[2] = 3; /* 'delay', in seconds */ 3459 isp_mboxcmd(isp, &mbs, MBLOGALL); 3460 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 3461 break; 3462 } 3463 isp_prt(isp, ISP_LOGINFO, 3464 "Target %d on Bus %d Reset Succeeded", tgt, bus); 3465 isp->isp_sendmarker |= (1 << bus); 3466 return (0); 3467 3468 case ISPCTL_ABORT_CMD: 3469 xs = (XS_T *) arg; 3470 tgt = XS_TGT(xs); 3471 handle = isp_find_handle(isp, xs); 3472 if (handle == 0) { 3473 isp_prt(isp, ISP_LOGWARN, 3474 "cannot find handle for command to abort"); 3475 break; 3476 } 3477 bus = XS_CHANNEL(xs); 3478 mbs.param[0] = MBOX_ABORT; 3479 if (IS_FC(isp)) { 3480 if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) { 3481 if (IS_2KLOGIN(isp)) { 3482 mbs.param[1] = tgt; 3483 } else { 3484 mbs.param[1] = tgt << 8; 3485 } 3486 mbs.param[4] = 0; 3487 mbs.param[5] = 0; 3488 mbs.param[6] = XS_LUN(xs); 3489 } else { 3490 mbs.param[1] = tgt << 8 | XS_LUN(xs); 3491 } 3492 } else { 3493 mbs.param[1] = 3494 (bus << 15) | (XS_TGT(xs) << 8) | XS_LUN(xs); 3495 } 3496 mbs.param[3] = 0; 3497 mbs.param[2] = handle; 3498 isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_ERROR); 3499 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 3500 return (0); 3501 } 3502 /* 3503 * XXX: Look for command in the REQUEST QUEUE. That is, 3504 * XXX: It hasen't been picked up by firmware yet. 3505 */ 3506 break; 3507 3508 case ISPCTL_UPDATE_PARAMS: 3509 3510 isp_update(isp); 3511 return (0); 3512 3513 case ISPCTL_FCLINK_TEST: 3514 3515 if (IS_FC(isp)) { 3516 int usdelay = (arg)? *((int *) arg) : 250000; 3517 return (isp_fclink_test(isp, usdelay)); 3518 } 3519 break; 3520 3521 case ISPCTL_SCAN_FABRIC: 3522 3523 if (IS_FC(isp)) { 3524 int ftype = (arg)? *((int *) arg) : FC4_SCSI; 3525 return (isp_scan_fabric(isp, ftype)); 3526 } 3527 break; 3528 3529 case ISPCTL_SCAN_LOOP: 3530 3531 if (IS_FC(isp)) { 3532 return (isp_scan_loop(isp)); 3533 } 3534 break; 3535 3536 case ISPCTL_PDB_SYNC: 3537 3538 if (IS_FC(isp)) { 3539 return (isp_pdb_sync(isp)); 3540 } 3541 break; 3542 3543 case ISPCTL_SEND_LIP: 3544 3545 if (IS_FC(isp)) { 3546 mbs.param[0] = MBOX_INIT_LIP; 3547 isp_mboxcmd(isp, &mbs, MBLOGALL); 3548 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 3549 return (0); 3550 } 3551 } 3552 break; 3553 3554 case ISPCTL_GET_POSMAP: 3555 3556 if (IS_FC(isp) && arg) { 3557 return (isp_getmap(isp, arg)); 3558 } 3559 break; 3560 3561 3562 case ISPCTL_GET_PDB: 3563 if (IS_FC(isp) && arg) { 3564 int id = *((int *)arg); 3565 isp_pdb_t *pdb = arg; 3566 return (isp_getpdb(isp, id, pdb)); 3567 } 3568 break; 3569 3570 case ISPCTL_RUN_MBOXCMD: 3571 3572 isp_mboxcmd(isp, arg, MBLOGALL); 3573 return(0); 3574 3575 #ifdef ISP_TARGET_MODE 3576 case ISPCTL_TOGGLE_TMODE: 3577 { 3578 3579 /* 3580 * We don't check/set against role here- that's the 3581 * responsibility for the outer layer to coordinate. 3582 */ 3583 if (IS_SCSI(isp)) { 3584 int param = *(int *)arg; 3585 mbs.param[0] = MBOX_ENABLE_TARGET_MODE; 3586 mbs.param[1] = param & 0xffff; 3587 mbs.param[2] = param >> 16; 3588 isp_mboxcmd(isp, &mbs, MBLOGALL); 3589 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 3590 break; 3591 } 3592 } 3593 return (0); 3594 } 3595 #endif 3596 } 3597 return (-1); 3598 } 3599 3600 /* 3601 * Interrupt Service Routine(s). 3602 * 3603 * External (OS) framework has done the appropriate locking, 3604 * and the locking will be held throughout this function. 3605 */ 3606 3607 /* 3608 * Limit our stack depth by sticking with the max likely number 3609 * of completions on a request queue at any one time. 3610 */ 3611 #ifndef MAX_REQUESTQ_COMPLETIONS 3612 #define MAX_REQUESTQ_COMPLETIONS 64 3613 #endif 3614 3615 void 3616 isp_intr(struct ispsoftc *isp, u_int16_t isr, u_int16_t sema, u_int16_t mbox) 3617 { 3618 XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs; 3619 u_int16_t iptr, optr, junk; 3620 int i, nlooked = 0, ndone = 0; 3621 3622 again: 3623 /* 3624 * Is this a mailbox related interrupt? 3625 * The mailbox semaphore will be nonzero if so. 3626 */ 3627 if (sema) { 3628 if (mbox & 0x4000) { 3629 isp->isp_intmboxc++; 3630 if (isp->isp_mboxbsy) { 3631 int i = 0, obits = isp->isp_obits; 3632 isp->isp_mboxtmp[i++] = mbox; 3633 for (i = 1; i < MAX_MAILBOX(isp); i++) { 3634 if ((obits & (1 << i)) == 0) { 3635 continue; 3636 } 3637 isp->isp_mboxtmp[i] = 3638 ISP_READ(isp, MBOX_OFF(i)); 3639 } 3640 if (isp->isp_mbxwrk0) { 3641 if (isp_mbox_continue(isp) == 0) { 3642 return; 3643 } 3644 } 3645 MBOX_NOTIFY_COMPLETE(isp); 3646 } else { 3647 isp_prt(isp, ISP_LOGWARN, 3648 "Mbox Command Async (0x%x) with no waiters", 3649 mbox); 3650 } 3651 } else if (isp_parse_async(isp, mbox) < 0) { 3652 return; 3653 } 3654 if ((IS_FC(isp) && mbox != ASYNC_RIO_RESP) || 3655 isp->isp_state != ISP_RUNSTATE) { 3656 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 3657 ISP_WRITE(isp, BIU_SEMA, 0); 3658 return; 3659 } 3660 } 3661 3662 /* 3663 * We can't be getting this now. 3664 */ 3665 if (isp->isp_state != ISP_RUNSTATE) { 3666 isp_prt(isp, ISP_LOGWARN, 3667 "interrupt (ISR=%x SEMA=%x) when not ready", isr, sema); 3668 /* 3669 * Thank you very much! *Burrrp*! 3670 */ 3671 WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, 3672 READ_RESPONSE_QUEUE_IN_POINTER(isp)); 3673 3674 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 3675 ISP_WRITE(isp, BIU_SEMA, 0); 3676 return; 3677 } 3678 3679 /* 3680 * Get the current Response Queue Out Pointer. 3681 * 3682 * If we're a 2300, we can ask what hardware what it thinks. 3683 */ 3684 if (IS_23XX(isp)) { 3685 optr = ISP_READ(isp, isp->isp_respoutrp); 3686 /* 3687 * Debug: to be taken out eventually 3688 */ 3689 if (isp->isp_residx != optr) { 3690 isp_prt(isp, ISP_LOGWARN, "optr %x soft optr %x", 3691 optr, isp->isp_residx); 3692 } 3693 } else { 3694 optr = isp->isp_residx; 3695 } 3696 3697 /* 3698 * You *must* read the Response Queue In Pointer 3699 * prior to clearing the RISC interrupt. 3700 * 3701 * Debounce the 2300 if revision less than 2. 3702 */ 3703 if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) { 3704 i = 0; 3705 do { 3706 iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp); 3707 junk = READ_RESPONSE_QUEUE_IN_POINTER(isp); 3708 } while (junk != iptr && ++i < 1000); 3709 3710 if (iptr != junk) { 3711 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 3712 isp_prt(isp, ISP_LOGWARN, 3713 "Response Queue Out Pointer Unstable (%x, %x)", 3714 iptr, junk); 3715 return; 3716 } 3717 } else { 3718 iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp); 3719 } 3720 isp->isp_resodx = iptr; 3721 3722 3723 if (optr == iptr && sema == 0) { 3724 /* 3725 * There are a lot of these- reasons unknown- mostly on 3726 * faster Alpha machines. 3727 * 3728 * I tried delaying after writing HCCR_CMD_CLEAR_RISC_INT to 3729 * make sure the old interrupt went away (to avoid 'ringing' 3730 * effects), but that didn't stop this from occurring. 3731 */ 3732 if (IS_23XX(isp)) { 3733 USEC_DELAY(100); 3734 iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp); 3735 junk = ISP_READ(isp, BIU_R2HSTSLO); 3736 } else { 3737 junk = ISP_READ(isp, BIU_ISR); 3738 } 3739 if (optr == iptr) { 3740 if (IS_23XX(isp)) { 3741 ; 3742 } else { 3743 sema = ISP_READ(isp, BIU_SEMA); 3744 mbox = ISP_READ(isp, OUTMAILBOX0); 3745 if ((sema & 0x3) && (mbox & 0x8000)) { 3746 goto again; 3747 } 3748 } 3749 isp->isp_intbogus++; 3750 isp_prt(isp, ISP_LOGDEBUG1, 3751 "bogus intr- isr %x (%x) iptr %x optr %x", 3752 isr, junk, iptr, optr); 3753 } 3754 } 3755 isp->isp_resodx = iptr; 3756 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 3757 ISP_WRITE(isp, BIU_SEMA, 0); 3758 3759 if (isp->isp_rspbsy) { 3760 return; 3761 } 3762 isp->isp_rspbsy = 1; 3763 3764 while (optr != iptr) { 3765 ispstatusreq_t local, *sp = &local; 3766 isphdr_t *hp; 3767 int type; 3768 u_int16_t oop; 3769 int buddaboom = 0; 3770 3771 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr); 3772 oop = optr; 3773 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp)); 3774 nlooked++; 3775 read_again: 3776 /* 3777 * Synchronize our view of this response queue entry. 3778 */ 3779 MEMORYBARRIER(isp, SYNC_RESULT, oop, QENTRY_LEN); 3780 3781 type = isp_get_response_type(isp, hp); 3782 3783 if (type == RQSTYPE_RESPONSE) { 3784 isp_get_response(isp, (ispstatusreq_t *) hp, sp); 3785 } else if (type == RQSTYPE_RIO2) { 3786 isp_rio2_t rio; 3787 isp_get_rio2(isp, (isp_rio2_t *) hp, &rio); 3788 for (i = 0; i < rio.req_header.rqs_seqno; i++) { 3789 isp_fastpost_complete(isp, rio.req_handles[i]); 3790 } 3791 if (isp->isp_fpcchiwater < rio.req_header.rqs_seqno) 3792 isp->isp_fpcchiwater = rio.req_header.rqs_seqno; 3793 MEMZERO(hp, QENTRY_LEN); /* PERF */ 3794 continue; 3795 } else { 3796 /* 3797 * Somebody reachable via isp_handle_other_response 3798 * may have updated the response queue pointers for 3799 * us, so we reload our goal index. 3800 */ 3801 int i = isp_handle_other_response(isp, type, hp, &optr); 3802 if (i < 0) { 3803 goto read_again; 3804 } else if (i > 0) { 3805 iptr = isp->isp_resodx; 3806 MEMZERO(hp, QENTRY_LEN); /* PERF */ 3807 continue; 3808 } 3809 3810 /* 3811 * After this point, we'll just look at the header as 3812 * we don't know how to deal with the rest of the 3813 * response. 3814 */ 3815 isp_get_response(isp, (ispstatusreq_t *) hp, sp); 3816 3817 /* 3818 * It really has to be a bounced request just copied 3819 * from the request queue to the response queue. If 3820 * not, something bad has happened. 3821 */ 3822 if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) { 3823 isp_prt(isp, ISP_LOGERR, notresp, 3824 sp->req_header.rqs_entry_type, oop, optr, 3825 nlooked); 3826 if (isp->isp_dblev & ISP_LOGDEBUG0) { 3827 isp_print_bytes(isp, "Queue Entry", 3828 QENTRY_LEN, sp); 3829 } 3830 MEMZERO(hp, QENTRY_LEN); /* PERF */ 3831 continue; 3832 } 3833 buddaboom = 1; 3834 } 3835 3836 if (sp->req_header.rqs_flags & 0xf) { 3837 #define _RQS_OFLAGS \ 3838 ~(RQSFLAG_CONTINUATION|RQSFLAG_FULL|RQSFLAG_BADHEADER|RQSFLAG_BADPACKET) 3839 if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) { 3840 isp_prt(isp, ISP_LOGWARN, 3841 "continuation segment"); 3842 WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr); 3843 continue; 3844 } 3845 if (sp->req_header.rqs_flags & RQSFLAG_FULL) { 3846 isp_prt(isp, ISP_LOGDEBUG1, 3847 "internal queues full"); 3848 /* 3849 * We'll synthesize a QUEUE FULL message below. 3850 */ 3851 } 3852 if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) { 3853 isp_prt(isp, ISP_LOGERR, "bad header flag"); 3854 buddaboom++; 3855 } 3856 if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) { 3857 isp_prt(isp, ISP_LOGERR, "bad request packet"); 3858 buddaboom++; 3859 } 3860 if (sp->req_header.rqs_flags & _RQS_OFLAGS) { 3861 isp_prt(isp, ISP_LOGERR, 3862 "unknown flags (0x%x) in response", 3863 sp->req_header.rqs_flags); 3864 buddaboom++; 3865 } 3866 #undef _RQS_OFLAGS 3867 } 3868 if (sp->req_handle > isp->isp_maxcmds || sp->req_handle < 1) { 3869 MEMZERO(hp, QENTRY_LEN); /* PERF */ 3870 isp_prt(isp, ISP_LOGERR, 3871 "bad request handle %d (type 0x%x, flags 0x%x)", 3872 sp->req_handle, sp->req_header.rqs_entry_type, 3873 sp->req_header.rqs_flags); 3874 WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr); 3875 continue; 3876 } 3877 xs = isp_find_xs(isp, sp->req_handle); 3878 if (xs == NULL) { 3879 u_int8_t ts = sp->req_completion_status & 0xff; 3880 MEMZERO(hp, QENTRY_LEN); /* PERF */ 3881 /* 3882 * Only whine if this isn't the expected fallout of 3883 * aborting the command. 3884 */ 3885 if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) { 3886 isp_prt(isp, ISP_LOGERR, 3887 "cannot find handle 0x%x (type 0x%x)", 3888 sp->req_handle, 3889 sp->req_header.rqs_entry_type); 3890 } else if (ts != RQCS_ABORTED) { 3891 isp_prt(isp, ISP_LOGERR, 3892 "cannot find handle 0x%x (status 0x%x)", 3893 sp->req_handle, ts); 3894 } 3895 WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr); 3896 continue; 3897 } 3898 isp_destroy_handle(isp, sp->req_handle); 3899 if (sp->req_status_flags & RQSTF_BUS_RESET) { 3900 XS_SETERR(xs, HBA_BUSRESET); 3901 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs)); 3902 } 3903 if (buddaboom) { 3904 XS_SETERR(xs, HBA_BOTCH); 3905 } 3906 3907 if (IS_FC(isp) && (sp->req_scsi_status & RQCS_SV)) { 3908 /* 3909 * Fibre Channel F/W doesn't say we got status 3910 * if there's Sense Data instead. I guess they 3911 * think it goes w/o saying. 3912 */ 3913 sp->req_state_flags |= RQSF_GOT_STATUS; 3914 } 3915 if (sp->req_state_flags & RQSF_GOT_STATUS) { 3916 *XS_STSP(xs) = sp->req_scsi_status & 0xff; 3917 } 3918 3919 switch (sp->req_header.rqs_entry_type) { 3920 case RQSTYPE_RESPONSE: 3921 XS_SET_STATE_STAT(isp, xs, sp); 3922 isp_parse_status(isp, sp, xs); 3923 if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) && 3924 (*XS_STSP(xs) == SCSI_BUSY)) { 3925 XS_SETERR(xs, HBA_TGTBSY); 3926 } 3927 if (IS_SCSI(isp)) { 3928 XS_RESID(xs) = sp->req_resid; 3929 if ((sp->req_state_flags & RQSF_GOT_STATUS) && 3930 (*XS_STSP(xs) == SCSI_CHECK) && 3931 (sp->req_state_flags & RQSF_GOT_SENSE)) { 3932 XS_SAVE_SENSE(xs, sp); 3933 } 3934 /* 3935 * A new synchronous rate was negotiated for 3936 * this target. Mark state such that we'll go 3937 * look up that which has changed later. 3938 */ 3939 if (sp->req_status_flags & RQSTF_NEGOTIATION) { 3940 int t = XS_TGT(xs); 3941 sdparam *sdp = isp->isp_param; 3942 sdp += XS_CHANNEL(xs); 3943 sdp->isp_devparam[t].dev_refresh = 1; 3944 isp->isp_update |= 3945 (1 << XS_CHANNEL(xs)); 3946 } 3947 } else { 3948 if (sp->req_status_flags & RQSF_XFER_COMPLETE) { 3949 XS_RESID(xs) = 0; 3950 } else if (sp->req_scsi_status & RQCS_RESID) { 3951 XS_RESID(xs) = sp->req_resid; 3952 } else { 3953 XS_RESID(xs) = 0; 3954 } 3955 if ((sp->req_state_flags & RQSF_GOT_STATUS) && 3956 (*XS_STSP(xs) == SCSI_CHECK) && 3957 (sp->req_scsi_status & RQCS_SV)) { 3958 XS_SAVE_SENSE(xs, sp); 3959 /* solely for the benefit of debug */ 3960 sp->req_state_flags |= RQSF_GOT_SENSE; 3961 } 3962 } 3963 isp_prt(isp, ISP_LOGDEBUG2, 3964 "asked for %ld got resid %ld", (long) XS_XFRLEN(xs), 3965 (long) sp->req_resid); 3966 break; 3967 case RQSTYPE_REQUEST: 3968 if (sp->req_header.rqs_flags & RQSFLAG_FULL) { 3969 /* 3970 * Force Queue Full status. 3971 */ 3972 *XS_STSP(xs) = SCSI_QFULL; 3973 XS_SETERR(xs, HBA_NOERROR); 3974 } else if (XS_NOERR(xs)) { 3975 /* 3976 * ???? 3977 */ 3978 isp_prt(isp, ISP_LOGDEBUG0, 3979 "Request Queue Entry bounced back"); 3980 XS_SETERR(xs, HBA_BOTCH); 3981 } 3982 XS_RESID(xs) = XS_XFRLEN(xs); 3983 break; 3984 default: 3985 isp_prt(isp, ISP_LOGWARN, 3986 "unhandled response queue type 0x%x", 3987 sp->req_header.rqs_entry_type); 3988 if (XS_NOERR(xs)) { 3989 XS_SETERR(xs, HBA_BOTCH); 3990 } 3991 break; 3992 } 3993 3994 /* 3995 * Free any DMA resources. As a side effect, this may 3996 * also do any cache flushing necessary for data coherence. */ 3997 if (XS_XFRLEN(xs)) { 3998 ISP_DMAFREE(isp, xs, sp->req_handle); 3999 } 4000 4001 if (((isp->isp_dblev & (ISP_LOGDEBUG2|ISP_LOGDEBUG3))) || 4002 ((isp->isp_dblev & ISP_LOGDEBUG1) && ((!XS_NOERR(xs)) || 4003 (*XS_STSP(xs) != SCSI_GOOD)))) { 4004 char skey; 4005 if (sp->req_state_flags & RQSF_GOT_SENSE) { 4006 skey = XS_SNSKEY(xs) & 0xf; 4007 if (skey < 10) 4008 skey += '0'; 4009 else 4010 skey += 'a' - 10; 4011 } else if (*XS_STSP(xs) == SCSI_CHECK) { 4012 skey = '?'; 4013 } else { 4014 skey = '.'; 4015 } 4016 isp_prt(isp, ISP_LOGALL, finmsg, XS_CHANNEL(xs), 4017 XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs), XS_RESID(xs), 4018 *XS_STSP(xs), skey, XS_ERR(xs)); 4019 } 4020 4021 if (isp->isp_nactive > 0) 4022 isp->isp_nactive--; 4023 complist[ndone++] = xs; /* defer completion call until later */ 4024 MEMZERO(hp, QENTRY_LEN); /* PERF */ 4025 if (ndone == MAX_REQUESTQ_COMPLETIONS) { 4026 break; 4027 } 4028 } 4029 4030 /* 4031 * If we looked at any commands, then it's valid to find out 4032 * what the outpointer is. It also is a trigger to update the 4033 * ISP's notion of what we've seen so far. 4034 */ 4035 if (nlooked) { 4036 WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr); 4037 /* 4038 * While we're at it, read the requst queue out pointer. 4039 */ 4040 isp->isp_reqodx = READ_REQUEST_QUEUE_OUT_POINTER(isp); 4041 if (isp->isp_rscchiwater < ndone) 4042 isp->isp_rscchiwater = ndone; 4043 } 4044 4045 isp->isp_residx = optr; 4046 isp->isp_rspbsy = 0; 4047 for (i = 0; i < ndone; i++) { 4048 xs = complist[i]; 4049 if (xs) { 4050 isp->isp_rsltccmplt++; 4051 isp_done(xs); 4052 } 4053 } 4054 } 4055 4056 /* 4057 * Support routines. 4058 */ 4059 4060 static int 4061 isp_parse_async(struct ispsoftc *isp, u_int16_t mbox) 4062 { 4063 int rval = 0; 4064 int bus; 4065 4066 if (IS_DUALBUS(isp)) { 4067 bus = ISP_READ(isp, OUTMAILBOX6); 4068 } else { 4069 bus = 0; 4070 } 4071 isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox); 4072 4073 switch (mbox) { 4074 case ASYNC_BUS_RESET: 4075 isp->isp_sendmarker |= (1 << bus); 4076 #ifdef ISP_TARGET_MODE 4077 if (isp_target_async(isp, bus, mbox)) 4078 rval = -1; 4079 #endif 4080 isp_async(isp, ISPASYNC_BUS_RESET, &bus); 4081 break; 4082 case ASYNC_SYSTEM_ERROR: 4083 #ifdef ISP_FW_CRASH_DUMP 4084 /* 4085 * If we have crash dumps enabled, it's up to the handler 4086 * for isp_async to reinit stuff and restart the firmware 4087 * after performing the crash dump. The reason we do things 4088 * this way is that we may need to activate a kernel thread 4089 * to do all the crash dump goop. 4090 */ 4091 isp_async(isp, ISPASYNC_FW_CRASH, NULL); 4092 #else 4093 isp_async(isp, ISPASYNC_FW_CRASH, NULL); 4094 isp_reinit(isp); 4095 isp_async(isp, ISPASYNC_FW_RESTARTED, NULL); 4096 #endif 4097 rval = -1; 4098 break; 4099 4100 case ASYNC_RQS_XFER_ERR: 4101 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error"); 4102 break; 4103 4104 case ASYNC_RSP_XFER_ERR: 4105 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error"); 4106 break; 4107 4108 case ASYNC_QWAKEUP: 4109 /* 4110 * We've just been notified that the Queue has woken up. 4111 * We don't need to be chatty about this- just unlatch things 4112 * and move on. 4113 */ 4114 mbox = READ_REQUEST_QUEUE_OUT_POINTER(isp); 4115 break; 4116 4117 case ASYNC_TIMEOUT_RESET: 4118 isp_prt(isp, ISP_LOGWARN, 4119 "timeout initiated SCSI bus reset of bus %d", bus); 4120 isp->isp_sendmarker |= (1 << bus); 4121 #ifdef ISP_TARGET_MODE 4122 if (isp_target_async(isp, bus, mbox)) 4123 rval = -1; 4124 #endif 4125 break; 4126 4127 case ASYNC_DEVICE_RESET: 4128 isp_prt(isp, ISP_LOGINFO, "device reset on bus %d", bus); 4129 isp->isp_sendmarker |= (1 << bus); 4130 #ifdef ISP_TARGET_MODE 4131 if (isp_target_async(isp, bus, mbox)) 4132 rval = -1; 4133 #endif 4134 break; 4135 4136 case ASYNC_EXTMSG_UNDERRUN: 4137 isp_prt(isp, ISP_LOGWARN, "extended message underrun"); 4138 break; 4139 4140 case ASYNC_SCAM_INT: 4141 isp_prt(isp, ISP_LOGINFO, "SCAM interrupt"); 4142 break; 4143 4144 case ASYNC_HUNG_SCSI: 4145 isp_prt(isp, ISP_LOGERR, 4146 "stalled SCSI Bus after DATA Overrun"); 4147 /* XXX: Need to issue SCSI reset at this point */ 4148 break; 4149 4150 case ASYNC_KILLED_BUS: 4151 isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun"); 4152 break; 4153 4154 case ASYNC_BUS_TRANSIT: 4155 mbox = ISP_READ(isp, OUTMAILBOX2); 4156 switch (mbox & 0x1c00) { 4157 case SXP_PINS_LVD_MODE: 4158 isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode"); 4159 SDPARAM(isp)->isp_diffmode = 0; 4160 SDPARAM(isp)->isp_ultramode = 0; 4161 SDPARAM(isp)->isp_lvdmode = 1; 4162 break; 4163 case SXP_PINS_HVD_MODE: 4164 isp_prt(isp, ISP_LOGINFO, 4165 "Transition to Differential mode"); 4166 SDPARAM(isp)->isp_diffmode = 1; 4167 SDPARAM(isp)->isp_ultramode = 0; 4168 SDPARAM(isp)->isp_lvdmode = 0; 4169 break; 4170 case SXP_PINS_SE_MODE: 4171 isp_prt(isp, ISP_LOGINFO, 4172 "Transition to Single Ended mode"); 4173 SDPARAM(isp)->isp_diffmode = 0; 4174 SDPARAM(isp)->isp_ultramode = 1; 4175 SDPARAM(isp)->isp_lvdmode = 0; 4176 break; 4177 default: 4178 isp_prt(isp, ISP_LOGWARN, 4179 "Transition to Unknown Mode 0x%x", mbox); 4180 break; 4181 } 4182 /* 4183 * XXX: Set up to renegotiate again! 4184 */ 4185 /* Can only be for a 1080... */ 4186 isp->isp_sendmarker |= (1 << bus); 4187 break; 4188 4189 /* 4190 * We can use bus, which will always be zero for FC cards, 4191 * as a mailbox pattern accumulator to be checked below. 4192 */ 4193 case ASYNC_RIO5: 4194 bus = 0x1ce; /* outgoing mailbox regs 1-3, 6-7 */ 4195 break; 4196 4197 case ASYNC_RIO4: 4198 bus = 0x14e; /* outgoing mailbox regs 1-3, 6 */ 4199 break; 4200 4201 case ASYNC_RIO3: 4202 bus = 0x10e; /* outgoing mailbox regs 1-3 */ 4203 break; 4204 4205 case ASYNC_RIO2: 4206 bus = 0x106; /* outgoing mailbox regs 1-2 */ 4207 break; 4208 4209 case ASYNC_RIO1: 4210 case ASYNC_CMD_CMPLT: 4211 bus = 0x102; /* outgoing mailbox regs 1 */ 4212 break; 4213 4214 case ASYNC_RIO_RESP: 4215 return (rval); 4216 4217 case ASYNC_CTIO_DONE: 4218 { 4219 #ifdef ISP_TARGET_MODE 4220 int handle = 4221 (ISP_READ(isp, OUTMAILBOX2) << 16) | 4222 (ISP_READ(isp, OUTMAILBOX1)); 4223 if (isp_target_async(isp, handle, mbox)) { 4224 rval = -1; 4225 } else { 4226 /* count it as a fast posting intr */ 4227 isp->isp_fphccmplt++; 4228 } 4229 #else 4230 isp_prt(isp, ISP_LOGINFO, "Fast Posting CTIO done"); 4231 isp->isp_fphccmplt++; /* count it as a fast posting intr */ 4232 #endif 4233 break; 4234 } 4235 case ASYNC_LIP_F8: 4236 case ASYNC_LIP_OCCURRED: 4237 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT; 4238 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD; 4239 isp->isp_sendmarker = 1; 4240 isp_mark_getpdb_all(isp); 4241 isp_async(isp, ISPASYNC_LIP, NULL); 4242 #ifdef ISP_TARGET_MODE 4243 if (isp_target_async(isp, bus, mbox)) 4244 rval = -1; 4245 #endif 4246 /* 4247 * We've had problems with data corruption occuring on 4248 * commands that complete (with no apparent error) after 4249 * we receive a LIP. This has been observed mostly on 4250 * Local Loop topologies. To be safe, let's just mark 4251 * all active commands as dead. 4252 */ 4253 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT || 4254 FCPARAM(isp)->isp_topo == TOPO_FL_PORT) { 4255 int i, j; 4256 for (i = j = 0; i < isp->isp_maxcmds; i++) { 4257 XS_T *xs; 4258 xs = isp->isp_xflist[i]; 4259 if (xs != NULL) { 4260 j++; 4261 XS_SETERR(xs, HBA_BUSRESET); 4262 } 4263 } 4264 if (j) { 4265 isp_prt(isp, ISP_LOGERR, 4266 "LIP destroyed %d active commands", j); 4267 } 4268 } 4269 break; 4270 4271 case ASYNC_LOOP_UP: 4272 isp->isp_sendmarker = 1; 4273 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT; 4274 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD; 4275 isp_mark_getpdb_all(isp); 4276 isp_async(isp, ISPASYNC_LOOP_UP, NULL); 4277 #ifdef ISP_TARGET_MODE 4278 if (isp_target_async(isp, bus, mbox)) 4279 rval = -1; 4280 #endif 4281 break; 4282 4283 case ASYNC_LOOP_DOWN: 4284 isp->isp_sendmarker = 1; 4285 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT; 4286 FCPARAM(isp)->isp_loopstate = LOOP_NIL; 4287 isp_mark_getpdb_all(isp); 4288 isp_async(isp, ISPASYNC_LOOP_DOWN, NULL); 4289 #ifdef ISP_TARGET_MODE 4290 if (isp_target_async(isp, bus, mbox)) 4291 rval = -1; 4292 #endif 4293 break; 4294 4295 case ASYNC_LOOP_RESET: 4296 isp->isp_sendmarker = 1; 4297 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT; 4298 FCPARAM(isp)->isp_loopstate = LOOP_NIL; 4299 isp_mark_getpdb_all(isp); 4300 isp_async(isp, ISPASYNC_LOOP_RESET, NULL); 4301 #ifdef ISP_TARGET_MODE 4302 if (isp_target_async(isp, bus, mbox)) 4303 rval = -1; 4304 #endif 4305 break; 4306 4307 case ASYNC_PDB_CHANGED: 4308 isp->isp_sendmarker = 1; 4309 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD; 4310 isp_mark_getpdb_all(isp); 4311 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_PDB); 4312 break; 4313 4314 case ASYNC_CHANGE_NOTIFY: 4315 /* 4316 * Not correct, but it will force us to rescan the loop. 4317 */ 4318 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD; 4319 isp_mark_getpdb_all(isp); 4320 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_SNS); 4321 break; 4322 4323 case ASYNC_PTPMODE: 4324 if (FCPARAM(isp)->isp_onfabric) 4325 FCPARAM(isp)->isp_topo = TOPO_F_PORT; 4326 else 4327 FCPARAM(isp)->isp_topo = TOPO_N_PORT; 4328 isp_mark_getpdb_all(isp); 4329 isp->isp_sendmarker = 1; 4330 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT; 4331 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD; 4332 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER); 4333 #ifdef ISP_TARGET_MODE 4334 if (isp_target_async(isp, bus, mbox)) 4335 rval = -1; 4336 #endif 4337 isp_prt(isp, ISP_LOGINFO, "Point-to-Point mode"); 4338 break; 4339 4340 case ASYNC_CONNMODE: 4341 mbox = ISP_READ(isp, OUTMAILBOX1); 4342 isp_mark_getpdb_all(isp); 4343 switch (mbox) { 4344 case ISP_CONN_LOOP: 4345 isp_prt(isp, ISP_LOGINFO, 4346 "Point-to-Point -> Loop mode"); 4347 break; 4348 case ISP_CONN_PTP: 4349 isp_prt(isp, ISP_LOGINFO, 4350 "Loop -> Point-to-Point mode"); 4351 break; 4352 case ISP_CONN_BADLIP: 4353 isp_prt(isp, ISP_LOGWARN, 4354 "Point-to-Point -> Loop mode (BAD LIP)"); 4355 break; 4356 case ISP_CONN_FATAL: 4357 isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR"); 4358 #ifdef ISP_FW_CRASH_DUMP 4359 isp_async(isp, ISPASYNC_FW_CRASH, NULL); 4360 #else 4361 isp_async(isp, ISPASYNC_FW_CRASH, NULL); 4362 isp_reinit(isp); 4363 isp_async(isp, ISPASYNC_FW_RESTARTED, NULL); 4364 #endif 4365 return (-1); 4366 case ISP_CONN_LOOPBACK: 4367 isp_prt(isp, ISP_LOGWARN, 4368 "Looped Back in Point-to-Point mode"); 4369 break; 4370 default: 4371 isp_prt(isp, ISP_LOGWARN, 4372 "Unknown connection mode (0x%x)", mbox); 4373 break; 4374 } 4375 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER); 4376 isp->isp_sendmarker = 1; 4377 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT; 4378 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD; 4379 break; 4380 4381 default: 4382 isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox); 4383 break; 4384 } 4385 4386 if (bus & 0x100) { 4387 int i, nh; 4388 u_int16_t handles[16]; 4389 4390 for (nh = 0, i = 1; i < MAX_MAILBOX(isp); i++) { 4391 if ((bus & (1 << i)) == 0) { 4392 continue; 4393 } 4394 handles[nh++] = ISP_READ(isp, MBOX_OFF(i)); 4395 } 4396 for (i = 0; i < nh; i++) { 4397 isp_fastpost_complete(isp, handles[i]); 4398 isp_prt(isp, ISP_LOGDEBUG3, 4399 "fast post completion of %u", handles[i]); 4400 } 4401 if (isp->isp_fpcchiwater < nh) 4402 isp->isp_fpcchiwater = nh; 4403 } else { 4404 isp->isp_intoasync++; 4405 } 4406 return (rval); 4407 } 4408 4409 /* 4410 * Handle other response entries. A pointer to the request queue output 4411 * index is here in case we want to eat several entries at once, although 4412 * this is not used currently. 4413 */ 4414 4415 static int 4416 isp_handle_other_response(struct ispsoftc *isp, int type, 4417 isphdr_t *hp, u_int16_t *optrp) 4418 { 4419 switch (type) { 4420 case RQSTYPE_STATUS_CONT: 4421 isp_prt(isp, ISP_LOGINFO, "Ignored Continuation Response"); 4422 return (1); 4423 case RQSTYPE_ATIO: 4424 case RQSTYPE_CTIO: 4425 case RQSTYPE_ENABLE_LUN: 4426 case RQSTYPE_MODIFY_LUN: 4427 case RQSTYPE_NOTIFY: 4428 case RQSTYPE_NOTIFY_ACK: 4429 case RQSTYPE_CTIO1: 4430 case RQSTYPE_ATIO2: 4431 case RQSTYPE_CTIO2: 4432 case RQSTYPE_CTIO3: 4433 isp->isp_rsltccmplt++; /* count as a response completion */ 4434 #ifdef ISP_TARGET_MODE 4435 if (isp_target_notify(isp, (ispstatusreq_t *) hp, optrp)) { 4436 return (1); 4437 } 4438 #endif 4439 /* FALLTHROUGH */ 4440 case RQSTYPE_REQUEST: 4441 default: 4442 USEC_DELAY(100); 4443 if (type != isp_get_response_type(isp, hp)) { 4444 /* 4445 * This is questionable- we're just papering over 4446 * something we've seen on SMP linux in target 4447 * mode- we don't really know what's happening 4448 * here that causes us to think we've gotten 4449 * an entry, but that either the entry isn't 4450 * filled out yet or our CPU read data is stale. 4451 */ 4452 isp_prt(isp, ISP_LOGINFO, 4453 "unstable type in response queue"); 4454 return (-1); 4455 } 4456 isp_prt(isp, ISP_LOGWARN, "Unhandled Response Type 0x%x", 4457 isp_get_response_type(isp, hp)); 4458 if (isp_async(isp, ISPASYNC_UNHANDLED_RESPONSE, hp)) { 4459 return (1); 4460 } 4461 return (0); 4462 } 4463 } 4464 4465 static void 4466 isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs) 4467 { 4468 switch (sp->req_completion_status & 0xff) { 4469 case RQCS_COMPLETE: 4470 if (XS_NOERR(xs)) { 4471 XS_SETERR(xs, HBA_NOERROR); 4472 } 4473 return; 4474 4475 case RQCS_INCOMPLETE: 4476 if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) { 4477 isp_prt(isp, ISP_LOGDEBUG1, 4478 "Selection Timeout for %d.%d.%d", 4479 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4480 if (XS_NOERR(xs)) { 4481 XS_SETERR(xs, HBA_SELTIMEOUT); 4482 } 4483 return; 4484 } 4485 isp_prt(isp, ISP_LOGERR, 4486 "command incomplete for %d.%d.%d, state 0x%x", 4487 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), 4488 sp->req_state_flags); 4489 break; 4490 4491 case RQCS_DMA_ERROR: 4492 isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d", 4493 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4494 break; 4495 4496 case RQCS_TRANSPORT_ERROR: 4497 { 4498 char buf[172]; 4499 SNPRINTF(buf, sizeof (buf), "states=>"); 4500 if (sp->req_state_flags & RQSF_GOT_BUS) { 4501 SNPRINTF(buf, sizeof (buf), "%s GOT_BUS", buf); 4502 } 4503 if (sp->req_state_flags & RQSF_GOT_TARGET) { 4504 SNPRINTF(buf, sizeof (buf), "%s GOT_TGT", buf); 4505 } 4506 if (sp->req_state_flags & RQSF_SENT_CDB) { 4507 SNPRINTF(buf, sizeof (buf), "%s SENT_CDB", buf); 4508 } 4509 if (sp->req_state_flags & RQSF_XFRD_DATA) { 4510 SNPRINTF(buf, sizeof (buf), "%s XFRD_DATA", buf); 4511 } 4512 if (sp->req_state_flags & RQSF_GOT_STATUS) { 4513 SNPRINTF(buf, sizeof (buf), "%s GOT_STS", buf); 4514 } 4515 if (sp->req_state_flags & RQSF_GOT_SENSE) { 4516 SNPRINTF(buf, sizeof (buf), "%s GOT_SNS", buf); 4517 } 4518 if (sp->req_state_flags & RQSF_XFER_COMPLETE) { 4519 SNPRINTF(buf, sizeof (buf), "%s XFR_CMPLT", buf); 4520 } 4521 SNPRINTF(buf, sizeof (buf), "%s\nstatus=>", buf); 4522 if (sp->req_status_flags & RQSTF_DISCONNECT) { 4523 SNPRINTF(buf, sizeof (buf), "%s Disconnect", buf); 4524 } 4525 if (sp->req_status_flags & RQSTF_SYNCHRONOUS) { 4526 SNPRINTF(buf, sizeof (buf), "%s Sync_xfr", buf); 4527 } 4528 if (sp->req_status_flags & RQSTF_PARITY_ERROR) { 4529 SNPRINTF(buf, sizeof (buf), "%s Parity", buf); 4530 } 4531 if (sp->req_status_flags & RQSTF_BUS_RESET) { 4532 SNPRINTF(buf, sizeof (buf), "%s Bus_Reset", buf); 4533 } 4534 if (sp->req_status_flags & RQSTF_DEVICE_RESET) { 4535 SNPRINTF(buf, sizeof (buf), "%s Device_Reset", buf); 4536 } 4537 if (sp->req_status_flags & RQSTF_ABORTED) { 4538 SNPRINTF(buf, sizeof (buf), "%s Aborted", buf); 4539 } 4540 if (sp->req_status_flags & RQSTF_TIMEOUT) { 4541 SNPRINTF(buf, sizeof (buf), "%s Timeout", buf); 4542 } 4543 if (sp->req_status_flags & RQSTF_NEGOTIATION) { 4544 SNPRINTF(buf, sizeof (buf), "%s Negotiation", buf); 4545 } 4546 isp_prt(isp, ISP_LOGERR, "%s", buf); 4547 isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d:\n%s", 4548 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), buf); 4549 break; 4550 } 4551 case RQCS_RESET_OCCURRED: 4552 isp_prt(isp, ISP_LOGWARN, 4553 "bus reset destroyed command for %d.%d.%d", 4554 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4555 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs)); 4556 if (XS_NOERR(xs)) { 4557 XS_SETERR(xs, HBA_BUSRESET); 4558 } 4559 return; 4560 4561 case RQCS_ABORTED: 4562 isp_prt(isp, ISP_LOGERR, "command aborted for %d.%d.%d", 4563 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4564 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs)); 4565 if (XS_NOERR(xs)) { 4566 XS_SETERR(xs, HBA_ABORTED); 4567 } 4568 return; 4569 4570 case RQCS_TIMEOUT: 4571 isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d", 4572 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4573 /* 4574 * Check to see if we logged out the device. 4575 */ 4576 if (IS_FC(isp)) { 4577 if ((sp->req_completion_status & RQSTF_LOGOUT) && 4578 FCPARAM(isp)->portdb[XS_TGT(xs)].valid && 4579 FCPARAM(isp)->portdb[XS_TGT(xs)].fabric_dev) { 4580 FCPARAM(isp)->portdb[XS_TGT(xs)].relogin = 1; 4581 } 4582 } 4583 if (XS_NOERR(xs)) { 4584 XS_SETERR(xs, HBA_CMDTIMEOUT); 4585 } 4586 return; 4587 4588 case RQCS_DATA_OVERRUN: 4589 XS_RESID(xs) = sp->req_resid; 4590 isp_prt(isp, ISP_LOGERR, "data overrun for command on %d.%d.%d", 4591 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4592 if (XS_NOERR(xs)) { 4593 XS_SETERR(xs, HBA_DATAOVR); 4594 } 4595 return; 4596 4597 case RQCS_COMMAND_OVERRUN: 4598 isp_prt(isp, ISP_LOGERR, 4599 "command overrun for command on %d.%d.%d", 4600 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4601 break; 4602 4603 case RQCS_STATUS_OVERRUN: 4604 isp_prt(isp, ISP_LOGERR, 4605 "status overrun for command on %d.%d.%d", 4606 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4607 break; 4608 4609 case RQCS_BAD_MESSAGE: 4610 isp_prt(isp, ISP_LOGERR, 4611 "msg not COMMAND COMPLETE after status %d.%d.%d", 4612 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4613 break; 4614 4615 case RQCS_NO_MESSAGE_OUT: 4616 isp_prt(isp, ISP_LOGERR, 4617 "No MESSAGE OUT phase after selection on %d.%d.%d", 4618 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4619 break; 4620 4621 case RQCS_EXT_ID_FAILED: 4622 isp_prt(isp, ISP_LOGERR, "EXTENDED IDENTIFY failed %d.%d.%d", 4623 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4624 break; 4625 4626 case RQCS_IDE_MSG_FAILED: 4627 isp_prt(isp, ISP_LOGERR, 4628 "INITIATOR DETECTED ERROR rejected by %d.%d.%d", 4629 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4630 break; 4631 4632 case RQCS_ABORT_MSG_FAILED: 4633 isp_prt(isp, ISP_LOGERR, "ABORT OPERATION rejected by %d.%d.%d", 4634 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4635 break; 4636 4637 case RQCS_REJECT_MSG_FAILED: 4638 isp_prt(isp, ISP_LOGERR, "MESSAGE REJECT rejected by %d.%d.%d", 4639 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4640 break; 4641 4642 case RQCS_NOP_MSG_FAILED: 4643 isp_prt(isp, ISP_LOGERR, "NOP rejected by %d.%d.%d", 4644 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4645 break; 4646 4647 case RQCS_PARITY_ERROR_MSG_FAILED: 4648 isp_prt(isp, ISP_LOGERR, 4649 "MESSAGE PARITY ERROR rejected by %d.%d.%d", 4650 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4651 break; 4652 4653 case RQCS_DEVICE_RESET_MSG_FAILED: 4654 isp_prt(isp, ISP_LOGWARN, 4655 "BUS DEVICE RESET rejected by %d.%d.%d", 4656 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4657 break; 4658 4659 case RQCS_ID_MSG_FAILED: 4660 isp_prt(isp, ISP_LOGERR, "IDENTIFY rejected by %d.%d.%d", 4661 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4662 break; 4663 4664 case RQCS_UNEXP_BUS_FREE: 4665 isp_prt(isp, ISP_LOGERR, "%d.%d.%d had an unexpected bus free", 4666 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4667 break; 4668 4669 case RQCS_DATA_UNDERRUN: 4670 { 4671 if (IS_FC(isp)) { 4672 int ru_marked = (sp->req_scsi_status & RQCS_RU) != 0; 4673 if (!ru_marked || sp->req_resid > XS_XFRLEN(xs)) { 4674 isp_prt(isp, ISP_LOGWARN, bun, XS_TGT(xs), 4675 XS_LUN(xs), XS_XFRLEN(xs), sp->req_resid, 4676 (ru_marked)? "marked" : "not marked"); 4677 if (XS_NOERR(xs)) { 4678 XS_SETERR(xs, HBA_BOTCH); 4679 } 4680 return; 4681 } 4682 } 4683 XS_RESID(xs) = sp->req_resid; 4684 if (XS_NOERR(xs)) { 4685 XS_SETERR(xs, HBA_NOERROR); 4686 } 4687 return; 4688 } 4689 4690 case RQCS_XACT_ERR1: 4691 isp_prt(isp, ISP_LOGERR, xact1, XS_CHANNEL(xs), 4692 XS_TGT(xs), XS_LUN(xs)); 4693 break; 4694 4695 case RQCS_XACT_ERR2: 4696 isp_prt(isp, ISP_LOGERR, xact2, 4697 XS_LUN(xs), XS_TGT(xs), XS_CHANNEL(xs)); 4698 break; 4699 4700 case RQCS_XACT_ERR3: 4701 isp_prt(isp, ISP_LOGERR, xact3, 4702 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4703 break; 4704 4705 case RQCS_BAD_ENTRY: 4706 isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected"); 4707 break; 4708 4709 case RQCS_QUEUE_FULL: 4710 isp_prt(isp, ISP_LOGDEBUG0, 4711 "internal queues full for %d.%d.%d status 0x%x", 4712 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), *XS_STSP(xs)); 4713 4714 /* 4715 * If QFULL or some other status byte is set, then this 4716 * isn't an error, per se. 4717 * 4718 * Unfortunately, some QLogic f/w writers have, in 4719 * some cases, ommitted to *set* status to QFULL. 4720 * 4721 4722 if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) { 4723 XS_SETERR(xs, HBA_NOERROR); 4724 return; 4725 } 4726 4727 * 4728 * 4729 */ 4730 4731 *XS_STSP(xs) = SCSI_QFULL; 4732 XS_SETERR(xs, HBA_NOERROR); 4733 return; 4734 4735 case RQCS_PHASE_SKIPPED: 4736 isp_prt(isp, ISP_LOGERR, pskip, XS_CHANNEL(xs), 4737 XS_TGT(xs), XS_LUN(xs)); 4738 break; 4739 4740 case RQCS_ARQS_FAILED: 4741 isp_prt(isp, ISP_LOGERR, 4742 "Auto Request Sense failed for %d.%d.%d", 4743 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 4744 if (XS_NOERR(xs)) { 4745 XS_SETERR(xs, HBA_ARQFAIL); 4746 } 4747 return; 4748 4749 case RQCS_WIDE_FAILED: 4750 isp_prt(isp, ISP_LOGERR, 4751 "Wide Negotiation failed for %d.%d.%d", 4752 XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs)); 4753 if (IS_SCSI(isp)) { 4754 sdparam *sdp = isp->isp_param; 4755 sdp += XS_CHANNEL(xs); 4756 sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_WIDE; 4757 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1; 4758 isp->isp_update |= (1 << XS_CHANNEL(xs)); 4759 } 4760 if (XS_NOERR(xs)) { 4761 XS_SETERR(xs, HBA_NOERROR); 4762 } 4763 return; 4764 4765 case RQCS_SYNCXFER_FAILED: 4766 isp_prt(isp, ISP_LOGERR, 4767 "SDTR Message failed for target %d.%d.%d", 4768 XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs)); 4769 if (IS_SCSI(isp)) { 4770 sdparam *sdp = isp->isp_param; 4771 sdp += XS_CHANNEL(xs); 4772 sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_SYNC; 4773 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1; 4774 isp->isp_update |= (1 << XS_CHANNEL(xs)); 4775 } 4776 break; 4777 4778 case RQCS_LVD_BUSERR: 4779 isp_prt(isp, ISP_LOGERR, 4780 "Bad LVD condition while talking to %d.%d.%d", 4781 XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs)); 4782 break; 4783 4784 case RQCS_PORT_UNAVAILABLE: 4785 /* 4786 * No such port on the loop. Moral equivalent of SELTIMEO 4787 */ 4788 case RQCS_PORT_LOGGED_OUT: 4789 /* 4790 * It was there (maybe)- treat as a selection timeout. 4791 */ 4792 if ((sp->req_completion_status & 0xff) == RQCS_PORT_UNAVAILABLE) 4793 isp_prt(isp, ISP_LOGINFO, 4794 "port unavailable for target %d", XS_TGT(xs)); 4795 else 4796 isp_prt(isp, ISP_LOGINFO, 4797 "port logout for target %d", XS_TGT(xs)); 4798 /* 4799 * If we're on a local loop, force a LIP (which is overkill) 4800 * to force a re-login of this unit. If we're on fabric, 4801 * then we'll have to relogin as a matter of course. 4802 */ 4803 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT || 4804 FCPARAM(isp)->isp_topo == TOPO_FL_PORT) { 4805 mbreg_t mbs; 4806 MEMZERO(&mbs, sizeof (mbs)); 4807 mbs.param[0] = MBOX_INIT_LIP; 4808 isp_mboxcmd_qnw(isp, &mbs, 1); 4809 } 4810 4811 /* 4812 * Probably overkill. 4813 */ 4814 isp->isp_sendmarker = 1; 4815 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD; 4816 isp_mark_getpdb_all(isp); 4817 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER); 4818 if (XS_NOERR(xs)) { 4819 XS_SETERR(xs, HBA_SELTIMEOUT); 4820 } 4821 return; 4822 4823 case RQCS_PORT_CHANGED: 4824 isp_prt(isp, ISP_LOGWARN, 4825 "port changed for target %d", XS_TGT(xs)); 4826 if (XS_NOERR(xs)) { 4827 XS_SETERR(xs, HBA_SELTIMEOUT); 4828 } 4829 return; 4830 4831 case RQCS_PORT_BUSY: 4832 isp_prt(isp, ISP_LOGWARN, 4833 "port busy for target %d", XS_TGT(xs)); 4834 if (XS_NOERR(xs)) { 4835 XS_SETERR(xs, HBA_TGTBSY); 4836 } 4837 return; 4838 4839 default: 4840 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x", 4841 sp->req_completion_status); 4842 break; 4843 } 4844 if (XS_NOERR(xs)) { 4845 XS_SETERR(xs, HBA_BOTCH); 4846 } 4847 } 4848 4849 static void 4850 isp_fastpost_complete(struct ispsoftc *isp, u_int16_t fph) 4851 { 4852 XS_T *xs; 4853 4854 if (fph == 0) { 4855 return; 4856 } 4857 xs = isp_find_xs(isp, fph); 4858 if (xs == NULL) { 4859 isp_prt(isp, ISP_LOGWARN, 4860 "Command for fast post handle 0x%x not found", fph); 4861 return; 4862 } 4863 isp_destroy_handle(isp, fph); 4864 4865 /* 4866 * Since we don't have a result queue entry item, 4867 * we must believe that SCSI status is zero and 4868 * that all data transferred. 4869 */ 4870 XS_SET_STATE_STAT(isp, xs, NULL); 4871 XS_RESID(xs) = 0; 4872 *XS_STSP(xs) = SCSI_GOOD; 4873 if (XS_XFRLEN(xs)) { 4874 ISP_DMAFREE(isp, xs, fph); 4875 } 4876 if (isp->isp_nactive) 4877 isp->isp_nactive--; 4878 isp->isp_fphccmplt++; 4879 isp_done(xs); 4880 } 4881 4882 static int 4883 isp_mbox_continue(struct ispsoftc *isp) 4884 { 4885 mbreg_t mbs; 4886 u_int16_t *ptr; 4887 4888 switch (isp->isp_lastmbxcmd) { 4889 case MBOX_WRITE_RAM_WORD: 4890 case MBOX_READ_RAM_WORD: 4891 case MBOX_READ_RAM_WORD_EXTENDED: 4892 break; 4893 default: 4894 return (1); 4895 } 4896 if (isp->isp_mboxtmp[0] != MBOX_COMMAND_COMPLETE) { 4897 isp->isp_mbxwrk0 = 0; 4898 return (-1); 4899 } 4900 4901 /* 4902 * Clear the previous interrupt. 4903 */ 4904 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 4905 ISP_WRITE(isp, BIU_SEMA, 0); 4906 4907 /* 4908 * Continue with next word. 4909 */ 4910 MEMZERO(&mbs, sizeof (mbs)); 4911 ptr = isp->isp_mbxworkp; 4912 switch (isp->isp_lastmbxcmd) { 4913 case MBOX_WRITE_RAM_WORD: 4914 mbs.param[2] = *ptr++; 4915 mbs.param[1] = isp->isp_mbxwrk1++; 4916 break; 4917 case MBOX_READ_RAM_WORD: 4918 case MBOX_READ_RAM_WORD_EXTENDED: 4919 *ptr++ = isp->isp_mboxtmp[2]; 4920 mbs.param[1] = isp->isp_mbxwrk1++; 4921 break; 4922 } 4923 isp->isp_mbxworkp = ptr; 4924 mbs.param[0] = isp->isp_lastmbxcmd; 4925 isp->isp_mbxwrk0 -= 1; 4926 isp_mboxcmd_qnw(isp, &mbs, 0); 4927 return (0); 4928 } 4929 4930 4931 #define HIWRD(x) ((x) >> 16) 4932 #define LOWRD(x) ((x) & 0xffff) 4933 #define ISPOPMAP(a, b) (((a) << 16) | (b)) 4934 static const u_int32_t mbpscsi[] = { 4935 ISPOPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */ 4936 ISPOPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */ 4937 ISPOPMAP(0x03, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */ 4938 ISPOPMAP(0x1f, 0x01), /* 0x03: MBOX_DUMP_RAM */ 4939 ISPOPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */ 4940 ISPOPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */ 4941 ISPOPMAP(0x3f, 0x3f), /* 0x06: MBOX_MAILBOX_REG_TEST */ 4942 ISPOPMAP(0x03, 0x07), /* 0x07: MBOX_VERIFY_CHECKSUM */ 4943 ISPOPMAP(0x01, 0x0f), /* 0x08: MBOX_ABOUT_FIRMWARE */ 4944 ISPOPMAP(0x00, 0x00), /* 0x09: */ 4945 ISPOPMAP(0x00, 0x00), /* 0x0a: */ 4946 ISPOPMAP(0x00, 0x00), /* 0x0b: */ 4947 ISPOPMAP(0x00, 0x00), /* 0x0c: */ 4948 ISPOPMAP(0x00, 0x00), /* 0x0d: */ 4949 ISPOPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */ 4950 ISPOPMAP(0x00, 0x00), /* 0x0f: */ 4951 ISPOPMAP(0x1f, 0x1f), /* 0x10: MBOX_INIT_REQ_QUEUE */ 4952 ISPOPMAP(0x3f, 0x3f), /* 0x11: MBOX_INIT_RES_QUEUE */ 4953 ISPOPMAP(0x0f, 0x0f), /* 0x12: MBOX_EXECUTE_IOCB */ 4954 ISPOPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */ 4955 ISPOPMAP(0x01, 0x3f), /* 0x14: MBOX_STOP_FIRMWARE */ 4956 ISPOPMAP(0x0f, 0x0f), /* 0x15: MBOX_ABORT */ 4957 ISPOPMAP(0x03, 0x03), /* 0x16: MBOX_ABORT_DEVICE */ 4958 ISPOPMAP(0x07, 0x07), /* 0x17: MBOX_ABORT_TARGET */ 4959 ISPOPMAP(0x07, 0x07), /* 0x18: MBOX_BUS_RESET */ 4960 ISPOPMAP(0x03, 0x07), /* 0x19: MBOX_STOP_QUEUE */ 4961 ISPOPMAP(0x03, 0x07), /* 0x1a: MBOX_START_QUEUE */ 4962 ISPOPMAP(0x03, 0x07), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */ 4963 ISPOPMAP(0x03, 0x07), /* 0x1c: MBOX_ABORT_QUEUE */ 4964 ISPOPMAP(0x03, 0x4f), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */ 4965 ISPOPMAP(0x00, 0x00), /* 0x1e: */ 4966 ISPOPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */ 4967 ISPOPMAP(0x01, 0x07), /* 0x20: MBOX_GET_INIT_SCSI_ID */ 4968 ISPOPMAP(0x01, 0x07), /* 0x21: MBOX_GET_SELECT_TIMEOUT */ 4969 ISPOPMAP(0x01, 0xc7), /* 0x22: MBOX_GET_RETRY_COUNT */ 4970 ISPOPMAP(0x01, 0x07), /* 0x23: MBOX_GET_TAG_AGE_LIMIT */ 4971 ISPOPMAP(0x01, 0x03), /* 0x24: MBOX_GET_CLOCK_RATE */ 4972 ISPOPMAP(0x01, 0x07), /* 0x25: MBOX_GET_ACT_NEG_STATE */ 4973 ISPOPMAP(0x01, 0x07), /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */ 4974 ISPOPMAP(0x01, 0x07), /* 0x27: MBOX_GET_PCI_PARAMS */ 4975 ISPOPMAP(0x03, 0x4f), /* 0x28: MBOX_GET_TARGET_PARAMS */ 4976 ISPOPMAP(0x03, 0x0f), /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */ 4977 ISPOPMAP(0x01, 0x07), /* 0x2a: MBOX_GET_RESET_DELAY_PARAMS */ 4978 ISPOPMAP(0x00, 0x00), /* 0x2b: */ 4979 ISPOPMAP(0x00, 0x00), /* 0x2c: */ 4980 ISPOPMAP(0x00, 0x00), /* 0x2d: */ 4981 ISPOPMAP(0x00, 0x00), /* 0x2e: */ 4982 ISPOPMAP(0x00, 0x00), /* 0x2f: */ 4983 ISPOPMAP(0x03, 0x03), /* 0x30: MBOX_SET_INIT_SCSI_ID */ 4984 ISPOPMAP(0x07, 0x07), /* 0x31: MBOX_SET_SELECT_TIMEOUT */ 4985 ISPOPMAP(0xc7, 0xc7), /* 0x32: MBOX_SET_RETRY_COUNT */ 4986 ISPOPMAP(0x07, 0x07), /* 0x33: MBOX_SET_TAG_AGE_LIMIT */ 4987 ISPOPMAP(0x03, 0x03), /* 0x34: MBOX_SET_CLOCK_RATE */ 4988 ISPOPMAP(0x07, 0x07), /* 0x35: MBOX_SET_ACT_NEG_STATE */ 4989 ISPOPMAP(0x07, 0x07), /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */ 4990 ISPOPMAP(0x07, 0x07), /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */ 4991 ISPOPMAP(0x4f, 0x4f), /* 0x38: MBOX_SET_TARGET_PARAMS */ 4992 ISPOPMAP(0x0f, 0x0f), /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */ 4993 ISPOPMAP(0x07, 0x07), /* 0x3a: MBOX_SET_RESET_DELAY_PARAMS */ 4994 ISPOPMAP(0x00, 0x00), /* 0x3b: */ 4995 ISPOPMAP(0x00, 0x00), /* 0x3c: */ 4996 ISPOPMAP(0x00, 0x00), /* 0x3d: */ 4997 ISPOPMAP(0x00, 0x00), /* 0x3e: */ 4998 ISPOPMAP(0x00, 0x00), /* 0x3f: */ 4999 ISPOPMAP(0x01, 0x03), /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */ 5000 ISPOPMAP(0x3f, 0x01), /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */ 5001 ISPOPMAP(0x03, 0x07), /* 0x42: MBOX_EXEC_BIOS_IOCB */ 5002 ISPOPMAP(0x00, 0x00), /* 0x43: */ 5003 ISPOPMAP(0x00, 0x00), /* 0x44: */ 5004 ISPOPMAP(0x03, 0x03), /* 0x45: SET SYSTEM PARAMETER */ 5005 ISPOPMAP(0x01, 0x03), /* 0x46: GET SYSTEM PARAMETER */ 5006 ISPOPMAP(0x00, 0x00), /* 0x47: */ 5007 ISPOPMAP(0x01, 0xcf), /* 0x48: GET SCAM CONFIGURATION */ 5008 ISPOPMAP(0xcf, 0xcf), /* 0x49: SET SCAM CONFIGURATION */ 5009 ISPOPMAP(0x03, 0x03), /* 0x4a: MBOX_SET_FIRMWARE_FEATURES */ 5010 ISPOPMAP(0x01, 0x03), /* 0x4b: MBOX_GET_FIRMWARE_FEATURES */ 5011 ISPOPMAP(0x00, 0x00), /* 0x4c: */ 5012 ISPOPMAP(0x00, 0x00), /* 0x4d: */ 5013 ISPOPMAP(0x00, 0x00), /* 0x4e: */ 5014 ISPOPMAP(0x00, 0x00), /* 0x4f: */ 5015 ISPOPMAP(0xdf, 0xdf), /* 0x50: LOAD RAM A64 */ 5016 ISPOPMAP(0xdf, 0xdf), /* 0x51: DUMP RAM A64 */ 5017 ISPOPMAP(0xdf, 0xff), /* 0x52: INITIALIZE REQUEST QUEUE A64 */ 5018 ISPOPMAP(0xef, 0xff), /* 0x53: INITIALIZE RESPONSE QUEUE A64 */ 5019 ISPOPMAP(0xcf, 0x01), /* 0x54: EXECUTE IOCB A64 */ 5020 ISPOPMAP(0x07, 0x01), /* 0x55: ENABLE TARGET MODE */ 5021 ISPOPMAP(0x03, 0x0f), /* 0x56: GET TARGET STATUS */ 5022 ISPOPMAP(0x00, 0x00), /* 0x57: */ 5023 ISPOPMAP(0x00, 0x00), /* 0x58: */ 5024 ISPOPMAP(0x00, 0x00), /* 0x59: */ 5025 ISPOPMAP(0x03, 0x03), /* 0x5a: SET DATA OVERRUN RECOVERY MODE */ 5026 ISPOPMAP(0x01, 0x03), /* 0x5b: GET DATA OVERRUN RECOVERY MODE */ 5027 ISPOPMAP(0x0f, 0x0f), /* 0x5c: SET HOST DATA */ 5028 ISPOPMAP(0x01, 0x01) /* 0x5d: GET NOST DATA */ 5029 }; 5030 5031 #ifndef ISP_STRIPPED 5032 static char *scsi_mbcmd_names[] = { 5033 "NO-OP", 5034 "LOAD RAM", 5035 "EXEC FIRMWARE", 5036 "DUMP RAM", 5037 "WRITE RAM WORD", 5038 "READ RAM WORD", 5039 "MAILBOX REG TEST", 5040 "VERIFY CHECKSUM", 5041 "ABOUT FIRMWARE", 5042 NULL, 5043 NULL, 5044 NULL, 5045 NULL, 5046 NULL, 5047 "CHECK FIRMWARE", 5048 NULL, 5049 "INIT REQUEST QUEUE", 5050 "INIT RESULT QUEUE", 5051 "EXECUTE IOCB", 5052 "WAKE UP", 5053 "STOP FIRMWARE", 5054 "ABORT", 5055 "ABORT DEVICE", 5056 "ABORT TARGET", 5057 "BUS RESET", 5058 "STOP QUEUE", 5059 "START QUEUE", 5060 "SINGLE STEP QUEUE", 5061 "ABORT QUEUE", 5062 "GET DEV QUEUE STATUS", 5063 NULL, 5064 "GET FIRMWARE STATUS", 5065 "GET INIT SCSI ID", 5066 "GET SELECT TIMEOUT", 5067 "GET RETRY COUNT", 5068 "GET TAG AGE LIMIT", 5069 "GET CLOCK RATE", 5070 "GET ACT NEG STATE", 5071 "GET ASYNC DATA SETUP TIME", 5072 "GET PCI PARAMS", 5073 "GET TARGET PARAMS", 5074 "GET DEV QUEUE PARAMS", 5075 "GET RESET DELAY PARAMS", 5076 NULL, 5077 NULL, 5078 NULL, 5079 NULL, 5080 NULL, 5081 "SET INIT SCSI ID", 5082 "SET SELECT TIMEOUT", 5083 "SET RETRY COUNT", 5084 "SET TAG AGE LIMIT", 5085 "SET CLOCK RATE", 5086 "SET ACT NEG STATE", 5087 "SET ASYNC DATA SETUP TIME", 5088 "SET PCI CONTROL PARAMS", 5089 "SET TARGET PARAMS", 5090 "SET DEV QUEUE PARAMS", 5091 "SET RESET DELAY PARAMS", 5092 NULL, 5093 NULL, 5094 NULL, 5095 NULL, 5096 NULL, 5097 "RETURN BIOS BLOCK ADDR", 5098 "WRITE FOUR RAM WORDS", 5099 "EXEC BIOS IOCB", 5100 NULL, 5101 NULL, 5102 "SET SYSTEM PARAMETER", 5103 "GET SYSTEM PARAMETER", 5104 NULL, 5105 "GET SCAM CONFIGURATION", 5106 "SET SCAM CONFIGURATION", 5107 "SET FIRMWARE FEATURES", 5108 "GET FIRMWARE FEATURES", 5109 NULL, 5110 NULL, 5111 NULL, 5112 NULL, 5113 "LOAD RAM A64", 5114 "DUMP RAM A64", 5115 "INITIALIZE REQUEST QUEUE A64", 5116 "INITIALIZE RESPONSE QUEUE A64", 5117 "EXECUTE IOCB A64", 5118 "ENABLE TARGET MODE", 5119 "GET TARGET MODE STATE", 5120 NULL, 5121 NULL, 5122 NULL, 5123 "SET DATA OVERRUN RECOVERY MODE", 5124 "GET DATA OVERRUN RECOVERY MODE", 5125 "SET HOST DATA", 5126 "GET NOST DATA", 5127 }; 5128 #endif 5129 5130 static const u_int32_t mbpfc[] = { 5131 ISPOPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */ 5132 ISPOPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */ 5133 ISPOPMAP(0x03, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */ 5134 ISPOPMAP(0xdf, 0x01), /* 0x03: MBOX_DUMP_RAM */ 5135 ISPOPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */ 5136 ISPOPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */ 5137 ISPOPMAP(0xff, 0xff), /* 0x06: MBOX_MAILBOX_REG_TEST */ 5138 ISPOPMAP(0x03, 0x05), /* 0x07: MBOX_VERIFY_CHECKSUM */ 5139 ISPOPMAP(0x01, 0x4f), /* 0x08: MBOX_ABOUT_FIRMWARE */ 5140 ISPOPMAP(0xdf, 0x01), /* 0x09: LOAD RAM */ 5141 ISPOPMAP(0xdf, 0x01), /* 0x0a: DUMP RAM */ 5142 ISPOPMAP(0x00, 0x00), /* 0x0b: */ 5143 ISPOPMAP(0x00, 0x00), /* 0x0c: */ 5144 ISPOPMAP(0x00, 0x00), /* 0x0d: */ 5145 ISPOPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */ 5146 ISPOPMAP(0x03, 0x07), /* 0x0f: MBOX_READ_RAM_WORD_EXTENDED(1) */ 5147 ISPOPMAP(0x1f, 0x11), /* 0x10: MBOX_INIT_REQ_QUEUE */ 5148 ISPOPMAP(0x2f, 0x21), /* 0x11: MBOX_INIT_RES_QUEUE */ 5149 ISPOPMAP(0x0f, 0x01), /* 0x12: MBOX_EXECUTE_IOCB */ 5150 ISPOPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */ 5151 ISPOPMAP(0x01, 0xff), /* 0x14: MBOX_STOP_FIRMWARE */ 5152 ISPOPMAP(0x4f, 0x01), /* 0x15: MBOX_ABORT */ 5153 ISPOPMAP(0x07, 0x01), /* 0x16: MBOX_ABORT_DEVICE */ 5154 ISPOPMAP(0x07, 0x01), /* 0x17: MBOX_ABORT_TARGET */ 5155 ISPOPMAP(0x03, 0x03), /* 0x18: MBOX_BUS_RESET */ 5156 ISPOPMAP(0x07, 0x05), /* 0x19: MBOX_STOP_QUEUE */ 5157 ISPOPMAP(0x07, 0x05), /* 0x1a: MBOX_START_QUEUE */ 5158 ISPOPMAP(0x07, 0x05), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */ 5159 ISPOPMAP(0x07, 0x05), /* 0x1c: MBOX_ABORT_QUEUE */ 5160 ISPOPMAP(0x07, 0x03), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */ 5161 ISPOPMAP(0x00, 0x00), /* 0x1e: */ 5162 ISPOPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */ 5163 ISPOPMAP(0x01, 0x4f), /* 0x20: MBOX_GET_LOOP_ID */ 5164 ISPOPMAP(0x00, 0x00), /* 0x21: */ 5165 ISPOPMAP(0x01, 0x07), /* 0x22: MBOX_GET_RETRY_COUNT */ 5166 ISPOPMAP(0x00, 0x00), /* 0x23: */ 5167 ISPOPMAP(0x00, 0x00), /* 0x24: */ 5168 ISPOPMAP(0x00, 0x00), /* 0x25: */ 5169 ISPOPMAP(0x00, 0x00), /* 0x26: */ 5170 ISPOPMAP(0x00, 0x00), /* 0x27: */ 5171 ISPOPMAP(0x01, 0x03), /* 0x28: MBOX_GET_FIRMWARE_OPTIONS */ 5172 ISPOPMAP(0x03, 0x07), /* 0x29: MBOX_GET_PORT_QUEUE_PARAMS */ 5173 ISPOPMAP(0x00, 0x00), /* 0x2a: */ 5174 ISPOPMAP(0x00, 0x00), /* 0x2b: */ 5175 ISPOPMAP(0x00, 0x00), /* 0x2c: */ 5176 ISPOPMAP(0x00, 0x00), /* 0x2d: */ 5177 ISPOPMAP(0x00, 0x00), /* 0x2e: */ 5178 ISPOPMAP(0x00, 0x00), /* 0x2f: */ 5179 ISPOPMAP(0x00, 0x00), /* 0x30: */ 5180 ISPOPMAP(0x00, 0x00), /* 0x31: */ 5181 ISPOPMAP(0x07, 0x07), /* 0x32: MBOX_SET_RETRY_COUNT */ 5182 ISPOPMAP(0x00, 0x00), /* 0x33: */ 5183 ISPOPMAP(0x00, 0x00), /* 0x34: */ 5184 ISPOPMAP(0x00, 0x00), /* 0x35: */ 5185 ISPOPMAP(0x00, 0x00), /* 0x36: */ 5186 ISPOPMAP(0x00, 0x00), /* 0x37: */ 5187 ISPOPMAP(0x0f, 0x01), /* 0x38: MBOX_SET_FIRMWARE_OPTIONS */ 5188 ISPOPMAP(0x0f, 0x07), /* 0x39: MBOX_SET_PORT_QUEUE_PARAMS */ 5189 ISPOPMAP(0x00, 0x00), /* 0x3a: */ 5190 ISPOPMAP(0x00, 0x00), /* 0x3b: */ 5191 ISPOPMAP(0x00, 0x00), /* 0x3c: */ 5192 ISPOPMAP(0x00, 0x00), /* 0x3d: */ 5193 ISPOPMAP(0x00, 0x00), /* 0x3e: */ 5194 ISPOPMAP(0x00, 0x00), /* 0x3f: */ 5195 ISPOPMAP(0x03, 0x01), /* 0x40: MBOX_LOOP_PORT_BYPASS */ 5196 ISPOPMAP(0x03, 0x01), /* 0x41: MBOX_LOOP_PORT_ENABLE */ 5197 ISPOPMAP(0x03, 0x07), /* 0x42: MBOX_GET_RESOURCE_COUNTS */ 5198 ISPOPMAP(0x01, 0x01), /* 0x43: MBOX_REQUEST_NON_PARTICIPATING_MODE */ 5199 ISPOPMAP(0x00, 0x00), /* 0x44: */ 5200 ISPOPMAP(0x00, 0x00), /* 0x45: */ 5201 ISPOPMAP(0x00, 0x00), /* 0x46: */ 5202 ISPOPMAP(0xcf, 0x03), /* 0x47: GET PORT_DATABASE ENHANCED */ 5203 ISPOPMAP(0x00, 0x00), /* 0x48: */ 5204 ISPOPMAP(0x00, 0x00), /* 0x49: */ 5205 ISPOPMAP(0x00, 0x00), /* 0x4a: */ 5206 ISPOPMAP(0x00, 0x00), /* 0x4b: */ 5207 ISPOPMAP(0x00, 0x00), /* 0x4c: */ 5208 ISPOPMAP(0x00, 0x00), /* 0x4d: */ 5209 ISPOPMAP(0x00, 0x00), /* 0x4e: */ 5210 ISPOPMAP(0x00, 0x00), /* 0x4f: */ 5211 ISPOPMAP(0x00, 0x00), /* 0x50: */ 5212 ISPOPMAP(0x00, 0x00), /* 0x51: */ 5213 ISPOPMAP(0x00, 0x00), /* 0x52: */ 5214 ISPOPMAP(0x00, 0x00), /* 0x53: */ 5215 ISPOPMAP(0xcf, 0x01), /* 0x54: EXECUTE IOCB A64 */ 5216 ISPOPMAP(0x00, 0x00), /* 0x55: */ 5217 ISPOPMAP(0x00, 0x00), /* 0x56: */ 5218 ISPOPMAP(0x00, 0x00), /* 0x57: */ 5219 ISPOPMAP(0x00, 0x00), /* 0x58: */ 5220 ISPOPMAP(0x00, 0x00), /* 0x59: */ 5221 ISPOPMAP(0x00, 0x00), /* 0x5a: */ 5222 ISPOPMAP(0x03, 0x01), /* 0x5b: MBOX_DRIVER_HEARTBEAT */ 5223 ISPOPMAP(0xcf, 0x01), /* 0x5c: MBOX_FW_HEARTBEAT */ 5224 ISPOPMAP(0x07, 0x03), /* 0x5d: MBOX_GET_SET_DATA_RATE */ 5225 ISPOPMAP(0x00, 0x00), /* 0x5e: */ 5226 ISPOPMAP(0x00, 0x00), /* 0x5f: */ 5227 ISPOPMAP(0xfd, 0x31), /* 0x60: MBOX_INIT_FIRMWARE */ 5228 ISPOPMAP(0x00, 0x00), /* 0x61: */ 5229 ISPOPMAP(0x01, 0x01), /* 0x62: MBOX_INIT_LIP */ 5230 ISPOPMAP(0xcd, 0x03), /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */ 5231 ISPOPMAP(0xcf, 0x01), /* 0x64: MBOX_GET_PORT_DB */ 5232 ISPOPMAP(0x07, 0x01), /* 0x65: MBOX_CLEAR_ACA */ 5233 ISPOPMAP(0x07, 0x01), /* 0x66: MBOX_TARGET_RESET */ 5234 ISPOPMAP(0x07, 0x01), /* 0x67: MBOX_CLEAR_TASK_SET */ 5235 ISPOPMAP(0x07, 0x01), /* 0x68: MBOX_ABORT_TASK_SET */ 5236 ISPOPMAP(0x01, 0x07), /* 0x69: MBOX_GET_FW_STATE */ 5237 ISPOPMAP(0x03, 0xcf), /* 0x6a: MBOX_GET_PORT_NAME */ 5238 ISPOPMAP(0xcf, 0x01), /* 0x6b: MBOX_GET_LINK_STATUS */ 5239 ISPOPMAP(0x0f, 0x01), /* 0x6c: MBOX_INIT_LIP_RESET */ 5240 ISPOPMAP(0x00, 0x00), /* 0x6d: */ 5241 ISPOPMAP(0xcf, 0x03), /* 0x6e: MBOX_SEND_SNS */ 5242 ISPOPMAP(0x0f, 0x07), /* 0x6f: MBOX_FABRIC_LOGIN */ 5243 ISPOPMAP(0x03, 0x01), /* 0x70: MBOX_SEND_CHANGE_REQUEST */ 5244 ISPOPMAP(0x03, 0x03), /* 0x71: MBOX_FABRIC_LOGOUT */ 5245 ISPOPMAP(0x0f, 0x0f), /* 0x72: MBOX_INIT_LIP_LOGIN */ 5246 ISPOPMAP(0x00, 0x00), /* 0x73: */ 5247 ISPOPMAP(0x07, 0x01), /* 0x74: LOGIN LOOP PORT */ 5248 ISPOPMAP(0xcf, 0x03), /* 0x75: GET PORT/NODE NAME LIST */ 5249 ISPOPMAP(0x4f, 0x01), /* 0x76: SET VENDOR ID */ 5250 ISPOPMAP(0xcd, 0x01), /* 0x77: INITIALIZE IP MAILBOX */ 5251 ISPOPMAP(0x00, 0x00), /* 0x78: */ 5252 ISPOPMAP(0x00, 0x00), /* 0x79: */ 5253 ISPOPMAP(0x00, 0x00), /* 0x7a: */ 5254 ISPOPMAP(0x00, 0x00), /* 0x7b: */ 5255 ISPOPMAP(0x4f, 0x03), /* 0x7c: Get ID List */ 5256 ISPOPMAP(0xcf, 0x01), /* 0x7d: SEND LFA */ 5257 ISPOPMAP(0x0f, 0x01) /* 0x7e: LUN RESET */ 5258 }; 5259 /* 5260 * Footnotes 5261 * 5262 * (1): this sets bits 21..16 in mailbox register #8, which we nominally 5263 * do not access at this time in the core driver. The caller is 5264 * responsible for setting this register first (Gross!). 5265 */ 5266 5267 #ifndef ISP_STRIPPED 5268 static char *fc_mbcmd_names[] = { 5269 "NO-OP", 5270 "LOAD RAM", 5271 "EXEC FIRMWARE", 5272 "DUMP RAM", 5273 "WRITE RAM WORD", 5274 "READ RAM WORD", 5275 "MAILBOX REG TEST", 5276 "VERIFY CHECKSUM", 5277 "ABOUT FIRMWARE", 5278 "LOAD RAM", 5279 "DUMP RAM", 5280 NULL, 5281 NULL, 5282 "READ RAM WORD EXTENDED", 5283 "CHECK FIRMWARE", 5284 NULL, 5285 "INIT REQUEST QUEUE", 5286 "INIT RESULT QUEUE", 5287 "EXECUTE IOCB", 5288 "WAKE UP", 5289 "STOP FIRMWARE", 5290 "ABORT", 5291 "ABORT DEVICE", 5292 "ABORT TARGET", 5293 "BUS RESET", 5294 "STOP QUEUE", 5295 "START QUEUE", 5296 "SINGLE STEP QUEUE", 5297 "ABORT QUEUE", 5298 "GET DEV QUEUE STATUS", 5299 NULL, 5300 "GET FIRMWARE STATUS", 5301 "GET LOOP ID", 5302 NULL, 5303 "GET RETRY COUNT", 5304 NULL, 5305 NULL, 5306 NULL, 5307 NULL, 5308 NULL, 5309 "GET FIRMWARE OPTIONS", 5310 "GET PORT QUEUE PARAMS", 5311 NULL, 5312 NULL, 5313 NULL, 5314 NULL, 5315 NULL, 5316 NULL, 5317 NULL, 5318 NULL, 5319 "SET RETRY COUNT", 5320 NULL, 5321 NULL, 5322 NULL, 5323 NULL, 5324 NULL, 5325 "SET FIRMWARE OPTIONS", 5326 "SET PORT QUEUE PARAMS", 5327 NULL, 5328 NULL, 5329 NULL, 5330 NULL, 5331 NULL, 5332 NULL, 5333 "LOOP PORT BYPASS", 5334 "LOOP PORT ENABLE", 5335 "GET RESOURCE COUNTS", 5336 "REQUEST NON PARTICIPATING MODE", 5337 NULL, 5338 NULL, 5339 NULL, 5340 "GET PORT DATABASE,, ENHANCED", 5341 NULL, 5342 NULL, 5343 NULL, 5344 NULL, 5345 NULL, 5346 NULL, 5347 NULL, 5348 NULL, 5349 NULL, 5350 NULL, 5351 NULL, 5352 NULL, 5353 "EXECUTE IOCB A64", 5354 NULL, 5355 NULL, 5356 NULL, 5357 NULL, 5358 NULL, 5359 NULL, 5360 "DRIVER HEARTBEAT", 5361 NULL, 5362 "GET/SET DATA RATE", 5363 NULL, 5364 NULL, 5365 "INIT FIRMWARE", 5366 NULL, 5367 "INIT LIP", 5368 "GET FC-AL POSITION MAP", 5369 "GET PORT DATABASE", 5370 "CLEAR ACA", 5371 "TARGET RESET", 5372 "CLEAR TASK SET", 5373 "ABORT TASK SET", 5374 "GET FW STATE", 5375 "GET PORT NAME", 5376 "GET LINK STATUS", 5377 "INIT LIP RESET", 5378 NULL, 5379 "SEND SNS", 5380 "FABRIC LOGIN", 5381 "SEND CHANGE REQUEST", 5382 "FABRIC LOGOUT", 5383 "INIT LIP LOGIN", 5384 NULL, 5385 "LOGIN LOOP PORT", 5386 "GET PORT/NODE NAME LIST", 5387 "SET VENDOR ID", 5388 "INITIALIZE IP MAILBOX", 5389 NULL, 5390 NULL, 5391 NULL, 5392 NULL, 5393 "Get ID List", 5394 "SEND LFA", 5395 "Lun RESET" 5396 }; 5397 #endif 5398 5399 static void 5400 isp_mboxcmd_qnw(struct ispsoftc *isp, mbreg_t *mbp, int nodelay) 5401 { 5402 unsigned int ibits, obits, box, opcode; 5403 const u_int32_t *mcp; 5404 5405 if (IS_FC(isp)) { 5406 mcp = mbpfc; 5407 } else { 5408 mcp = mbpscsi; 5409 } 5410 opcode = mbp->param[0]; 5411 ibits = HIWRD(mcp[opcode]) & NMBOX_BMASK(isp); 5412 obits = LOWRD(mcp[opcode]) & NMBOX_BMASK(isp); 5413 ibits |= mbp->ibits; 5414 obits |= mbp->obits; 5415 for (box = 0; box < MAX_MAILBOX(isp); box++) { 5416 if (ibits & (1 << box)) { 5417 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]); 5418 } 5419 if (nodelay == 0) { 5420 isp->isp_mboxtmp[box] = mbp->param[box] = 0; 5421 } 5422 } 5423 if (nodelay == 0) { 5424 isp->isp_lastmbxcmd = opcode; 5425 isp->isp_obits = obits; 5426 isp->isp_mboxbsy = 1; 5427 } 5428 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT); 5429 /* 5430 * Oddly enough, if we're not delaying for an answer, 5431 * delay a bit to give the f/w a chance to pick up the 5432 * command. 5433 */ 5434 if (nodelay) { 5435 USEC_DELAY(1000); 5436 } 5437 } 5438 5439 static void 5440 isp_mboxcmd(struct ispsoftc *isp, mbreg_t *mbp, int logmask) 5441 { 5442 char *cname, *xname, tname[16], mname[16]; 5443 unsigned int lim, ibits, obits, box, opcode; 5444 const u_int32_t *mcp; 5445 5446 if (IS_FC(isp)) { 5447 mcp = mbpfc; 5448 lim = (sizeof (mbpfc) / sizeof (mbpfc[0])); 5449 } else { 5450 mcp = mbpscsi; 5451 lim = (sizeof (mbpscsi) / sizeof (mbpscsi[0])); 5452 } 5453 5454 if ((opcode = mbp->param[0]) >= lim) { 5455 mbp->param[0] = MBOX_INVALID_COMMAND; 5456 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode); 5457 return; 5458 } 5459 5460 ibits = HIWRD(mcp[opcode]) & NMBOX_BMASK(isp); 5461 obits = LOWRD(mcp[opcode]) & NMBOX_BMASK(isp); 5462 5463 ibits |= mbp->ibits; 5464 obits |= mbp->obits; 5465 5466 if (ibits == 0 && obits == 0) { 5467 mbp->param[0] = MBOX_COMMAND_PARAM_ERROR; 5468 isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode); 5469 return; 5470 } 5471 5472 /* 5473 * Get exclusive usage of mailbox registers. 5474 */ 5475 MBOX_ACQUIRE(isp); 5476 5477 for (box = 0; box < MAX_MAILBOX(isp); box++) { 5478 if (ibits & (1 << box)) { 5479 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]); 5480 } 5481 isp->isp_mboxtmp[box] = mbp->param[box] = 0; 5482 } 5483 5484 isp->isp_lastmbxcmd = opcode; 5485 5486 /* 5487 * We assume that we can't overwrite a previous command. 5488 */ 5489 isp->isp_obits = obits; 5490 isp->isp_mboxbsy = 1; 5491 5492 /* 5493 * Set Host Interrupt condition so that RISC will pick up mailbox regs. 5494 */ 5495 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT); 5496 5497 /* 5498 * While we haven't finished the command, spin our wheels here. 5499 */ 5500 MBOX_WAIT_COMPLETE(isp); 5501 5502 if (isp->isp_mboxbsy) { 5503 /* 5504 * Command timed out. 5505 */ 5506 isp->isp_mboxbsy = 0; 5507 MBOX_RELEASE(isp); 5508 return; 5509 } 5510 5511 /* 5512 * Copy back output registers. 5513 */ 5514 for (box = 0; box < MAX_MAILBOX(isp); box++) { 5515 if (obits & (1 << box)) { 5516 mbp->param[box] = isp->isp_mboxtmp[box]; 5517 } 5518 } 5519 5520 MBOX_RELEASE(isp); 5521 5522 if (logmask == 0 || opcode == MBOX_EXEC_FIRMWARE) { 5523 return; 5524 } 5525 #ifdef ISP_STRIPPED 5526 cname = NULL; 5527 #else 5528 cname = (IS_FC(isp))? fc_mbcmd_names[opcode] : scsi_mbcmd_names[opcode]; 5529 #endif 5530 if (cname == NULL) { 5531 cname = tname; 5532 SNPRINTF(tname, sizeof tname, "opcode %x", opcode); 5533 } 5534 5535 /* 5536 * Just to be chatty here... 5537 */ 5538 xname = NULL; 5539 switch (mbp->param[0]) { 5540 case MBOX_COMMAND_COMPLETE: 5541 break; 5542 case MBOX_INVALID_COMMAND: 5543 if (logmask & MBLOGMASK(MBOX_COMMAND_COMPLETE)) 5544 xname = "INVALID COMMAND"; 5545 break; 5546 case MBOX_HOST_INTERFACE_ERROR: 5547 if (logmask & MBLOGMASK(MBOX_HOST_INTERFACE_ERROR)) 5548 xname = "HOST INTERFACE ERROR"; 5549 break; 5550 case MBOX_TEST_FAILED: 5551 if (logmask & MBLOGMASK(MBOX_TEST_FAILED)) 5552 xname = "TEST FAILED"; 5553 break; 5554 case MBOX_COMMAND_ERROR: 5555 if (logmask & MBLOGMASK(MBOX_COMMAND_ERROR)) 5556 xname = "COMMAND ERROR"; 5557 break; 5558 case MBOX_COMMAND_PARAM_ERROR: 5559 if (logmask & MBLOGMASK(MBOX_COMMAND_PARAM_ERROR)) 5560 xname = "COMMAND PARAMETER ERROR"; 5561 break; 5562 case MBOX_LOOP_ID_USED: 5563 if (logmask & MBLOGMASK(MBOX_LOOP_ID_USED)) 5564 xname = "LOOP ID ALREADY IN USE"; 5565 break; 5566 case MBOX_PORT_ID_USED: 5567 if (logmask & MBLOGMASK(MBOX_PORT_ID_USED)) 5568 xname = "PORT ID ALREADY IN USE"; 5569 break; 5570 case MBOX_ALL_IDS_USED: 5571 if (logmask & MBLOGMASK(MBOX_ALL_IDS_USED)) 5572 xname = "ALL LOOP IDS IN USE"; 5573 break; 5574 case 0: /* special case */ 5575 xname = "TIMEOUT"; 5576 break; 5577 default: 5578 SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]); 5579 xname = mname; 5580 break; 5581 } 5582 if (xname) 5583 isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s)", 5584 cname, xname); 5585 } 5586 5587 static void 5588 isp_fw_state(struct ispsoftc *isp) 5589 { 5590 if (IS_FC(isp)) { 5591 mbreg_t mbs; 5592 fcparam *fcp = isp->isp_param; 5593 5594 MEMZERO(&mbs, sizeof (mbs)); 5595 mbs.param[0] = MBOX_GET_FW_STATE; 5596 isp_mboxcmd(isp, &mbs, MBLOGALL); 5597 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 5598 fcp->isp_fwstate = mbs.param[1]; 5599 } 5600 } 5601 } 5602 5603 static void 5604 isp_update(struct ispsoftc *isp) 5605 { 5606 int bus, upmask; 5607 5608 for (bus = 0, upmask = isp->isp_update; upmask != 0; bus++) { 5609 if (upmask & (1 << bus)) { 5610 isp_update_bus(isp, bus); 5611 } 5612 upmask &= ~(1 << bus); 5613 } 5614 } 5615 5616 static void 5617 isp_update_bus(struct ispsoftc *isp, int bus) 5618 { 5619 int tgt; 5620 mbreg_t mbs; 5621 sdparam *sdp; 5622 5623 isp->isp_update &= ~(1 << bus); 5624 if (IS_FC(isp)) { 5625 /* 5626 * There are no 'per-bus' settings for Fibre Channel. 5627 */ 5628 return; 5629 } 5630 sdp = isp->isp_param; 5631 sdp += bus; 5632 MEMZERO(&mbs, sizeof (mbs)); 5633 5634 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 5635 u_int16_t flags, period, offset; 5636 int get; 5637 5638 if (sdp->isp_devparam[tgt].dev_enable == 0) { 5639 sdp->isp_devparam[tgt].dev_update = 0; 5640 sdp->isp_devparam[tgt].dev_refresh = 0; 5641 isp_prt(isp, ISP_LOGDEBUG0, 5642 "skipping target %d bus %d update", tgt, bus); 5643 continue; 5644 } 5645 /* 5646 * If the goal is to update the status of the device, 5647 * take what's in goal_flags and try and set the device 5648 * toward that. Otherwise, if we're just refreshing the 5649 * current device state, get the current parameters. 5650 */ 5651 5652 /* 5653 * Refresh overrides set 5654 */ 5655 if (sdp->isp_devparam[tgt].dev_refresh) { 5656 mbs.param[0] = MBOX_GET_TARGET_PARAMS; 5657 sdp->isp_devparam[tgt].dev_refresh = 0; 5658 get = 1; 5659 } else if (sdp->isp_devparam[tgt].dev_update) { 5660 mbs.param[0] = MBOX_SET_TARGET_PARAMS; 5661 /* 5662 * Make sure goal_flags has "Renegotiate on Error" 5663 * on and "Freeze Queue on Error" off. 5664 */ 5665 sdp->isp_devparam[tgt].goal_flags |= DPARM_RENEG; 5666 sdp->isp_devparam[tgt].goal_flags &= ~DPARM_QFRZ; 5667 5668 mbs.param[2] = sdp->isp_devparam[tgt].goal_flags; 5669 5670 /* 5671 * Insist that PARITY must be enabled 5672 * if SYNC or WIDE is enabled. 5673 */ 5674 if ((mbs.param[2] & (DPARM_SYNC|DPARM_WIDE)) != 0) { 5675 mbs.param[2] |= DPARM_PARITY; 5676 } 5677 5678 if ((mbs.param[2] & DPARM_SYNC) == 0) { 5679 mbs.param[3] = 0; 5680 } else { 5681 mbs.param[3] = 5682 (sdp->isp_devparam[tgt].goal_offset << 8) | 5683 (sdp->isp_devparam[tgt].goal_period); 5684 } 5685 /* 5686 * A command completion later that has 5687 * RQSTF_NEGOTIATION set can cause 5688 * the dev_refresh/announce cycle also. 5689 * 5690 * Note: It is really important to update our current 5691 * flags with at least the state of TAG capabilities- 5692 * otherwise we might try and send a tagged command 5693 * when we have it all turned off. So change it here 5694 * to say that current already matches goal. 5695 */ 5696 sdp->isp_devparam[tgt].actv_flags &= ~DPARM_TQING; 5697 sdp->isp_devparam[tgt].actv_flags |= 5698 (sdp->isp_devparam[tgt].goal_flags & DPARM_TQING); 5699 isp_prt(isp, ISP_LOGDEBUG0, 5700 "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x", 5701 bus, tgt, mbs.param[2], mbs.param[3] >> 8, 5702 mbs.param[3] & 0xff); 5703 sdp->isp_devparam[tgt].dev_update = 0; 5704 sdp->isp_devparam[tgt].dev_refresh = 1; 5705 get = 0; 5706 } else { 5707 continue; 5708 } 5709 mbs.param[1] = (bus << 15) | (tgt << 8); 5710 isp_mboxcmd(isp, &mbs, MBLOGALL); 5711 if (get == 0) { 5712 isp->isp_sendmarker |= (1 << bus); 5713 continue; 5714 } 5715 flags = mbs.param[2]; 5716 period = mbs.param[3] & 0xff; 5717 offset = mbs.param[3] >> 8; 5718 sdp->isp_devparam[tgt].actv_flags = flags; 5719 sdp->isp_devparam[tgt].actv_period = period; 5720 sdp->isp_devparam[tgt].actv_offset = offset; 5721 get = (bus << 16) | tgt; 5722 (void) isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, &get); 5723 } 5724 5725 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 5726 if (sdp->isp_devparam[tgt].dev_update || 5727 sdp->isp_devparam[tgt].dev_refresh) { 5728 isp->isp_update |= (1 << bus); 5729 break; 5730 } 5731 } 5732 } 5733 5734 #ifndef DEFAULT_FRAMESIZE 5735 #define DEFAULT_FRAMESIZE(isp) ICB_DFLT_FRMLEN 5736 #endif 5737 #ifndef DEFAULT_EXEC_THROTTLE 5738 #define DEFAULT_EXEC_THROTTLE(isp) ISP_EXEC_THROTTLE 5739 #endif 5740 5741 static void 5742 isp_setdfltparm(struct ispsoftc *isp, int channel) 5743 { 5744 int tgt; 5745 mbreg_t mbs; 5746 sdparam *sdp; 5747 5748 MEMZERO(&mbs, sizeof (mbs)); 5749 if (IS_FC(isp)) { 5750 fcparam *fcp = (fcparam *) isp->isp_param; 5751 int nvfail; 5752 5753 fcp += channel; 5754 if (fcp->isp_gotdparms) { 5755 return; 5756 } 5757 fcp->isp_gotdparms = 1; 5758 fcp->isp_maxfrmlen = DEFAULT_FRAMESIZE(isp); 5759 fcp->isp_maxalloc = ICB_DFLT_ALLOC; 5760 fcp->isp_execthrottle = DEFAULT_EXEC_THROTTLE(isp); 5761 fcp->isp_retry_delay = ICB_DFLT_RDELAY; 5762 fcp->isp_retry_count = ICB_DFLT_RCOUNT; 5763 /* Platform specific.... */ 5764 fcp->isp_loopid = DEFAULT_LOOPID(isp); 5765 fcp->isp_nodewwn = DEFAULT_NODEWWN(isp); 5766 fcp->isp_portwwn = DEFAULT_PORTWWN(isp); 5767 fcp->isp_fwoptions = 0; 5768 fcp->isp_fwoptions |= ICBOPT_FAIRNESS; 5769 fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE; 5770 fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS; 5771 #ifndef ISP_NO_FASTPOST_FC 5772 fcp->isp_fwoptions |= ICBOPT_FAST_POST; 5773 #endif 5774 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX) 5775 fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX; 5776 5777 /* 5778 * Make sure this is turned off now until we get 5779 * extended options from NVRAM 5780 */ 5781 fcp->isp_fwoptions &= ~ICBOPT_EXTENDED; 5782 5783 /* 5784 * Now try and read NVRAM unless told to not do so. 5785 * This will set fcparam's isp_nodewwn && isp_portwwn. 5786 */ 5787 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) { 5788 nvfail = isp_read_nvram(isp); 5789 if (nvfail) 5790 isp->isp_confopts |= ISP_CFG_NONVRAM; 5791 } else { 5792 nvfail = 1; 5793 } 5794 /* 5795 * Set node && port to override platform set defaults 5796 * unless the nvram read failed (or none was done), 5797 * or the platform code wants to use what had been 5798 * set in the defaults. 5799 */ 5800 if (nvfail) { 5801 isp->isp_confopts |= ISP_CFG_OWNWWPN|ISP_CFG_OWNWWNN; 5802 } 5803 if (isp->isp_confopts & ISP_CFG_OWNWWNN) { 5804 isp_prt(isp, ISP_LOGCONFIG, "Using Node WWN 0x%08x%08x", 5805 (u_int32_t) (DEFAULT_NODEWWN(isp) >> 32), 5806 (u_int32_t) (DEFAULT_NODEWWN(isp) & 0xffffffff)); 5807 ISP_NODEWWN(isp) = DEFAULT_NODEWWN(isp); 5808 } else { 5809 /* 5810 * We always start out with values derived 5811 * from NVRAM or our platform default. 5812 */ 5813 ISP_NODEWWN(isp) = fcp->isp_nodewwn; 5814 } 5815 if (isp->isp_confopts & ISP_CFG_OWNWWPN) { 5816 isp_prt(isp, ISP_LOGCONFIG, "Using Port WWN 0x%08x%08x", 5817 (u_int32_t) (DEFAULT_PORTWWN(isp) >> 32), 5818 (u_int32_t) (DEFAULT_PORTWWN(isp) & 0xffffffff)); 5819 ISP_PORTWWN(isp) = DEFAULT_PORTWWN(isp); 5820 } else { 5821 /* 5822 * We always start out with values derived 5823 * from NVRAM or our platform default. 5824 */ 5825 ISP_PORTWWN(isp) = fcp->isp_portwwn; 5826 } 5827 return; 5828 } 5829 5830 sdp = (sdparam *) isp->isp_param; 5831 sdp += channel; 5832 5833 /* 5834 * Been there, done that, got the T-shirt... 5835 */ 5836 if (sdp->isp_gotdparms) { 5837 return; 5838 } 5839 sdp->isp_gotdparms = 1; 5840 5841 /* 5842 * Establish some default parameters. 5843 */ 5844 sdp->isp_cmd_dma_burst_enable = 0; 5845 sdp->isp_data_dma_burst_enabl = 1; 5846 sdp->isp_fifo_threshold = 0; 5847 sdp->isp_initiator_id = DEFAULT_IID(isp); 5848 if (isp->isp_type >= ISP_HA_SCSI_1040) { 5849 sdp->isp_async_data_setup = 9; 5850 } else { 5851 sdp->isp_async_data_setup = 6; 5852 } 5853 sdp->isp_selection_timeout = 250; 5854 sdp->isp_max_queue_depth = MAXISPREQUEST(isp); 5855 sdp->isp_tag_aging = 8; 5856 sdp->isp_bus_reset_delay = 5; 5857 /* 5858 * Don't retry selection, busy or queue full automatically- reflect 5859 * these back to us. 5860 */ 5861 sdp->isp_retry_count = 0; 5862 sdp->isp_retry_delay = 0; 5863 5864 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 5865 sdp->isp_devparam[tgt].exc_throttle = ISP_EXEC_THROTTLE; 5866 sdp->isp_devparam[tgt].dev_enable = 1; 5867 } 5868 5869 /* 5870 * If we've not been told to avoid reading NVRAM, try and read it. 5871 * If we're successful reading it, we can then return because NVRAM 5872 * will tell us what the desired settings are. Otherwise, we establish 5873 * some reasonable 'fake' nvram and goal defaults. 5874 */ 5875 5876 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) { 5877 if (isp_read_nvram(isp) == 0) { 5878 return; 5879 } 5880 } 5881 5882 /* 5883 * Now try and see whether we have specific values for them. 5884 */ 5885 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) { 5886 mbs.param[0] = MBOX_GET_ACT_NEG_STATE; 5887 isp_mboxcmd(isp, &mbs, MBLOGNONE); 5888 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 5889 sdp->isp_req_ack_active_neg = 1; 5890 sdp->isp_data_line_active_neg = 1; 5891 } else { 5892 sdp->isp_req_ack_active_neg = 5893 (mbs.param[1+channel] >> 4) & 0x1; 5894 sdp->isp_data_line_active_neg = 5895 (mbs.param[1+channel] >> 5) & 0x1; 5896 } 5897 } 5898 5899 isp_prt(isp, ISP_LOGDEBUG0, sc0, sc3, 5900 0, sdp->isp_fifo_threshold, sdp->isp_initiator_id, 5901 sdp->isp_bus_reset_delay, sdp->isp_retry_count, 5902 sdp->isp_retry_delay, sdp->isp_async_data_setup); 5903 isp_prt(isp, ISP_LOGDEBUG0, sc1, sc3, 5904 sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg, 5905 sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable, 5906 sdp->isp_selection_timeout, sdp->isp_max_queue_depth); 5907 5908 /* 5909 * The trick here is to establish a default for the default (honk!) 5910 * state (goal_flags). Then try and get the current status from 5911 * the card to fill in the current state. We don't, in fact, set 5912 * the default to the SAFE default state- that's not the goal state. 5913 */ 5914 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 5915 u_int8_t off, per; 5916 sdp->isp_devparam[tgt].actv_offset = 0; 5917 sdp->isp_devparam[tgt].actv_period = 0; 5918 sdp->isp_devparam[tgt].actv_flags = 0; 5919 5920 sdp->isp_devparam[tgt].goal_flags = 5921 sdp->isp_devparam[tgt].nvrm_flags = DPARM_DEFAULT; 5922 5923 /* 5924 * We default to Wide/Fast for versions less than a 1040 5925 * (unless it's SBus). 5926 */ 5927 if (IS_ULTRA3(isp)) { 5928 off = ISP_80M_SYNCPARMS >> 8; 5929 per = ISP_80M_SYNCPARMS & 0xff; 5930 } else if (IS_ULTRA2(isp)) { 5931 off = ISP_40M_SYNCPARMS >> 8; 5932 per = ISP_40M_SYNCPARMS & 0xff; 5933 } else if (IS_1240(isp)) { 5934 off = ISP_20M_SYNCPARMS >> 8; 5935 per = ISP_20M_SYNCPARMS & 0xff; 5936 } else if ((isp->isp_bustype == ISP_BT_SBUS && 5937 isp->isp_type < ISP_HA_SCSI_1020A) || 5938 (isp->isp_bustype == ISP_BT_PCI && 5939 isp->isp_type < ISP_HA_SCSI_1040) || 5940 (isp->isp_clock && isp->isp_clock < 60) || 5941 (sdp->isp_ultramode == 0)) { 5942 off = ISP_10M_SYNCPARMS >> 8; 5943 per = ISP_10M_SYNCPARMS & 0xff; 5944 } else { 5945 off = ISP_20M_SYNCPARMS_1040 >> 8; 5946 per = ISP_20M_SYNCPARMS_1040 & 0xff; 5947 } 5948 sdp->isp_devparam[tgt].goal_offset = 5949 sdp->isp_devparam[tgt].nvrm_offset = off; 5950 sdp->isp_devparam[tgt].goal_period = 5951 sdp->isp_devparam[tgt].nvrm_period = per; 5952 5953 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc3, 5954 channel, tgt, sdp->isp_devparam[tgt].nvrm_flags, 5955 sdp->isp_devparam[tgt].nvrm_offset, 5956 sdp->isp_devparam[tgt].nvrm_period); 5957 } 5958 } 5959 5960 /* 5961 * Re-initialize the ISP and complete all orphaned commands 5962 * with a 'botched' notice. The reset/init routines should 5963 * not disturb an already active list of commands. 5964 * 5965 * Locks held prior to coming here. 5966 */ 5967 5968 void 5969 isp_reinit(struct ispsoftc *isp) 5970 { 5971 XS_T *xs; 5972 int i; 5973 5974 if (IS_FC(isp)) { 5975 isp_mark_getpdb_all(isp); 5976 } 5977 isp_reset(isp); 5978 if (isp->isp_state != ISP_RESETSTATE) { 5979 isp_prt(isp, ISP_LOGERR, "isp_reinit cannot reset card"); 5980 } else if (isp->isp_role != ISP_ROLE_NONE) { 5981 isp_init(isp); 5982 if (isp->isp_state == ISP_INITSTATE) { 5983 isp->isp_state = ISP_RUNSTATE; 5984 } 5985 if (isp->isp_state != ISP_RUNSTATE) { 5986 isp_prt(isp, ISP_LOGERR, 5987 "isp_reinit cannot restart card"); 5988 } 5989 } 5990 isp->isp_nactive = 0; 5991 5992 for (i = 0; i < isp->isp_maxcmds; i++) { 5993 u_int16_t handle; 5994 xs = isp->isp_xflist[i]; 5995 if (xs == NULL) { 5996 continue; 5997 } 5998 handle = isp_index_handle(i); 5999 isp_destroy_handle(isp, handle); 6000 if (XS_XFRLEN(xs)) { 6001 ISP_DMAFREE(isp, xs, handle); 6002 XS_RESID(xs) = XS_XFRLEN(xs); 6003 } else { 6004 XS_RESID(xs) = 0; 6005 } 6006 XS_SETERR(xs, HBA_BUSRESET); 6007 isp_done(xs); 6008 } 6009 } 6010 6011 /* 6012 * NVRAM Routines 6013 */ 6014 static int 6015 isp_read_nvram(struct ispsoftc *isp) 6016 { 6017 int i, amt; 6018 u_int8_t csum, minversion; 6019 union { 6020 u_int8_t _x[ISP2100_NVRAM_SIZE]; 6021 u_int16_t _s[ISP2100_NVRAM_SIZE>>1]; 6022 } _n; 6023 #define nvram_data _n._x 6024 #define nvram_words _n._s 6025 6026 if (IS_FC(isp)) { 6027 amt = ISP2100_NVRAM_SIZE; 6028 minversion = 1; 6029 } else if (IS_ULTRA2(isp)) { 6030 amt = ISP1080_NVRAM_SIZE; 6031 minversion = 0; 6032 } else { 6033 amt = ISP_NVRAM_SIZE; 6034 minversion = 2; 6035 } 6036 6037 /* 6038 * Just read the first two words first to see if we have a valid 6039 * NVRAM to continue reading the rest with. 6040 */ 6041 for (i = 0; i < 2; i++) { 6042 isp_rdnvram_word(isp, i, &nvram_words[i]); 6043 } 6044 if (nvram_data[0] != 'I' || nvram_data[1] != 'S' || 6045 nvram_data[2] != 'P') { 6046 if (isp->isp_bustype != ISP_BT_SBUS) { 6047 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header"); 6048 isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x", 6049 nvram_data[0], nvram_data[1], nvram_data[2]); 6050 } 6051 return (-1); 6052 } 6053 for (i = 2; i < amt>>1; i++) { 6054 isp_rdnvram_word(isp, i, &nvram_words[i]); 6055 } 6056 for (csum = 0, i = 0; i < amt; i++) { 6057 csum += nvram_data[i]; 6058 } 6059 if (csum != 0) { 6060 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum"); 6061 return (-1); 6062 } 6063 if (ISP_NVRAM_VERSION(nvram_data) < minversion) { 6064 isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood", 6065 ISP_NVRAM_VERSION(nvram_data)); 6066 return (-1); 6067 } 6068 6069 if (IS_ULTRA3(isp)) { 6070 isp_parse_nvram_12160(isp, 0, nvram_data); 6071 if (IS_12160(isp)) 6072 isp_parse_nvram_12160(isp, 1, nvram_data); 6073 } else if (IS_1080(isp)) { 6074 isp_parse_nvram_1080(isp, 0, nvram_data); 6075 } else if (IS_1280(isp) || IS_1240(isp)) { 6076 isp_parse_nvram_1080(isp, 0, nvram_data); 6077 isp_parse_nvram_1080(isp, 1, nvram_data); 6078 } else if (IS_SCSI(isp)) { 6079 isp_parse_nvram_1020(isp, nvram_data); 6080 } else { 6081 isp_parse_nvram_2100(isp, nvram_data); 6082 } 6083 return (0); 6084 #undef nvram_data 6085 #undef nvram_words 6086 } 6087 6088 static void 6089 isp_rdnvram_word(struct ispsoftc *isp, int wo, u_int16_t *rp) 6090 { 6091 int i, cbits; 6092 u_int16_t bit, rqst; 6093 6094 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT); 6095 USEC_DELAY(2); 6096 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK); 6097 USEC_DELAY(2); 6098 6099 if (IS_FC(isp)) { 6100 wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1); 6101 if (IS_2312(isp) && isp->isp_port) { 6102 wo += 128; 6103 } 6104 rqst = (ISP_NVRAM_READ << 8) | wo; 6105 cbits = 10; 6106 } else if (IS_ULTRA2(isp)) { 6107 wo &= ((ISP1080_NVRAM_SIZE >> 1) - 1); 6108 rqst = (ISP_NVRAM_READ << 8) | wo; 6109 cbits = 10; 6110 } else { 6111 wo &= ((ISP_NVRAM_SIZE >> 1) - 1); 6112 rqst = (ISP_NVRAM_READ << 6) | wo; 6113 cbits = 8; 6114 } 6115 6116 /* 6117 * Clock the word select request out... 6118 */ 6119 for (i = cbits; i >= 0; i--) { 6120 if ((rqst >> i) & 1) { 6121 bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT; 6122 } else { 6123 bit = BIU_NVRAM_SELECT; 6124 } 6125 ISP_WRITE(isp, BIU_NVRAM, bit); 6126 USEC_DELAY(2); 6127 ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK); 6128 USEC_DELAY(2); 6129 ISP_WRITE(isp, BIU_NVRAM, bit); 6130 USEC_DELAY(2); 6131 } 6132 /* 6133 * Now read the result back in (bits come back in MSB format). 6134 */ 6135 *rp = 0; 6136 for (i = 0; i < 16; i++) { 6137 u_int16_t rv; 6138 *rp <<= 1; 6139 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK); 6140 USEC_DELAY(2); 6141 rv = ISP_READ(isp, BIU_NVRAM); 6142 if (rv & BIU_NVRAM_DATAIN) { 6143 *rp |= 1; 6144 } 6145 USEC_DELAY(2); 6146 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT); 6147 USEC_DELAY(2); 6148 } 6149 ISP_WRITE(isp, BIU_NVRAM, 0); 6150 USEC_DELAY(2); 6151 ISP_SWIZZLE_NVRAM_WORD(isp, rp); 6152 } 6153 6154 static void 6155 isp_parse_nvram_1020(struct ispsoftc *isp, u_int8_t *nvram_data) 6156 { 6157 sdparam *sdp = (sdparam *) isp->isp_param; 6158 int tgt; 6159 6160 sdp->isp_fifo_threshold = 6161 ISP_NVRAM_FIFO_THRESHOLD(nvram_data) | 6162 (ISP_NVRAM_FIFO_THRESHOLD_128(nvram_data) << 2); 6163 6164 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) 6165 sdp->isp_initiator_id = 6166 ISP_NVRAM_INITIATOR_ID(nvram_data); 6167 6168 sdp->isp_bus_reset_delay = 6169 ISP_NVRAM_BUS_RESET_DELAY(nvram_data); 6170 6171 sdp->isp_retry_count = 6172 ISP_NVRAM_BUS_RETRY_COUNT(nvram_data); 6173 6174 sdp->isp_retry_delay = 6175 ISP_NVRAM_BUS_RETRY_DELAY(nvram_data); 6176 6177 sdp->isp_async_data_setup = 6178 ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data); 6179 6180 if (isp->isp_type >= ISP_HA_SCSI_1040) { 6181 if (sdp->isp_async_data_setup < 9) { 6182 sdp->isp_async_data_setup = 9; 6183 } 6184 } else { 6185 if (sdp->isp_async_data_setup != 6) { 6186 sdp->isp_async_data_setup = 6; 6187 } 6188 } 6189 6190 sdp->isp_req_ack_active_neg = 6191 ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data); 6192 6193 sdp->isp_data_line_active_neg = 6194 ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data); 6195 6196 sdp->isp_data_dma_burst_enabl = 6197 ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data); 6198 6199 sdp->isp_cmd_dma_burst_enable = 6200 ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data); 6201 6202 sdp->isp_tag_aging = 6203 ISP_NVRAM_TAG_AGE_LIMIT(nvram_data); 6204 6205 sdp->isp_selection_timeout = 6206 ISP_NVRAM_SELECTION_TIMEOUT(nvram_data); 6207 6208 sdp->isp_max_queue_depth = 6209 ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data); 6210 6211 sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data); 6212 6213 isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4, 6214 0, sdp->isp_fifo_threshold, sdp->isp_initiator_id, 6215 sdp->isp_bus_reset_delay, sdp->isp_retry_count, 6216 sdp->isp_retry_delay, sdp->isp_async_data_setup); 6217 isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4, 6218 sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg, 6219 sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable, 6220 sdp->isp_selection_timeout, sdp->isp_max_queue_depth); 6221 6222 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 6223 sdp->isp_devparam[tgt].dev_enable = 6224 ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt); 6225 sdp->isp_devparam[tgt].exc_throttle = 6226 ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt); 6227 sdp->isp_devparam[tgt].nvrm_offset = 6228 ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt); 6229 sdp->isp_devparam[tgt].nvrm_period = 6230 ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt); 6231 /* 6232 * We probably shouldn't lie about this, but it 6233 * it makes it much safer if we limit NVRAM values 6234 * to sanity. 6235 */ 6236 if (isp->isp_type < ISP_HA_SCSI_1040) { 6237 /* 6238 * If we're not ultra, we can't possibly 6239 * be a shorter period than this. 6240 */ 6241 if (sdp->isp_devparam[tgt].nvrm_period < 0x19) { 6242 sdp->isp_devparam[tgt].nvrm_period = 0x19; 6243 } 6244 if (sdp->isp_devparam[tgt].nvrm_offset > 0xc) { 6245 sdp->isp_devparam[tgt].nvrm_offset = 0x0c; 6246 } 6247 } else { 6248 if (sdp->isp_devparam[tgt].nvrm_offset > 0x8) { 6249 sdp->isp_devparam[tgt].nvrm_offset = 0x8; 6250 } 6251 } 6252 sdp->isp_devparam[tgt].nvrm_flags = 0; 6253 if (ISP_NVRAM_TGT_RENEG(nvram_data, tgt)) 6254 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG; 6255 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ; 6256 if (ISP_NVRAM_TGT_TQING(nvram_data, tgt)) 6257 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING; 6258 if (ISP_NVRAM_TGT_SYNC(nvram_data, tgt)) 6259 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC; 6260 if (ISP_NVRAM_TGT_WIDE(nvram_data, tgt)) 6261 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE; 6262 if (ISP_NVRAM_TGT_PARITY(nvram_data, tgt)) 6263 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY; 6264 if (ISP_NVRAM_TGT_DISC(nvram_data, tgt)) 6265 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC; 6266 sdp->isp_devparam[tgt].actv_flags = 0; /* we don't know */ 6267 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4, 6268 0, tgt, sdp->isp_devparam[tgt].nvrm_flags, 6269 sdp->isp_devparam[tgt].nvrm_offset, 6270 sdp->isp_devparam[tgt].nvrm_period); 6271 sdp->isp_devparam[tgt].goal_offset = 6272 sdp->isp_devparam[tgt].nvrm_offset; 6273 sdp->isp_devparam[tgt].goal_period = 6274 sdp->isp_devparam[tgt].nvrm_period; 6275 sdp->isp_devparam[tgt].goal_flags = 6276 sdp->isp_devparam[tgt].nvrm_flags; 6277 } 6278 } 6279 6280 static void 6281 isp_parse_nvram_1080(struct ispsoftc *isp, int bus, u_int8_t *nvram_data) 6282 { 6283 sdparam *sdp = (sdparam *) isp->isp_param; 6284 int tgt; 6285 6286 sdp += bus; 6287 6288 sdp->isp_fifo_threshold = 6289 ISP1080_NVRAM_FIFO_THRESHOLD(nvram_data); 6290 6291 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) 6292 sdp->isp_initiator_id = 6293 ISP1080_NVRAM_INITIATOR_ID(nvram_data, bus); 6294 6295 sdp->isp_bus_reset_delay = 6296 ISP1080_NVRAM_BUS_RESET_DELAY(nvram_data, bus); 6297 6298 sdp->isp_retry_count = 6299 ISP1080_NVRAM_BUS_RETRY_COUNT(nvram_data, bus); 6300 6301 sdp->isp_retry_delay = 6302 ISP1080_NVRAM_BUS_RETRY_DELAY(nvram_data, bus); 6303 6304 sdp->isp_async_data_setup = 6305 ISP1080_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus); 6306 6307 sdp->isp_req_ack_active_neg = 6308 ISP1080_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus); 6309 6310 sdp->isp_data_line_active_neg = 6311 ISP1080_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus); 6312 6313 sdp->isp_data_dma_burst_enabl = 6314 ISP1080_NVRAM_BURST_ENABLE(nvram_data); 6315 6316 sdp->isp_cmd_dma_burst_enable = 6317 ISP1080_NVRAM_BURST_ENABLE(nvram_data); 6318 6319 sdp->isp_selection_timeout = 6320 ISP1080_NVRAM_SELECTION_TIMEOUT(nvram_data, bus); 6321 6322 sdp->isp_max_queue_depth = 6323 ISP1080_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus); 6324 6325 isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4, 6326 bus, sdp->isp_fifo_threshold, sdp->isp_initiator_id, 6327 sdp->isp_bus_reset_delay, sdp->isp_retry_count, 6328 sdp->isp_retry_delay, sdp->isp_async_data_setup); 6329 isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4, 6330 sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg, 6331 sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable, 6332 sdp->isp_selection_timeout, sdp->isp_max_queue_depth); 6333 6334 6335 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 6336 sdp->isp_devparam[tgt].dev_enable = 6337 ISP1080_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus); 6338 sdp->isp_devparam[tgt].exc_throttle = 6339 ISP1080_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus); 6340 sdp->isp_devparam[tgt].nvrm_offset = 6341 ISP1080_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus); 6342 sdp->isp_devparam[tgt].nvrm_period = 6343 ISP1080_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus); 6344 sdp->isp_devparam[tgt].nvrm_flags = 0; 6345 if (ISP1080_NVRAM_TGT_RENEG(nvram_data, tgt, bus)) 6346 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG; 6347 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ; 6348 if (ISP1080_NVRAM_TGT_TQING(nvram_data, tgt, bus)) 6349 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING; 6350 if (ISP1080_NVRAM_TGT_SYNC(nvram_data, tgt, bus)) 6351 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC; 6352 if (ISP1080_NVRAM_TGT_WIDE(nvram_data, tgt, bus)) 6353 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE; 6354 if (ISP1080_NVRAM_TGT_PARITY(nvram_data, tgt, bus)) 6355 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY; 6356 if (ISP1080_NVRAM_TGT_DISC(nvram_data, tgt, bus)) 6357 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC; 6358 sdp->isp_devparam[tgt].actv_flags = 0; 6359 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4, 6360 bus, tgt, sdp->isp_devparam[tgt].nvrm_flags, 6361 sdp->isp_devparam[tgt].nvrm_offset, 6362 sdp->isp_devparam[tgt].nvrm_period); 6363 sdp->isp_devparam[tgt].goal_offset = 6364 sdp->isp_devparam[tgt].nvrm_offset; 6365 sdp->isp_devparam[tgt].goal_period = 6366 sdp->isp_devparam[tgt].nvrm_period; 6367 sdp->isp_devparam[tgt].goal_flags = 6368 sdp->isp_devparam[tgt].nvrm_flags; 6369 } 6370 } 6371 6372 static void 6373 isp_parse_nvram_12160(struct ispsoftc *isp, int bus, u_int8_t *nvram_data) 6374 { 6375 sdparam *sdp = (sdparam *) isp->isp_param; 6376 int tgt; 6377 6378 sdp += bus; 6379 6380 sdp->isp_fifo_threshold = 6381 ISP12160_NVRAM_FIFO_THRESHOLD(nvram_data); 6382 6383 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) 6384 sdp->isp_initiator_id = 6385 ISP12160_NVRAM_INITIATOR_ID(nvram_data, bus); 6386 6387 sdp->isp_bus_reset_delay = 6388 ISP12160_NVRAM_BUS_RESET_DELAY(nvram_data, bus); 6389 6390 sdp->isp_retry_count = 6391 ISP12160_NVRAM_BUS_RETRY_COUNT(nvram_data, bus); 6392 6393 sdp->isp_retry_delay = 6394 ISP12160_NVRAM_BUS_RETRY_DELAY(nvram_data, bus); 6395 6396 sdp->isp_async_data_setup = 6397 ISP12160_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus); 6398 6399 sdp->isp_req_ack_active_neg = 6400 ISP12160_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus); 6401 6402 sdp->isp_data_line_active_neg = 6403 ISP12160_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus); 6404 6405 sdp->isp_data_dma_burst_enabl = 6406 ISP12160_NVRAM_BURST_ENABLE(nvram_data); 6407 6408 sdp->isp_cmd_dma_burst_enable = 6409 ISP12160_NVRAM_BURST_ENABLE(nvram_data); 6410 6411 sdp->isp_selection_timeout = 6412 ISP12160_NVRAM_SELECTION_TIMEOUT(nvram_data, bus); 6413 6414 sdp->isp_max_queue_depth = 6415 ISP12160_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus); 6416 6417 isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4, 6418 bus, sdp->isp_fifo_threshold, sdp->isp_initiator_id, 6419 sdp->isp_bus_reset_delay, sdp->isp_retry_count, 6420 sdp->isp_retry_delay, sdp->isp_async_data_setup); 6421 isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4, 6422 sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg, 6423 sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable, 6424 sdp->isp_selection_timeout, sdp->isp_max_queue_depth); 6425 6426 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 6427 sdp->isp_devparam[tgt].dev_enable = 6428 ISP12160_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus); 6429 sdp->isp_devparam[tgt].exc_throttle = 6430 ISP12160_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus); 6431 sdp->isp_devparam[tgt].nvrm_offset = 6432 ISP12160_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus); 6433 sdp->isp_devparam[tgt].nvrm_period = 6434 ISP12160_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus); 6435 sdp->isp_devparam[tgt].nvrm_flags = 0; 6436 if (ISP12160_NVRAM_TGT_RENEG(nvram_data, tgt, bus)) 6437 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG; 6438 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ; 6439 if (ISP12160_NVRAM_TGT_TQING(nvram_data, tgt, bus)) 6440 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING; 6441 if (ISP12160_NVRAM_TGT_SYNC(nvram_data, tgt, bus)) 6442 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC; 6443 if (ISP12160_NVRAM_TGT_WIDE(nvram_data, tgt, bus)) 6444 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE; 6445 if (ISP12160_NVRAM_TGT_PARITY(nvram_data, tgt, bus)) 6446 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY; 6447 if (ISP12160_NVRAM_TGT_DISC(nvram_data, tgt, bus)) 6448 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC; 6449 sdp->isp_devparam[tgt].actv_flags = 0; 6450 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4, 6451 bus, tgt, sdp->isp_devparam[tgt].nvrm_flags, 6452 sdp->isp_devparam[tgt].nvrm_offset, 6453 sdp->isp_devparam[tgt].nvrm_period); 6454 sdp->isp_devparam[tgt].goal_offset = 6455 sdp->isp_devparam[tgt].nvrm_offset; 6456 sdp->isp_devparam[tgt].goal_period = 6457 sdp->isp_devparam[tgt].nvrm_period; 6458 sdp->isp_devparam[tgt].goal_flags = 6459 sdp->isp_devparam[tgt].nvrm_flags; 6460 } 6461 } 6462 6463 static void 6464 isp_parse_nvram_2100(struct ispsoftc *isp, u_int8_t *nvram_data) 6465 { 6466 fcparam *fcp = (fcparam *) isp->isp_param; 6467 u_int64_t wwn; 6468 6469 /* 6470 * There is NVRAM storage for both Port and Node entities- 6471 * but the Node entity appears to be unused on all the cards 6472 * I can find. However, we should account for this being set 6473 * at some point in the future. 6474 * 6475 * Qlogic WWNs have an NAA of 2, but usually nothing shows up in 6476 * bits 48..60. In the case of the 2202, it appears that they do 6477 * use bit 48 to distinguish between the two instances on the card. 6478 * The 2204, which I've never seen, *probably* extends this method. 6479 */ 6480 wwn = ISP2100_NVRAM_PORT_NAME(nvram_data); 6481 if (wwn) { 6482 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x", 6483 (u_int32_t) (wwn >> 32), (u_int32_t) (wwn & 0xffffffff)); 6484 if ((wwn >> 60) == 0) { 6485 wwn |= (((u_int64_t) 2)<< 60); 6486 } 6487 } 6488 fcp->isp_portwwn = wwn; 6489 if (IS_2200(isp) || IS_23XX(isp)) { 6490 wwn = ISP2200_NVRAM_NODE_NAME(nvram_data); 6491 if (wwn) { 6492 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x", 6493 (u_int32_t) (wwn >> 32), 6494 (u_int32_t) (wwn & 0xffffffff)); 6495 if ((wwn >> 60) == 0) { 6496 wwn |= (((u_int64_t) 2)<< 60); 6497 } 6498 } 6499 } else { 6500 wwn &= ~((u_int64_t) 0xfff << 48); 6501 } 6502 fcp->isp_nodewwn = wwn; 6503 6504 /* 6505 * Make sure we have both Node and Port as non-zero values. 6506 */ 6507 if (fcp->isp_nodewwn != 0 && fcp->isp_portwwn == 0) { 6508 fcp->isp_portwwn = fcp->isp_nodewwn; 6509 } else if (fcp->isp_nodewwn == 0 && fcp->isp_portwwn != 0) { 6510 fcp->isp_nodewwn = fcp->isp_portwwn; 6511 } 6512 6513 /* 6514 * Make the Node and Port values sane if they're NAA == 2. 6515 * This means to clear bits 48..56 for the Node WWN and 6516 * make sure that there's some non-zero value in 48..56 6517 * for the Port WWN. 6518 */ 6519 if (fcp->isp_nodewwn && fcp->isp_portwwn) { 6520 if ((fcp->isp_nodewwn & (((u_int64_t) 0xfff) << 48)) != 0 && 6521 (fcp->isp_nodewwn >> 60) == 2) { 6522 fcp->isp_nodewwn &= ~((u_int64_t) 0xfff << 48); 6523 } 6524 if ((fcp->isp_portwwn & (((u_int64_t) 0xfff) << 48)) == 0 && 6525 (fcp->isp_portwwn >> 60) == 2) { 6526 fcp->isp_portwwn |= ((u_int64_t) 1 << 56); 6527 } 6528 } 6529 6530 isp_prt(isp, ISP_LOGDEBUG0, 6531 "NVRAM: maxfrmlen %d execthrottle %d fwoptions 0x%x loopid %x", 6532 ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data), 6533 ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data), 6534 ISP2100_NVRAM_OPTIONS(nvram_data), 6535 ISP2100_NVRAM_HARDLOOPID(nvram_data)); 6536 6537 fcp->isp_maxalloc = 6538 ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data); 6539 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) 6540 fcp->isp_maxfrmlen = 6541 ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data); 6542 fcp->isp_retry_delay = 6543 ISP2100_NVRAM_RETRY_DELAY(nvram_data); 6544 fcp->isp_retry_count = 6545 ISP2100_NVRAM_RETRY_COUNT(nvram_data); 6546 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) 6547 fcp->isp_loopid = 6548 ISP2100_NVRAM_HARDLOOPID(nvram_data); 6549 if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) 6550 fcp->isp_execthrottle = 6551 ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data); 6552 fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data); 6553 } 6554 6555 #ifdef ISP_FW_CRASH_DUMP 6556 static void isp2200_fw_dump(struct ispsoftc *); 6557 static void isp2300_fw_dump(struct ispsoftc *); 6558 6559 static void 6560 isp2200_fw_dump(struct ispsoftc *isp) 6561 { 6562 int i, j; 6563 mbreg_t mbs; 6564 u_int16_t *ptr; 6565 6566 MEMZERO(&mbs, sizeof (mbs)); 6567 ptr = FCPARAM(isp)->isp_dump_data; 6568 if (ptr == NULL) { 6569 isp_prt(isp, ISP_LOGERR, 6570 "No place to dump RISC registers and SRAM"); 6571 return; 6572 } 6573 if (*ptr++) { 6574 isp_prt(isp, ISP_LOGERR, 6575 "dump area for RISC registers and SRAM already used"); 6576 return; 6577 } 6578 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE); 6579 for (i = 0; i < 100; i++) { 6580 USEC_DELAY(100); 6581 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) { 6582 break; 6583 } 6584 } 6585 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) { 6586 /* 6587 * PBIU Registers 6588 */ 6589 for (i = 0; i < 8; i++) { 6590 *ptr++ = ISP_READ(isp, BIU_BLOCK + (i << 1)); 6591 } 6592 6593 /* 6594 * Mailbox Registers 6595 */ 6596 for (i = 0; i < 8; i++) { 6597 *ptr++ = ISP_READ(isp, MBOX_BLOCK + (i << 1)); 6598 } 6599 6600 /* 6601 * DMA Registers 6602 */ 6603 for (i = 0; i < 48; i++) { 6604 *ptr++ = ISP_READ(isp, DMA_BLOCK + 0x20 + (i << 1)); 6605 } 6606 6607 /* 6608 * RISC H/W Registers 6609 */ 6610 ISP_WRITE(isp, BIU2100_CSR, 0); 6611 for (i = 0; i < 16; i++) { 6612 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0xA0 + (i << 1)); 6613 } 6614 6615 /* 6616 * RISC GP Registers 6617 */ 6618 for (j = 0; j < 8; j++) { 6619 ISP_WRITE(isp, BIU_BLOCK + 0xA4, 0x2000 + (j << 8)); 6620 for (i = 0; i < 16; i++) { 6621 *ptr++ = 6622 ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1)); 6623 } 6624 } 6625 6626 /* 6627 * Frame Buffer Hardware Registers 6628 */ 6629 ISP_WRITE(isp, BIU2100_CSR, 0x10); 6630 for (i = 0; i < 16; i++) { 6631 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1)); 6632 } 6633 6634 /* 6635 * Fibre Protocol Module 0 Hardware Registers 6636 */ 6637 ISP_WRITE(isp, BIU2100_CSR, 0x20); 6638 for (i = 0; i < 64; i++) { 6639 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1)); 6640 } 6641 6642 /* 6643 * Fibre Protocol Module 1 Hardware Registers 6644 */ 6645 ISP_WRITE(isp, BIU2100_CSR, 0x30); 6646 for (i = 0; i < 64; i++) { 6647 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1)); 6648 } 6649 } else { 6650 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause"); 6651 return; 6652 } 6653 isp_prt(isp, ISP_LOGALL, 6654 "isp_fw_dump: RISC registers dumped successfully"); 6655 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET); 6656 for (i = 0; i < 100; i++) { 6657 USEC_DELAY(100); 6658 if (ISP_READ(isp, OUTMAILBOX0) == 0) { 6659 break; 6660 } 6661 } 6662 if (ISP_READ(isp, OUTMAILBOX0) != 0) { 6663 isp_prt(isp, ISP_LOGERR, "Board Would Not Reset"); 6664 return; 6665 } 6666 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE); 6667 for (i = 0; i < 100; i++) { 6668 USEC_DELAY(100); 6669 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) { 6670 break; 6671 } 6672 } 6673 if ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) { 6674 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause After Reset"); 6675 return; 6676 } 6677 ISP_WRITE(isp, RISC_EMB, 0xf2); 6678 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); 6679 for (i = 0; i < 100; i++) { 6680 USEC_DELAY(100); 6681 if ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) { 6682 break; 6683 } 6684 } 6685 ENABLE_INTS(isp); 6686 mbs.param[0] = MBOX_READ_RAM_WORD; 6687 mbs.param[1] = 0x1000; 6688 isp->isp_mbxworkp = (void *) ptr; 6689 isp->isp_mbxwrk0 = 0xefff; /* continuation count */ 6690 isp->isp_mbxwrk1 = 0x1001; /* next SRAM address */ 6691 isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs); 6692 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 6693 isp_prt(isp, ISP_LOGWARN, 6694 "RAM DUMP FAILED @ WORD %x", isp->isp_mbxwrk1); 6695 return; 6696 } 6697 ptr = isp->isp_mbxworkp; /* finish fetch of final word */ 6698 *ptr++ = isp->isp_mboxtmp[2]; 6699 isp_prt(isp, ISP_LOGALL, "isp_fw_dump: SRAM dumped successfully"); 6700 FCPARAM(isp)->isp_dump_data[0] = isp->isp_type; /* now used */ 6701 (void) isp_async(isp, ISPASYNC_FW_DUMPED, 0); 6702 } 6703 6704 static void 6705 isp2300_fw_dump(struct ispsoftc *isp) 6706 { 6707 int i, j; 6708 mbreg_t mbs; 6709 u_int16_t *ptr; 6710 6711 MEMZERO(&mbs, sizeof (mbs)); 6712 ptr = FCPARAM(isp)->isp_dump_data; 6713 if (ptr == NULL) { 6714 isp_prt(isp, ISP_LOGERR, 6715 "No place to dump RISC registers and SRAM"); 6716 return; 6717 } 6718 if (*ptr++) { 6719 isp_prt(isp, ISP_LOGERR, 6720 "dump area for RISC registers and SRAM already used"); 6721 return; 6722 } 6723 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE); 6724 for (i = 0; i < 100; i++) { 6725 USEC_DELAY(100); 6726 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) { 6727 break; 6728 } 6729 } 6730 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) { 6731 /* 6732 * PBIU registers 6733 */ 6734 for (i = 0; i < 8; i++) { 6735 *ptr++ = ISP_READ(isp, BIU_BLOCK + (i << 1)); 6736 } 6737 6738 /* 6739 * ReqQ-RspQ-Risc2Host Status registers 6740 */ 6741 for (i = 0; i < 8; i++) { 6742 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x10 + (i << 1)); 6743 } 6744 6745 /* 6746 * Mailbox Registers 6747 */ 6748 for (i = 0; i < 32; i++) { 6749 *ptr++ = 6750 ISP_READ(isp, PCI_MBOX_REGS2300_OFF + (i << 1)); 6751 } 6752 6753 /* 6754 * Auto Request Response DMA registers 6755 */ 6756 ISP_WRITE(isp, BIU2100_CSR, 0x40); 6757 for (i = 0; i < 32; i++) { 6758 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1)); 6759 } 6760 6761 /* 6762 * DMA registers 6763 */ 6764 ISP_WRITE(isp, BIU2100_CSR, 0x50); 6765 for (i = 0; i < 48; i++) { 6766 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1)); 6767 } 6768 6769 /* 6770 * RISC hardware registers 6771 */ 6772 ISP_WRITE(isp, BIU2100_CSR, 0); 6773 for (i = 0; i < 16; i++) { 6774 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0xA0 + (i << 1)); 6775 } 6776 6777 /* 6778 * RISC GP? registers 6779 */ 6780 for (j = 0; j < 8; j++) { 6781 ISP_WRITE(isp, BIU_BLOCK + 0xA4, 0x2000 + (j << 9)); 6782 for (i = 0; i < 16; i++) { 6783 *ptr++ = 6784 ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1)); 6785 } 6786 } 6787 6788 /* 6789 * frame buffer hardware registers 6790 */ 6791 ISP_WRITE(isp, BIU2100_CSR, 0x10); 6792 for (i = 0; i < 64; i++) { 6793 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1)); 6794 } 6795 6796 /* 6797 * FPM B0 hardware registers 6798 */ 6799 ISP_WRITE(isp, BIU2100_CSR, 0x20); 6800 for (i = 0; i < 64; i++) { 6801 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1)); 6802 } 6803 6804 /* 6805 * FPM B1 hardware registers 6806 */ 6807 ISP_WRITE(isp, BIU2100_CSR, 0x30); 6808 for (i = 0; i < 64; i++) { 6809 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1)); 6810 } 6811 } else { 6812 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause"); 6813 return; 6814 } 6815 isp_prt(isp, ISP_LOGALL, 6816 "isp_fw_dump: RISC registers dumped successfully"); 6817 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET); 6818 for (i = 0; i < 100; i++) { 6819 USEC_DELAY(100); 6820 if (ISP_READ(isp, OUTMAILBOX0) == 0) { 6821 break; 6822 } 6823 } 6824 if (ISP_READ(isp, OUTMAILBOX0) != 0) { 6825 isp_prt(isp, ISP_LOGERR, "Board Would Not Reset"); 6826 return; 6827 } 6828 ENABLE_INTS(isp); 6829 mbs.param[0] = MBOX_READ_RAM_WORD; 6830 mbs.param[1] = 0x800; 6831 isp->isp_mbxworkp = (void *) ptr; 6832 isp->isp_mbxwrk0 = 0xf7ff; /* continuation count */ 6833 isp->isp_mbxwrk1 = 0x801; /* next SRAM address */ 6834 isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs); 6835 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 6836 isp_prt(isp, ISP_LOGWARN, 6837 "RAM DUMP FAILED @ WORD %x", isp->isp_mbxwrk1); 6838 return; 6839 } 6840 ptr = isp->isp_mbxworkp; /* finish fetch of final word */ 6841 *ptr++ = isp->isp_mboxtmp[2]; 6842 6843 /* 6844 * We don't have access to mailbox registers 8.. onward 6845 * in our 'common' device model- so we have to set it 6846 * here and hope it stays the same! 6847 */ 6848 ISP_WRITE(isp, PCI_MBOX_REGS2300_OFF + (8 << 1), 0x1); 6849 6850 mbs.param[0] = MBOX_READ_RAM_WORD_EXTENDED; 6851 mbs.param[1] = 0; 6852 isp->isp_mbxworkp = (void *) ptr; 6853 isp->isp_mbxwrk0 = 0xffff; /* continuation count */ 6854 isp->isp_mbxwrk1 = 0x1; /* next SRAM address */ 6855 isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs); 6856 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 6857 isp_prt(isp, ISP_LOGWARN, 6858 "RAM DUMP FAILED @ WORD %x", 0x10000 + isp->isp_mbxwrk1); 6859 return; 6860 } 6861 ptr = isp->isp_mbxworkp; /* finish final word */ 6862 *ptr++ = mbs.param[2]; 6863 isp_prt(isp, ISP_LOGALL, "isp_fw_dump: SRAM dumped successfully"); 6864 FCPARAM(isp)->isp_dump_data[0] = isp->isp_type; /* now used */ 6865 (void) isp_async(isp, ISPASYNC_FW_DUMPED, 0); 6866 } 6867 6868 void 6869 isp_fw_dump(struct ispsoftc *isp) 6870 { 6871 if (IS_2200(isp)) 6872 isp2200_fw_dump(isp); 6873 else if (IS_23XX(isp)) 6874 isp2300_fw_dump(isp); 6875 } 6876 #endif 6877