isp.c revision 1.77
1 /* $NetBSD: isp.c,v 1.77 2001/05/25 21:45:55 mjacob Exp $ */ 2 /* 3 * This driver, which is contained in NetBSD in the files: 4 * 5 * sys/dev/ic/isp.c 6 * sys/dev/ic/isp_inline.h 7 * sys/dev/ic/isp_netbsd.c 8 * sys/dev/ic/isp_netbsd.h 9 * sys/dev/ic/isp_target.c 10 * sys/dev/ic/isp_target.h 11 * sys/dev/ic/isp_tpublic.h 12 * sys/dev/ic/ispmbox.h 13 * sys/dev/ic/ispreg.h 14 * sys/dev/ic/ispvar.h 15 * sys/microcode/isp/asm_sbus.h 16 * sys/microcode/isp/asm_1040.h 17 * sys/microcode/isp/asm_1080.h 18 * sys/microcode/isp/asm_12160.h 19 * sys/microcode/isp/asm_2100.h 20 * sys/microcode/isp/asm_2200.h 21 * sys/pci/isp_pci.c 22 * sys/sbus/isp_sbus.c 23 * 24 * Is being actively maintained by Matthew Jacob (mjacob (at) netbsd.org). 25 * This driver also is shared source with FreeBSD, OpenBSD, Linux, Solaris, 26 * Linux versions. This tends to be an interesting maintenance problem. 27 * 28 * Please coordinate with Matthew Jacob on changes you wish to make here. 29 */ 30 /* 31 * Machine and OS Independent (well, as best as possible) 32 * code for the Qlogic ISP SCSI adapters. 33 * 34 * Copyright (c) 1997, 1998, 1999, 2000, 2001 by Matthew Jacob 35 * NASA/Ames Research Center 36 * All rights reserved. 37 * 38 * Redistribution and use in source and binary forms, with or without 39 * modification, are permitted provided that the following conditions 40 * are met: 41 * 1. Redistributions of source code must retain the above copyright 42 * notice immediately at the beginning of the file, without modification, 43 * this list of conditions, and the following disclaimer. 44 * 2. The name of the author may not be used to endorse or promote products 45 * derived from this software without specific prior written permission. 46 * 47 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 48 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 49 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 50 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 51 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 52 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 53 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 54 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 55 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 56 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 57 * SUCH DAMAGE. 58 */ 59 60 /* 61 * Inspiration and ideas about this driver are from Erik Moe's Linux driver 62 * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some 63 * ideas dredged from the Solaris driver. 64 */ 65 66 /* 67 * Include header file appropriate for platform we're building on. 68 */ 69 70 #ifdef __NetBSD__ 71 #include <dev/ic/isp_netbsd.h> 72 #endif 73 #ifdef __FreeBSD__ 74 #include <dev/isp/isp_freebsd.h> 75 #endif 76 #ifdef __OpenBSD__ 77 #include <dev/ic/isp_openbsd.h> 78 #endif 79 #ifdef __linux__ 80 #include "isp_linux.h" 81 #endif 82 #ifdef __svr4__ 83 #include "isp_solaris.h" 84 #endif 85 86 /* 87 * General defines 88 */ 89 90 #define MBOX_DELAY_COUNT 1000000 / 100 91 92 /* 93 * Local static data 94 */ 95 static const char warnlun[] = 96 "WARNING- cannot determine Expanded LUN capability- limiting to one LUN"; 97 static const char portshift[] = 98 "Target %d Loop ID 0x%x (Port 0x%x) => Loop 0x%x (Port 0x%x)"; 99 static const char portdup[] = 100 "Target %d duplicates Target %d- killing off both"; 101 static const char retained[] = 102 "Retaining Loop ID 0x%x for Target %d (Port 0x%x)"; 103 static const char lretained[] = 104 "Retained login of Target %d (Loop ID 0x%x) Port 0x%x"; 105 static const char plogout[] = 106 "Logging out Target %d at Loop ID 0x%x (Port 0x%x)"; 107 static const char plogierr[] = 108 "Command Error in PLOGI for Port 0x%x (0x%x)"; 109 static const char nopdb[] = 110 "Could not get PDB for Device @ Port 0x%x"; 111 static const char pdbmfail1[] = 112 "PDB Loop ID info for Device @ Port 0x%x does not match up (0x%x)"; 113 static const char pdbmfail2[] = 114 "PDB Port info for Device @ Port 0x%x does not match up (0x%x)"; 115 static const char ldumped[] = 116 "Target %d (Loop ID 0x%x) Port 0x%x dumped after login info mismatch"; 117 static const char notresp[] = 118 "Not RESPONSE in RESPONSE Queue (type 0x%x) @ idx %d (next %d) nlooked %d"; 119 static const char xact1[] = 120 "HBA attempted queued transaction with disconnect not set for %d.%d.%d"; 121 static const char xact2[] = 122 "HBA attempted queued transaction to target routine %d on target %d bus %d"; 123 static const char xact3[] = 124 "HBA attempted queued cmd for %d.%d.%d when queueing disabled"; 125 static const char pskip[] = 126 "SCSI phase skipped for target %d.%d.%d"; 127 static const char topology[] = 128 "Loop ID %d, AL_PA 0x%x, Port ID 0x%x, Loop State 0x%x, Topology '%s'"; 129 static const char finmsg[] = 130 "(%d.%d.%d): FIN dl%d resid %d STS 0x%x SKEY %c XS_ERR=0x%x"; 131 /* 132 * Local function prototypes. 133 */ 134 static int isp_parse_async __P((struct ispsoftc *, int)); 135 static int isp_handle_other_response 136 __P((struct ispsoftc *, ispstatusreq_t *, u_int16_t *)); 137 static void isp_parse_status 138 __P((struct ispsoftc *, ispstatusreq_t *, XS_T *)); 139 static void isp_fastpost_complete __P((struct ispsoftc *, u_int16_t)); 140 static void isp_scsi_init __P((struct ispsoftc *)); 141 static void isp_scsi_channel_init __P((struct ispsoftc *, int)); 142 static void isp_fibre_init __P((struct ispsoftc *)); 143 static void isp_mark_getpdb_all __P((struct ispsoftc *)); 144 static int isp_getmap __P((struct ispsoftc *, fcpos_map_t *)); 145 static int isp_getpdb __P((struct ispsoftc *, int, isp_pdb_t *)); 146 static u_int64_t isp_get_portname __P((struct ispsoftc *, int, int)); 147 static int isp_fclink_test __P((struct ispsoftc *, int)); 148 static char *isp2100_fw_statename __P((int)); 149 static int isp_pdb_sync __P((struct ispsoftc *)); 150 static int isp_scan_loop __P((struct ispsoftc *)); 151 static int isp_scan_fabric __P((struct ispsoftc *)); 152 static void isp_register_fc4_type __P((struct ispsoftc *)); 153 static void isp_fw_state __P((struct ispsoftc *)); 154 static void isp_mboxcmd __P((struct ispsoftc *, mbreg_t *, int)); 155 156 static void isp_update __P((struct ispsoftc *)); 157 static void isp_update_bus __P((struct ispsoftc *, int)); 158 static void isp_setdfltparm __P((struct ispsoftc *, int)); 159 static int isp_read_nvram __P((struct ispsoftc *)); 160 static void isp_rdnvram_word __P((struct ispsoftc *, int, u_int16_t *)); 161 static void isp_parse_nvram_1020 __P((struct ispsoftc *, u_int8_t *)); 162 static void isp_parse_nvram_1080 __P((struct ispsoftc *, int, u_int8_t *)); 163 static void isp_parse_nvram_12160 __P((struct ispsoftc *, int, u_int8_t *)); 164 static void isp_parse_nvram_2100 __P((struct ispsoftc *, u_int8_t *)); 165 166 /* 167 * Reset Hardware. 168 * 169 * Hit the chip over the head, download new f/w if available and set it running. 170 * 171 * Locking done elsewhere. 172 */ 173 void 174 isp_reset(struct ispsoftc *isp) 175 { 176 mbreg_t mbs; 177 int loops, i, touched, dodnld = 1; 178 char *revname = "????"; 179 180 isp->isp_state = ISP_NILSTATE; 181 182 183 /* 184 * Basic types (SCSI, FibreChannel and PCI or SBus) 185 * have been set in the MD code. We figure out more 186 * here. 187 * 188 * After we've fired this chip up, zero out the conf1 register 189 * for SCSI adapters and do other settings for the 2100. 190 */ 191 192 /* 193 * Get the current running firmware revision out of the 194 * chip before we hit it over the head (if this is our 195 * first time through). Note that we store this as the 196 * 'ROM' firmware revision- which it may not be. In any 197 * case, we don't really use this yet, but we may in 198 * the future. 199 */ 200 if ((touched = isp->isp_touched) == 0) { 201 /* 202 * First see whether or not we're sitting in the ISP PROM. 203 * If we've just been reset, we'll have the string "ISP " 204 * spread through outgoing mailbox registers 1-3. 205 */ 206 if (ISP_READ(isp, OUTMAILBOX1) != 0x4953 || 207 ISP_READ(isp, OUTMAILBOX2) != 0x5020 || 208 ISP_READ(isp, OUTMAILBOX3) != 0x2020) { 209 /* 210 * Just in case it was paused... 211 */ 212 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); 213 mbs.param[0] = MBOX_ABOUT_FIRMWARE; 214 isp_mboxcmd(isp, &mbs, MBOX_COMMAND_ERROR); 215 /* 216 * This *shouldn't* fail..... 217 */ 218 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 219 isp->isp_romfw_rev[0] = mbs.param[1]; 220 isp->isp_romfw_rev[1] = mbs.param[2]; 221 isp->isp_romfw_rev[2] = mbs.param[3]; 222 } 223 } 224 isp->isp_touched = 1; 225 } 226 227 DISABLE_INTS(isp); 228 229 /* 230 * Put the board into PAUSE mode (so we can read the SXP registers 231 * or write FPM/FBM registers). 232 */ 233 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE); 234 235 if (IS_FC(isp)) { 236 switch (isp->isp_type) { 237 case ISP_HA_FC_2100: 238 revname = "2100"; 239 break; 240 case ISP_HA_FC_2200: 241 revname = "2200"; 242 break; 243 case ISP_HA_FC_2300: 244 revname = "2300"; 245 break; 246 default: 247 break; 248 } 249 /* 250 * While we're paused, reset the FPM module and FBM fifos. 251 */ 252 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS); 253 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET); 254 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS); 255 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL); 256 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS); 257 } else if (IS_1240(isp)) { 258 sdparam *sdp = isp->isp_param; 259 revname = "1240"; 260 isp->isp_clock = 60; 261 sdp->isp_ultramode = 1; 262 sdp++; 263 sdp->isp_ultramode = 1; 264 /* 265 * XXX: Should probably do some bus sensing. 266 */ 267 } else if (IS_ULTRA2(isp)) { 268 static const char m[] = "bus %d is in %s Mode"; 269 u_int16_t l; 270 sdparam *sdp = isp->isp_param; 271 272 isp->isp_clock = 100; 273 274 if (IS_1280(isp)) 275 revname = "1280"; 276 else if (IS_1080(isp)) 277 revname = "1080"; 278 else if (IS_12160(isp)) 279 revname = "12160"; 280 else 281 revname = "<UNKLVD>"; 282 283 l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK; 284 switch (l) { 285 case ISP1080_LVD_MODE: 286 sdp->isp_lvdmode = 1; 287 isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD"); 288 break; 289 case ISP1080_HVD_MODE: 290 sdp->isp_diffmode = 1; 291 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential"); 292 break; 293 case ISP1080_SE_MODE: 294 sdp->isp_ultramode = 1; 295 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended"); 296 break; 297 default: 298 isp_prt(isp, ISP_LOGERR, 299 "unknown mode on bus %d (0x%x)", 0, l); 300 break; 301 } 302 303 if (IS_DUALBUS(isp)) { 304 sdp++; 305 l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT); 306 l &= ISP1080_MODE_MASK; 307 switch(l) { 308 case ISP1080_LVD_MODE: 309 sdp->isp_lvdmode = 1; 310 isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD"); 311 break; 312 case ISP1080_HVD_MODE: 313 sdp->isp_diffmode = 1; 314 isp_prt(isp, ISP_LOGCONFIG, 315 m, 1, "Differential"); 316 break; 317 case ISP1080_SE_MODE: 318 sdp->isp_ultramode = 1; 319 isp_prt(isp, ISP_LOGCONFIG, 320 m, 1, "Single-Ended"); 321 break; 322 default: 323 isp_prt(isp, ISP_LOGERR, 324 "unknown mode on bus %d (0x%x)", 1, l); 325 break; 326 } 327 } 328 } else { 329 sdparam *sdp = isp->isp_param; 330 i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK; 331 switch (i) { 332 default: 333 isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i); 334 /* FALLTHROUGH */ 335 case 1: 336 revname = "1020"; 337 isp->isp_type = ISP_HA_SCSI_1020; 338 isp->isp_clock = 40; 339 break; 340 case 2: 341 /* 342 * Some 1020A chips are Ultra Capable, but don't 343 * run the clock rate up for that unless told to 344 * do so by the Ultra Capable bits being set. 345 */ 346 revname = "1020A"; 347 isp->isp_type = ISP_HA_SCSI_1020A; 348 isp->isp_clock = 40; 349 break; 350 case 3: 351 revname = "1040"; 352 isp->isp_type = ISP_HA_SCSI_1040; 353 isp->isp_clock = 60; 354 break; 355 case 4: 356 revname = "1040A"; 357 isp->isp_type = ISP_HA_SCSI_1040A; 358 isp->isp_clock = 60; 359 break; 360 case 5: 361 revname = "1040B"; 362 isp->isp_type = ISP_HA_SCSI_1040B; 363 isp->isp_clock = 60; 364 break; 365 case 6: 366 revname = "1040C"; 367 isp->isp_type = ISP_HA_SCSI_1040C; 368 isp->isp_clock = 60; 369 break; 370 } 371 /* 372 * Now, while we're at it, gather info about ultra 373 * and/or differential mode. 374 */ 375 if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) { 376 isp_prt(isp, ISP_LOGCONFIG, "Differential Mode"); 377 sdp->isp_diffmode = 1; 378 } else { 379 sdp->isp_diffmode = 0; 380 } 381 i = ISP_READ(isp, RISC_PSR); 382 if (isp->isp_bustype == ISP_BT_SBUS) { 383 i &= RISC_PSR_SBUS_ULTRA; 384 } else { 385 i &= RISC_PSR_PCI_ULTRA; 386 } 387 if (i != 0) { 388 isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable"); 389 sdp->isp_ultramode = 1; 390 /* 391 * If we're in Ultra Mode, we have to be 60Mhz clock- 392 * even for the SBus version. 393 */ 394 isp->isp_clock = 60; 395 } else { 396 sdp->isp_ultramode = 0; 397 /* 398 * Clock is known. Gronk. 399 */ 400 } 401 402 /* 403 * Machine dependent clock (if set) overrides 404 * our generic determinations. 405 */ 406 if (isp->isp_mdvec->dv_clock) { 407 if (isp->isp_mdvec->dv_clock < isp->isp_clock) { 408 isp->isp_clock = isp->isp_mdvec->dv_clock; 409 } 410 } 411 412 } 413 414 /* 415 * Clear instrumentation 416 */ 417 isp->isp_intcnt = isp->isp_intbogus = 0; 418 419 /* 420 * Do MD specific pre initialization 421 */ 422 ISP_RESET0(isp); 423 424 again: 425 426 /* 427 * Hit the chip over the head with hammer, 428 * and give the ISP a chance to recover. 429 */ 430 431 if (IS_SCSI(isp)) { 432 ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET); 433 /* 434 * A slight delay... 435 */ 436 USEC_DELAY(100); 437 438 /* 439 * Clear data && control DMA engines. 440 */ 441 ISP_WRITE(isp, CDMA_CONTROL, 442 DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT); 443 ISP_WRITE(isp, DDMA_CONTROL, 444 DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT); 445 446 447 } else { 448 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET); 449 /* 450 * A slight delay... 451 */ 452 USEC_DELAY(100); 453 454 /* 455 * Clear data && control DMA engines. 456 */ 457 ISP_WRITE(isp, CDMA2100_CONTROL, 458 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT); 459 ISP_WRITE(isp, TDMA2100_CONTROL, 460 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT); 461 ISP_WRITE(isp, RDMA2100_CONTROL, 462 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT); 463 } 464 465 /* 466 * Wait for ISP to be ready to go... 467 */ 468 loops = MBOX_DELAY_COUNT; 469 for (;;) { 470 if (IS_SCSI(isp)) { 471 if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) 472 break; 473 } else { 474 if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET)) 475 break; 476 } 477 USEC_DELAY(100); 478 if (--loops < 0) { 479 ISP_DUMPREGS(isp, "chip reset timed out"); 480 return; 481 } 482 } 483 484 /* 485 * After we've fired this chip up, zero out the conf1 register 486 * for SCSI adapters and other settings for the 2100. 487 */ 488 489 if (IS_SCSI(isp)) { 490 ISP_WRITE(isp, BIU_CONF1, 0); 491 } else { 492 ISP_WRITE(isp, BIU2100_CSR, 0); 493 } 494 495 /* 496 * Reset RISC Processor 497 */ 498 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET); 499 USEC_DELAY(100); 500 /* Clear semaphore register (just to be sure) */ 501 ISP_WRITE(isp, BIU_SEMA, 0); 502 503 /* 504 * Establish some initial burst rate stuff. 505 * (only for the 1XX0 boards). This really should 506 * be done later after fetching from NVRAM. 507 */ 508 if (IS_SCSI(isp)) { 509 u_int16_t tmp = isp->isp_mdvec->dv_conf1; 510 /* 511 * Busted FIFO. Turn off all but burst enables. 512 */ 513 if (isp->isp_type == ISP_HA_SCSI_1040A) { 514 tmp &= BIU_BURST_ENABLE; 515 } 516 ISP_SETBITS(isp, BIU_CONF1, tmp); 517 if (tmp & BIU_BURST_ENABLE) { 518 ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST); 519 ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST); 520 } 521 #ifdef PTI_CARDS 522 if (((sdparam *) isp->isp_param)->isp_ultramode) { 523 while (ISP_READ(isp, RISC_MTR) != 0x1313) { 524 ISP_WRITE(isp, RISC_MTR, 0x1313); 525 ISP_WRITE(isp, HCCR, HCCR_CMD_STEP); 526 } 527 } else { 528 ISP_WRITE(isp, RISC_MTR, 0x1212); 529 } 530 /* 531 * PTI specific register 532 */ 533 ISP_WRITE(isp, RISC_EMB, DUAL_BANK) 534 #else 535 ISP_WRITE(isp, RISC_MTR, 0x1212); 536 #endif 537 } else { 538 ISP_WRITE(isp, RISC_MTR2100, 0x1212); 539 if (IS_2200(isp) || IS_2300(isp)) { 540 ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE); 541 } 542 } 543 544 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */ 545 546 /* 547 * Do MD specific post initialization 548 */ 549 ISP_RESET1(isp); 550 551 /* 552 * Wait for everything to finish firing up... 553 */ 554 loops = MBOX_DELAY_COUNT; 555 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) { 556 USEC_DELAY(100); 557 if (--loops < 0) { 558 isp_prt(isp, ISP_LOGERR, 559 "MBOX_BUSY never cleared on reset"); 560 return; 561 } 562 } 563 564 /* 565 * Up until this point we've done everything by just reading or 566 * setting registers. From this point on we rely on at least *some* 567 * kind of firmware running in the card. 568 */ 569 570 /* 571 * Do some sanity checking. 572 */ 573 mbs.param[0] = MBOX_NO_OP; 574 isp_mboxcmd(isp, &mbs, MBLOGALL); 575 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 576 return; 577 } 578 579 if (IS_SCSI(isp)) { 580 mbs.param[0] = MBOX_MAILBOX_REG_TEST; 581 mbs.param[1] = 0xdead; 582 mbs.param[2] = 0xbeef; 583 mbs.param[3] = 0xffff; 584 mbs.param[4] = 0x1111; 585 mbs.param[5] = 0xa5a5; 586 isp_mboxcmd(isp, &mbs, MBLOGALL); 587 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 588 return; 589 } 590 if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef || 591 mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 || 592 mbs.param[5] != 0xa5a5) { 593 isp_prt(isp, ISP_LOGERR, 594 "Register Test Failed (0x%x 0x%x 0x%x 0x%x 0x%x)", 595 mbs.param[1], mbs.param[2], mbs.param[3], 596 mbs.param[4], mbs.param[5]); 597 return; 598 } 599 600 } 601 602 /* 603 * Download new Firmware, unless requested not to do so. 604 * This is made slightly trickier in some cases where the 605 * firmware of the ROM revision is newer than the revision 606 * compiled into the driver. So, where we used to compare 607 * versions of our f/w and the ROM f/w, now we just see 608 * whether we have f/w at all and whether a config flag 609 * has disabled our download. 610 */ 611 if ((isp->isp_mdvec->dv_ispfw == NULL) || 612 (isp->isp_confopts & ISP_CFG_NORELOAD)) { 613 dodnld = 0; 614 } 615 616 if (dodnld) { 617 u_int16_t fwlen = isp->isp_mdvec->dv_ispfw[3]; 618 for (i = 0; i < fwlen; i++) { 619 mbs.param[0] = MBOX_WRITE_RAM_WORD; 620 mbs.param[1] = ISP_CODE_ORG + i; 621 mbs.param[2] = isp->isp_mdvec->dv_ispfw[i]; 622 isp_mboxcmd(isp, &mbs, MBLOGNONE); 623 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 624 isp_prt(isp, ISP_LOGERR, 625 "F/W download failed at word %d", i); 626 dodnld = 0; 627 goto again; 628 } 629 } 630 631 /* 632 * Verify that it downloaded correctly. 633 */ 634 mbs.param[0] = MBOX_VERIFY_CHECKSUM; 635 mbs.param[1] = ISP_CODE_ORG; 636 isp_mboxcmd(isp, &mbs, MBLOGNONE); 637 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 638 isp_prt(isp, ISP_LOGERR, "Ram Checksum Failure"); 639 return; 640 } 641 isp->isp_loaded_fw = 1; 642 } else { 643 isp->isp_loaded_fw = 0; 644 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download"); 645 } 646 647 /* 648 * Now start it rolling. 649 * 650 * If we didn't actually download f/w, 651 * we still need to (re)start it. 652 */ 653 654 mbs.param[0] = MBOX_EXEC_FIRMWARE; 655 mbs.param[1] = ISP_CODE_ORG; 656 isp_mboxcmd(isp, &mbs, MBLOGNONE); 657 /* give it a chance to start */ 658 USEC_SLEEP(isp, 500); 659 660 if (IS_SCSI(isp)) { 661 /* 662 * Set CLOCK RATE, but only if asked to. 663 */ 664 if (isp->isp_clock) { 665 mbs.param[0] = MBOX_SET_CLOCK_RATE; 666 mbs.param[1] = isp->isp_clock; 667 isp_mboxcmd(isp, &mbs, MBLOGALL); 668 /* we will try not to care if this fails */ 669 } 670 } 671 672 mbs.param[0] = MBOX_ABOUT_FIRMWARE; 673 isp_mboxcmd(isp, &mbs, MBLOGALL); 674 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 675 return; 676 } 677 isp_prt(isp, ISP_LOGCONFIG, 678 "Board Revision %s, %s F/W Revision %d.%d.%d", revname, 679 dodnld? "loaded" : "resident", mbs.param[1], mbs.param[2], 680 mbs.param[3]); 681 if (IS_FC(isp)) { 682 isp_prt(isp, ISP_LOGCONFIG, "Firmware Attributes = 0x%x", 683 mbs.param[6]); 684 if (ISP_READ(isp, BIU2100_CSR) & BIU2100_PCI64) { 685 isp_prt(isp, ISP_LOGCONFIG, 686 "Installed in 64-Bit PCI slot"); 687 } 688 } 689 690 isp->isp_fwrev[0] = mbs.param[1]; 691 isp->isp_fwrev[1] = mbs.param[2]; 692 isp->isp_fwrev[2] = mbs.param[3]; 693 if (isp->isp_romfw_rev[0] || isp->isp_romfw_rev[1] || 694 isp->isp_romfw_rev[2]) { 695 isp_prt(isp, ISP_LOGCONFIG, "Last F/W revision was %d.%d.%d", 696 isp->isp_romfw_rev[0], isp->isp_romfw_rev[1], 697 isp->isp_romfw_rev[2]); 698 } 699 700 mbs.param[0] = MBOX_GET_FIRMWARE_STATUS; 701 isp_mboxcmd(isp, &mbs, MBLOGALL); 702 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 703 return; 704 } 705 isp->isp_maxcmds = mbs.param[2]; 706 isp_prt(isp, ISP_LOGINFO, 707 "%d max I/O commands supported", mbs.param[2]); 708 isp_fw_state(isp); 709 710 /* 711 * Set up DMA for the request and result mailboxes. 712 */ 713 if (ISP_MBOXDMASETUP(isp) != 0) { 714 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA"); 715 return; 716 } 717 isp->isp_state = ISP_RESETSTATE; 718 719 /* 720 * Okay- now that we have new firmware running, we now (re)set our 721 * notion of how many luns we support. This is somewhat tricky because 722 * if we haven't loaded firmware, we don't have an easy way of telling 723 * how many luns we support. 724 * 725 * We'll make a simplifying assumption- if we loaded firmware, we 726 * are running with expanded lun firmware, otherwise not. 727 * 728 * Expanded lun firmware gives you 32 luns for SCSI cards and 729 * 65536 luns for Fibre Channel cards. 730 * 731 * Because the lun is in a a different position in the Request Queue 732 * Entry structure for Fibre Channel with expanded lun firmware, we 733 * can only support one lun (lun zero) when we don't know what kind 734 * of firmware we're running. 735 * 736 * Note that we only do this once (the first time thru isp_reset) 737 * because we may be called again after firmware has been loaded once 738 * and released. 739 */ 740 if (touched == 0) { 741 if (dodnld) { 742 if (IS_SCSI(isp)) { 743 isp->isp_maxluns = 32; 744 } else { 745 isp->isp_maxluns = 65536; 746 } 747 } else { 748 if (IS_SCSI(isp)) { 749 isp->isp_maxluns = 8; 750 } else { 751 isp_prt(isp, ISP_LOGALL, warnlun); 752 isp->isp_maxluns = 1; 753 } 754 } 755 } 756 } 757 758 /* 759 * Initialize Parameters of Hardware to a known state. 760 * 761 * Locks are held before coming here. 762 */ 763 764 void 765 isp_init(struct ispsoftc *isp) 766 { 767 /* 768 * Must do this first to get defaults established. 769 */ 770 isp_setdfltparm(isp, 0); 771 if (IS_DUALBUS(isp)) { 772 isp_setdfltparm(isp, 1); 773 } 774 if (IS_FC(isp)) { 775 isp_fibre_init(isp); 776 } else { 777 isp_scsi_init(isp); 778 } 779 } 780 781 static void 782 isp_scsi_init(struct ispsoftc *isp) 783 { 784 sdparam *sdp_chan0, *sdp_chan1; 785 mbreg_t mbs; 786 787 sdp_chan0 = isp->isp_param; 788 sdp_chan1 = sdp_chan0; 789 if (IS_DUALBUS(isp)) { 790 sdp_chan1++; 791 } 792 793 /* 794 * If we have no role (neither target nor initiator), return. 795 */ 796 if (isp->isp_role == ISP_ROLE_NONE) { 797 return; 798 } 799 800 /* First do overall per-card settings. */ 801 802 /* 803 * If we have fast memory timing enabled, turn it on. 804 */ 805 if (sdp_chan0->isp_fast_mttr) { 806 ISP_WRITE(isp, RISC_MTR, 0x1313); 807 } 808 809 /* 810 * Set Retry Delay and Count. 811 * You set both channels at the same time. 812 */ 813 mbs.param[0] = MBOX_SET_RETRY_COUNT; 814 mbs.param[1] = sdp_chan0->isp_retry_count; 815 mbs.param[2] = sdp_chan0->isp_retry_delay; 816 mbs.param[6] = sdp_chan1->isp_retry_count; 817 mbs.param[7] = sdp_chan1->isp_retry_delay; 818 819 isp_mboxcmd(isp, &mbs, MBLOGALL); 820 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 821 return; 822 } 823 824 /* 825 * Set ASYNC DATA SETUP time. This is very important. 826 */ 827 mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME; 828 mbs.param[1] = sdp_chan0->isp_async_data_setup; 829 mbs.param[2] = sdp_chan1->isp_async_data_setup; 830 isp_mboxcmd(isp, &mbs, MBLOGALL); 831 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 832 return; 833 } 834 835 /* 836 * Set ACTIVE Negation State. 837 */ 838 mbs.param[0] = MBOX_SET_ACT_NEG_STATE; 839 mbs.param[1] = 840 (sdp_chan0->isp_req_ack_active_neg << 4) | 841 (sdp_chan0->isp_data_line_active_neg << 5); 842 mbs.param[2] = 843 (sdp_chan1->isp_req_ack_active_neg << 4) | 844 (sdp_chan1->isp_data_line_active_neg << 5); 845 846 isp_mboxcmd(isp, &mbs, MBLOGNONE); 847 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 848 isp_prt(isp, ISP_LOGERR, 849 "failed to set active negation state (%d,%d), (%d,%d)", 850 sdp_chan0->isp_req_ack_active_neg, 851 sdp_chan0->isp_data_line_active_neg, 852 sdp_chan1->isp_req_ack_active_neg, 853 sdp_chan1->isp_data_line_active_neg); 854 /* 855 * But don't return. 856 */ 857 } 858 859 /* 860 * Set the Tag Aging limit 861 */ 862 mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT; 863 mbs.param[1] = sdp_chan0->isp_tag_aging; 864 mbs.param[2] = sdp_chan1->isp_tag_aging; 865 isp_mboxcmd(isp, &mbs, MBLOGALL); 866 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 867 isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)", 868 sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging); 869 return; 870 } 871 872 /* 873 * Set selection timeout. 874 */ 875 mbs.param[0] = MBOX_SET_SELECT_TIMEOUT; 876 mbs.param[1] = sdp_chan0->isp_selection_timeout; 877 mbs.param[2] = sdp_chan1->isp_selection_timeout; 878 isp_mboxcmd(isp, &mbs, MBLOGALL); 879 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 880 return; 881 } 882 883 /* now do per-channel settings */ 884 isp_scsi_channel_init(isp, 0); 885 if (IS_DUALBUS(isp)) 886 isp_scsi_channel_init(isp, 1); 887 888 /* 889 * Now enable request/response queues 890 */ 891 892 mbs.param[0] = MBOX_INIT_RES_QUEUE; 893 mbs.param[1] = RESULT_QUEUE_LEN(isp); 894 mbs.param[2] = DMA_MSW(isp->isp_result_dma); 895 mbs.param[3] = DMA_LSW(isp->isp_result_dma); 896 mbs.param[4] = 0; 897 mbs.param[5] = 0; 898 isp_mboxcmd(isp, &mbs, MBLOGALL); 899 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 900 return; 901 } 902 isp->isp_residx = mbs.param[5]; 903 904 mbs.param[0] = MBOX_INIT_REQ_QUEUE; 905 mbs.param[1] = RQUEST_QUEUE_LEN(isp); 906 mbs.param[2] = DMA_MSW(isp->isp_rquest_dma); 907 mbs.param[3] = DMA_LSW(isp->isp_rquest_dma); 908 mbs.param[4] = 0; 909 isp_mboxcmd(isp, &mbs, MBLOGALL); 910 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 911 return; 912 } 913 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4]; 914 915 /* 916 * Turn on Fast Posting, LVD transitions 917 * 918 * Ultra2 F/W always has had fast posting (and LVD transitions) 919 * 920 * Ultra and older (i.e., SBus) cards may not. It's just safer 921 * to assume not for them. 922 */ 923 924 mbs.param[0] = MBOX_SET_FW_FEATURES; 925 mbs.param[1] = 0; 926 if (IS_ULTRA2(isp)) 927 mbs.param[1] |= FW_FEATURE_LVD_NOTIFY; 928 if (IS_ULTRA2(isp) || IS_1240(isp)) 929 mbs.param[1] |= FW_FEATURE_FAST_POST; 930 if (mbs.param[1] != 0) { 931 u_int16_t sfeat = mbs.param[1]; 932 isp_mboxcmd(isp, &mbs, MBLOGALL); 933 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 934 isp_prt(isp, ISP_LOGINFO, 935 "Enabled FW features (0x%x)", sfeat); 936 } 937 } 938 939 /* 940 * Let the outer layers decide whether to issue a SCSI bus reset. 941 */ 942 isp->isp_state = ISP_INITSTATE; 943 } 944 945 static void 946 isp_scsi_channel_init(struct ispsoftc *isp, int channel) 947 { 948 sdparam *sdp; 949 mbreg_t mbs; 950 int tgt; 951 952 sdp = isp->isp_param; 953 sdp += channel; 954 955 /* 956 * Set (possibly new) Initiator ID. 957 */ 958 mbs.param[0] = MBOX_SET_INIT_SCSI_ID; 959 mbs.param[1] = (channel << 7) | sdp->isp_initiator_id; 960 isp_mboxcmd(isp, &mbs, MBLOGALL); 961 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 962 return; 963 } 964 isp_prt(isp, ISP_LOGINFO, "Initiator ID is %d on Channel %d", 965 sdp->isp_initiator_id, channel); 966 967 968 /* 969 * Set current per-target parameters to a safe minimum. 970 */ 971 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 972 int lun; 973 u_int16_t sdf; 974 975 if (sdp->isp_devparam[tgt].dev_enable == 0) { 976 continue; 977 } 978 #ifndef ISP_TARGET_MODE 979 if (tgt == sdp->isp_initiator_id) { 980 sdf = DPARM_DEFAULT; 981 } else { 982 sdf = DPARM_SAFE_DFLT; 983 /* 984 * It is not quite clear when this changed over so that 985 * we could force narrow and async for 1000/1020 cards, 986 * but assume that this is only the case for loaded 987 * firmware. 988 */ 989 if (isp->isp_loaded_fw) { 990 sdf |= DPARM_NARROW | DPARM_ASYNC; 991 } 992 } 993 #else 994 /* 995 * The !$*!)$!$)* f/w uses the same index into some 996 * internal table to decide how to respond to negotiations, 997 * so if we've said "let's be safe" for ID X, and ID X 998 * selects *us*, the negotiations will back to 'safe' 999 * (as in narrow/async). What the f/w *should* do is 1000 * use the initiator id settings to decide how to respond. 1001 */ 1002 sdf = DPARM_DEFAULT; 1003 #endif 1004 mbs.param[0] = MBOX_SET_TARGET_PARAMS; 1005 mbs.param[1] = (channel << 15) | (tgt << 8); 1006 mbs.param[2] = sdf; 1007 if ((sdf & DPARM_SYNC) == 0) { 1008 mbs.param[3] = 0; 1009 } else { 1010 mbs.param[3] = 1011 (sdp->isp_devparam[tgt].sync_offset << 8) | 1012 (sdp->isp_devparam[tgt].sync_period); 1013 } 1014 isp_prt(isp, ISP_LOGDEBUG0, 1015 "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x", 1016 channel, tgt, mbs.param[2], mbs.param[3] >> 8, 1017 mbs.param[3] & 0xff); 1018 isp_mboxcmd(isp, &mbs, MBLOGNONE); 1019 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1020 sdf = DPARM_SAFE_DFLT; 1021 mbs.param[0] = MBOX_SET_TARGET_PARAMS; 1022 mbs.param[1] = (tgt << 8) | (channel << 15); 1023 mbs.param[2] = sdf; 1024 mbs.param[3] = 0; 1025 isp_mboxcmd(isp, &mbs, MBLOGALL); 1026 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1027 continue; 1028 } 1029 } 1030 1031 /* 1032 * We don't update any information directly from the f/w 1033 * because we need to run at least one command to cause a 1034 * new state to be latched up. So, we just assume that we 1035 * converge to the values we just had set. 1036 * 1037 * Ensure that we don't believe tagged queuing is enabled yet. 1038 * It turns out that sometimes the ISP just ignores our 1039 * attempts to set parameters for devices that it hasn't 1040 * seen yet. 1041 */ 1042 sdp->isp_devparam[tgt].cur_dflags = sdf & ~DPARM_TQING; 1043 for (lun = 0; lun < (int) isp->isp_maxluns; lun++) { 1044 mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS; 1045 mbs.param[1] = (channel << 15) | (tgt << 8) | lun; 1046 mbs.param[2] = sdp->isp_max_queue_depth; 1047 mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle; 1048 isp_mboxcmd(isp, &mbs, MBLOGALL); 1049 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1050 break; 1051 } 1052 } 1053 } 1054 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 1055 if (sdp->isp_devparam[tgt].dev_refresh) { 1056 isp->isp_sendmarker |= (1 << channel); 1057 isp->isp_update |= (1 << channel); 1058 break; 1059 } 1060 } 1061 } 1062 1063 /* 1064 * Fibre Channel specific initialization. 1065 * 1066 * Locks are held before coming here. 1067 */ 1068 static void 1069 isp_fibre_init(struct ispsoftc *isp) 1070 { 1071 fcparam *fcp; 1072 isp_icb_t *icbp; 1073 mbreg_t mbs; 1074 int loopid; 1075 u_int64_t nwwn, pwwn; 1076 1077 fcp = isp->isp_param; 1078 1079 /* 1080 * Do this *before* initializing the firmware. 1081 */ 1082 isp_mark_getpdb_all(isp); 1083 fcp->isp_fwstate = FW_CONFIG_WAIT; 1084 fcp->isp_loopstate = LOOP_NIL; 1085 1086 /* 1087 * If we have no role (neither target nor initiator), return. 1088 */ 1089 if (isp->isp_role == ISP_ROLE_NONE) { 1090 return; 1091 } 1092 1093 loopid = DEFAULT_LOOPID(isp); 1094 icbp = (isp_icb_t *) fcp->isp_scratch; 1095 MEMZERO(icbp, sizeof (*icbp)); 1096 1097 icbp->icb_version = ICB_VERSION1; 1098 1099 /* 1100 * Firmware Options are either retrieved from NVRAM or 1101 * are patched elsewhere. We check them for sanity here 1102 * and make changes based on board revision, but otherwise 1103 * let others decide policy. 1104 */ 1105 1106 /* 1107 * If this is a 2100 < revision 5, we have to turn off FAIRNESS. 1108 */ 1109 if ((isp->isp_type == ISP_HA_FC_2100) && isp->isp_revision < 5) { 1110 fcp->isp_fwoptions &= ~ICBOPT_FAIRNESS; 1111 } 1112 1113 /* 1114 * We have to use FULL LOGIN even though it resets the loop too much 1115 * because otherwise port database entries don't get updated after 1116 * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0. 1117 */ 1118 if (ISP_FW_REVX(isp->isp_fwrev) < ISP_FW_REV(1, 17, 0)) { 1119 fcp->isp_fwoptions |= ICBOPT_FULL_LOGIN; 1120 } 1121 1122 /* 1123 * Insist on Port Database Update Async notifications 1124 */ 1125 fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE; 1126 1127 1128 /* 1129 * Make sure that target role reflects into fwoptions. 1130 */ 1131 if (isp->isp_role & ISP_ROLE_TARGET) { 1132 fcp->isp_fwoptions |= ICBOPT_TGT_ENABLE; 1133 } else { 1134 fcp->isp_fwoptions &= ~ICBOPT_TGT_ENABLE; 1135 } 1136 1137 /* 1138 * Propagate all of this into the ICB structure. 1139 */ 1140 icbp->icb_fwoptions = fcp->isp_fwoptions; 1141 icbp->icb_maxfrmlen = fcp->isp_maxfrmlen; 1142 if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN || 1143 icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) { 1144 isp_prt(isp, ISP_LOGERR, 1145 "bad frame length (%d) from NVRAM- using %d", 1146 fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN); 1147 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN; 1148 } 1149 icbp->icb_maxalloc = fcp->isp_maxalloc; 1150 if (icbp->icb_maxalloc < 1) { 1151 isp_prt(isp, ISP_LOGERR, 1152 "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc); 1153 icbp->icb_maxalloc = 16; 1154 } 1155 icbp->icb_execthrottle = fcp->isp_execthrottle; 1156 if (icbp->icb_execthrottle < 1) { 1157 isp_prt(isp, ISP_LOGERR, 1158 "bad execution throttle of %d- using 16", 1159 fcp->isp_execthrottle); 1160 icbp->icb_execthrottle = ICB_DFLT_THROTTLE; 1161 } 1162 icbp->icb_retry_delay = fcp->isp_retry_delay; 1163 icbp->icb_retry_count = fcp->isp_retry_count; 1164 icbp->icb_hardaddr = loopid; 1165 /* 1166 * Right now we just set extended options to prefer point-to-point 1167 * over loop based upon some soft config options. 1168 */ 1169 if (IS_2200(isp) || IS_2300(isp)) { 1170 icbp->icb_fwoptions |= ICBOPT_EXTENDED; 1171 /* 1172 * Prefer or force Point-To-Point instead Loop? 1173 */ 1174 switch(isp->isp_confopts & ISP_CFG_PORT_PREF) { 1175 case ISP_CFG_NPORT: 1176 icbp->icb_xfwoptions = ICBXOPT_PTP_2_LOOP; 1177 break; 1178 case ISP_CFG_NPORT_ONLY: 1179 icbp->icb_xfwoptions = ICBXOPT_PTP_ONLY; 1180 break; 1181 case ISP_CFG_LPORT_ONLY: 1182 icbp->icb_xfwoptions = ICBXOPT_LOOP_ONLY; 1183 break; 1184 default: 1185 icbp->icb_xfwoptions = ICBXOPT_LOOP_2_PTP; 1186 break; 1187 } 1188 } 1189 icbp->icb_logintime = 60; /* 60 second login timeout */ 1190 1191 nwwn = ISP_NODEWWN(isp); 1192 pwwn = ISP_PORTWWN(isp); 1193 if (nwwn && pwwn) { 1194 icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS; 1195 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, nwwn); 1196 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn); 1197 isp_prt(isp, ISP_LOGDEBUG1, 1198 "Setting ICB Node 0x%08x%08x Port 0x%08x%08x", 1199 ((u_int32_t) (nwwn >> 32)), 1200 ((u_int32_t) (nwwn & 0xffffffff)), 1201 ((u_int32_t) (pwwn >> 32)), 1202 ((u_int32_t) (pwwn & 0xffffffff))); 1203 } else { 1204 isp_prt(isp, ISP_LOGDEBUG1, "Not using any WWNs"); 1205 icbp->icb_fwoptions &= ~(ICBOPT_BOTH_WWNS|ICBOPT_FULL_LOGIN); 1206 } 1207 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp); 1208 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp); 1209 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_LSW(isp->isp_rquest_dma); 1210 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_MSW(isp->isp_rquest_dma); 1211 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_LSW(isp->isp_result_dma); 1212 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_MSW(isp->isp_result_dma); 1213 isp_prt(isp, ISP_LOGDEBUG1, 1214 "isp_fibre_init: fwoptions 0x%x", fcp->isp_fwoptions); 1215 ISP_SWIZZLE_ICB(isp, icbp); 1216 1217 1218 /* 1219 * Init the firmware 1220 */ 1221 mbs.param[0] = MBOX_INIT_FIRMWARE; 1222 mbs.param[1] = 0; 1223 mbs.param[2] = DMA_MSW(fcp->isp_scdma); 1224 mbs.param[3] = DMA_LSW(fcp->isp_scdma); 1225 mbs.param[4] = 0; 1226 mbs.param[5] = 0; 1227 mbs.param[6] = 0; 1228 mbs.param[7] = 0; 1229 isp_mboxcmd(isp, &mbs, MBLOGALL); 1230 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1231 return; 1232 } 1233 isp->isp_reqidx = isp->isp_reqodx = 0; 1234 isp->isp_residx = 0; 1235 isp->isp_sendmarker = 1; 1236 1237 /* 1238 * Whatever happens, we're now committed to being here. 1239 */ 1240 isp->isp_state = ISP_INITSTATE; 1241 } 1242 1243 /* 1244 * Fibre Channel Support- get the port database for the id. 1245 * 1246 * Locks are held before coming here. Return 0 if success, 1247 * else failure. 1248 */ 1249 1250 static int 1251 isp_getmap(struct ispsoftc *isp, fcpos_map_t *map) 1252 { 1253 fcparam *fcp = (fcparam *) isp->isp_param; 1254 mbreg_t mbs; 1255 1256 mbs.param[0] = MBOX_GET_FC_AL_POSITION_MAP; 1257 mbs.param[1] = 0; 1258 mbs.param[2] = DMA_MSW(fcp->isp_scdma); 1259 mbs.param[3] = DMA_LSW(fcp->isp_scdma); 1260 /* 1261 * Unneeded. For the 2100, except for initializing f/w, registers 1262 * 4/5 have to not be written to. 1263 * mbs.param[4] = 0; 1264 * mbs.param[5] = 0; 1265 * 1266 */ 1267 mbs.param[6] = 0; 1268 mbs.param[7] = 0; 1269 isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR); 1270 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 1271 MEMCPY(map, fcp->isp_scratch, sizeof (fcpos_map_t)); 1272 map->fwmap = mbs.param[1] != 0; 1273 return (0); 1274 } 1275 return (-1); 1276 } 1277 1278 static void 1279 isp_mark_getpdb_all(struct ispsoftc *isp) 1280 { 1281 fcparam *fcp = (fcparam *) isp->isp_param; 1282 int i; 1283 for (i = 0; i < MAX_FC_TARG; i++) { 1284 fcp->portdb[i].valid = fcp->portdb[i].fabric_dev = 0; 1285 } 1286 } 1287 1288 static int 1289 isp_getpdb(struct ispsoftc *isp, int id, isp_pdb_t *pdbp) 1290 { 1291 fcparam *fcp = (fcparam *) isp->isp_param; 1292 mbreg_t mbs; 1293 1294 mbs.param[0] = MBOX_GET_PORT_DB; 1295 mbs.param[1] = id << 8; 1296 mbs.param[2] = DMA_MSW(fcp->isp_scdma); 1297 mbs.param[3] = DMA_LSW(fcp->isp_scdma); 1298 /* 1299 * Unneeded. For the 2100, except for initializing f/w, registers 1300 * 4/5 have to not be written to. 1301 * mbs.param[4] = 0; 1302 * mbs.param[5] = 0; 1303 * 1304 */ 1305 mbs.param[6] = 0; 1306 mbs.param[7] = 0; 1307 isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR); 1308 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 1309 ISP_UNSWIZZLE_AND_COPY_PDBP(isp, pdbp, fcp->isp_scratch); 1310 return (0); 1311 } 1312 return (-1); 1313 } 1314 1315 static u_int64_t 1316 isp_get_portname(struct ispsoftc *isp, int loopid, int nodename) 1317 { 1318 u_int64_t wwn = 0; 1319 mbreg_t mbs; 1320 1321 mbs.param[0] = MBOX_GET_PORT_NAME; 1322 mbs.param[1] = loopid << 8; 1323 if (nodename) 1324 mbs.param[1] |= 1; 1325 isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR); 1326 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 1327 wwn = 1328 (((u_int64_t)(mbs.param[2] & 0xff)) << 56) | 1329 (((u_int64_t)(mbs.param[2] >> 8)) << 48) | 1330 (((u_int64_t)(mbs.param[3] & 0xff)) << 40) | 1331 (((u_int64_t)(mbs.param[3] >> 8)) << 32) | 1332 (((u_int64_t)(mbs.param[6] & 0xff)) << 24) | 1333 (((u_int64_t)(mbs.param[6] >> 8)) << 16) | 1334 (((u_int64_t)(mbs.param[7] & 0xff)) << 8) | 1335 (((u_int64_t)(mbs.param[7] >> 8))); 1336 } 1337 return (wwn); 1338 } 1339 1340 /* 1341 * Make sure we have good FC link and know our Loop ID. 1342 */ 1343 1344 static int 1345 isp_fclink_test(struct ispsoftc *isp, int usdelay) 1346 { 1347 static char *toponames[] = { 1348 "Private Loop", 1349 "FL Port", 1350 "N-Port to N-Port", 1351 "F Port", 1352 "F Port (no FLOGI_ACC response)" 1353 }; 1354 mbreg_t mbs; 1355 int count, check_for_fabric; 1356 u_int8_t lwfs; 1357 fcparam *fcp; 1358 struct lportdb *lp; 1359 isp_pdb_t pdb; 1360 1361 fcp = isp->isp_param; 1362 1363 /* 1364 * XXX: Here is where we would start a 'loop dead' timeout 1365 */ 1366 1367 /* 1368 * Wait up to N microseconds for F/W to go to a ready state. 1369 */ 1370 lwfs = FW_CONFIG_WAIT; 1371 count = 0; 1372 while (count < usdelay) { 1373 u_int64_t enano; 1374 u_int32_t wrk; 1375 NANOTIME_T hra, hrb; 1376 1377 GET_NANOTIME(&hra); 1378 isp_fw_state(isp); 1379 if (lwfs != fcp->isp_fwstate) { 1380 isp_prt(isp, ISP_LOGINFO, "Firmware State <%s->%s>", 1381 isp2100_fw_statename((int)lwfs), 1382 isp2100_fw_statename((int)fcp->isp_fwstate)); 1383 lwfs = fcp->isp_fwstate; 1384 } 1385 if (fcp->isp_fwstate == FW_READY) { 1386 break; 1387 } 1388 GET_NANOTIME(&hrb); 1389 1390 /* 1391 * Get the elapsed time in nanoseconds. 1392 * Always guaranteed to be non-zero. 1393 */ 1394 enano = NANOTIME_SUB(&hrb, &hra); 1395 1396 isp_prt(isp, ISP_LOGDEBUG1, 1397 "usec%d: 0x%lx->0x%lx enano 0x%x%08x", 1398 count, (long) GET_NANOSEC(&hra), (long) GET_NANOSEC(&hrb), 1399 (u_int32_t)(enano >> 32), (u_int32_t)(enano & 0xffffffff)); 1400 1401 /* 1402 * If the elapsed time is less than 1 millisecond, 1403 * delay a period of time up to that millisecond of 1404 * waiting. 1405 * 1406 * This peculiar code is an attempt to try and avoid 1407 * invoking u_int64_t math support functions for some 1408 * platforms where linkage is a problem. 1409 */ 1410 if (enano < (1000 * 1000)) { 1411 count += 1000; 1412 enano = (1000 * 1000) - enano; 1413 while (enano > (u_int64_t) 4000000000U) { 1414 USEC_SLEEP(isp, 4000000); 1415 enano -= (u_int64_t) 4000000000U; 1416 } 1417 wrk = enano; 1418 wrk /= 1000; 1419 USEC_SLEEP(isp, wrk); 1420 } else { 1421 while (enano > (u_int64_t) 4000000000U) { 1422 count += 4000000; 1423 enano -= (u_int64_t) 4000000000U; 1424 } 1425 wrk = enano; 1426 count += (wrk / 1000); 1427 } 1428 } 1429 1430 /* 1431 * If we haven't gone to 'ready' state, return. 1432 */ 1433 if (fcp->isp_fwstate != FW_READY) { 1434 return (-1); 1435 } 1436 1437 /* 1438 * Get our Loop ID (if possible). We really need to have it. 1439 */ 1440 mbs.param[0] = MBOX_GET_LOOP_ID; 1441 isp_mboxcmd(isp, &mbs, MBLOGALL); 1442 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1443 return (-1); 1444 } 1445 fcp->isp_loopid = mbs.param[1]; 1446 if (IS_2200(isp) || IS_2300(isp)) { 1447 int topo = (int) mbs.param[6]; 1448 if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB) 1449 topo = TOPO_PTP_STUB; 1450 fcp->isp_topo = topo; 1451 } else { 1452 fcp->isp_topo = TOPO_NL_PORT; 1453 } 1454 fcp->isp_portid = fcp->isp_alpa = mbs.param[2] & 0xff; 1455 1456 /* 1457 * Check to see if we're on a fabric by trying to see if we 1458 * can talk to the fabric name server. This can be a bit 1459 * tricky because if we're a 2100, we should check always 1460 * (in case we're connected to an server doing aliasing). 1461 */ 1462 fcp->isp_onfabric = 0; 1463 1464 if (IS_2100(isp)) 1465 check_for_fabric = 1; 1466 else if (fcp->isp_topo == TOPO_FL_PORT || fcp->isp_topo == TOPO_F_PORT) 1467 check_for_fabric = 1; 1468 else 1469 check_for_fabric = 0; 1470 1471 if (check_for_fabric && isp_getpdb(isp, FL_PORT_ID, &pdb) == 0) { 1472 int loopid = FL_PORT_ID; 1473 if (IS_2100(isp)) { 1474 fcp->isp_topo = TOPO_FL_PORT; 1475 } 1476 1477 if (BITS2WORD(pdb.pdb_portid_bits) == 0) { 1478 /* 1479 * Crock. 1480 */ 1481 fcp->isp_topo = TOPO_NL_PORT; 1482 goto not_on_fabric; 1483 } 1484 fcp->isp_portid = mbs.param[2] | ((int) mbs.param[3] << 16); 1485 1486 /* 1487 * Save the Fabric controller's port database entry. 1488 */ 1489 lp = &fcp->portdb[loopid]; 1490 lp->node_wwn = 1491 (((u_int64_t)pdb.pdb_nodename[0]) << 56) | 1492 (((u_int64_t)pdb.pdb_nodename[1]) << 48) | 1493 (((u_int64_t)pdb.pdb_nodename[2]) << 40) | 1494 (((u_int64_t)pdb.pdb_nodename[3]) << 32) | 1495 (((u_int64_t)pdb.pdb_nodename[4]) << 24) | 1496 (((u_int64_t)pdb.pdb_nodename[5]) << 16) | 1497 (((u_int64_t)pdb.pdb_nodename[6]) << 8) | 1498 (((u_int64_t)pdb.pdb_nodename[7])); 1499 lp->port_wwn = 1500 (((u_int64_t)pdb.pdb_portname[0]) << 56) | 1501 (((u_int64_t)pdb.pdb_portname[1]) << 48) | 1502 (((u_int64_t)pdb.pdb_portname[2]) << 40) | 1503 (((u_int64_t)pdb.pdb_portname[3]) << 32) | 1504 (((u_int64_t)pdb.pdb_portname[4]) << 24) | 1505 (((u_int64_t)pdb.pdb_portname[5]) << 16) | 1506 (((u_int64_t)pdb.pdb_portname[6]) << 8) | 1507 (((u_int64_t)pdb.pdb_portname[7])); 1508 lp->roles = 1509 (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT; 1510 lp->portid = BITS2WORD(pdb.pdb_portid_bits); 1511 lp->loopid = pdb.pdb_loopid; 1512 lp->loggedin = lp->valid = 1; 1513 fcp->isp_onfabric = 1; 1514 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid); 1515 isp_register_fc4_type(isp); 1516 } else { 1517 not_on_fabric: 1518 fcp->isp_onfabric = 0; 1519 fcp->portdb[FL_PORT_ID].valid = 0; 1520 } 1521 1522 isp_prt(isp, ISP_LOGINFO, topology, fcp->isp_loopid, fcp->isp_alpa, 1523 fcp->isp_portid, fcp->isp_loopstate, toponames[fcp->isp_topo]); 1524 1525 /* 1526 * Announce ourselves, too. This involves synthesizing an entry. 1527 */ 1528 if (fcp->isp_iid_set == 0) { 1529 fcp->isp_iid_set = 1; 1530 fcp->isp_iid = fcp->isp_loopid; 1531 lp = &fcp->portdb[fcp->isp_iid]; 1532 } else { 1533 lp = &fcp->portdb[fcp->isp_iid]; 1534 if (fcp->isp_portid != lp->portid || 1535 fcp->isp_loopid != lp->loopid || 1536 fcp->isp_nodewwn != ISP_NODEWWN(isp) || 1537 fcp->isp_portwwn != ISP_PORTWWN(isp)) { 1538 lp->valid = 0; 1539 count = fcp->isp_iid; 1540 (void) isp_async(isp, ISPASYNC_PROMENADE, &count); 1541 } 1542 } 1543 lp->loopid = fcp->isp_loopid; 1544 lp->portid = fcp->isp_portid; 1545 lp->node_wwn = ISP_NODEWWN(isp); 1546 lp->port_wwn = ISP_PORTWWN(isp); 1547 switch (isp->isp_role) { 1548 case ISP_ROLE_NONE: 1549 lp->roles = 0; 1550 break; 1551 case ISP_ROLE_TARGET: 1552 lp->roles = SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT; 1553 break; 1554 case ISP_ROLE_INITIATOR: 1555 lp->roles = SVC3_INI_ROLE >> SVC3_ROLE_SHIFT; 1556 break; 1557 case ISP_ROLE_BOTH: 1558 lp->roles = (SVC3_INI_ROLE|SVC3_TGT_ROLE) >> SVC3_ROLE_SHIFT; 1559 break; 1560 } 1561 lp->loggedin = lp->valid = 1; 1562 count = fcp->isp_iid; 1563 (void) isp_async(isp, ISPASYNC_PROMENADE, &count); 1564 return (0); 1565 } 1566 1567 static char * 1568 isp2100_fw_statename(int state) 1569 { 1570 switch(state) { 1571 case FW_CONFIG_WAIT: return "Config Wait"; 1572 case FW_WAIT_AL_PA: return "Waiting for AL_PA"; 1573 case FW_WAIT_LOGIN: return "Wait Login"; 1574 case FW_READY: return "Ready"; 1575 case FW_LOSS_OF_SYNC: return "Loss Of Sync"; 1576 case FW_ERROR: return "Error"; 1577 case FW_REINIT: return "Re-Init"; 1578 case FW_NON_PART: return "Nonparticipating"; 1579 default: return "?????"; 1580 } 1581 } 1582 1583 /* 1584 * Synchronize our soft copy of the port database with what the f/w thinks 1585 * (with a view toward possibly for a specific target....) 1586 */ 1587 1588 static int 1589 isp_pdb_sync(struct ispsoftc *isp) 1590 { 1591 struct lportdb *lp; 1592 fcparam *fcp = isp->isp_param; 1593 isp_pdb_t pdb; 1594 int loopid, base, lim; 1595 1596 /* 1597 * Make sure we're okay for doing this right now. 1598 */ 1599 if (fcp->isp_loopstate != LOOP_PDB_RCVD && 1600 fcp->isp_loopstate != LOOP_FSCAN_DONE && 1601 fcp->isp_loopstate != LOOP_LSCAN_DONE) { 1602 return (-1); 1603 } 1604 1605 if (fcp->isp_topo == TOPO_FL_PORT || fcp->isp_topo == TOPO_NL_PORT || 1606 fcp->isp_topo == TOPO_N_PORT) { 1607 if (fcp->isp_loopstate < LOOP_LSCAN_DONE) { 1608 if (isp_scan_loop(isp) != 0) { 1609 return (-1); 1610 } 1611 } 1612 } 1613 fcp->isp_loopstate = LOOP_SYNCING_PDB; 1614 1615 /* 1616 * If we get this far, we've settled our differences with the f/w 1617 * (for local loop device) and we can say that the loop state is ready. 1618 */ 1619 1620 if (fcp->isp_topo == TOPO_NL_PORT) { 1621 fcp->loop_seen_once = 1; 1622 fcp->isp_loopstate = LOOP_READY; 1623 return (0); 1624 } 1625 1626 /* 1627 * Find all Fabric Entities that didn't make it from one scan to the 1628 * next and let the world know they went away. Scan the whole database. 1629 */ 1630 for (lp = &fcp->portdb[0]; lp < &fcp->portdb[MAX_FC_TARG]; lp++) { 1631 if (lp->was_fabric_dev && lp->fabric_dev == 0) { 1632 loopid = lp - fcp->portdb; 1633 lp->valid = 0; /* should already be set */ 1634 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid); 1635 MEMZERO((void *) lp, sizeof (*lp)); 1636 continue; 1637 } 1638 lp->was_fabric_dev = lp->fabric_dev; 1639 } 1640 1641 if (fcp->isp_topo == TOPO_FL_PORT) 1642 base = FC_SNS_ID+1; 1643 else 1644 base = 0; 1645 1646 if (fcp->isp_topo == TOPO_N_PORT) 1647 lim = 1; 1648 else 1649 lim = MAX_FC_TARG; 1650 1651 /* 1652 * Now log in any fabric devices that the outer layer has 1653 * left for us to see. This seems the most sane policy 1654 * for the moment. 1655 */ 1656 for (lp = &fcp->portdb[base]; lp < &fcp->portdb[lim]; lp++) { 1657 u_int32_t portid; 1658 mbreg_t mbs; 1659 1660 loopid = lp - fcp->portdb; 1661 if (loopid >= FL_PORT_ID && loopid <= FC_SNS_ID) { 1662 continue; 1663 } 1664 1665 /* 1666 * Anything here? 1667 */ 1668 if (lp->port_wwn == 0) { 1669 continue; 1670 } 1671 1672 /* 1673 * Don't try to log into yourself. 1674 */ 1675 if ((portid = lp->portid) == fcp->isp_portid) { 1676 continue; 1677 } 1678 1679 1680 /* 1681 * If we'd been logged in- see if we still are and we haven't 1682 * changed. If so, no need to log ourselves out, etc.. 1683 * 1684 * Unfortunately, our charming Qlogic f/w has decided to 1685 * return a valid port database entry for a fabric device 1686 * that has, in fact, gone away. And it hangs trying to 1687 * log it out. 1688 */ 1689 if (lp->loggedin && 1690 isp_getpdb(isp, lp->loopid, &pdb) == 0) { 1691 int nrole; 1692 u_int64_t nwwnn, nwwpn; 1693 nwwnn = 1694 (((u_int64_t)pdb.pdb_nodename[0]) << 56) | 1695 (((u_int64_t)pdb.pdb_nodename[1]) << 48) | 1696 (((u_int64_t)pdb.pdb_nodename[2]) << 40) | 1697 (((u_int64_t)pdb.pdb_nodename[3]) << 32) | 1698 (((u_int64_t)pdb.pdb_nodename[4]) << 24) | 1699 (((u_int64_t)pdb.pdb_nodename[5]) << 16) | 1700 (((u_int64_t)pdb.pdb_nodename[6]) << 8) | 1701 (((u_int64_t)pdb.pdb_nodename[7])); 1702 nwwpn = 1703 (((u_int64_t)pdb.pdb_portname[0]) << 56) | 1704 (((u_int64_t)pdb.pdb_portname[1]) << 48) | 1705 (((u_int64_t)pdb.pdb_portname[2]) << 40) | 1706 (((u_int64_t)pdb.pdb_portname[3]) << 32) | 1707 (((u_int64_t)pdb.pdb_portname[4]) << 24) | 1708 (((u_int64_t)pdb.pdb_portname[5]) << 16) | 1709 (((u_int64_t)pdb.pdb_portname[6]) << 8) | 1710 (((u_int64_t)pdb.pdb_portname[7])); 1711 nrole = (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> 1712 SVC3_ROLE_SHIFT; 1713 if (pdb.pdb_loopid == lp->loopid && lp->portid == 1714 (u_int32_t) BITS2WORD(pdb.pdb_portid_bits) && 1715 nwwnn == lp->node_wwn && nwwpn == lp->port_wwn && 1716 lp->roles == nrole) { 1717 lp->loggedin = lp->valid = 1; 1718 isp_prt(isp, ISP_LOGINFO, lretained, 1719 (int) (lp - fcp->portdb), 1720 (int) lp->loopid, lp->portid); 1721 continue; 1722 } 1723 } 1724 1725 if (fcp->isp_fwstate != FW_READY || 1726 fcp->isp_loopstate != LOOP_SYNCING_PDB) { 1727 return (-1); 1728 } 1729 1730 /* 1731 * Force a logout if we were logged in. 1732 */ 1733 if (lp->loggedin) { 1734 if (isp_getpdb(isp, lp->loopid, &pdb) == 0) { 1735 mbs.param[0] = MBOX_FABRIC_LOGOUT; 1736 mbs.param[1] = lp->loopid << 8; 1737 mbs.param[2] = 0; 1738 mbs.param[3] = 0; 1739 isp_mboxcmd(isp, &mbs, MBLOGNONE); 1740 lp->loggedin = 0; 1741 isp_prt(isp, ISP_LOGINFO, plogout, 1742 (int) (lp - fcp->portdb), lp->loopid, 1743 lp->portid); 1744 } 1745 lp->loggedin = 0; 1746 if (fcp->isp_fwstate != FW_READY || 1747 fcp->isp_loopstate != LOOP_SYNCING_PDB) { 1748 return (-1); 1749 } 1750 } 1751 1752 /* 1753 * And log in.... 1754 */ 1755 loopid = lp - fcp->portdb; 1756 lp->loopid = FL_PORT_ID; 1757 do { 1758 mbs.param[0] = MBOX_FABRIC_LOGIN; 1759 mbs.param[1] = loopid << 8; 1760 mbs.param[2] = portid >> 16; 1761 mbs.param[3] = portid & 0xffff; 1762 if (IS_2200(isp) || IS_2300(isp)) { 1763 /* only issue a PLOGI if not logged in */ 1764 mbs.param[1] |= 0x1; 1765 } 1766 isp_mboxcmd(isp, &mbs, MBLOGALL & ~(MBOX_LOOP_ID_USED | 1767 MBOX_PORT_ID_USED | MBOX_COMMAND_ERROR)); 1768 if (fcp->isp_fwstate != FW_READY || 1769 fcp->isp_loopstate != LOOP_SYNCING_PDB) { 1770 return (-1); 1771 } 1772 switch (mbs.param[0]) { 1773 case MBOX_LOOP_ID_USED: 1774 /* 1775 * Try the next available loop id. 1776 */ 1777 loopid++; 1778 break; 1779 case MBOX_PORT_ID_USED: 1780 /* 1781 * This port is already logged in. 1782 * Snaffle the loop id it's using if it's 1783 * nonzero, otherwise we're hosed. 1784 */ 1785 if (mbs.param[1] != 0) { 1786 loopid = mbs.param[1]; 1787 isp_prt(isp, ISP_LOGINFO, retained, 1788 loopid, (int) (lp - fcp->portdb), 1789 lp->portid); 1790 } else { 1791 loopid = MAX_FC_TARG; 1792 break; 1793 } 1794 /* FALLTHROUGH */ 1795 case MBOX_COMMAND_COMPLETE: 1796 lp->loggedin = 1; 1797 lp->loopid = loopid; 1798 break; 1799 case MBOX_COMMAND_ERROR: 1800 isp_prt(isp, ISP_LOGINFO, plogierr, 1801 portid, mbs.param[1]); 1802 /* FALLTHROUGH */ 1803 case MBOX_ALL_IDS_USED: /* We're outta IDs */ 1804 default: 1805 loopid = MAX_FC_TARG; 1806 break; 1807 } 1808 } while (lp->loopid == FL_PORT_ID && loopid < MAX_FC_TARG); 1809 1810 /* 1811 * If we get here and we haven't set a Loop ID, 1812 * we failed to log into this device. 1813 */ 1814 1815 if (lp->loopid == FL_PORT_ID) { 1816 lp->loopid = 0; 1817 continue; 1818 } 1819 1820 /* 1821 * Make sure we can get the approriate port information. 1822 */ 1823 if (isp_getpdb(isp, lp->loopid, &pdb) != 0) { 1824 isp_prt(isp, ISP_LOGWARN, nopdb, lp->portid); 1825 goto dump_em; 1826 } 1827 1828 if (fcp->isp_fwstate != FW_READY || 1829 fcp->isp_loopstate != LOOP_SYNCING_PDB) { 1830 return (-1); 1831 } 1832 1833 if (pdb.pdb_loopid != lp->loopid) { 1834 isp_prt(isp, ISP_LOGWARN, pdbmfail1, 1835 lp->portid, pdb.pdb_loopid); 1836 goto dump_em; 1837 } 1838 1839 if (lp->portid != (u_int32_t) BITS2WORD(pdb.pdb_portid_bits)) { 1840 isp_prt(isp, ISP_LOGWARN, pdbmfail2, 1841 lp->portid, BITS2WORD(pdb.pdb_portid_bits)); 1842 goto dump_em; 1843 } 1844 1845 lp->roles = 1846 (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT; 1847 lp->node_wwn = 1848 (((u_int64_t)pdb.pdb_nodename[0]) << 56) | 1849 (((u_int64_t)pdb.pdb_nodename[1]) << 48) | 1850 (((u_int64_t)pdb.pdb_nodename[2]) << 40) | 1851 (((u_int64_t)pdb.pdb_nodename[3]) << 32) | 1852 (((u_int64_t)pdb.pdb_nodename[4]) << 24) | 1853 (((u_int64_t)pdb.pdb_nodename[5]) << 16) | 1854 (((u_int64_t)pdb.pdb_nodename[6]) << 8) | 1855 (((u_int64_t)pdb.pdb_nodename[7])); 1856 lp->port_wwn = 1857 (((u_int64_t)pdb.pdb_portname[0]) << 56) | 1858 (((u_int64_t)pdb.pdb_portname[1]) << 48) | 1859 (((u_int64_t)pdb.pdb_portname[2]) << 40) | 1860 (((u_int64_t)pdb.pdb_portname[3]) << 32) | 1861 (((u_int64_t)pdb.pdb_portname[4]) << 24) | 1862 (((u_int64_t)pdb.pdb_portname[5]) << 16) | 1863 (((u_int64_t)pdb.pdb_portname[6]) << 8) | 1864 (((u_int64_t)pdb.pdb_portname[7])); 1865 /* 1866 * Check to make sure this all makes sense. 1867 */ 1868 if (lp->node_wwn && lp->port_wwn) { 1869 lp->valid = 1; 1870 loopid = lp - fcp->portdb; 1871 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid); 1872 continue; 1873 } 1874 dump_em: 1875 lp->valid = 0; 1876 isp_prt(isp, ISP_LOGINFO, 1877 ldumped, loopid, lp->loopid, lp->portid); 1878 mbs.param[0] = MBOX_FABRIC_LOGOUT; 1879 mbs.param[1] = lp->loopid << 8; 1880 mbs.param[2] = 0; 1881 mbs.param[3] = 0; 1882 isp_mboxcmd(isp, &mbs, MBLOGNONE); 1883 if (fcp->isp_fwstate != FW_READY || 1884 fcp->isp_loopstate != LOOP_SYNCING_PDB) { 1885 return (-1); 1886 } 1887 } 1888 /* 1889 * If we get here, we've for sure seen not only a valid loop 1890 * but know what is or isn't on it, so mark this for usage 1891 * in isp_start. 1892 */ 1893 fcp->loop_seen_once = 1; 1894 fcp->isp_loopstate = LOOP_READY; 1895 return (0); 1896 } 1897 1898 static int 1899 isp_scan_loop(struct ispsoftc *isp) 1900 { 1901 struct lportdb *lp; 1902 fcparam *fcp = isp->isp_param; 1903 isp_pdb_t pdb; 1904 int loopid, lim, hival; 1905 1906 switch (fcp->isp_topo) { 1907 case TOPO_NL_PORT: 1908 hival = FL_PORT_ID; 1909 break; 1910 case TOPO_N_PORT: 1911 hival = 2; 1912 break; 1913 case TOPO_FL_PORT: 1914 hival = FC_PORT_ID; 1915 break; 1916 default: 1917 fcp->isp_loopstate = LOOP_LSCAN_DONE; 1918 return (0); 1919 } 1920 fcp->isp_loopstate = LOOP_SCANNING_LOOP; 1921 1922 /* 1923 * make sure the temp port database is clean... 1924 */ 1925 MEMZERO((void *)fcp->tport, sizeof (fcp->tport)); 1926 1927 /* 1928 * Run through the local loop ports and get port database info 1929 * for each loop ID. 1930 * 1931 * There's a somewhat unexplained situation where the f/w passes back 1932 * the wrong database entity- if that happens, just restart (up to 1933 * FL_PORT_ID times). 1934 */ 1935 for (lim = loopid = 0; loopid < hival; loopid++) { 1936 lp = &fcp->tport[loopid]; 1937 1938 /* 1939 * Don't even try for ourselves... 1940 */ 1941 if (loopid == fcp->isp_loopid) 1942 continue; 1943 1944 lp->node_wwn = isp_get_portname(isp, loopid, 1); 1945 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) 1946 return (-1); 1947 if (lp->node_wwn == 0) 1948 continue; 1949 lp->port_wwn = isp_get_portname(isp, loopid, 0); 1950 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) 1951 return (-1); 1952 if (lp->port_wwn == 0) { 1953 lp->node_wwn = 0; 1954 continue; 1955 } 1956 1957 /* 1958 * Get an entry.... 1959 */ 1960 if (isp_getpdb(isp, loopid, &pdb) != 0) { 1961 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) 1962 return (-1); 1963 continue; 1964 } 1965 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) { 1966 return (-1); 1967 } 1968 1969 /* 1970 * If the returned database element doesn't match what we 1971 * asked for, restart the process entirely (up to a point...). 1972 */ 1973 if (pdb.pdb_loopid != loopid) { 1974 loopid = 0; 1975 if (lim++ < hival) { 1976 continue; 1977 } 1978 isp_prt(isp, ISP_LOGWARN, 1979 "giving up on synchronizing the port database"); 1980 return (-1); 1981 } 1982 1983 /* 1984 * Save the pertinent info locally. 1985 */ 1986 lp->node_wwn = 1987 (((u_int64_t)pdb.pdb_nodename[0]) << 56) | 1988 (((u_int64_t)pdb.pdb_nodename[1]) << 48) | 1989 (((u_int64_t)pdb.pdb_nodename[2]) << 40) | 1990 (((u_int64_t)pdb.pdb_nodename[3]) << 32) | 1991 (((u_int64_t)pdb.pdb_nodename[4]) << 24) | 1992 (((u_int64_t)pdb.pdb_nodename[5]) << 16) | 1993 (((u_int64_t)pdb.pdb_nodename[6]) << 8) | 1994 (((u_int64_t)pdb.pdb_nodename[7])); 1995 lp->port_wwn = 1996 (((u_int64_t)pdb.pdb_portname[0]) << 56) | 1997 (((u_int64_t)pdb.pdb_portname[1]) << 48) | 1998 (((u_int64_t)pdb.pdb_portname[2]) << 40) | 1999 (((u_int64_t)pdb.pdb_portname[3]) << 32) | 2000 (((u_int64_t)pdb.pdb_portname[4]) << 24) | 2001 (((u_int64_t)pdb.pdb_portname[5]) << 16) | 2002 (((u_int64_t)pdb.pdb_portname[6]) << 8) | 2003 (((u_int64_t)pdb.pdb_portname[7])); 2004 lp->roles = 2005 (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT; 2006 lp->portid = BITS2WORD(pdb.pdb_portid_bits); 2007 lp->loopid = pdb.pdb_loopid; 2008 } 2009 2010 /* 2011 * Mark all of the permanent local loop database entries as invalid 2012 * (except our own entry). 2013 */ 2014 for (loopid = 0; loopid < hival; loopid++) { 2015 if (loopid == fcp->isp_iid) { 2016 fcp->portdb[loopid].valid = 1; 2017 fcp->portdb[loopid].loopid = fcp->isp_loopid; 2018 continue; 2019 } 2020 fcp->portdb[loopid].valid = 0; 2021 } 2022 2023 /* 2024 * Now merge our local copy of the port database into our saved copy. 2025 * Notify the outer layers of new devices arriving. 2026 */ 2027 for (loopid = 0; loopid < hival; loopid++) { 2028 int i; 2029 2030 /* 2031 * If we don't have a non-zero Port WWN, we're not here. 2032 */ 2033 if (fcp->tport[loopid].port_wwn == 0) { 2034 continue; 2035 } 2036 2037 /* 2038 * Skip ourselves. 2039 */ 2040 if (loopid == fcp->isp_iid) { 2041 continue; 2042 } 2043 2044 /* 2045 * For the purposes of deciding whether this is the 2046 * 'same' device or not, we only search for an identical 2047 * Port WWN. Node WWNs may or may not be the same as 2048 * the Port WWN, and there may be multiple different 2049 * Port WWNs with the same Node WWN. It would be chaos 2050 * to have multiple identical Port WWNs, so we don't 2051 * allow that. 2052 */ 2053 2054 for (i = 0; i < hival; i++) { 2055 int j; 2056 if (fcp->portdb[i].port_wwn == 0) 2057 continue; 2058 if (fcp->portdb[i].port_wwn != 2059 fcp->tport[loopid].port_wwn) 2060 continue; 2061 /* 2062 * We found this WWN elsewhere- it's changed 2063 * loopids then. We don't change it's actual 2064 * position in our cached port database- we 2065 * just change the actual loop ID we'd use. 2066 */ 2067 if (fcp->portdb[i].loopid != loopid) { 2068 isp_prt(isp, ISP_LOGINFO, portshift, i, 2069 fcp->portdb[i].loopid, 2070 fcp->portdb[i].portid, loopid, 2071 fcp->tport[loopid].portid); 2072 } 2073 fcp->portdb[i].portid = fcp->tport[loopid].portid; 2074 fcp->portdb[i].loopid = loopid; 2075 fcp->portdb[i].valid = 1; 2076 fcp->portdb[i].roles = fcp->tport[loopid].roles; 2077 2078 /* 2079 * Now make sure this Port WWN doesn't exist elsewhere 2080 * in the port database. 2081 */ 2082 for (j = i+1; j < hival; j++) { 2083 if (fcp->portdb[i].port_wwn != 2084 fcp->portdb[j].port_wwn) { 2085 continue; 2086 } 2087 isp_prt(isp, ISP_LOGWARN, portdup, j, i); 2088 /* 2089 * Invalidate the 'old' *and* 'new' ones. 2090 * This is really harsh and not quite right, 2091 * but if this happens, we really don't know 2092 * who is what at this point. 2093 */ 2094 fcp->portdb[i].valid = 0; 2095 fcp->portdb[j].valid = 0; 2096 } 2097 break; 2098 } 2099 2100 /* 2101 * If we didn't traverse the entire port database, 2102 * then we found (and remapped) an existing entry. 2103 * No need to notify anyone- go for the next one. 2104 */ 2105 if (i < hival) { 2106 continue; 2107 } 2108 2109 /* 2110 * We've not found this Port WWN anywhere. It's a new entry. 2111 * See if we can leave it where it is (with target == loopid). 2112 */ 2113 if (fcp->portdb[loopid].port_wwn != 0) { 2114 for (lim = 0; lim < hival; lim++) { 2115 if (fcp->portdb[lim].port_wwn == 0) 2116 break; 2117 } 2118 /* "Cannot Happen" */ 2119 if (lim == hival) { 2120 isp_prt(isp, ISP_LOGWARN, "Remap Overflow"); 2121 continue; 2122 } 2123 i = lim; 2124 } else { 2125 i = loopid; 2126 } 2127 2128 /* 2129 * NB: The actual loopid we use here is loopid- we may 2130 * in fact be at a completely different index (target). 2131 */ 2132 fcp->portdb[i].loopid = loopid; 2133 fcp->portdb[i].port_wwn = fcp->tport[loopid].port_wwn; 2134 fcp->portdb[i].node_wwn = fcp->tport[loopid].node_wwn; 2135 fcp->portdb[i].roles = fcp->tport[loopid].roles; 2136 fcp->portdb[i].portid = fcp->tport[loopid].portid; 2137 fcp->portdb[i].valid = 1; 2138 2139 /* 2140 * Tell the outside world we've arrived. 2141 */ 2142 (void) isp_async(isp, ISPASYNC_PROMENADE, &i); 2143 } 2144 2145 /* 2146 * Now find all previously used targets that are now invalid and 2147 * notify the outer layers that they're gone. 2148 */ 2149 for (lp = &fcp->portdb[0]; lp < &fcp->portdb[hival]; lp++) { 2150 if (lp->valid || lp->port_wwn == 0) { 2151 continue; 2152 } 2153 2154 /* 2155 * Tell the outside world we've gone 2156 * away and erase our pdb entry. 2157 * 2158 */ 2159 loopid = lp - fcp->portdb; 2160 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid); 2161 MEMZERO((void *) lp, sizeof (*lp)); 2162 } 2163 fcp->isp_loopstate = LOOP_LSCAN_DONE; 2164 return (0); 2165 } 2166 2167 static int 2168 isp_scan_fabric(struct ispsoftc *isp) 2169 { 2170 fcparam *fcp = isp->isp_param; 2171 u_int32_t portid, first_portid; 2172 sns_screq_t *reqp; 2173 sns_scrsp_t *resp; 2174 mbreg_t mbs; 2175 int hicap, first_portid_seen; 2176 2177 if (fcp->isp_onfabric == 0) { 2178 fcp->isp_loopstate = LOOP_FSCAN_DONE; 2179 return (0); 2180 } 2181 2182 reqp = (sns_screq_t *) fcp->isp_scratch; 2183 resp = (sns_scrsp_t *) (&((char *)fcp->isp_scratch)[0x100]); 2184 /* 2185 * Since Port IDs are 24 bits, we can check against having seen 2186 * anything yet with this value. 2187 */ 2188 first_portid = portid = fcp->isp_portid; 2189 fcp->isp_loopstate = LOOP_SCANNING_FABRIC; 2190 2191 for (first_portid_seen = hicap = 0; hicap < 65535; hicap++) { 2192 MEMZERO((void *) reqp, SNS_GAN_REQ_SIZE); 2193 reqp->snscb_rblen = SNS_GAN_RESP_SIZE >> 1; 2194 reqp->snscb_addr[RQRSP_ADDR0015] = 2195 DMA_LSW(fcp->isp_scdma + 0x100); 2196 reqp->snscb_addr[RQRSP_ADDR1631] = 2197 DMA_MSW(fcp->isp_scdma + 0x100); 2198 reqp->snscb_sblen = 6; 2199 reqp->snscb_data[0] = SNS_GAN; 2200 reqp->snscb_data[4] = portid & 0xffff; 2201 reqp->snscb_data[5] = (portid >> 16) & 0xff; 2202 ISP_SWIZZLE_SNS_REQ(isp, reqp); 2203 mbs.param[0] = MBOX_SEND_SNS; 2204 mbs.param[1] = SNS_GAN_REQ_SIZE >> 1; 2205 mbs.param[2] = DMA_MSW(fcp->isp_scdma); 2206 mbs.param[3] = DMA_LSW(fcp->isp_scdma); 2207 mbs.param[6] = 0; 2208 mbs.param[7] = 0; 2209 isp_mboxcmd(isp, &mbs, MBLOGALL); 2210 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 2211 if (fcp->isp_loopstate == LOOP_SCANNING_FABRIC) { 2212 fcp->isp_loopstate = LOOP_PDB_RCVD; 2213 } 2214 return (-1); 2215 } 2216 if (fcp->isp_fwstate != FW_READY || 2217 fcp->isp_loopstate < LOOP_SCANNING_FABRIC) { 2218 return (-1); 2219 } 2220 ISP_UNSWIZZLE_SNS_RSP(isp, resp, SNS_GAN_RESP_SIZE >> 1); 2221 portid = (((u_int32_t) resp->snscb_port_id[0]) << 16) | 2222 (((u_int32_t) resp->snscb_port_id[1]) << 8) | 2223 (((u_int32_t) resp->snscb_port_id[2])); 2224 (void) isp_async(isp, ISPASYNC_FABRIC_DEV, resp); 2225 if (first_portid == portid) { 2226 fcp->isp_loopstate = LOOP_FSCAN_DONE; 2227 return (0); 2228 } 2229 } 2230 2231 isp_prt(isp, ISP_LOGWARN, "broken fabric nameserver...*wheeze*..."); 2232 2233 /* 2234 * We either have a broken name server or a huge fabric if we get here. 2235 */ 2236 fcp->isp_loopstate = LOOP_FSCAN_DONE; 2237 return (0); 2238 } 2239 2240 static void 2241 isp_register_fc4_type(struct ispsoftc *isp) 2242 { 2243 fcparam *fcp = isp->isp_param; 2244 sns_screq_t *reqp; 2245 mbreg_t mbs; 2246 2247 reqp = (sns_screq_t *) fcp->isp_scratch; 2248 MEMZERO((void *) reqp, SNS_RFT_REQ_SIZE); 2249 reqp->snscb_rblen = SNS_RFT_RESP_SIZE >> 1; 2250 reqp->snscb_addr[RQRSP_ADDR0015] = DMA_LSW(fcp->isp_scdma + 0x100); 2251 reqp->snscb_addr[RQRSP_ADDR1631] = DMA_MSW(fcp->isp_scdma + 0x100); 2252 reqp->snscb_sblen = 22; 2253 reqp->snscb_data[0] = SNS_RFT; 2254 reqp->snscb_data[4] = fcp->isp_portid & 0xffff; 2255 reqp->snscb_data[5] = (fcp->isp_portid >> 16) & 0xff; 2256 reqp->snscb_data[6] = 0x100; /* SCS - FCP */ 2257 #if 0 2258 reqp->snscb_data[6] |= 20; /* ISO/IEC 8802-2 LLC/SNAP */ 2259 #endif 2260 ISP_SWIZZLE_SNS_REQ(isp, reqp); 2261 mbs.param[0] = MBOX_SEND_SNS; 2262 mbs.param[1] = SNS_RFT_REQ_SIZE >> 1; 2263 mbs.param[2] = DMA_MSW(fcp->isp_scdma); 2264 mbs.param[3] = DMA_LSW(fcp->isp_scdma); 2265 mbs.param[6] = 0; 2266 mbs.param[7] = 0; 2267 isp_mboxcmd(isp, &mbs, MBLOGALL); 2268 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 2269 isp_prt(isp, ISP_LOGDEBUG0, "Register FC4 types succeeded"); 2270 } 2271 } 2272 2273 /* 2274 * Start a command. Locking is assumed done in the caller. 2275 */ 2276 2277 int 2278 isp_start(XS_T *xs) 2279 { 2280 struct ispsoftc *isp; 2281 u_int16_t iptr, optr, handle; 2282 union { 2283 ispreq_t *_reqp; 2284 ispreqt2_t *_t2reqp; 2285 } _u; 2286 #define reqp _u._reqp 2287 #define t2reqp _u._t2reqp 2288 #define UZSIZE max(sizeof (ispreq_t), sizeof (ispreqt2_t)) 2289 int target, i; 2290 2291 XS_INITERR(xs); 2292 isp = XS_ISP(xs); 2293 2294 /* 2295 * Check to make sure we're supporting initiator role. 2296 */ 2297 if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) { 2298 XS_SETERR(xs, HBA_SELTIMEOUT); 2299 return (CMD_COMPLETE); 2300 } 2301 2302 /* 2303 * Now make sure we're running. 2304 */ 2305 2306 if (isp->isp_state != ISP_RUNSTATE) { 2307 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE"); 2308 XS_SETERR(xs, HBA_BOTCH); 2309 return (CMD_COMPLETE); 2310 } 2311 2312 /* 2313 * Check command CDB length, etc.. We really are limited to 16 bytes 2314 * for Fibre Channel, but can do up to 44 bytes in parallel SCSI, 2315 * but probably only if we're running fairly new firmware (we'll 2316 * let the old f/w choke on an extended command queue entry). 2317 */ 2318 2319 if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) { 2320 isp_prt(isp, ISP_LOGERR, 2321 "unsupported cdb length (%d, CDB[0]=0x%x)", 2322 XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff); 2323 XS_SETERR(xs, HBA_BOTCH); 2324 return (CMD_COMPLETE); 2325 } 2326 2327 /* 2328 * Check to see whether we have good firmware state still or 2329 * need to refresh our port database for this target. 2330 */ 2331 target = XS_TGT(xs); 2332 if (IS_FC(isp)) { 2333 fcparam *fcp = isp->isp_param; 2334 struct lportdb *lp; 2335 #ifdef HANDLE_LOOPSTATE_IN_OUTER_LAYERS 2336 if (fcp->isp_fwstate != FW_READY || 2337 fcp->isp_loopstate != LOOP_READY) { 2338 return (CMD_RQLATER); 2339 } 2340 2341 /* 2342 * If we're not on a Fabric, we can't have a target 2343 * above FL_PORT_ID-1. 2344 * 2345 * If we're on a fabric and *not* connected as an F-port, 2346 * we can't have a target less than FC_SNS_ID+1. This 2347 * keeps us from having to sort out the difference between 2348 * local public loop devices and those which we might get 2349 * from a switch's database. 2350 */ 2351 if (fcp->isp_onfabric == 0) { 2352 if (target >= FL_PORT_ID) { 2353 XS_SETERR(xs, HBA_SELTIMEOUT); 2354 return (CMD_COMPLETE); 2355 } 2356 } else { 2357 if (target >= FL_PORT_ID && target <= FC_SNS_ID) { 2358 XS_SETERR(xs, HBA_SELTIMEOUT); 2359 return (CMD_COMPLETE); 2360 } 2361 if (fcp->isp_topo != TOPO_F_PORT && 2362 target < FL_PORT_ID) { 2363 XS_SETERR(xs, HBA_SELTIMEOUT); 2364 return (CMD_COMPLETE); 2365 } 2366 } 2367 #else 2368 /* 2369 * Check for f/w being in ready state. If the f/w 2370 * isn't in ready state, then we don't know our 2371 * loop ID and the f/w hasn't completed logging 2372 * into all targets on the loop. If this is the 2373 * case, then bounce the command. We pretend this is 2374 * a SELECTION TIMEOUT error if we've never gone to 2375 * FW_READY state at all- in this case we may not 2376 * be hooked to a loop at all and we shouldn't hang 2377 * the machine for this. Otherwise, defer this command 2378 * until later. 2379 */ 2380 if (fcp->isp_fwstate != FW_READY) { 2381 /* 2382 * Give ourselves at most a 250ms delay. 2383 */ 2384 if (isp_fclink_test(isp, 250000)) { 2385 XS_SETERR(xs, HBA_SELTIMEOUT); 2386 if (fcp->loop_seen_once) { 2387 return (CMD_RQLATER); 2388 } else { 2389 return (CMD_COMPLETE); 2390 } 2391 } 2392 } 2393 2394 /* 2395 * If we're not on a Fabric, we can't have a target 2396 * above FL_PORT_ID-1. 2397 * 2398 * If we're on a fabric and *not* connected as an F-port, 2399 * we can't have a target less than FC_SNS_ID+1. This 2400 * keeps us from having to sort out the difference between 2401 * local public loop devices and those which we might get 2402 * from a switch's database. 2403 */ 2404 if (fcp->isp_onfabric == 0) { 2405 if (target >= FL_PORT_ID) { 2406 XS_SETERR(xs, HBA_SELTIMEOUT); 2407 return (CMD_COMPLETE); 2408 } 2409 } else { 2410 if (target >= FL_PORT_ID && target <= FC_SNS_ID) { 2411 XS_SETERR(xs, HBA_SELTIMEOUT); 2412 return (CMD_COMPLETE); 2413 } 2414 if (fcp->isp_topo != TOPO_F_PORT && 2415 target < FL_PORT_ID) { 2416 XS_SETERR(xs, HBA_SELTIMEOUT); 2417 return (CMD_COMPLETE); 2418 } 2419 } 2420 2421 /* 2422 * If our loop state is such that we haven't yet received 2423 * a "Port Database Changed" notification (after a LIP or 2424 * a Loop Reset or firmware initialization), then defer 2425 * sending commands for a little while, but only if we've 2426 * seen a valid loop at one point (otherwise we can get 2427 * stuck at initialization time). 2428 */ 2429 if (fcp->isp_loopstate < LOOP_PDB_RCVD) { 2430 XS_SETERR(xs, HBA_SELTIMEOUT); 2431 if (fcp->loop_seen_once) { 2432 return (CMD_RQLATER); 2433 } else { 2434 return (CMD_COMPLETE); 2435 } 2436 } 2437 2438 /* 2439 * If we're in the middle of loop or fabric scanning 2440 * or merging the port databases, retry this command later. 2441 */ 2442 if (fcp->isp_loopstate == LOOP_SCANNING_FABRIC || 2443 fcp->isp_loopstate == LOOP_SCANNING_LOOP || 2444 fcp->isp_loopstate == LOOP_SYNCING_PDB) { 2445 return (CMD_RQLATER); 2446 } 2447 2448 /* 2449 * If our loop state is now such that we've just now 2450 * received a Port Database Change notification, then 2451 * we have to go off and (re)scan the fabric. We back 2452 * out and try again later if this doesn't work. 2453 */ 2454 if (fcp->isp_loopstate == LOOP_PDB_RCVD && fcp->isp_onfabric) { 2455 if (isp_scan_fabric(isp)) { 2456 return (CMD_RQLATER); 2457 } 2458 if (fcp->isp_fwstate != FW_READY || 2459 fcp->isp_loopstate < LOOP_PDB_RCVD) { 2460 return (CMD_RQLATER); 2461 } 2462 } 2463 2464 /* 2465 * If our loop state is now such that we've just now 2466 * received a Port Database Change notification, then 2467 * we have to go off and (re)synchronize our port 2468 * database. 2469 */ 2470 if (fcp->isp_loopstate < LOOP_READY) { 2471 if (isp_pdb_sync(isp)) { 2472 return (CMD_RQLATER); 2473 } 2474 if (fcp->isp_fwstate != FW_READY || 2475 fcp->isp_loopstate != LOOP_READY) { 2476 return (CMD_RQLATER); 2477 } 2478 } 2479 2480 /* 2481 * XXX: Here's were we would cancel any loop_dead flag 2482 * XXX: also cancel in dead_loop timeout that's running 2483 */ 2484 #endif 2485 2486 /* 2487 * Now check whether we should even think about pursuing this. 2488 */ 2489 lp = &fcp->portdb[target]; 2490 if (lp->valid == 0) { 2491 XS_SETERR(xs, HBA_SELTIMEOUT); 2492 return (CMD_COMPLETE); 2493 } 2494 if ((lp->roles & (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT)) == 0) { 2495 isp_prt(isp, ISP_LOGDEBUG2, 2496 "Target %d does not have target service", target); 2497 XS_SETERR(xs, HBA_SELTIMEOUT); 2498 return (CMD_COMPLETE); 2499 } 2500 /* 2501 * Now turn target into what the actual Loop ID is. 2502 */ 2503 target = lp->loopid; 2504 } 2505 2506 /* 2507 * Next check to see if any HBA or Device 2508 * parameters need to be updated. 2509 */ 2510 if (isp->isp_update != 0) { 2511 isp_update(isp); 2512 } 2513 2514 if (isp_getrqentry(isp, &iptr, &optr, (void **) &reqp)) { 2515 isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow"); 2516 XS_SETERR(xs, HBA_BOTCH); 2517 return (CMD_EAGAIN); 2518 } 2519 2520 /* 2521 * Now see if we need to synchronize the ISP with respect to anything. 2522 * We do dual duty here (cough) for synchronizing for busses other 2523 * than which we got here to send a command to. 2524 */ 2525 if (isp->isp_sendmarker) { 2526 u_int8_t n = (IS_DUALBUS(isp)? 2: 1); 2527 /* 2528 * Check ports to send markers for... 2529 */ 2530 for (i = 0; i < n; i++) { 2531 if ((isp->isp_sendmarker & (1 << i)) == 0) { 2532 continue; 2533 } 2534 MEMZERO((void *) reqp, sizeof (*reqp)); 2535 reqp->req_header.rqs_entry_count = 1; 2536 reqp->req_header.rqs_entry_type = RQSTYPE_MARKER; 2537 reqp->req_modifier = SYNC_ALL; 2538 reqp->req_target = i << 7; /* insert bus number */ 2539 ISP_SWIZZLE_REQUEST(isp, reqp); 2540 ISP_ADD_REQUEST(isp, iptr); 2541 2542 if (isp_getrqentry(isp, &iptr, &optr, (void **)&reqp)) { 2543 isp_prt(isp, ISP_LOGDEBUG0, 2544 "Request Queue Overflow+"); 2545 XS_SETERR(xs, HBA_BOTCH); 2546 return (CMD_EAGAIN); 2547 } 2548 } 2549 } 2550 2551 MEMZERO((void *) reqp, UZSIZE); 2552 reqp->req_header.rqs_entry_count = 1; 2553 if (IS_FC(isp)) { 2554 reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS; 2555 } else { 2556 if (XS_CDBLEN(xs) > 12) 2557 reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY; 2558 else 2559 reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST; 2560 } 2561 reqp->req_header.rqs_flags = 0; 2562 reqp->req_header.rqs_seqno = 0; 2563 if (IS_FC(isp)) { 2564 /* 2565 * See comment in isp_intr 2566 */ 2567 XS_RESID(xs) = 0; 2568 2569 /* 2570 * Fibre Channel always requires some kind of tag. 2571 * The Qlogic drivers seem be happy not to use a tag, 2572 * but this breaks for some devices (IBM drives). 2573 */ 2574 if (XS_TAG_P(xs)) { 2575 t2reqp->req_flags = XS_TAG_TYPE(xs); 2576 } else { 2577 /* 2578 * If we don't know what tag to use, use HEAD OF QUEUE 2579 * for Request Sense or Ordered (for safety's sake). 2580 */ 2581 if (XS_CDBP(xs)[0] == 0x3) /* REQUEST SENSE */ 2582 t2reqp->req_flags = REQFLAG_HTAG; 2583 else 2584 t2reqp->req_flags = REQFLAG_OTAG; 2585 } 2586 } else { 2587 sdparam *sdp = (sdparam *)isp->isp_param; 2588 if ((sdp->isp_devparam[target].cur_dflags & DPARM_TQING) && 2589 XS_TAG_P(xs)) { 2590 reqp->req_flags = XS_TAG_TYPE(xs); 2591 } 2592 } 2593 reqp->req_target = target | (XS_CHANNEL(xs) << 7); 2594 if (IS_SCSI(isp)) { 2595 reqp->req_lun_trn = XS_LUN(xs); 2596 reqp->req_cdblen = XS_CDBLEN(xs); 2597 } else { 2598 if (isp->isp_maxluns > 16) 2599 t2reqp->req_scclun = XS_LUN(xs); 2600 else 2601 t2reqp->req_lun_trn = XS_LUN(xs); 2602 } 2603 MEMCPY(reqp->req_cdb, XS_CDBP(xs), XS_CDBLEN(xs)); 2604 2605 reqp->req_time = XS_TIME(xs) / 1000; 2606 if (reqp->req_time == 0 && XS_TIME(xs)) 2607 reqp->req_time = 1; 2608 2609 /* 2610 * Always give a bit more leeway to commands after a bus reset. 2611 * XXX: DOES NOT DISTINGUISH WHICH PORT MAY HAVE BEEN SYNCED 2612 */ 2613 if (isp->isp_sendmarker && reqp->req_time < 5) { 2614 reqp->req_time = 5; 2615 } 2616 if (isp_save_xs(isp, xs, &handle)) { 2617 isp_prt(isp, ISP_LOGDEBUG1, "out of xflist pointers"); 2618 XS_SETERR(xs, HBA_BOTCH); 2619 return (CMD_EAGAIN); 2620 } 2621 reqp->req_handle = handle; 2622 /* 2623 * Set up DMA and/or do any bus swizzling of the request entry 2624 * so that the Qlogic F/W understands what is being asked of it. 2625 */ 2626 i = ISP_DMASETUP(isp, xs, reqp, &iptr, optr); 2627 if (i != CMD_QUEUED) { 2628 isp_destroy_handle(isp, handle); 2629 /* 2630 * dmasetup sets actual error in packet, and 2631 * return what we were given to return. 2632 */ 2633 return (i); 2634 } 2635 XS_SETERR(xs, HBA_NOERROR); 2636 isp_prt(isp, ISP_LOGDEBUG2, 2637 "START cmd for %d.%d.%d cmd 0x%x datalen %ld", 2638 XS_CHANNEL(xs), target, XS_LUN(xs), XS_CDBP(xs)[0], 2639 (long) XS_XFRLEN(xs)); 2640 ISP_ADD_REQUEST(isp, iptr); 2641 isp->isp_nactive++; 2642 if (isp->isp_sendmarker) 2643 isp->isp_sendmarker = 0; 2644 return (CMD_QUEUED); 2645 #undef reqp 2646 #undef t2reqp 2647 } 2648 2649 /* 2650 * isp control 2651 * Locks (ints blocked) assumed held. 2652 */ 2653 2654 int 2655 isp_control(struct ispsoftc *isp, ispctl_t ctl, void *arg) 2656 { 2657 XS_T *xs; 2658 mbreg_t mbs; 2659 int bus, tgt; 2660 u_int16_t handle; 2661 2662 switch (ctl) { 2663 default: 2664 isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl); 2665 break; 2666 2667 case ISPCTL_RESET_BUS: 2668 /* 2669 * Issue a bus reset. 2670 */ 2671 mbs.param[0] = MBOX_BUS_RESET; 2672 mbs.param[2] = 0; 2673 if (IS_SCSI(isp)) { 2674 mbs.param[1] = 2675 ((sdparam *) isp->isp_param)->isp_bus_reset_delay; 2676 if (mbs.param[1] < 2) 2677 mbs.param[1] = 2; 2678 bus = *((int *) arg); 2679 if (IS_DUALBUS(isp)) 2680 mbs.param[2] = bus; 2681 } else { 2682 mbs.param[1] = 10; 2683 bus = 0; 2684 } 2685 isp->isp_sendmarker |= (1 << bus); 2686 isp_mboxcmd(isp, &mbs, MBLOGALL); 2687 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 2688 break; 2689 } 2690 isp_prt(isp, ISP_LOGINFO, 2691 "driver initiated bus reset of bus %d", bus); 2692 return (0); 2693 2694 case ISPCTL_RESET_DEV: 2695 tgt = (*((int *) arg)) & 0xffff; 2696 bus = (*((int *) arg)) >> 16; 2697 mbs.param[0] = MBOX_ABORT_TARGET; 2698 mbs.param[1] = (tgt << 8) | (bus << 15); 2699 mbs.param[2] = 3; /* 'delay', in seconds */ 2700 isp_mboxcmd(isp, &mbs, MBLOGALL); 2701 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 2702 break; 2703 } 2704 isp_prt(isp, ISP_LOGINFO, 2705 "Target %d on Bus %d Reset Succeeded", tgt, bus); 2706 isp->isp_sendmarker |= (1 << bus); 2707 return (0); 2708 2709 case ISPCTL_ABORT_CMD: 2710 xs = (XS_T *) arg; 2711 tgt = XS_TGT(xs); 2712 handle = isp_find_handle(isp, xs); 2713 if (handle == 0) { 2714 isp_prt(isp, ISP_LOGWARN, 2715 "cannot find handle for command to abort"); 2716 break; 2717 } 2718 bus = XS_CHANNEL(xs); 2719 mbs.param[0] = MBOX_ABORT; 2720 if (IS_FC(isp)) { 2721 if (isp->isp_maxluns > 16) { 2722 mbs.param[1] = tgt << 8; 2723 mbs.param[4] = 0; 2724 mbs.param[5] = 0; 2725 mbs.param[6] = XS_LUN(xs); 2726 } else { 2727 mbs.param[1] = tgt << 8 | XS_LUN(xs); 2728 } 2729 } else { 2730 mbs.param[1] = 2731 (bus << 15) | (XS_TGT(xs) << 8) | XS_LUN(xs); 2732 } 2733 mbs.param[3] = 0; 2734 mbs.param[2] = handle; 2735 isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_ERROR); 2736 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 2737 return (0); 2738 } 2739 /* 2740 * XXX: Look for command in the REQUEST QUEUE. That is, 2741 * XXX: It hasen't been picked up by firmware yet. 2742 */ 2743 break; 2744 2745 case ISPCTL_UPDATE_PARAMS: 2746 2747 isp_update(isp); 2748 return (0); 2749 2750 case ISPCTL_FCLINK_TEST: 2751 2752 if (IS_FC(isp)) { 2753 int usdelay = (arg)? *((int *) arg) : 250000; 2754 return (isp_fclink_test(isp, usdelay)); 2755 } 2756 break; 2757 2758 case ISPCTL_SCAN_FABRIC: 2759 2760 if (IS_FC(isp)) { 2761 return (isp_scan_fabric(isp)); 2762 } 2763 break; 2764 2765 case ISPCTL_SCAN_LOOP: 2766 2767 if (IS_FC(isp)) { 2768 return (isp_scan_loop(isp)); 2769 } 2770 break; 2771 2772 case ISPCTL_PDB_SYNC: 2773 2774 if (IS_FC(isp)) { 2775 return (isp_pdb_sync(isp)); 2776 } 2777 break; 2778 2779 case ISPCTL_SEND_LIP: 2780 2781 if (IS_FC(isp)) { 2782 mbs.param[0] = MBOX_INIT_LIP; 2783 isp_mboxcmd(isp, &mbs, MBLOGALL); 2784 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 2785 return (0); 2786 } 2787 } 2788 break; 2789 2790 case ISPCTL_GET_POSMAP: 2791 2792 if (IS_FC(isp) && arg) { 2793 return (isp_getmap(isp, arg)); 2794 } 2795 break; 2796 2797 case ISPCTL_RUN_MBOXCMD: 2798 2799 isp_mboxcmd(isp, arg, MBLOGALL); 2800 return(0); 2801 2802 #ifdef ISP_TARGET_MODE 2803 case ISPCTL_TOGGLE_TMODE: 2804 { 2805 2806 /* 2807 * We don't check/set against role here- that's the 2808 * responsibility for the outer layer to coordinate. 2809 */ 2810 if (IS_SCSI(isp)) { 2811 int param = *(int *)arg; 2812 mbs.param[0] = MBOX_ENABLE_TARGET_MODE; 2813 mbs.param[1] = param & 0xffff; 2814 mbs.param[2] = param >> 16; 2815 isp_mboxcmd(isp, &mbs, MBLOGALL); 2816 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 2817 break; 2818 } 2819 } 2820 return (0); 2821 } 2822 #endif 2823 } 2824 return (-1); 2825 } 2826 2827 /* 2828 * Interrupt Service Routine(s). 2829 * 2830 * External (OS) framework has done the appropriate locking, 2831 * and the locking will be held throughout this function. 2832 */ 2833 2834 /* 2835 * Limit our stack depth by sticking with the max likely number 2836 * of completions on a request queue at any one time. 2837 */ 2838 #define MAX_REQUESTQ_COMPLETIONS 32 2839 2840 int 2841 isp_intr(void *arg) 2842 { 2843 struct ispsoftc *isp = arg; 2844 XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs; 2845 u_int16_t iptr, optr, isr, sema, junk; 2846 int i, nlooked = 0, ndone = 0; 2847 2848 if (IS_2100(isp)) { 2849 i = 0; 2850 do { 2851 isr = ISP_READ(isp, BIU_ISR); 2852 junk = ISP_READ(isp, BIU_ISR); 2853 } while (isr != junk && ++i < 1000); 2854 if (isr != junk) { 2855 isp_prt(isp, ISP_LOGWARN, 2856 "isr unsteady (%x, %x)", isr, junk); 2857 } 2858 i = 0; 2859 do { 2860 sema = ISP_READ(isp, BIU_SEMA); 2861 junk = ISP_READ(isp, BIU_SEMA); 2862 } while (sema != junk && ++i < 1000); 2863 if (sema != junk) { 2864 isp_prt(isp, ISP_LOGWARN, 2865 "sema unsteady (%x, %x)", sema, junk); 2866 } 2867 } else { 2868 isr = ISP_READ(isp, BIU_ISR); 2869 sema = ISP_READ(isp, BIU_SEMA); 2870 } 2871 isp_prt(isp, ISP_LOGDEBUG3, "isp_intr isr %x sem %x", isr, sema); 2872 isr &= INT_PENDING_MASK(isp); 2873 sema &= BIU_SEMA_LOCK; 2874 isp->isp_intcnt++; 2875 if (isr == 0 && sema == 0) { 2876 isp->isp_intbogus++; 2877 return (0); 2878 } 2879 2880 if (sema) { 2881 u_int16_t mbox; 2882 2883 if (IS_2100(isp)) { 2884 i = 0; 2885 do { 2886 mbox = ISP_READ(isp, OUTMAILBOX0); 2887 junk = ISP_READ(isp, OUTMAILBOX0);; 2888 } while (junk != mbox && ++i < 1000); 2889 if (mbox != junk) { 2890 isp_prt(isp, ISP_LOGWARN, 2891 "mailbox0 unsteady (%x, %x)", mbox, junk); 2892 ISP_WRITE(isp, BIU_SEMA, 0); 2893 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 2894 return (1); 2895 } 2896 } else { 2897 mbox = ISP_READ(isp, OUTMAILBOX0); 2898 } 2899 if (mbox & 0x4000) { 2900 int obits, i = 0; 2901 if ((obits = isp->isp_mboxbsy) != 0) { 2902 isp->isp_mboxtmp[i++] = mbox; 2903 for (i = 1; i < MAX_MAILBOX; i++) { 2904 if ((obits & (1 << i)) == 0) { 2905 continue; 2906 } 2907 isp->isp_mboxtmp[i] = 2908 ISP_READ(isp, MBOX_OFF(i)); 2909 } 2910 MBOX_NOTIFY_COMPLETE(isp); 2911 } else { 2912 isp_prt(isp, ISP_LOGWARN, 2913 "Mbox Command Async (0x%x) with no waiters", 2914 mbox); 2915 } 2916 } else { 2917 int fhandle = isp_parse_async(isp, (int) mbox); 2918 isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox); 2919 if (fhandle > 0) { 2920 isp_fastpost_complete(isp, (u_int16_t) fhandle); 2921 } 2922 } 2923 if (IS_FC(isp) || isp->isp_state != ISP_RUNSTATE) { 2924 ISP_WRITE(isp, BIU_SEMA, 0); 2925 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 2926 return (1); 2927 } 2928 } 2929 2930 /* 2931 * We can't be getting this now. 2932 */ 2933 if (isp->isp_state != ISP_RUNSTATE) { 2934 isp_prt(isp, ISP_LOGWARN, 2935 "interrupt (isr=%x, sema=%x) when not ready", isr, sema); 2936 ISP_WRITE(isp, INMAILBOX5, ISP_READ(isp, OUTMAILBOX5)); 2937 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 2938 ISP_WRITE(isp, BIU_SEMA, 0); 2939 return (1); 2940 } 2941 2942 /* 2943 * You *must* read OUTMAILBOX5 prior to clearing the RISC interrupt. 2944 */ 2945 optr = isp->isp_residx; 2946 2947 if (IS_2100(isp)) { 2948 i = 0; 2949 do { 2950 iptr = ISP_READ(isp, OUTMAILBOX5); 2951 junk = ISP_READ(isp, OUTMAILBOX5); 2952 } while (junk != iptr && ++i < 1000); 2953 2954 if (iptr != junk) { 2955 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 2956 isp_prt(isp, ISP_LOGWARN, 2957 "mailbox5 unsteady (%x, %x)", iptr, junk); 2958 return (1); 2959 } 2960 } else { 2961 iptr = ISP_READ(isp, OUTMAILBOX5); 2962 } 2963 2964 if (sema) { 2965 ISP_WRITE(isp, BIU_SEMA, 0); 2966 } 2967 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 2968 2969 if (optr == iptr && sema == 0) { 2970 /* 2971 * There are a lot of these- reasons unknown- mostly on 2972 * faster Alpha machines. 2973 * 2974 * I tried delaying after writing HCCR_CMD_CLEAR_RISC_INT to 2975 * make sure the old interrupt went away (to avoid 'ringing' 2976 * effects), but that didn't stop this from occurring. 2977 */ 2978 junk = ISP_READ(isp, BIU_ISR); 2979 isp_prt(isp, ISP_LOGDEBUG2, 2980 "bogus intr- isr %x (%x) iptr %x optr %x", 2981 isr, junk, iptr, optr); 2982 isp->isp_intbogus++; 2983 } 2984 2985 while (optr != iptr) { 2986 ispstatusreq_t *sp; 2987 u_int16_t oop; 2988 int buddaboom = 0; 2989 2990 sp = (ispstatusreq_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr); 2991 oop = optr; 2992 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp)); 2993 nlooked++; 2994 /* 2995 * Do any appropriate unswizzling of what the Qlogic f/w has 2996 * written into memory so it makes sense to us. This is a 2997 * per-platform thing. Also includes any memory barriers. 2998 */ 2999 ISP_UNSWIZZLE_RESPONSE(isp, sp, oop); 3000 if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) { 3001 if (isp_handle_other_response(isp, sp, &optr) == 0) { 3002 MEMZERO(sp, sizeof (isphdr_t)); 3003 continue; 3004 } 3005 /* 3006 * It really has to be a bounced request just copied 3007 * from the request queue to the response queue. If 3008 * not, something bad has happened. 3009 */ 3010 if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) { 3011 isp_prt(isp, ISP_LOGERR, notresp, 3012 sp->req_header.rqs_entry_type, oop, optr, 3013 nlooked); 3014 if (isp->isp_dblev & ISP_LOGDEBUG0) { 3015 isp_print_bytes(isp, "Queue Entry", 3016 QENTRY_LEN, sp); 3017 } 3018 MEMZERO(sp, sizeof (isphdr_t)); 3019 continue; 3020 } 3021 buddaboom = 1; 3022 } 3023 3024 if (sp->req_header.rqs_flags & 0xf) { 3025 #define _RQS_OFLAGS \ 3026 ~(RQSFLAG_CONTINUATION|RQSFLAG_FULL|RQSFLAG_BADHEADER|RQSFLAG_BADPACKET) 3027 if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) { 3028 isp_prt(isp, ISP_LOGWARN, 3029 "continuation segment"); 3030 ISP_WRITE(isp, INMAILBOX5, optr); 3031 continue; 3032 } 3033 if (sp->req_header.rqs_flags & RQSFLAG_FULL) { 3034 isp_prt(isp, ISP_LOGDEBUG1, 3035 "internal queues full"); 3036 /* 3037 * We'll synthesize a QUEUE FULL message below. 3038 */ 3039 } 3040 if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) { 3041 isp_prt(isp, ISP_LOGERR, "bad header flag"); 3042 buddaboom++; 3043 } 3044 if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) { 3045 isp_prt(isp, ISP_LOGERR, "bad request packet"); 3046 buddaboom++; 3047 } 3048 if (sp->req_header.rqs_flags & _RQS_OFLAGS) { 3049 isp_prt(isp, ISP_LOGERR, 3050 "unknown flags (0x%x) in response", 3051 sp->req_header.rqs_flags); 3052 buddaboom++; 3053 } 3054 #undef _RQS_OFLAGS 3055 } 3056 if (sp->req_handle > isp->isp_maxcmds || sp->req_handle < 1) { 3057 MEMZERO(sp, sizeof (isphdr_t)); 3058 isp_prt(isp, ISP_LOGERR, 3059 "bad request handle %d (type 0x%x, flags 0x%x)", 3060 sp->req_handle, sp->req_header.rqs_entry_type, 3061 sp->req_header.rqs_flags); 3062 ISP_WRITE(isp, INMAILBOX5, optr); 3063 continue; 3064 } 3065 xs = isp_find_xs(isp, sp->req_handle); 3066 if (xs == NULL) { 3067 MEMZERO(sp, sizeof (isphdr_t)); 3068 isp_prt(isp, ISP_LOGERR, 3069 "cannot find handle 0x%x in xflist", 3070 sp->req_handle); 3071 ISP_WRITE(isp, INMAILBOX5, optr); 3072 continue; 3073 } 3074 isp_destroy_handle(isp, sp->req_handle); 3075 if (sp->req_status_flags & RQSTF_BUS_RESET) { 3076 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs)); 3077 } 3078 if (buddaboom) { 3079 XS_SETERR(xs, HBA_BOTCH); 3080 } 3081 3082 if (IS_FC(isp) && (sp->req_scsi_status & RQCS_SV)) { 3083 /* 3084 * Fibre Channel F/W doesn't say we got status 3085 * if there's Sense Data instead. I guess they 3086 * think it goes w/o saying. 3087 */ 3088 sp->req_state_flags |= RQSF_GOT_STATUS; 3089 } 3090 if (sp->req_state_flags & RQSF_GOT_STATUS) { 3091 *XS_STSP(xs) = sp->req_scsi_status & 0xff; 3092 } 3093 3094 switch (sp->req_header.rqs_entry_type) { 3095 case RQSTYPE_RESPONSE: 3096 XS_SET_STATE_STAT(isp, xs, sp); 3097 isp_parse_status(isp, sp, xs); 3098 if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) && 3099 (*XS_STSP(xs) == SCSI_BUSY)) { 3100 XS_SETERR(xs, HBA_TGTBSY); 3101 } 3102 if (IS_SCSI(isp)) { 3103 XS_RESID(xs) = sp->req_resid; 3104 if ((sp->req_state_flags & RQSF_GOT_STATUS) && 3105 (*XS_STSP(xs) == SCSI_CHECK) && 3106 (sp->req_state_flags & RQSF_GOT_SENSE)) { 3107 XS_SAVE_SENSE(xs, sp); 3108 } 3109 /* 3110 * A new synchronous rate was negotiated for 3111 * this target. Mark state such that we'll go 3112 * look up that which has changed later. 3113 */ 3114 if (sp->req_status_flags & RQSTF_NEGOTIATION) { 3115 int t = XS_TGT(xs); 3116 sdparam *sdp = isp->isp_param; 3117 sdp += XS_CHANNEL(xs); 3118 sdp->isp_devparam[t].dev_refresh = 1; 3119 isp->isp_update |= 3120 (1 << XS_CHANNEL(xs)); 3121 } 3122 } else { 3123 if (sp->req_status_flags & RQSF_XFER_COMPLETE) { 3124 XS_RESID(xs) = 0; 3125 } else if (sp->req_scsi_status & RQCS_RESID) { 3126 XS_RESID(xs) = sp->req_resid; 3127 } else { 3128 XS_RESID(xs) = 0; 3129 } 3130 if ((sp->req_state_flags & RQSF_GOT_STATUS) && 3131 (*XS_STSP(xs) == SCSI_CHECK) && 3132 (sp->req_scsi_status & RQCS_SV)) { 3133 XS_SAVE_SENSE(xs, sp); 3134 /* solely for the benefit of debug */ 3135 sp->req_state_flags |= RQSF_GOT_SENSE; 3136 } 3137 } 3138 isp_prt(isp, ISP_LOGDEBUG2, 3139 "asked for %ld got resid %ld", (long) XS_XFRLEN(xs), 3140 (long) sp->req_resid); 3141 break; 3142 case RQSTYPE_REQUEST: 3143 if (sp->req_header.rqs_flags & RQSFLAG_FULL) { 3144 /* 3145 * Force Queue Full status. 3146 */ 3147 *XS_STSP(xs) = SCSI_QFULL; 3148 XS_SETERR(xs, HBA_NOERROR); 3149 } else if (XS_NOERR(xs)) { 3150 XS_SETERR(xs, HBA_BOTCH); 3151 } 3152 XS_RESID(xs) = XS_XFRLEN(xs); 3153 break; 3154 default: 3155 isp_prt(isp, ISP_LOGWARN, 3156 "unhandled response queue type 0x%x", 3157 sp->req_header.rqs_entry_type); 3158 if (XS_NOERR(xs)) { 3159 XS_SETERR(xs, HBA_BOTCH); 3160 } 3161 break; 3162 } 3163 3164 /* 3165 * Free any dma resources. As a side effect, this may 3166 * also do any cache flushing necessary for data coherence. */ 3167 if (XS_XFRLEN(xs)) { 3168 ISP_DMAFREE(isp, xs, sp->req_handle); 3169 } 3170 3171 if (((isp->isp_dblev & (ISP_LOGDEBUG2|ISP_LOGDEBUG3))) || 3172 ((isp->isp_dblev & ISP_LOGDEBUG1) && ((!XS_NOERR(xs)) || 3173 (*XS_STSP(xs) != SCSI_GOOD)))) { 3174 char skey; 3175 if (sp->req_state_flags & RQSF_GOT_SENSE) { 3176 skey = XS_SNSKEY(xs) & 0xf; 3177 if (skey < 10) 3178 skey += '0'; 3179 else 3180 skey += 'a' - 10; 3181 } else if (*XS_STSP(xs) == SCSI_CHECK) { 3182 skey = '?'; 3183 } else { 3184 skey = '.'; 3185 } 3186 isp_prt(isp, ISP_LOGALL, finmsg, XS_CHANNEL(xs), 3187 XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs), XS_RESID(xs), 3188 *XS_STSP(xs), skey, XS_ERR(xs)); 3189 } 3190 3191 if (isp->isp_nactive > 0) 3192 isp->isp_nactive--; 3193 complist[ndone++] = xs; /* defer completion call until later */ 3194 MEMZERO(sp, sizeof (isphdr_t)); 3195 if (ndone == MAX_REQUESTQ_COMPLETIONS) { 3196 break; 3197 } 3198 } 3199 3200 /* 3201 * If we looked at any commands, then it's valid to find out 3202 * what the outpointer is. It also is a trigger to update the 3203 * ISP's notion of what we've seen so far. 3204 */ 3205 if (nlooked) { 3206 ISP_WRITE(isp, INMAILBOX5, optr); 3207 isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4); 3208 } 3209 3210 isp->isp_residx = optr; 3211 for (i = 0; i < ndone; i++) { 3212 xs = complist[i]; 3213 if (xs) { 3214 isp_done(xs); 3215 } 3216 } 3217 return (1); 3218 } 3219 3220 /* 3221 * Support routines. 3222 */ 3223 3224 static int 3225 isp_parse_async(struct ispsoftc *isp, int mbox) 3226 { 3227 int bus; 3228 u_int16_t fast_post_handle = 0; 3229 3230 if (IS_DUALBUS(isp)) { 3231 bus = ISP_READ(isp, OUTMAILBOX6); 3232 } else { 3233 bus = 0; 3234 } 3235 3236 switch (mbox) { 3237 case ASYNC_BUS_RESET: 3238 isp->isp_sendmarker |= (1 << bus); 3239 #ifdef ISP_TARGET_MODE 3240 isp_target_async(isp, bus, mbox); 3241 #endif 3242 isp_async(isp, ISPASYNC_BUS_RESET, &bus); 3243 break; 3244 case ASYNC_SYSTEM_ERROR: 3245 mbox = ISP_READ(isp, OUTMAILBOX1); 3246 isp_prt(isp, ISP_LOGERR, 3247 "Internal Firmware Error @ RISC Addr 0x%x", mbox); 3248 ISP_DUMPREGS(isp, "Firmware Error"); 3249 isp_reinit(isp); 3250 #ifdef ISP_TARGET_MODE 3251 isp_target_async(isp, bus, ASYNC_SYSTEM_ERROR); 3252 #endif 3253 /* no point continuing after this */ 3254 return (-1); 3255 3256 case ASYNC_RQS_XFER_ERR: 3257 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error"); 3258 break; 3259 3260 case ASYNC_RSP_XFER_ERR: 3261 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error"); 3262 break; 3263 3264 case ASYNC_QWAKEUP: 3265 /* 3266 * We've just been notified that the Queue has woken up. 3267 * We don't need to be chatty about this- just unlatch things 3268 * and move on. 3269 */ 3270 mbox = ISP_READ(isp, OUTMAILBOX4); 3271 break; 3272 3273 case ASYNC_TIMEOUT_RESET: 3274 isp_prt(isp, ISP_LOGWARN, 3275 "timeout initiated SCSI bus reset of bus %d", bus); 3276 isp->isp_sendmarker |= (1 << bus); 3277 #ifdef ISP_TARGET_MODE 3278 isp_target_async(isp, bus, mbox); 3279 #endif 3280 break; 3281 3282 case ASYNC_DEVICE_RESET: 3283 isp_prt(isp, ISP_LOGINFO, "device reset on bus %d", bus); 3284 isp->isp_sendmarker |= (1 << bus); 3285 #ifdef ISP_TARGET_MODE 3286 isp_target_async(isp, bus, mbox); 3287 #endif 3288 break; 3289 3290 case ASYNC_EXTMSG_UNDERRUN: 3291 isp_prt(isp, ISP_LOGWARN, "extended message underrun"); 3292 break; 3293 3294 case ASYNC_SCAM_INT: 3295 isp_prt(isp, ISP_LOGINFO, "SCAM interrupt"); 3296 break; 3297 3298 case ASYNC_HUNG_SCSI: 3299 isp_prt(isp, ISP_LOGERR, 3300 "stalled SCSI Bus after DATA Overrun"); 3301 /* XXX: Need to issue SCSI reset at this point */ 3302 break; 3303 3304 case ASYNC_KILLED_BUS: 3305 isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun"); 3306 break; 3307 3308 case ASYNC_BUS_TRANSIT: 3309 mbox = ISP_READ(isp, OUTMAILBOX2); 3310 switch (mbox & 0x1c00) { 3311 case SXP_PINS_LVD_MODE: 3312 isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode"); 3313 SDPARAM(isp)->isp_diffmode = 0; 3314 SDPARAM(isp)->isp_ultramode = 0; 3315 SDPARAM(isp)->isp_lvdmode = 1; 3316 break; 3317 case SXP_PINS_HVD_MODE: 3318 isp_prt(isp, ISP_LOGINFO, 3319 "Transition to Differential mode"); 3320 SDPARAM(isp)->isp_diffmode = 1; 3321 SDPARAM(isp)->isp_ultramode = 0; 3322 SDPARAM(isp)->isp_lvdmode = 0; 3323 break; 3324 case SXP_PINS_SE_MODE: 3325 isp_prt(isp, ISP_LOGINFO, 3326 "Transition to Single Ended mode"); 3327 SDPARAM(isp)->isp_diffmode = 0; 3328 SDPARAM(isp)->isp_ultramode = 1; 3329 SDPARAM(isp)->isp_lvdmode = 0; 3330 break; 3331 default: 3332 isp_prt(isp, ISP_LOGWARN, 3333 "Transition to Unknown Mode 0x%x", mbox); 3334 break; 3335 } 3336 /* 3337 * XXX: Set up to renegotiate again! 3338 */ 3339 /* Can only be for a 1080... */ 3340 isp->isp_sendmarker |= (1 << bus); 3341 break; 3342 3343 case ASYNC_CMD_CMPLT: 3344 fast_post_handle = ISP_READ(isp, OUTMAILBOX1); 3345 isp_prt(isp, ISP_LOGDEBUG3, "fast post completion of %u", 3346 fast_post_handle); 3347 break; 3348 3349 case ASYNC_CTIO_DONE: 3350 #ifdef ISP_TARGET_MODE 3351 /* 3352 * Bus gets overloaded with the handle. Dual bus 3353 * cards don't put bus# into the handle. 3354 */ 3355 bus = (ISP_READ(isp, OUTMAILBOX2) << 16) | 3356 ISP_READ(isp, OUTMAILBOX1); 3357 isp_target_async(isp, bus, mbox); 3358 #else 3359 isp_prt(isp, ISP_LOGINFO, "Fast Posting CTIO done"); 3360 #endif 3361 break; 3362 3363 case ASYNC_LIP_OCCURRED: 3364 FCPARAM(isp)->isp_lipseq = 3365 ISP_READ(isp, OUTMAILBOX1); 3366 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT; 3367 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD; 3368 isp->isp_sendmarker = 1; 3369 isp_mark_getpdb_all(isp); 3370 isp_async(isp, ISPASYNC_LIP, NULL); 3371 #ifdef ISP_TARGET_MODE 3372 isp_target_async(isp, bus, mbox); 3373 #endif 3374 break; 3375 3376 case ASYNC_LOOP_UP: 3377 isp->isp_sendmarker = 1; 3378 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT; 3379 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD; 3380 isp_mark_getpdb_all(isp); 3381 isp_async(isp, ISPASYNC_LOOP_UP, NULL); 3382 #ifdef ISP_TARGET_MODE 3383 isp_target_async(isp, bus, mbox); 3384 #endif 3385 break; 3386 3387 case ASYNC_LOOP_DOWN: 3388 isp->isp_sendmarker = 1; 3389 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT; 3390 FCPARAM(isp)->isp_loopstate = LOOP_NIL; 3391 isp_mark_getpdb_all(isp); 3392 isp_async(isp, ISPASYNC_LOOP_DOWN, NULL); 3393 #ifdef ISP_TARGET_MODE 3394 isp_target_async(isp, bus, mbox); 3395 #endif 3396 break; 3397 3398 case ASYNC_LOOP_RESET: 3399 isp->isp_sendmarker = 1; 3400 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT; 3401 FCPARAM(isp)->isp_loopstate = LOOP_NIL; 3402 isp_mark_getpdb_all(isp); 3403 isp_async(isp, ISPASYNC_LOOP_RESET, NULL); 3404 #ifdef ISP_TARGET_MODE 3405 isp_target_async(isp, bus, mbox); 3406 #endif 3407 break; 3408 3409 case ASYNC_PDB_CHANGED: 3410 isp->isp_sendmarker = 1; 3411 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD; 3412 isp_mark_getpdb_all(isp); 3413 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_PDB); 3414 break; 3415 3416 case ASYNC_CHANGE_NOTIFY: 3417 /* 3418 * Not correct, but it will force us to rescan the loop. 3419 */ 3420 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD; 3421 isp_mark_getpdb_all(isp); 3422 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_SNS); 3423 break; 3424 3425 case ASYNC_PTPMODE: 3426 if (FCPARAM(isp)->isp_onfabric) 3427 FCPARAM(isp)->isp_topo = TOPO_F_PORT; 3428 else 3429 FCPARAM(isp)->isp_topo = TOPO_N_PORT; 3430 isp_mark_getpdb_all(isp); 3431 isp->isp_sendmarker = 1; 3432 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT; 3433 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD; 3434 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER); 3435 #ifdef ISP_TARGET_MODE 3436 isp_target_async(isp, bus, mbox); 3437 #endif 3438 isp_prt(isp, ISP_LOGINFO, "Point-to-Point mode"); 3439 break; 3440 3441 case ASYNC_CONNMODE: 3442 mbox = ISP_READ(isp, OUTMAILBOX1); 3443 isp_mark_getpdb_all(isp); 3444 switch (mbox) { 3445 case ISP_CONN_LOOP: 3446 isp_prt(isp, ISP_LOGINFO, 3447 "Point-to-Point -> Loop mode"); 3448 break; 3449 case ISP_CONN_PTP: 3450 isp_prt(isp, ISP_LOGINFO, 3451 "Loop -> Point-to-Point mode"); 3452 break; 3453 case ISP_CONN_BADLIP: 3454 isp_prt(isp, ISP_LOGWARN, 3455 "Point-to-Point -> Loop mode (BAD LIP)"); 3456 break; 3457 case ISP_CONN_FATAL: 3458 isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR"); 3459 isp_reinit(isp); 3460 #ifdef ISP_TARGET_MODE 3461 isp_target_async(isp, bus, ASYNC_SYSTEM_ERROR); 3462 #endif 3463 /* no point continuing after this */ 3464 return (-1); 3465 case ISP_CONN_LOOPBACK: 3466 isp_prt(isp, ISP_LOGWARN, 3467 "Looped Back in Point-to-Point mode"); 3468 break; 3469 default: 3470 isp_prt(isp, ISP_LOGWARN, 3471 "Unknown connection mode (0x%x)", mbox); 3472 break; 3473 } 3474 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER); 3475 isp->isp_sendmarker = 1; 3476 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT; 3477 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD; 3478 break; 3479 3480 default: 3481 isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox); 3482 break; 3483 } 3484 return (fast_post_handle); 3485 } 3486 3487 /* 3488 * Handle other response entries. A pointer to the request queue output 3489 * index is here in case we want to eat several entries at once, although 3490 * this is not used currently. 3491 */ 3492 3493 static int 3494 isp_handle_other_response(struct ispsoftc *isp, 3495 ispstatusreq_t *sp, u_int16_t *optrp) 3496 { 3497 switch (sp->req_header.rqs_entry_type) { 3498 case RQSTYPE_STATUS_CONT: 3499 isp_prt(isp, ISP_LOGINFO, "Ignored Continuation Response"); 3500 return (0); 3501 case RQSTYPE_ATIO: 3502 case RQSTYPE_CTIO: 3503 case RQSTYPE_ENABLE_LUN: 3504 case RQSTYPE_MODIFY_LUN: 3505 case RQSTYPE_NOTIFY: 3506 case RQSTYPE_NOTIFY_ACK: 3507 case RQSTYPE_CTIO1: 3508 case RQSTYPE_ATIO2: 3509 case RQSTYPE_CTIO2: 3510 case RQSTYPE_CTIO3: 3511 #ifdef ISP_TARGET_MODE 3512 return (isp_target_notify(isp, sp, optrp)); 3513 #else 3514 optrp = optrp; 3515 /* FALLTHROUGH */ 3516 #endif 3517 case RQSTYPE_REQUEST: 3518 default: 3519 if (isp_async(isp, ISPASYNC_UNHANDLED_RESPONSE, sp)) { 3520 return (0); 3521 } 3522 isp_prt(isp, ISP_LOGWARN, "Unhandled Response Type 0x%x", 3523 sp->req_header.rqs_entry_type); 3524 return (-1); 3525 } 3526 } 3527 3528 static void 3529 isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs) 3530 { 3531 switch (sp->req_completion_status & 0xff) { 3532 case RQCS_COMPLETE: 3533 if (XS_NOERR(xs)) { 3534 XS_SETERR(xs, HBA_NOERROR); 3535 } 3536 return; 3537 3538 case RQCS_INCOMPLETE: 3539 if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) { 3540 isp_prt(isp, ISP_LOGDEBUG1, 3541 "Selection Timeout for %d.%d.%d", 3542 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3543 if (XS_NOERR(xs)) { 3544 XS_SETERR(xs, HBA_SELTIMEOUT); 3545 } 3546 return; 3547 } 3548 isp_prt(isp, ISP_LOGERR, 3549 "command incomplete for %d.%d.%d, state 0x%x", 3550 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), 3551 sp->req_state_flags); 3552 break; 3553 3554 case RQCS_DMA_ERROR: 3555 isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d", 3556 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3557 break; 3558 3559 case RQCS_TRANSPORT_ERROR: 3560 { 3561 char buf[172]; 3562 buf[0] = 0; 3563 STRNCAT(buf, "states=>", sizeof buf); 3564 if (sp->req_state_flags & RQSF_GOT_BUS) { 3565 STRNCAT(buf, " GOT_BUS", sizeof buf); 3566 } 3567 if (sp->req_state_flags & RQSF_GOT_TARGET) { 3568 STRNCAT(buf, " GOT_TGT", sizeof buf); 3569 } 3570 if (sp->req_state_flags & RQSF_SENT_CDB) { 3571 STRNCAT(buf, " SENT_CDB", sizeof buf); 3572 } 3573 if (sp->req_state_flags & RQSF_XFRD_DATA) { 3574 STRNCAT(buf, " XFRD_DATA", sizeof buf); 3575 } 3576 if (sp->req_state_flags & RQSF_GOT_STATUS) { 3577 STRNCAT(buf, " GOT_STS", sizeof buf); 3578 } 3579 if (sp->req_state_flags & RQSF_GOT_SENSE) { 3580 STRNCAT(buf, " GOT_SNS", sizeof buf); 3581 } 3582 if (sp->req_state_flags & RQSF_XFER_COMPLETE) { 3583 STRNCAT(buf, " XFR_CMPLT", sizeof buf); 3584 } 3585 STRNCAT(buf, "\nstatus=>", sizeof buf); 3586 if (sp->req_status_flags & RQSTF_DISCONNECT) { 3587 STRNCAT(buf, " Disconnect", sizeof buf); 3588 } 3589 if (sp->req_status_flags & RQSTF_SYNCHRONOUS) { 3590 STRNCAT(buf, " Sync_xfr", sizeof buf); 3591 } 3592 if (sp->req_status_flags & RQSTF_PARITY_ERROR) { 3593 STRNCAT(buf, " Parity", sizeof buf); 3594 } 3595 if (sp->req_status_flags & RQSTF_BUS_RESET) { 3596 STRNCAT(buf, " Bus_Reset", sizeof buf); 3597 } 3598 if (sp->req_status_flags & RQSTF_DEVICE_RESET) { 3599 STRNCAT(buf, " Device_Reset", sizeof buf); 3600 } 3601 if (sp->req_status_flags & RQSTF_ABORTED) { 3602 STRNCAT(buf, " Aborted", sizeof buf); 3603 } 3604 if (sp->req_status_flags & RQSTF_TIMEOUT) { 3605 STRNCAT(buf, " Timeout", sizeof buf); 3606 } 3607 if (sp->req_status_flags & RQSTF_NEGOTIATION) { 3608 STRNCAT(buf, " Negotiation", sizeof buf); 3609 } 3610 isp_prt(isp, ISP_LOGERR, "%s", buf); 3611 isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d:\n%s", 3612 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), buf); 3613 break; 3614 } 3615 case RQCS_RESET_OCCURRED: 3616 isp_prt(isp, ISP_LOGWARN, 3617 "bus reset destroyed command for %d.%d.%d", 3618 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3619 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs)); 3620 if (XS_NOERR(xs)) { 3621 XS_SETERR(xs, HBA_BUSRESET); 3622 } 3623 return; 3624 3625 case RQCS_ABORTED: 3626 isp_prt(isp, ISP_LOGERR, "command aborted for %d.%d.%d", 3627 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3628 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs)); 3629 if (XS_NOERR(xs)) { 3630 XS_SETERR(xs, HBA_ABORTED); 3631 } 3632 return; 3633 3634 case RQCS_TIMEOUT: 3635 isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d", 3636 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3637 if (XS_NOERR(xs)) { 3638 XS_SETERR(xs, HBA_CMDTIMEOUT); 3639 } 3640 return; 3641 3642 case RQCS_DATA_OVERRUN: 3643 XS_RESID(xs) = sp->req_resid; 3644 isp_prt(isp, ISP_LOGERR, "data overrun for command on %d.%d.%d", 3645 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3646 if (XS_NOERR(xs)) { 3647 XS_SETERR(xs, HBA_DATAOVR); 3648 } 3649 return; 3650 3651 case RQCS_COMMAND_OVERRUN: 3652 isp_prt(isp, ISP_LOGERR, 3653 "command overrun for command on %d.%d.%d", 3654 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3655 break; 3656 3657 case RQCS_STATUS_OVERRUN: 3658 isp_prt(isp, ISP_LOGERR, 3659 "status overrun for command on %d.%d.%d", 3660 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3661 break; 3662 3663 case RQCS_BAD_MESSAGE: 3664 isp_prt(isp, ISP_LOGERR, 3665 "msg not COMMAND COMPLETE after status %d.%d.%d", 3666 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3667 break; 3668 3669 case RQCS_NO_MESSAGE_OUT: 3670 isp_prt(isp, ISP_LOGERR, 3671 "No MESSAGE OUT phase after selection on %d.%d.%d", 3672 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3673 break; 3674 3675 case RQCS_EXT_ID_FAILED: 3676 isp_prt(isp, ISP_LOGERR, "EXTENDED IDENTIFY failed %d.%d.%d", 3677 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3678 break; 3679 3680 case RQCS_IDE_MSG_FAILED: 3681 isp_prt(isp, ISP_LOGERR, 3682 "INITIATOR DETECTED ERROR rejected by %d.%d.%d", 3683 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3684 break; 3685 3686 case RQCS_ABORT_MSG_FAILED: 3687 isp_prt(isp, ISP_LOGERR, "ABORT OPERATION rejected by %d.%d.%d", 3688 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3689 break; 3690 3691 case RQCS_REJECT_MSG_FAILED: 3692 isp_prt(isp, ISP_LOGERR, "MESSAGE REJECT rejected by %d.%d.%d", 3693 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3694 break; 3695 3696 case RQCS_NOP_MSG_FAILED: 3697 isp_prt(isp, ISP_LOGERR, "NOP rejected by %d.%d.%d", 3698 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3699 break; 3700 3701 case RQCS_PARITY_ERROR_MSG_FAILED: 3702 isp_prt(isp, ISP_LOGERR, 3703 "MESSAGE PARITY ERROR rejected by %d.%d.%d", 3704 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3705 break; 3706 3707 case RQCS_DEVICE_RESET_MSG_FAILED: 3708 isp_prt(isp, ISP_LOGWARN, 3709 "BUS DEVICE RESET rejected by %d.%d.%d", 3710 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3711 break; 3712 3713 case RQCS_ID_MSG_FAILED: 3714 isp_prt(isp, ISP_LOGERR, "IDENTIFY rejected by %d.%d.%d", 3715 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3716 break; 3717 3718 case RQCS_UNEXP_BUS_FREE: 3719 isp_prt(isp, ISP_LOGERR, "%d.%d.%d had an unexpected bus free", 3720 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3721 break; 3722 3723 case RQCS_DATA_UNDERRUN: 3724 XS_RESID(xs) = sp->req_resid; 3725 if (XS_NOERR(xs)) { 3726 XS_SETERR(xs, HBA_NOERROR); 3727 } 3728 return; 3729 3730 case RQCS_XACT_ERR1: 3731 isp_prt(isp, ISP_LOGERR, xact1, XS_CHANNEL(xs), 3732 XS_TGT(xs), XS_LUN(xs)); 3733 break; 3734 3735 case RQCS_XACT_ERR2: 3736 isp_prt(isp, ISP_LOGERR, xact2, 3737 XS_LUN(xs), XS_TGT(xs), XS_CHANNEL(xs)); 3738 break; 3739 3740 case RQCS_XACT_ERR3: 3741 isp_prt(isp, ISP_LOGERR, xact3, XS_TGT(xs), 3742 XS_LUN(xs), XS_CHANNEL(xs)); 3743 break; 3744 3745 case RQCS_BAD_ENTRY: 3746 isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected"); 3747 break; 3748 3749 case RQCS_QUEUE_FULL: 3750 isp_prt(isp, ISP_LOGDEBUG1, 3751 "internal queues full for %d.%d.%d status 0x%x", XS_TGT(xs), 3752 XS_LUN(xs), XS_CHANNEL(xs), *XS_STSP(xs)); 3753 /* 3754 * If QFULL or some other status byte is set, then this 3755 * isn't an error, per se. 3756 */ 3757 if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) { 3758 XS_SETERR(xs, HBA_NOERROR); 3759 return; 3760 } 3761 break; 3762 3763 case RQCS_PHASE_SKIPPED: 3764 isp_prt(isp, ISP_LOGERR, pskip, 3765 XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs)); 3766 break; 3767 3768 case RQCS_ARQS_FAILED: 3769 isp_prt(isp, ISP_LOGERR, 3770 "Auto Request Sense failed for %d.%d.%d", 3771 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)); 3772 if (XS_NOERR(xs)) { 3773 XS_SETERR(xs, HBA_ARQFAIL); 3774 } 3775 return; 3776 3777 case RQCS_WIDE_FAILED: 3778 isp_prt(isp, ISP_LOGERR, 3779 "Wide Negotiation failed for %d.%d.%d", 3780 XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs)); 3781 if (IS_SCSI(isp)) { 3782 sdparam *sdp = isp->isp_param; 3783 sdp += XS_CHANNEL(xs); 3784 sdp->isp_devparam[XS_TGT(xs)].dev_flags &= ~DPARM_WIDE; 3785 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1; 3786 isp->isp_update |= (1 << XS_CHANNEL(xs)); 3787 } 3788 if (XS_NOERR(xs)) { 3789 XS_SETERR(xs, HBA_NOERROR); 3790 } 3791 return; 3792 3793 case RQCS_SYNCXFER_FAILED: 3794 isp_prt(isp, ISP_LOGERR, 3795 "SDTR Message failed for target %d.%d.%d", 3796 XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs)); 3797 if (IS_SCSI(isp)) { 3798 sdparam *sdp = isp->isp_param; 3799 sdp += XS_CHANNEL(xs); 3800 sdp->isp_devparam[XS_TGT(xs)].dev_flags &= ~DPARM_SYNC; 3801 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1; 3802 isp->isp_update |= (1 << XS_CHANNEL(xs)); 3803 } 3804 break; 3805 3806 case RQCS_LVD_BUSERR: 3807 isp_prt(isp, ISP_LOGERR, 3808 "Bad LVD condition while talking to %d.%d.%d", 3809 XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs)); 3810 break; 3811 3812 case RQCS_PORT_UNAVAILABLE: 3813 /* 3814 * No such port on the loop. Moral equivalent of SELTIMEO 3815 */ 3816 isp_prt(isp, ISP_LOGINFO, 3817 "Port Unavailable for target %d", XS_TGT(xs)); 3818 if (XS_NOERR(xs)) { 3819 XS_SETERR(xs, HBA_SELTIMEOUT); 3820 } 3821 return; 3822 3823 case RQCS_PORT_LOGGED_OUT: 3824 /* 3825 * It was there (maybe)- treat as a selection timeout. 3826 */ 3827 isp_prt(isp, ISP_LOGINFO, 3828 "port logout for target %d", XS_TGT(xs)); 3829 if (XS_NOERR(xs)) { 3830 XS_SETERR(xs, HBA_SELTIMEOUT); 3831 } 3832 return; 3833 3834 case RQCS_PORT_CHANGED: 3835 isp_prt(isp, ISP_LOGWARN, 3836 "port changed for target %d", XS_TGT(xs)); 3837 if (XS_NOERR(xs)) { 3838 XS_SETERR(xs, HBA_SELTIMEOUT); 3839 } 3840 return; 3841 3842 case RQCS_PORT_BUSY: 3843 isp_prt(isp, ISP_LOGWARN, 3844 "port busy for target %d", XS_TGT(xs)); 3845 if (XS_NOERR(xs)) { 3846 XS_SETERR(xs, HBA_TGTBSY); 3847 } 3848 return; 3849 3850 default: 3851 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x", 3852 sp->req_completion_status); 3853 break; 3854 } 3855 if (XS_NOERR(xs)) { 3856 XS_SETERR(xs, HBA_BOTCH); 3857 } 3858 } 3859 3860 static void 3861 isp_fastpost_complete(struct ispsoftc *isp, u_int16_t fph) 3862 { 3863 XS_T *xs; 3864 3865 if (fph == 0) { 3866 return; 3867 } 3868 xs = isp_find_xs(isp, fph); 3869 if (xs == NULL) { 3870 isp_prt(isp, ISP_LOGWARN, 3871 "Command for fast post handle 0x%x not found", fph); 3872 return; 3873 } 3874 isp_destroy_handle(isp, fph); 3875 3876 /* 3877 * Since we don't have a result queue entry item, 3878 * we must believe that SCSI status is zero and 3879 * that all data transferred. 3880 */ 3881 XS_SET_STATE_STAT(isp, xs, NULL); 3882 XS_RESID(xs) = 0; 3883 *XS_STSP(xs) = SCSI_GOOD; 3884 if (XS_XFRLEN(xs)) { 3885 ISP_DMAFREE(isp, xs, fph); 3886 } 3887 if (isp->isp_nactive) 3888 isp->isp_nactive--; 3889 isp_done(xs); 3890 } 3891 3892 #define HIBYT(x) ((x) >> 0x8) 3893 #define LOBYT(x) ((x) & 0xff) 3894 #define ISPOPMAP(a, b) (((a) << 8) | (b)) 3895 static u_int16_t mbpscsi[] = { 3896 ISPOPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */ 3897 ISPOPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */ 3898 ISPOPMAP(0x03, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */ 3899 ISPOPMAP(0x1f, 0x01), /* 0x03: MBOX_DUMP_RAM */ 3900 ISPOPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */ 3901 ISPOPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */ 3902 ISPOPMAP(0x3f, 0x3f), /* 0x06: MBOX_MAILBOX_REG_TEST */ 3903 ISPOPMAP(0x03, 0x07), /* 0x07: MBOX_VERIFY_CHECKSUM */ 3904 ISPOPMAP(0x01, 0x4f), /* 0x08: MBOX_ABOUT_FIRMWARE */ 3905 ISPOPMAP(0x00, 0x00), /* 0x09: */ 3906 ISPOPMAP(0x00, 0x00), /* 0x0a: */ 3907 ISPOPMAP(0x00, 0x00), /* 0x0b: */ 3908 ISPOPMAP(0x00, 0x00), /* 0x0c: */ 3909 ISPOPMAP(0x00, 0x00), /* 0x0d: */ 3910 ISPOPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */ 3911 ISPOPMAP(0x00, 0x00), /* 0x0f: */ 3912 ISPOPMAP(0x1f, 0x1f), /* 0x10: MBOX_INIT_REQ_QUEUE */ 3913 ISPOPMAP(0x3f, 0x3f), /* 0x11: MBOX_INIT_RES_QUEUE */ 3914 ISPOPMAP(0x0f, 0x0f), /* 0x12: MBOX_EXECUTE_IOCB */ 3915 ISPOPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */ 3916 ISPOPMAP(0x01, 0x3f), /* 0x14: MBOX_STOP_FIRMWARE */ 3917 ISPOPMAP(0x0f, 0x0f), /* 0x15: MBOX_ABORT */ 3918 ISPOPMAP(0x03, 0x03), /* 0x16: MBOX_ABORT_DEVICE */ 3919 ISPOPMAP(0x07, 0x07), /* 0x17: MBOX_ABORT_TARGET */ 3920 ISPOPMAP(0x07, 0x07), /* 0x18: MBOX_BUS_RESET */ 3921 ISPOPMAP(0x03, 0x07), /* 0x19: MBOX_STOP_QUEUE */ 3922 ISPOPMAP(0x03, 0x07), /* 0x1a: MBOX_START_QUEUE */ 3923 ISPOPMAP(0x03, 0x07), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */ 3924 ISPOPMAP(0x03, 0x07), /* 0x1c: MBOX_ABORT_QUEUE */ 3925 ISPOPMAP(0x03, 0x4f), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */ 3926 ISPOPMAP(0x00, 0x00), /* 0x1e: */ 3927 ISPOPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */ 3928 ISPOPMAP(0x01, 0x07), /* 0x20: MBOX_GET_INIT_SCSI_ID */ 3929 ISPOPMAP(0x01, 0x07), /* 0x21: MBOX_GET_SELECT_TIMEOUT */ 3930 ISPOPMAP(0x01, 0xc7), /* 0x22: MBOX_GET_RETRY_COUNT */ 3931 ISPOPMAP(0x01, 0x07), /* 0x23: MBOX_GET_TAG_AGE_LIMIT */ 3932 ISPOPMAP(0x01, 0x03), /* 0x24: MBOX_GET_CLOCK_RATE */ 3933 ISPOPMAP(0x01, 0x07), /* 0x25: MBOX_GET_ACT_NEG_STATE */ 3934 ISPOPMAP(0x01, 0x07), /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */ 3935 ISPOPMAP(0x01, 0x07), /* 0x27: MBOX_GET_PCI_PARAMS */ 3936 ISPOPMAP(0x03, 0x4f), /* 0x28: MBOX_GET_TARGET_PARAMS */ 3937 ISPOPMAP(0x03, 0x0f), /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */ 3938 ISPOPMAP(0x01, 0x07), /* 0x2a: MBOX_GET_RESET_DELAY_PARAMS */ 3939 ISPOPMAP(0x00, 0x00), /* 0x2b: */ 3940 ISPOPMAP(0x00, 0x00), /* 0x2c: */ 3941 ISPOPMAP(0x00, 0x00), /* 0x2d: */ 3942 ISPOPMAP(0x00, 0x00), /* 0x2e: */ 3943 ISPOPMAP(0x00, 0x00), /* 0x2f: */ 3944 ISPOPMAP(0x03, 0x03), /* 0x30: MBOX_SET_INIT_SCSI_ID */ 3945 ISPOPMAP(0x07, 0x07), /* 0x31: MBOX_SET_SELECT_TIMEOUT */ 3946 ISPOPMAP(0xc7, 0xc7), /* 0x32: MBOX_SET_RETRY_COUNT */ 3947 ISPOPMAP(0x07, 0x07), /* 0x33: MBOX_SET_TAG_AGE_LIMIT */ 3948 ISPOPMAP(0x03, 0x03), /* 0x34: MBOX_SET_CLOCK_RATE */ 3949 ISPOPMAP(0x07, 0x07), /* 0x35: MBOX_SET_ACT_NEG_STATE */ 3950 ISPOPMAP(0x07, 0x07), /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */ 3951 ISPOPMAP(0x07, 0x07), /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */ 3952 ISPOPMAP(0x4f, 0x4f), /* 0x38: MBOX_SET_TARGET_PARAMS */ 3953 ISPOPMAP(0x0f, 0x0f), /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */ 3954 ISPOPMAP(0x07, 0x07), /* 0x3a: MBOX_SET_RESET_DELAY_PARAMS */ 3955 ISPOPMAP(0x00, 0x00), /* 0x3b: */ 3956 ISPOPMAP(0x00, 0x00), /* 0x3c: */ 3957 ISPOPMAP(0x00, 0x00), /* 0x3d: */ 3958 ISPOPMAP(0x00, 0x00), /* 0x3e: */ 3959 ISPOPMAP(0x00, 0x00), /* 0x3f: */ 3960 ISPOPMAP(0x01, 0x03), /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */ 3961 ISPOPMAP(0x3f, 0x01), /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */ 3962 ISPOPMAP(0x03, 0x07), /* 0x42: MBOX_EXEC_BIOS_IOCB */ 3963 ISPOPMAP(0x00, 0x00), /* 0x43: */ 3964 ISPOPMAP(0x00, 0x00), /* 0x44: */ 3965 ISPOPMAP(0x03, 0x03), /* 0x45: SET SYSTEM PARAMETER */ 3966 ISPOPMAP(0x01, 0x03), /* 0x46: GET SYSTEM PARAMETER */ 3967 ISPOPMAP(0x00, 0x00), /* 0x47: */ 3968 ISPOPMAP(0x01, 0xcf), /* 0x48: GET SCAM CONFIGURATION */ 3969 ISPOPMAP(0xcf, 0xcf), /* 0x49: SET SCAM CONFIGURATION */ 3970 ISPOPMAP(0x03, 0x03), /* 0x4a: MBOX_SET_FIRMWARE_FEATURES */ 3971 ISPOPMAP(0x01, 0x03), /* 0x4b: MBOX_GET_FIRMWARE_FEATURES */ 3972 ISPOPMAP(0x00, 0x00), /* 0x4c: */ 3973 ISPOPMAP(0x00, 0x00), /* 0x4d: */ 3974 ISPOPMAP(0x00, 0x00), /* 0x4e: */ 3975 ISPOPMAP(0x00, 0x00), /* 0x4f: */ 3976 ISPOPMAP(0xdf, 0xdf), /* 0x50: LOAD RAM A64 */ 3977 ISPOPMAP(0xdf, 0xdf), /* 0x51: DUMP RAM A64 */ 3978 ISPOPMAP(0xdf, 0xdf), /* 0x52: INITIALIZE REQUEST QUEUE A64 */ 3979 ISPOPMAP(0xff, 0xff), /* 0x53: INITIALIZE RESPONSE QUEUE A64 */ 3980 ISPOPMAP(0xcf, 0xff), /* 0x54: EXECUTE IOCB A64 */ 3981 ISPOPMAP(0x07, 0x01), /* 0x55: ENABLE TARGET MODE */ 3982 ISPOPMAP(0x03, 0x0f), /* 0x56: GET TARGET STATUS */ 3983 ISPOPMAP(0x00, 0x00), /* 0x57: */ 3984 ISPOPMAP(0x00, 0x00), /* 0x58: */ 3985 ISPOPMAP(0x00, 0x00), /* 0x59: */ 3986 ISPOPMAP(0x03, 0x03), /* 0x5a: SET DATA OVERRUN RECOVERY MODE */ 3987 ISPOPMAP(0x01, 0x03), /* 0x5b: GET DATA OVERRUN RECOVERY MODE */ 3988 ISPOPMAP(0x0f, 0x0f), /* 0x5c: SET HOST DATA */ 3989 ISPOPMAP(0x01, 0x01) /* 0x5d: GET NOST DATA */ 3990 }; 3991 3992 #ifndef ISP_STRIPPED 3993 static char *scsi_mbcmd_names[] = { 3994 "NO-OP", 3995 "LOAD RAM", 3996 "EXEC FIRMWARE", 3997 "DUMP RAM", 3998 "WRITE RAM WORD", 3999 "READ RAM WORD", 4000 "MAILBOX REG TEST", 4001 "VERIFY CHECKSUM", 4002 "ABOUT FIRMWARE", 4003 NULL, 4004 NULL, 4005 NULL, 4006 NULL, 4007 NULL, 4008 "CHECK FIRMWARE", 4009 NULL, 4010 "INIT REQUEST QUEUE", 4011 "INIT RESULT QUEUE", 4012 "EXECUTE IOCB", 4013 "WAKE UP", 4014 "STOP FIRMWARE", 4015 "ABORT", 4016 "ABORT DEVICE", 4017 "ABORT TARGET", 4018 "BUS RESET", 4019 "STOP QUEUE", 4020 "START QUEUE", 4021 "SINGLE STEP QUEUE", 4022 "ABORT QUEUE", 4023 "GET DEV QUEUE STATUS", 4024 NULL, 4025 "GET FIRMWARE STATUS", 4026 "GET INIT SCSI ID", 4027 "GET SELECT TIMEOUT", 4028 "GET RETRY COUNT", 4029 "GET TAG AGE LIMIT", 4030 "GET CLOCK RATE", 4031 "GET ACT NEG STATE", 4032 "GET ASYNC DATA SETUP TIME", 4033 "GET PCI PARAMS", 4034 "GET TARGET PARAMS", 4035 "GET DEV QUEUE PARAMS", 4036 "GET RESET DELAY PARAMS", 4037 NULL, 4038 NULL, 4039 NULL, 4040 NULL, 4041 NULL, 4042 "SET INIT SCSI ID", 4043 "SET SELECT TIMEOUT", 4044 "SET RETRY COUNT", 4045 "SET TAG AGE LIMIT", 4046 "SET CLOCK RATE", 4047 "SET ACT NEG STATE", 4048 "SET ASYNC DATA SETUP TIME", 4049 "SET PCI CONTROL PARAMS", 4050 "SET TARGET PARAMS", 4051 "SET DEV QUEUE PARAMS", 4052 "SET RESET DELAY PARAMS", 4053 NULL, 4054 NULL, 4055 NULL, 4056 NULL, 4057 NULL, 4058 "RETURN BIOS BLOCK ADDR", 4059 "WRITE FOUR RAM WORDS", 4060 "EXEC BIOS IOCB", 4061 NULL, 4062 NULL, 4063 "SET SYSTEM PARAMETER", 4064 "GET SYSTEM PARAMETER", 4065 NULL, 4066 "GET SCAM CONFIGURATION", 4067 "SET SCAM CONFIGURATION", 4068 "SET FIRMWARE FEATURES", 4069 "GET FIRMWARE FEATURES", 4070 NULL, 4071 NULL, 4072 NULL, 4073 NULL, 4074 "LOAD RAM A64", 4075 "DUMP RAM A64", 4076 "INITIALIZE REQUEST QUEUE A64", 4077 "INITIALIZE RESPONSE QUEUE A64", 4078 "EXECUTE IOCB A64", 4079 "ENABLE TARGET MODE", 4080 "GET TARGET MODE STATE", 4081 NULL, 4082 NULL, 4083 NULL, 4084 "SET DATA OVERRUN RECOVERY MODE", 4085 "GET DATA OVERRUN RECOVERY MODE", 4086 "SET HOST DATA", 4087 "GET NOST DATA", 4088 }; 4089 #endif 4090 4091 static u_int16_t mbpfc[] = { 4092 ISPOPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */ 4093 ISPOPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */ 4094 ISPOPMAP(0x03, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */ 4095 ISPOPMAP(0xdf, 0x01), /* 0x03: MBOX_DUMP_RAM */ 4096 ISPOPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */ 4097 ISPOPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */ 4098 ISPOPMAP(0xff, 0xff), /* 0x06: MBOX_MAILBOX_REG_TEST */ 4099 ISPOPMAP(0x03, 0x05), /* 0x07: MBOX_VERIFY_CHECKSUM */ 4100 ISPOPMAP(0x01, 0x0f), /* 0x08: MBOX_ABOUT_FIRMWARE */ 4101 ISPOPMAP(0xdf, 0x01), /* 0x09: LOAD RAM */ 4102 ISPOPMAP(0xdf, 0x01), /* 0x0a: DUMP RAM */ 4103 ISPOPMAP(0x00, 0x00), /* 0x0b: */ 4104 ISPOPMAP(0x00, 0x00), /* 0x0c: */ 4105 ISPOPMAP(0x00, 0x00), /* 0x0d: */ 4106 ISPOPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */ 4107 ISPOPMAP(0x00, 0x00), /* 0x0f: */ 4108 ISPOPMAP(0x1f, 0x11), /* 0x10: MBOX_INIT_REQ_QUEUE */ 4109 ISPOPMAP(0x2f, 0x21), /* 0x11: MBOX_INIT_RES_QUEUE */ 4110 ISPOPMAP(0x0f, 0x01), /* 0x12: MBOX_EXECUTE_IOCB */ 4111 ISPOPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */ 4112 ISPOPMAP(0x01, 0xff), /* 0x14: MBOX_STOP_FIRMWARE */ 4113 ISPOPMAP(0x4f, 0x01), /* 0x15: MBOX_ABORT */ 4114 ISPOPMAP(0x07, 0x01), /* 0x16: MBOX_ABORT_DEVICE */ 4115 ISPOPMAP(0x07, 0x01), /* 0x17: MBOX_ABORT_TARGET */ 4116 ISPOPMAP(0x03, 0x03), /* 0x18: MBOX_BUS_RESET */ 4117 ISPOPMAP(0x07, 0x05), /* 0x19: MBOX_STOP_QUEUE */ 4118 ISPOPMAP(0x07, 0x05), /* 0x1a: MBOX_START_QUEUE */ 4119 ISPOPMAP(0x07, 0x05), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */ 4120 ISPOPMAP(0x07, 0x05), /* 0x1c: MBOX_ABORT_QUEUE */ 4121 ISPOPMAP(0x07, 0x03), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */ 4122 ISPOPMAP(0x00, 0x00), /* 0x1e: */ 4123 ISPOPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */ 4124 ISPOPMAP(0x01, 0x4f), /* 0x20: MBOX_GET_LOOP_ID */ 4125 ISPOPMAP(0x00, 0x00), /* 0x21: */ 4126 ISPOPMAP(0x01, 0x07), /* 0x22: MBOX_GET_RETRY_COUNT */ 4127 ISPOPMAP(0x00, 0x00), /* 0x23: */ 4128 ISPOPMAP(0x00, 0x00), /* 0x24: */ 4129 ISPOPMAP(0x00, 0x00), /* 0x25: */ 4130 ISPOPMAP(0x00, 0x00), /* 0x26: */ 4131 ISPOPMAP(0x00, 0x00), /* 0x27: */ 4132 ISPOPMAP(0x0f, 0x1), /* 0x28: MBOX_GET_FIRMWARE_OPTIONS */ 4133 ISPOPMAP(0x03, 0x07), /* 0x29: MBOX_GET_PORT_QUEUE_PARAMS */ 4134 ISPOPMAP(0x00, 0x00), /* 0x2a: */ 4135 ISPOPMAP(0x00, 0x00), /* 0x2b: */ 4136 ISPOPMAP(0x00, 0x00), /* 0x2c: */ 4137 ISPOPMAP(0x00, 0x00), /* 0x2d: */ 4138 ISPOPMAP(0x00, 0x00), /* 0x2e: */ 4139 ISPOPMAP(0x00, 0x00), /* 0x2f: */ 4140 ISPOPMAP(0x00, 0x00), /* 0x30: */ 4141 ISPOPMAP(0x00, 0x00), /* 0x31: */ 4142 ISPOPMAP(0x07, 0x07), /* 0x32: MBOX_SET_RETRY_COUNT */ 4143 ISPOPMAP(0x00, 0x00), /* 0x33: */ 4144 ISPOPMAP(0x00, 0x00), /* 0x34: */ 4145 ISPOPMAP(0x00, 0x00), /* 0x35: */ 4146 ISPOPMAP(0x00, 0x00), /* 0x36: */ 4147 ISPOPMAP(0x00, 0x00), /* 0x37: */ 4148 ISPOPMAP(0x0f, 0x01), /* 0x38: MBOX_SET_FIRMWARE_OPTIONS */ 4149 ISPOPMAP(0x0f, 0x07), /* 0x39: MBOX_SET_PORT_QUEUE_PARAMS */ 4150 ISPOPMAP(0x00, 0x00), /* 0x3a: */ 4151 ISPOPMAP(0x00, 0x00), /* 0x3b: */ 4152 ISPOPMAP(0x00, 0x00), /* 0x3c: */ 4153 ISPOPMAP(0x00, 0x00), /* 0x3d: */ 4154 ISPOPMAP(0x00, 0x00), /* 0x3e: */ 4155 ISPOPMAP(0x00, 0x00), /* 0x3f: */ 4156 ISPOPMAP(0x03, 0x01), /* 0x40: MBOX_LOOP_PORT_BYPASS */ 4157 ISPOPMAP(0x03, 0x01), /* 0x41: MBOX_LOOP_PORT_ENABLE */ 4158 ISPOPMAP(0x03, 0x07), /* 0x42: MBOX_GET_RESOURCE_COUNTS */ 4159 ISPOPMAP(0x01, 0x01), /* 0x43: MBOX_REQUEST_NON_PARTICIPATING_MODE */ 4160 ISPOPMAP(0x00, 0x00), /* 0x44: */ 4161 ISPOPMAP(0x00, 0x00), /* 0x45: */ 4162 ISPOPMAP(0x00, 0x00), /* 0x46: */ 4163 ISPOPMAP(0xcf, 0x03), /* 0x47: GET PORT_DATABASE ENHANCED */ 4164 ISPOPMAP(0x00, 0x00), /* 0x48: */ 4165 ISPOPMAP(0x00, 0x00), /* 0x49: */ 4166 ISPOPMAP(0x00, 0x00), /* 0x4a: */ 4167 ISPOPMAP(0x00, 0x00), /* 0x4b: */ 4168 ISPOPMAP(0x00, 0x00), /* 0x4c: */ 4169 ISPOPMAP(0x00, 0x00), /* 0x4d: */ 4170 ISPOPMAP(0x00, 0x00), /* 0x4e: */ 4171 ISPOPMAP(0x00, 0x00), /* 0x4f: */ 4172 ISPOPMAP(0x00, 0x00), /* 0x50: */ 4173 ISPOPMAP(0x00, 0x00), /* 0x51: */ 4174 ISPOPMAP(0x00, 0x00), /* 0x52: */ 4175 ISPOPMAP(0x00, 0x00), /* 0x53: */ 4176 ISPOPMAP(0xcf, 0x01), /* 0x54: EXECUTE IOCB A64 */ 4177 ISPOPMAP(0x00, 0x00), /* 0x55: */ 4178 ISPOPMAP(0x00, 0x00), /* 0x56: */ 4179 ISPOPMAP(0x00, 0x00), /* 0x57: */ 4180 ISPOPMAP(0x00, 0x00), /* 0x58: */ 4181 ISPOPMAP(0x00, 0x00), /* 0x59: */ 4182 ISPOPMAP(0x00, 0x00), /* 0x5a: */ 4183 ISPOPMAP(0x00, 0x00), /* 0x5b: */ 4184 ISPOPMAP(0x00, 0x00), /* 0x5c: */ 4185 ISPOPMAP(0x00, 0x00), /* 0x5d: */ 4186 ISPOPMAP(0x00, 0x00), /* 0x5e: */ 4187 ISPOPMAP(0x00, 0x00), /* 0x5f: */ 4188 ISPOPMAP(0xfd, 0x31), /* 0x60: MBOX_INIT_FIRMWARE */ 4189 ISPOPMAP(0x00, 0x00), /* 0x61: */ 4190 ISPOPMAP(0x01, 0x01), /* 0x62: MBOX_INIT_LIP */ 4191 ISPOPMAP(0xcd, 0x03), /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */ 4192 ISPOPMAP(0xcf, 0x01), /* 0x64: MBOX_GET_PORT_DB */ 4193 ISPOPMAP(0x07, 0x01), /* 0x65: MBOX_CLEAR_ACA */ 4194 ISPOPMAP(0x07, 0x01), /* 0x66: MBOX_TARGET_RESET */ 4195 ISPOPMAP(0x07, 0x01), /* 0x67: MBOX_CLEAR_TASK_SET */ 4196 ISPOPMAP(0x07, 0x01), /* 0x68: MBOX_ABORT_TASK_SET */ 4197 ISPOPMAP(0x01, 0x07), /* 0x69: MBOX_GET_FW_STATE */ 4198 ISPOPMAP(0x03, 0xcf), /* 0x6a: MBOX_GET_PORT_NAME */ 4199 ISPOPMAP(0xcf, 0x01), /* 0x6b: MBOX_GET_LINK_STATUS */ 4200 ISPOPMAP(0x0f, 0x01), /* 0x6c: MBOX_INIT_LIP_RESET */ 4201 ISPOPMAP(0x00, 0x00), /* 0x6d: */ 4202 ISPOPMAP(0xcf, 0x03), /* 0x6e: MBOX_SEND_SNS */ 4203 ISPOPMAP(0x0f, 0x07), /* 0x6f: MBOX_FABRIC_LOGIN */ 4204 ISPOPMAP(0x03, 0x01), /* 0x70: MBOX_SEND_CHANGE_REQUEST */ 4205 ISPOPMAP(0x03, 0x03), /* 0x71: MBOX_FABRIC_LOGOUT */ 4206 ISPOPMAP(0x0f, 0x0f), /* 0x72: MBOX_INIT_LIP_LOGIN */ 4207 ISPOPMAP(0x00, 0x00), /* 0x73: */ 4208 ISPOPMAP(0x07, 0x01), /* 0x74: LOGIN LOOP PORT */ 4209 ISPOPMAP(0xcf, 0x03), /* 0x75: GET PORT/NODE NAME LIST */ 4210 ISPOPMAP(0x4f, 0x01), /* 0x76: SET VENDOR ID */ 4211 ISPOPMAP(0xcd, 0x01), /* 0x77: INITIALIZE IP MAILBOX */ 4212 ISPOPMAP(0x00, 0x00), /* 0x78: */ 4213 ISPOPMAP(0x00, 0x00), /* 0x79: */ 4214 ISPOPMAP(0x00, 0x00), /* 0x7a: */ 4215 ISPOPMAP(0x00, 0x00), /* 0x7b: */ 4216 ISPOPMAP(0x4f, 0x03), /* 0x7c: Get ID List */ 4217 ISPOPMAP(0xcf, 0x01), /* 0x7d: SEND LFA */ 4218 ISPOPMAP(0x07, 0x01) /* 0x7e: Lun RESET */ 4219 }; 4220 4221 #ifndef ISP_STRIPPED 4222 static char *fc_mbcmd_names[] = { 4223 "NO-OP", 4224 "LOAD RAM", 4225 "EXEC FIRMWARE", 4226 "DUMP RAM", 4227 "WRITE RAM WORD", 4228 "READ RAM WORD", 4229 "MAILBOX REG TEST", 4230 "VERIFY CHECKSUM", 4231 "ABOUT FIRMWARE", 4232 "LOAD RAM", 4233 "DUMP RAM", 4234 NULL, 4235 NULL, 4236 NULL, 4237 "CHECK FIRMWARE", 4238 NULL, 4239 "INIT REQUEST QUEUE", 4240 "INIT RESULT QUEUE", 4241 "EXECUTE IOCB", 4242 "WAKE UP", 4243 "STOP FIRMWARE", 4244 "ABORT", 4245 "ABORT DEVICE", 4246 "ABORT TARGET", 4247 "BUS RESET", 4248 "STOP QUEUE", 4249 "START QUEUE", 4250 "SINGLE STEP QUEUE", 4251 "ABORT QUEUE", 4252 "GET DEV QUEUE STATUS", 4253 NULL, 4254 "GET FIRMWARE STATUS", 4255 "GET LOOP ID", 4256 NULL, 4257 "GET RETRY COUNT", 4258 NULL, 4259 NULL, 4260 NULL, 4261 NULL, 4262 NULL, 4263 "GET FIRMWARE OPTIONS", 4264 "GET PORT QUEUE PARAMS", 4265 NULL, 4266 NULL, 4267 NULL, 4268 NULL, 4269 NULL, 4270 NULL, 4271 NULL, 4272 NULL, 4273 "SET RETRY COUNT", 4274 NULL, 4275 NULL, 4276 NULL, 4277 NULL, 4278 NULL, 4279 "SET FIRMWARE OPTIONS", 4280 "SET PORT QUEUE PARAMS", 4281 NULL, 4282 NULL, 4283 NULL, 4284 NULL, 4285 NULL, 4286 NULL, 4287 "LOOP PORT BYPASS", 4288 "LOOP PORT ENABLE", 4289 "GET RESOURCE COUNTS", 4290 "REQUEST NON PARTICIPATING MODE", 4291 NULL, 4292 NULL, 4293 NULL, 4294 "GET PORT DATABASE,, ENHANCED", 4295 NULL, 4296 NULL, 4297 NULL, 4298 NULL, 4299 NULL, 4300 NULL, 4301 NULL, 4302 NULL, 4303 NULL, 4304 NULL, 4305 NULL, 4306 NULL, 4307 "EXECUTE IOCB A64", 4308 NULL, 4309 NULL, 4310 NULL, 4311 NULL, 4312 NULL, 4313 NULL, 4314 NULL, 4315 NULL, 4316 NULL, 4317 NULL, 4318 NULL, 4319 "INIT FIRMWARE", 4320 NULL, 4321 "INIT LIP", 4322 "GET FC-AL POSITION MAP", 4323 "GET PORT DATABASE", 4324 "CLEAR ACA", 4325 "TARGET RESET", 4326 "CLEAR TASK SET", 4327 "ABORT TASK SET", 4328 "GET FW STATE", 4329 "GET PORT NAME", 4330 "GET LINK STATUS", 4331 "INIT LIP RESET", 4332 NULL, 4333 "SEND SNS", 4334 "FABRIC LOGIN", 4335 "SEND CHANGE REQUEST", 4336 "FABRIC LOGOUT", 4337 "INIT LIP LOGIN", 4338 NULL, 4339 "LOGIN LOOP PORT", 4340 "GET PORT/NODE NAME LIST", 4341 "SET VENDOR ID", 4342 "INITIALIZE IP MAILBOX", 4343 NULL, 4344 NULL, 4345 NULL, 4346 NULL, 4347 "Get ID List", 4348 "SEND LFA", 4349 "Lun RESET" 4350 }; 4351 #endif 4352 4353 static void 4354 isp_mboxcmd(struct ispsoftc *isp, mbreg_t *mbp, int logmask) 4355 { 4356 char *cname, *xname, tname[16], mname[16]; 4357 unsigned int lim, ibits, obits, box, opcode; 4358 u_int16_t *mcp; 4359 4360 if (IS_FC(isp)) { 4361 mcp = mbpfc; 4362 lim = (sizeof (mbpfc) / sizeof (mbpfc[0])); 4363 } else { 4364 mcp = mbpscsi; 4365 lim = (sizeof (mbpscsi) / sizeof (mbpscsi[0])); 4366 } 4367 4368 if ((opcode = mbp->param[0]) >= lim) { 4369 mbp->param[0] = MBOX_INVALID_COMMAND; 4370 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode); 4371 return; 4372 } 4373 4374 ibits = HIBYT(mcp[opcode]) & NMBOX_BMASK(isp); 4375 obits = LOBYT(mcp[opcode]) & NMBOX_BMASK(isp); 4376 4377 if (ibits == 0 && obits == 0) { 4378 mbp->param[0] = MBOX_COMMAND_PARAM_ERROR; 4379 isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode); 4380 return; 4381 } 4382 4383 /* 4384 * Get exclusive usage of mailbox registers. 4385 */ 4386 MBOX_ACQUIRE(isp); 4387 4388 for (box = 0; box < MAX_MAILBOX; box++) { 4389 if (ibits & (1 << box)) { 4390 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]); 4391 } 4392 isp->isp_mboxtmp[box] = mbp->param[box] = 0; 4393 } 4394 4395 isp->isp_lastmbxcmd = opcode; 4396 4397 /* 4398 * We assume that we can't overwrite a previous command. 4399 */ 4400 isp->isp_mboxbsy = obits; 4401 4402 /* 4403 * Set Host Interrupt condition so that RISC will pick up mailbox regs. 4404 */ 4405 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT); 4406 4407 /* 4408 * While we haven't finished the command, spin our wheels here. 4409 */ 4410 MBOX_WAIT_COMPLETE(isp); 4411 4412 /* 4413 * Copy back output registers. 4414 */ 4415 for (box = 0; box < MAX_MAILBOX; box++) { 4416 if (obits & (1 << box)) { 4417 mbp->param[box] = isp->isp_mboxtmp[box]; 4418 } 4419 } 4420 4421 MBOX_RELEASE(isp); 4422 4423 if (logmask == 0 || opcode == MBOX_EXEC_FIRMWARE) { 4424 return; 4425 } 4426 #ifdef ISP_STRIPPED 4427 cname = NULL; 4428 #else 4429 cname = (IS_FC(isp))? fc_mbcmd_names[opcode] : scsi_mbcmd_names[opcode]; 4430 #endif 4431 if (cname == NULL) { 4432 cname = tname; 4433 SNPRINTF(tname, sizeof tname, "opcode %x", opcode); 4434 } 4435 4436 /* 4437 * Just to be chatty here... 4438 */ 4439 xname = NULL; 4440 switch (mbp->param[0]) { 4441 case MBOX_COMMAND_COMPLETE: 4442 break; 4443 case MBOX_INVALID_COMMAND: 4444 if (logmask & MBLOGMASK(MBOX_COMMAND_COMPLETE)) 4445 xname = "INVALID COMMAND"; 4446 break; 4447 case MBOX_HOST_INTERFACE_ERROR: 4448 if (logmask & MBLOGMASK(MBOX_HOST_INTERFACE_ERROR)) 4449 xname = "HOST INTERFACE ERROR"; 4450 break; 4451 case MBOX_TEST_FAILED: 4452 if (logmask & MBLOGMASK(MBOX_TEST_FAILED)) 4453 xname = "TEST FAILED"; 4454 break; 4455 case MBOX_COMMAND_ERROR: 4456 if (logmask & MBLOGMASK(MBOX_COMMAND_ERROR)) 4457 xname = "COMMAND ERROR"; 4458 break; 4459 case MBOX_COMMAND_PARAM_ERROR: 4460 if (logmask & MBLOGMASK(MBOX_COMMAND_PARAM_ERROR)) 4461 xname = "COMMAND PARAMETER ERROR"; 4462 break; 4463 case MBOX_LOOP_ID_USED: 4464 if (logmask & MBLOGMASK(MBOX_LOOP_ID_USED)) 4465 xname = "LOOP ID ALREADY IN USE"; 4466 break; 4467 case MBOX_PORT_ID_USED: 4468 if (logmask & MBLOGMASK(MBOX_PORT_ID_USED)) 4469 xname = "PORT ID ALREADY IN USE"; 4470 break; 4471 case MBOX_ALL_IDS_USED: 4472 if (logmask & MBLOGMASK(MBOX_ALL_IDS_USED)) 4473 xname = "ALL LOOP IDS IN USE"; 4474 break; 4475 case 0: /* special case */ 4476 xname = "TIMEOUT"; 4477 break; 4478 default: 4479 SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]); 4480 xname = mname; 4481 break; 4482 } 4483 if (xname) 4484 isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s)", 4485 cname, xname); 4486 } 4487 4488 static void 4489 isp_fw_state(struct ispsoftc *isp) 4490 { 4491 if (IS_FC(isp)) { 4492 mbreg_t mbs; 4493 fcparam *fcp = isp->isp_param; 4494 4495 mbs.param[0] = MBOX_GET_FW_STATE; 4496 isp_mboxcmd(isp, &mbs, MBLOGALL); 4497 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { 4498 fcp->isp_fwstate = mbs.param[1]; 4499 } 4500 } 4501 } 4502 4503 static void 4504 isp_update(struct ispsoftc *isp) 4505 { 4506 int bus, upmask; 4507 4508 for (bus = 0, upmask = isp->isp_update; upmask != 0; bus++) { 4509 if (upmask & (1 << bus)) { 4510 isp_update_bus(isp, bus); 4511 } 4512 upmask &= ~(1 << bus); 4513 } 4514 } 4515 4516 static void 4517 isp_update_bus(struct ispsoftc *isp, int bus) 4518 { 4519 int tgt; 4520 mbreg_t mbs; 4521 sdparam *sdp; 4522 4523 isp->isp_update &= ~(1 << bus); 4524 if (IS_FC(isp)) { 4525 /* 4526 * There are no 'per-bus' settings for Fibre Channel. 4527 */ 4528 return; 4529 } 4530 sdp = isp->isp_param; 4531 sdp += bus; 4532 4533 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 4534 u_int16_t flags, period, offset; 4535 int get; 4536 4537 if (sdp->isp_devparam[tgt].dev_enable == 0) { 4538 sdp->isp_devparam[tgt].dev_update = 0; 4539 sdp->isp_devparam[tgt].dev_refresh = 0; 4540 isp_prt(isp, ISP_LOGDEBUG0, 4541 "skipping target %d bus %d update", tgt, bus); 4542 continue; 4543 } 4544 /* 4545 * If the goal is to update the status of the device, 4546 * take what's in dev_flags and try and set the device 4547 * toward that. Otherwise, if we're just refreshing the 4548 * current device state, get the current parameters. 4549 */ 4550 4551 /* 4552 * Refresh overrides set 4553 */ 4554 if (sdp->isp_devparam[tgt].dev_refresh) { 4555 mbs.param[0] = MBOX_GET_TARGET_PARAMS; 4556 sdp->isp_devparam[tgt].dev_refresh = 0; 4557 get = 1; 4558 } else if (sdp->isp_devparam[tgt].dev_update) { 4559 mbs.param[0] = MBOX_SET_TARGET_PARAMS; 4560 /* 4561 * Make sure dev_flags has "Renegotiate on Error" 4562 * on and "Freeze Queue on Error" off. 4563 */ 4564 sdp->isp_devparam[tgt].dev_flags |= DPARM_RENEG; 4565 sdp->isp_devparam[tgt].dev_flags &= ~DPARM_QFRZ; 4566 4567 mbs.param[2] = sdp->isp_devparam[tgt].dev_flags; 4568 4569 /* 4570 * Insist that PARITY must be enabled 4571 * if SYNC or WIDE is enabled. 4572 */ 4573 if ((mbs.param[2] & (DPARM_SYNC|DPARM_WIDE)) != 0) { 4574 mbs.param[2] |= DPARM_PARITY; 4575 } 4576 4577 if ((mbs.param[2] & DPARM_SYNC) == 0) { 4578 mbs.param[3] = 0; 4579 } else { 4580 mbs.param[3] = 4581 (sdp->isp_devparam[tgt].sync_offset << 8) | 4582 (sdp->isp_devparam[tgt].sync_period); 4583 } 4584 /* 4585 * A command completion later that has 4586 * RQSTF_NEGOTIATION set canl cause 4587 * the dev_refresh/announce cycle also. 4588 & 4589 * 4590 * Note: It is really important to update our current 4591 * flags with at least the state of TAG capabilities- 4592 * otherwise we might try and send a tagged command 4593 * when we have it all turned off. So change it here 4594 * to say that current already matches goal. 4595 */ 4596 sdp->isp_devparam[tgt].cur_dflags &= ~DPARM_TQING; 4597 sdp->isp_devparam[tgt].cur_dflags |= 4598 (sdp->isp_devparam[tgt].dev_flags & DPARM_TQING); 4599 isp_prt(isp, ISP_LOGDEBUG0, 4600 "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x", 4601 bus, tgt, mbs.param[2], mbs.param[3] >> 8, 4602 mbs.param[3] & 0xff); 4603 sdp->isp_devparam[tgt].dev_update = 0; 4604 sdp->isp_devparam[tgt].dev_refresh = 1; 4605 get = 0; 4606 } else { 4607 continue; 4608 } 4609 mbs.param[1] = (bus << 15) | (tgt << 8); 4610 isp_mboxcmd(isp, &mbs, MBLOGALL); 4611 if (get == 0) { 4612 isp->isp_sendmarker |= (1 << bus); 4613 continue; 4614 } 4615 flags = mbs.param[2]; 4616 period = mbs.param[3] & 0xff; 4617 offset = mbs.param[3] >> 8; 4618 sdp->isp_devparam[tgt].cur_dflags = flags; 4619 sdp->isp_devparam[tgt].cur_period = period; 4620 sdp->isp_devparam[tgt].cur_offset = offset; 4621 get = (bus << 16) | tgt; 4622 (void) isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, &get); 4623 } 4624 4625 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 4626 if (sdp->isp_devparam[tgt].dev_update || 4627 sdp->isp_devparam[tgt].dev_refresh) { 4628 isp->isp_update |= (1 << bus); 4629 break; 4630 } 4631 } 4632 } 4633 4634 static void 4635 isp_setdfltparm(struct ispsoftc *isp, int channel) 4636 { 4637 int tgt; 4638 mbreg_t mbs; 4639 sdparam *sdp; 4640 4641 if (IS_FC(isp)) { 4642 fcparam *fcp = (fcparam *) isp->isp_param; 4643 int nvfail; 4644 4645 fcp += channel; 4646 if (fcp->isp_gotdparms) { 4647 return; 4648 } 4649 fcp->isp_gotdparms = 1; 4650 fcp->isp_maxfrmlen = ICB_DFLT_FRMLEN; 4651 fcp->isp_maxalloc = ICB_DFLT_ALLOC; 4652 fcp->isp_execthrottle = ISP_EXEC_THROTTLE; 4653 fcp->isp_retry_delay = ICB_DFLT_RDELAY; 4654 fcp->isp_retry_count = ICB_DFLT_RCOUNT; 4655 /* Platform specific.... */ 4656 fcp->isp_loopid = DEFAULT_LOOPID(isp); 4657 fcp->isp_nodewwn = DEFAULT_NODEWWN(isp); 4658 fcp->isp_portwwn = DEFAULT_PORTWWN(isp); 4659 fcp->isp_fwoptions = 0; 4660 fcp->isp_fwoptions |= ICBOPT_FAIRNESS; 4661 fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE; 4662 fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS; 4663 #ifndef ISP_NO_FASTPOST_FC 4664 fcp->isp_fwoptions |= ICBOPT_FAST_POST; 4665 #endif 4666 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX) 4667 fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX; 4668 4669 /* 4670 * Make sure this is turned off now until we get 4671 * extended options from NVRAM 4672 */ 4673 fcp->isp_fwoptions &= ~ICBOPT_EXTENDED; 4674 4675 /* 4676 * Now try and read NVRAM unless told to not do so. 4677 * This will set fcparam's isp_nodewwn && isp_portwwn. 4678 */ 4679 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) { 4680 nvfail = isp_read_nvram(isp); 4681 if (nvfail) 4682 isp->isp_confopts |= ISP_CFG_NONVRAM; 4683 } else { 4684 nvfail = 1; 4685 } 4686 /* 4687 * Set node && port to override platform set defaults 4688 * unless the nvram read failed (or none was done), 4689 * or the platform code wants to use what had been 4690 * set in the defaults. 4691 */ 4692 if (nvfail || (isp->isp_confopts & ISP_CFG_OWNWWN)) { 4693 isp_prt(isp, ISP_LOGCONFIG, 4694 "Using Node WWN 0x%08x%08x, Port WWN 0x%08x%08x", 4695 (u_int32_t) (DEFAULT_NODEWWN(isp) >> 32), 4696 (u_int32_t) (DEFAULT_NODEWWN(isp) & 0xffffffff), 4697 (u_int32_t) (DEFAULT_PORTWWN(isp) >> 32), 4698 (u_int32_t) (DEFAULT_PORTWWN(isp) & 0xffffffff)); 4699 isp->isp_confopts |= ISP_CFG_OWNWWN; 4700 ISP_NODEWWN(isp) = DEFAULT_NODEWWN(isp); 4701 ISP_PORTWWN(isp) = DEFAULT_PORTWWN(isp); 4702 } else { 4703 /* 4704 * We always start out with values derived 4705 * from NVRAM or our platform default. 4706 */ 4707 ISP_NODEWWN(isp) = fcp->isp_nodewwn; 4708 ISP_PORTWWN(isp) = fcp->isp_portwwn; 4709 } 4710 return; 4711 } 4712 4713 sdp = (sdparam *) isp->isp_param; 4714 sdp += channel; 4715 4716 /* 4717 * Been there, done that, got the T-shirt... 4718 */ 4719 if (sdp->isp_gotdparms) { 4720 return; 4721 } 4722 sdp->isp_gotdparms = 1; 4723 4724 /* 4725 * Establish some default parameters. 4726 */ 4727 sdp->isp_cmd_dma_burst_enable = 1; 4728 sdp->isp_data_dma_burst_enabl = 1; 4729 sdp->isp_fifo_threshold = 0; 4730 sdp->isp_initiator_id = DEFAULT_IID(isp); 4731 if (isp->isp_type >= ISP_HA_SCSI_1040) { 4732 sdp->isp_async_data_setup = 9; 4733 } else { 4734 sdp->isp_async_data_setup = 6; 4735 } 4736 sdp->isp_selection_timeout = 250; 4737 sdp->isp_max_queue_depth = MAXISPREQUEST(isp); 4738 sdp->isp_tag_aging = 8; 4739 sdp->isp_bus_reset_delay = 3; 4740 sdp->isp_retry_count = 2; 4741 sdp->isp_retry_delay = 2; 4742 4743 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 4744 sdp->isp_devparam[tgt].exc_throttle = ISP_EXEC_THROTTLE; 4745 sdp->isp_devparam[tgt].dev_enable = 1; 4746 } 4747 4748 /* 4749 * If we've not been told to avoid reading NVRAM, try and read it. 4750 * If we're successful reading it, we can return since NVRAM will 4751 * tell us the right thing to do. Otherwise, establish some reasonable 4752 * defaults. 4753 */ 4754 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) { 4755 if (isp_read_nvram(isp) == 0) { 4756 return; 4757 } 4758 } 4759 4760 /* 4761 * Now try and see whether we have specific values for them. 4762 */ 4763 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) { 4764 mbs.param[0] = MBOX_GET_ACT_NEG_STATE; 4765 isp_mboxcmd(isp, &mbs, MBLOGNONE); 4766 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 4767 sdp->isp_req_ack_active_neg = 1; 4768 sdp->isp_data_line_active_neg = 1; 4769 } else { 4770 sdp->isp_req_ack_active_neg = 4771 (mbs.param[1+channel] >> 4) & 0x1; 4772 sdp->isp_data_line_active_neg = 4773 (mbs.param[1+channel] >> 5) & 0x1; 4774 } 4775 } 4776 4777 isp_prt(isp, ISP_LOGDEBUG0, 4778 "defaulting bus %d REQ/ACK Active Negation is %d", 4779 channel, sdp->isp_req_ack_active_neg); 4780 isp_prt(isp, ISP_LOGDEBUG0, 4781 "defaulting bus %d DATA Active Negation is %d", 4782 channel, sdp->isp_data_line_active_neg); 4783 4784 /* 4785 * The trick here is to establish a default for the default (honk!) 4786 * state (dev_flags). Then try and get the current status from 4787 * the card to fill in the current state. We don't, in fact, set 4788 * the default to the SAFE default state- that's not the goal state. 4789 */ 4790 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 4791 sdp->isp_devparam[tgt].cur_offset = 0; 4792 sdp->isp_devparam[tgt].cur_period = 0; 4793 sdp->isp_devparam[tgt].dev_flags = DPARM_DEFAULT; 4794 sdp->isp_devparam[tgt].cur_dflags = 0; 4795 /* 4796 * We default to Wide/Fast for versions less than a 1040 4797 * (unless it's SBus). 4798 */ 4799 if ((isp->isp_bustype == ISP_BT_SBUS && 4800 isp->isp_type < ISP_HA_SCSI_1020A) || 4801 (isp->isp_bustype == ISP_BT_PCI && 4802 isp->isp_type < ISP_HA_SCSI_1040) || 4803 (isp->isp_clock && isp->isp_clock < 60) || 4804 (sdp->isp_ultramode == 0)) { 4805 sdp->isp_devparam[tgt].sync_offset = 4806 ISP_10M_SYNCPARMS >> 8; 4807 sdp->isp_devparam[tgt].sync_period = 4808 ISP_10M_SYNCPARMS & 0xff; 4809 } else if (IS_ULTRA3(isp)) { 4810 sdp->isp_devparam[tgt].sync_offset = 4811 ISP_80M_SYNCPARMS >> 8; 4812 sdp->isp_devparam[tgt].sync_period = 4813 ISP_80M_SYNCPARMS & 0xff; 4814 } else if (IS_ULTRA2(isp)) { 4815 sdp->isp_devparam[tgt].sync_offset = 4816 ISP_40M_SYNCPARMS >> 8; 4817 sdp->isp_devparam[tgt].sync_period = 4818 ISP_40M_SYNCPARMS & 0xff; 4819 } else if (IS_1240(isp)) { 4820 sdp->isp_devparam[tgt].sync_offset = 4821 ISP_20M_SYNCPARMS >> 8; 4822 sdp->isp_devparam[tgt].sync_period = 4823 ISP_20M_SYNCPARMS & 0xff; 4824 } else { 4825 sdp->isp_devparam[tgt].sync_offset = 4826 ISP_20M_SYNCPARMS_1040 >> 8; 4827 sdp->isp_devparam[tgt].sync_period = 4828 ISP_20M_SYNCPARMS_1040 & 0xff; 4829 } 4830 4831 /* 4832 * Don't get current target parameters if we've been 4833 * told not to use NVRAM- it's really the same thing. 4834 */ 4835 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) { 4836 4837 mbs.param[0] = MBOX_GET_TARGET_PARAMS; 4838 mbs.param[1] = tgt << 8; 4839 isp_mboxcmd(isp, &mbs, MBLOGALL); 4840 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 4841 continue; 4842 } 4843 sdp->isp_devparam[tgt].cur_dflags = mbs.param[2]; 4844 sdp->isp_devparam[tgt].dev_flags = mbs.param[2]; 4845 sdp->isp_devparam[tgt].cur_period = mbs.param[3] & 0xff; 4846 sdp->isp_devparam[tgt].cur_offset = mbs.param[3] >> 8; 4847 4848 /* 4849 * The maximum period we can really see 4850 * here is 100 (decimal), or 400 ns. 4851 * For some unknown reason we sometimes 4852 * get back wildass numbers from the 4853 * boot device's parameters (alpha only). 4854 */ 4855 if ((mbs.param[3] & 0xff) <= 0x64) { 4856 sdp->isp_devparam[tgt].sync_period = 4857 mbs.param[3] & 0xff; 4858 sdp->isp_devparam[tgt].sync_offset = 4859 mbs.param[3] >> 8; 4860 } 4861 4862 /* 4863 * It is not safe to run Ultra Mode with a clock < 60. 4864 */ 4865 if (((isp->isp_clock && isp->isp_clock < 60) || 4866 (isp->isp_type < ISP_HA_SCSI_1020A)) && 4867 (sdp->isp_devparam[tgt].sync_period <= 4868 (ISP_20M_SYNCPARMS & 0xff))) { 4869 sdp->isp_devparam[tgt].sync_offset = 4870 ISP_10M_SYNCPARMS >> 8; 4871 sdp->isp_devparam[tgt].sync_period = 4872 ISP_10M_SYNCPARMS & 0xff; 4873 } 4874 } 4875 isp_prt(isp, ISP_LOGDEBUG0, 4876 "Initial bus %d tgt %d flags %x offset %x period %x", 4877 channel, tgt, sdp->isp_devparam[tgt].dev_flags, 4878 sdp->isp_devparam[tgt].sync_offset, 4879 sdp->isp_devparam[tgt].sync_period); 4880 } 4881 } 4882 4883 /* 4884 * Re-initialize the ISP and complete all orphaned commands 4885 * with a 'botched' notice. The reset/init routines should 4886 * not disturb an already active list of commands. 4887 * 4888 * Locks held prior to coming here. 4889 */ 4890 4891 void 4892 isp_reinit(struct ispsoftc *isp) 4893 { 4894 XS_T *xs; 4895 u_int16_t handle; 4896 4897 isp_reset(isp); 4898 if (isp->isp_state != ISP_RESETSTATE) { 4899 isp_prt(isp, ISP_LOGERR, "isp_reinit cannot reset card"); 4900 goto skip; 4901 } 4902 isp_init(isp); 4903 if (isp->isp_role == ISP_ROLE_NONE) { 4904 goto skip; 4905 } 4906 if (isp->isp_state == ISP_INITSTATE) { 4907 isp->isp_state = ISP_RUNSTATE; 4908 } 4909 if (isp->isp_state != ISP_RUNSTATE) { 4910 isp_prt(isp, ISP_LOGERR, "isp_reinit cannot restart card"); 4911 } 4912 skip: 4913 isp->isp_nactive = 0; 4914 4915 for (handle = 1; (int) handle <= isp->isp_maxcmds; handle++) { 4916 xs = isp_find_xs(isp, handle); 4917 if (xs == NULL) { 4918 continue; 4919 } 4920 isp_destroy_handle(isp, handle); 4921 if (XS_XFRLEN(xs)) { 4922 ISP_DMAFREE(isp, xs, handle); 4923 XS_RESID(xs) = XS_XFRLEN(xs); 4924 } else { 4925 XS_RESID(xs) = 0; 4926 } 4927 XS_SETERR(xs, HBA_BUSRESET); 4928 isp_done(xs); 4929 } 4930 } 4931 4932 /* 4933 * NVRAM Routines 4934 */ 4935 static int 4936 isp_read_nvram(struct ispsoftc *isp) 4937 { 4938 int i, amt; 4939 u_int8_t csum, minversion; 4940 union { 4941 u_int8_t _x[ISP2100_NVRAM_SIZE]; 4942 u_int16_t _s[ISP2100_NVRAM_SIZE>>1]; 4943 } _n; 4944 #define nvram_data _n._x 4945 #define nvram_words _n._s 4946 4947 if (IS_FC(isp)) { 4948 amt = ISP2100_NVRAM_SIZE; 4949 minversion = 1; 4950 } else if (IS_ULTRA2(isp)) { 4951 amt = ISP1080_NVRAM_SIZE; 4952 minversion = 0; 4953 } else { 4954 amt = ISP_NVRAM_SIZE; 4955 minversion = 2; 4956 } 4957 4958 /* 4959 * Just read the first two words first to see if we have a valid 4960 * NVRAM to continue reading the rest with. 4961 */ 4962 for (i = 0; i < 2; i++) { 4963 isp_rdnvram_word(isp, i, &nvram_words[i]); 4964 } 4965 if (nvram_data[0] != 'I' || nvram_data[1] != 'S' || 4966 nvram_data[2] != 'P') { 4967 if (isp->isp_bustype != ISP_BT_SBUS) { 4968 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header"); 4969 isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x", 4970 nvram_data[0], nvram_data[1], nvram_data[2]); 4971 } 4972 return (-1); 4973 } 4974 for (i = 2; i < amt>>1; i++) { 4975 isp_rdnvram_word(isp, i, &nvram_words[i]); 4976 } 4977 for (csum = 0, i = 0; i < amt; i++) { 4978 csum += nvram_data[i]; 4979 } 4980 if (csum != 0) { 4981 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum"); 4982 return (-1); 4983 } 4984 if (ISP_NVRAM_VERSION(nvram_data) < minversion) { 4985 isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood", 4986 ISP_NVRAM_VERSION(nvram_data)); 4987 return (-1); 4988 } 4989 4990 if (IS_ULTRA3(isp)) { 4991 isp_parse_nvram_12160(isp, 0, nvram_data); 4992 isp_parse_nvram_12160(isp, 1, nvram_data); 4993 } else if (IS_1080(isp)) { 4994 isp_parse_nvram_1080(isp, 0, nvram_data); 4995 } else if (IS_1280(isp) || IS_1240(isp)) { 4996 isp_parse_nvram_1080(isp, 0, nvram_data); 4997 isp_parse_nvram_1080(isp, 1, nvram_data); 4998 } else if (IS_SCSI(isp)) { 4999 isp_parse_nvram_1020(isp, nvram_data); 5000 } else { 5001 isp_parse_nvram_2100(isp, nvram_data); 5002 } 5003 return (0); 5004 #undef nvram_data 5005 #undef nvram_words 5006 } 5007 5008 static void 5009 isp_rdnvram_word(struct ispsoftc *isp, int wo, u_int16_t *rp) 5010 { 5011 int i, cbits; 5012 u_int16_t bit, rqst; 5013 5014 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT); 5015 USEC_DELAY(2); 5016 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK); 5017 USEC_DELAY(2); 5018 5019 if (IS_FC(isp)) { 5020 wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1); 5021 rqst = (ISP_NVRAM_READ << 8) | wo; 5022 cbits = 10; 5023 } else if (IS_ULTRA2(isp)) { 5024 wo &= ((ISP1080_NVRAM_SIZE >> 1) - 1); 5025 rqst = (ISP_NVRAM_READ << 8) | wo; 5026 cbits = 10; 5027 } else { 5028 wo &= ((ISP_NVRAM_SIZE >> 1) - 1); 5029 rqst = (ISP_NVRAM_READ << 6) | wo; 5030 cbits = 8; 5031 } 5032 5033 /* 5034 * Clock the word select request out... 5035 */ 5036 for (i = cbits; i >= 0; i--) { 5037 if ((rqst >> i) & 1) { 5038 bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT; 5039 } else { 5040 bit = BIU_NVRAM_SELECT; 5041 } 5042 ISP_WRITE(isp, BIU_NVRAM, bit); 5043 USEC_DELAY(2); 5044 ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK); 5045 USEC_DELAY(2); 5046 ISP_WRITE(isp, BIU_NVRAM, bit); 5047 USEC_DELAY(2); 5048 } 5049 /* 5050 * Now read the result back in (bits come back in MSB format). 5051 */ 5052 *rp = 0; 5053 for (i = 0; i < 16; i++) { 5054 u_int16_t rv; 5055 *rp <<= 1; 5056 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK); 5057 USEC_DELAY(2); 5058 rv = ISP_READ(isp, BIU_NVRAM); 5059 if (rv & BIU_NVRAM_DATAIN) { 5060 *rp |= 1; 5061 } 5062 USEC_DELAY(2); 5063 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT); 5064 USEC_DELAY(2); 5065 } 5066 ISP_WRITE(isp, BIU_NVRAM, 0); 5067 USEC_DELAY(2); 5068 ISP_SWIZZLE_NVRAM_WORD(isp, rp); 5069 } 5070 5071 static void 5072 isp_parse_nvram_1020(struct ispsoftc *isp, u_int8_t *nvram_data) 5073 { 5074 int i; 5075 sdparam *sdp = (sdparam *) isp->isp_param; 5076 5077 sdp->isp_fifo_threshold = 5078 ISP_NVRAM_FIFO_THRESHOLD(nvram_data) | 5079 (ISP_NVRAM_FIFO_THRESHOLD_128(nvram_data) << 2); 5080 5081 sdp->isp_initiator_id = 5082 ISP_NVRAM_INITIATOR_ID(nvram_data); 5083 5084 sdp->isp_bus_reset_delay = 5085 ISP_NVRAM_BUS_RESET_DELAY(nvram_data); 5086 5087 sdp->isp_retry_count = 5088 ISP_NVRAM_BUS_RETRY_COUNT(nvram_data); 5089 5090 sdp->isp_retry_delay = 5091 ISP_NVRAM_BUS_RETRY_DELAY(nvram_data); 5092 5093 sdp->isp_async_data_setup = 5094 ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data); 5095 5096 if (isp->isp_type >= ISP_HA_SCSI_1040) { 5097 if (sdp->isp_async_data_setup < 9) { 5098 sdp->isp_async_data_setup = 9; 5099 } 5100 } else { 5101 if (sdp->isp_async_data_setup != 6) { 5102 sdp->isp_async_data_setup = 6; 5103 } 5104 } 5105 5106 sdp->isp_req_ack_active_neg = 5107 ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data); 5108 5109 sdp->isp_data_line_active_neg = 5110 ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data); 5111 5112 sdp->isp_data_dma_burst_enabl = 5113 ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data); 5114 5115 sdp->isp_cmd_dma_burst_enable = 5116 ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data); 5117 5118 sdp->isp_tag_aging = 5119 ISP_NVRAM_TAG_AGE_LIMIT(nvram_data); 5120 5121 sdp->isp_selection_timeout = 5122 ISP_NVRAM_SELECTION_TIMEOUT(nvram_data); 5123 5124 sdp->isp_max_queue_depth = 5125 ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data); 5126 5127 sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data); 5128 for (i = 0; i < MAX_TARGETS; i++) { 5129 sdp->isp_devparam[i].dev_enable = 5130 ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, i); 5131 sdp->isp_devparam[i].exc_throttle = 5132 ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, i); 5133 sdp->isp_devparam[i].sync_offset = 5134 ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, i); 5135 sdp->isp_devparam[i].sync_period = 5136 ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, i); 5137 5138 if (isp->isp_type < ISP_HA_SCSI_1040) { 5139 /* 5140 * If we're not ultra, we can't possibly 5141 * be a shorter period than this. 5142 */ 5143 if (sdp->isp_devparam[i].sync_period < 0x19) { 5144 sdp->isp_devparam[i].sync_period = 0x19; 5145 } 5146 if (sdp->isp_devparam[i].sync_offset > 0xc) { 5147 sdp->isp_devparam[i].sync_offset = 0x0c; 5148 } 5149 } else { 5150 if (sdp->isp_devparam[i].sync_offset > 0x8) { 5151 sdp->isp_devparam[i].sync_offset = 0x8; 5152 } 5153 } 5154 sdp->isp_devparam[i].dev_flags = 0; 5155 if (ISP_NVRAM_TGT_RENEG(nvram_data, i)) 5156 sdp->isp_devparam[i].dev_flags |= DPARM_RENEG; 5157 sdp->isp_devparam[i].dev_flags |= DPARM_ARQ; 5158 if (ISP_NVRAM_TGT_TQING(nvram_data, i)) 5159 sdp->isp_devparam[i].dev_flags |= DPARM_TQING; 5160 if (ISP_NVRAM_TGT_SYNC(nvram_data, i)) 5161 sdp->isp_devparam[i].dev_flags |= DPARM_SYNC; 5162 if (ISP_NVRAM_TGT_WIDE(nvram_data, i)) 5163 sdp->isp_devparam[i].dev_flags |= DPARM_WIDE; 5164 if (ISP_NVRAM_TGT_PARITY(nvram_data, i)) 5165 sdp->isp_devparam[i].dev_flags |= DPARM_PARITY; 5166 if (ISP_NVRAM_TGT_DISC(nvram_data, i)) 5167 sdp->isp_devparam[i].dev_flags |= DPARM_DISC; 5168 sdp->isp_devparam[i].cur_dflags = 0; /* we don't know */ 5169 } 5170 } 5171 5172 static void 5173 isp_parse_nvram_1080(struct ispsoftc *isp, int bus, u_int8_t *nvram_data) 5174 { 5175 int i; 5176 sdparam *sdp = (sdparam *) isp->isp_param; 5177 sdp += bus; 5178 5179 sdp->isp_fifo_threshold = 5180 ISP1080_NVRAM_FIFO_THRESHOLD(nvram_data); 5181 5182 sdp->isp_initiator_id = 5183 ISP1080_NVRAM_INITIATOR_ID(nvram_data, bus); 5184 5185 sdp->isp_bus_reset_delay = 5186 ISP1080_NVRAM_BUS_RESET_DELAY(nvram_data, bus); 5187 5188 sdp->isp_retry_count = 5189 ISP1080_NVRAM_BUS_RETRY_COUNT(nvram_data, bus); 5190 5191 sdp->isp_retry_delay = 5192 ISP1080_NVRAM_BUS_RETRY_DELAY(nvram_data, bus); 5193 5194 sdp->isp_async_data_setup = 5195 ISP1080_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, 5196 bus); 5197 5198 sdp->isp_req_ack_active_neg = 5199 ISP1080_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, 5200 bus); 5201 5202 sdp->isp_data_line_active_neg = 5203 ISP1080_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, 5204 bus); 5205 5206 sdp->isp_data_dma_burst_enabl = 5207 ISP1080_NVRAM_BURST_ENABLE(nvram_data); 5208 5209 sdp->isp_cmd_dma_burst_enable = 5210 ISP1080_NVRAM_BURST_ENABLE(nvram_data); 5211 5212 sdp->isp_selection_timeout = 5213 ISP1080_NVRAM_SELECTION_TIMEOUT(nvram_data, bus); 5214 5215 sdp->isp_max_queue_depth = 5216 ISP1080_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus); 5217 5218 for (i = 0; i < MAX_TARGETS; i++) { 5219 sdp->isp_devparam[i].dev_enable = 5220 ISP1080_NVRAM_TGT_DEVICE_ENABLE(nvram_data, i, bus); 5221 sdp->isp_devparam[i].exc_throttle = 5222 ISP1080_NVRAM_TGT_EXEC_THROTTLE(nvram_data, i, bus); 5223 sdp->isp_devparam[i].sync_offset = 5224 ISP1080_NVRAM_TGT_SYNC_OFFSET(nvram_data, i, bus); 5225 sdp->isp_devparam[i].sync_period = 5226 ISP1080_NVRAM_TGT_SYNC_PERIOD(nvram_data, i, bus); 5227 sdp->isp_devparam[i].dev_flags = 0; 5228 if (ISP1080_NVRAM_TGT_RENEG(nvram_data, i, bus)) 5229 sdp->isp_devparam[i].dev_flags |= DPARM_RENEG; 5230 sdp->isp_devparam[i].dev_flags |= DPARM_ARQ; 5231 if (ISP1080_NVRAM_TGT_TQING(nvram_data, i, bus)) 5232 sdp->isp_devparam[i].dev_flags |= DPARM_TQING; 5233 if (ISP1080_NVRAM_TGT_SYNC(nvram_data, i, bus)) 5234 sdp->isp_devparam[i].dev_flags |= DPARM_SYNC; 5235 if (ISP1080_NVRAM_TGT_WIDE(nvram_data, i, bus)) 5236 sdp->isp_devparam[i].dev_flags |= DPARM_WIDE; 5237 if (ISP1080_NVRAM_TGT_PARITY(nvram_data, i, bus)) 5238 sdp->isp_devparam[i].dev_flags |= DPARM_PARITY; 5239 if (ISP1080_NVRAM_TGT_DISC(nvram_data, i, bus)) 5240 sdp->isp_devparam[i].dev_flags |= DPARM_DISC; 5241 sdp->isp_devparam[i].cur_dflags = 0; 5242 } 5243 } 5244 5245 static void 5246 isp_parse_nvram_12160(struct ispsoftc *isp, int bus, u_int8_t *nvram_data) 5247 { 5248 sdparam *sdp = (sdparam *) isp->isp_param; 5249 int i; 5250 5251 sdp += bus; 5252 5253 sdp->isp_fifo_threshold = 5254 ISP12160_NVRAM_FIFO_THRESHOLD(nvram_data); 5255 5256 sdp->isp_initiator_id = 5257 ISP12160_NVRAM_INITIATOR_ID(nvram_data, bus); 5258 5259 sdp->isp_bus_reset_delay = 5260 ISP12160_NVRAM_BUS_RESET_DELAY(nvram_data, bus); 5261 5262 sdp->isp_retry_count = 5263 ISP12160_NVRAM_BUS_RETRY_COUNT(nvram_data, bus); 5264 5265 sdp->isp_retry_delay = 5266 ISP12160_NVRAM_BUS_RETRY_DELAY(nvram_data, bus); 5267 5268 sdp->isp_async_data_setup = 5269 ISP12160_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, 5270 bus); 5271 5272 sdp->isp_req_ack_active_neg = 5273 ISP12160_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, 5274 bus); 5275 5276 sdp->isp_data_line_active_neg = 5277 ISP12160_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, 5278 bus); 5279 5280 sdp->isp_data_dma_burst_enabl = 5281 ISP12160_NVRAM_BURST_ENABLE(nvram_data); 5282 5283 sdp->isp_cmd_dma_burst_enable = 5284 ISP12160_NVRAM_BURST_ENABLE(nvram_data); 5285 5286 sdp->isp_selection_timeout = 5287 ISP12160_NVRAM_SELECTION_TIMEOUT(nvram_data, bus); 5288 5289 sdp->isp_max_queue_depth = 5290 ISP12160_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus); 5291 5292 for (i = 0; i < MAX_TARGETS; i++) { 5293 sdp->isp_devparam[i].dev_enable = 5294 ISP12160_NVRAM_TGT_DEVICE_ENABLE(nvram_data, i, bus); 5295 sdp->isp_devparam[i].exc_throttle = 5296 ISP12160_NVRAM_TGT_EXEC_THROTTLE(nvram_data, i, bus); 5297 sdp->isp_devparam[i].sync_offset = 5298 ISP12160_NVRAM_TGT_SYNC_OFFSET(nvram_data, i, bus); 5299 sdp->isp_devparam[i].sync_period = 5300 ISP12160_NVRAM_TGT_SYNC_PERIOD(nvram_data, i, bus); 5301 sdp->isp_devparam[i].dev_flags = 0; 5302 if (ISP12160_NVRAM_TGT_RENEG(nvram_data, i, bus)) 5303 sdp->isp_devparam[i].dev_flags |= DPARM_RENEG; 5304 sdp->isp_devparam[i].dev_flags |= DPARM_ARQ; 5305 if (ISP12160_NVRAM_TGT_TQING(nvram_data, i, bus)) 5306 sdp->isp_devparam[i].dev_flags |= DPARM_TQING; 5307 if (ISP12160_NVRAM_TGT_SYNC(nvram_data, i, bus)) 5308 sdp->isp_devparam[i].dev_flags |= DPARM_SYNC; 5309 if (ISP12160_NVRAM_TGT_WIDE(nvram_data, i, bus)) 5310 sdp->isp_devparam[i].dev_flags |= DPARM_WIDE; 5311 if (ISP12160_NVRAM_TGT_PARITY(nvram_data, i, bus)) 5312 sdp->isp_devparam[i].dev_flags |= DPARM_PARITY; 5313 if (ISP12160_NVRAM_TGT_DISC(nvram_data, i, bus)) 5314 sdp->isp_devparam[i].dev_flags |= DPARM_DISC; 5315 sdp->isp_devparam[i].cur_dflags = 0; 5316 } 5317 } 5318 5319 static void 5320 isp_parse_nvram_2100(struct ispsoftc *isp, u_int8_t *nvram_data) 5321 { 5322 fcparam *fcp = (fcparam *) isp->isp_param; 5323 u_int64_t wwn; 5324 5325 /* 5326 * There is NVRAM storage for both Port and Node entities- 5327 * but the Node entity appears to be unused on all the cards 5328 * I can find. However, we should account for this being set 5329 * at some point in the future. 5330 * 5331 * Qlogic WWNs have an NAA of 2, but usually nothing shows up in 5332 * bits 48..60. In the case of the 2202, it appears that they do 5333 * use bit 48 to distinguish between the two instances on the card. 5334 * The 2204, which I've never seen, *probably* extends this method. 5335 */ 5336 wwn = ISP2100_NVRAM_PORT_NAME(nvram_data); 5337 if (wwn) { 5338 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x", 5339 (u_int32_t) (wwn >> 32), (u_int32_t) (wwn & 0xffffffff)); 5340 if ((wwn >> 60) == 0) { 5341 wwn |= (((u_int64_t) 2)<< 60); 5342 } 5343 } 5344 fcp->isp_portwwn = wwn; 5345 wwn = ISP2100_NVRAM_NODE_NAME(nvram_data); 5346 if (wwn) { 5347 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x", 5348 (u_int32_t) (wwn >> 32), (u_int32_t) (wwn & 0xffffffff)); 5349 if ((wwn >> 60) == 0) { 5350 wwn |= (((u_int64_t) 2)<< 60); 5351 } 5352 } 5353 fcp->isp_nodewwn = wwn; 5354 5355 /* 5356 * Make sure we have both Node and Port as non-zero values. 5357 */ 5358 if (fcp->isp_nodewwn != 0 && fcp->isp_portwwn == 0) { 5359 fcp->isp_portwwn = fcp->isp_nodewwn; 5360 } else if (fcp->isp_nodewwn == 0 && fcp->isp_portwwn != 0) { 5361 fcp->isp_nodewwn = fcp->isp_portwwn; 5362 } 5363 5364 /* 5365 * Make the Node and Port values sane if they're NAA == 2. 5366 * This means to clear bits 48..56 for the Node WWN and 5367 * make sure that there's some non-zero value in 48..56 5368 * for the Port WWN. 5369 */ 5370 if (fcp->isp_nodewwn && fcp->isp_portwwn) { 5371 if ((fcp->isp_nodewwn & (((u_int64_t) 0xfff) << 48)) != 0 && 5372 (fcp->isp_nodewwn >> 60) == 2) { 5373 fcp->isp_nodewwn &= ~((u_int64_t) 0xfff << 48); 5374 } 5375 if ((fcp->isp_portwwn & (((u_int64_t) 0xfff) << 48)) == 0 && 5376 (fcp->isp_portwwn >> 60) == 2) { 5377 fcp->isp_portwwn |= ((u_int64_t) 1 << 56); 5378 } 5379 } 5380 5381 fcp->isp_maxalloc = 5382 ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data); 5383 fcp->isp_maxfrmlen = 5384 ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data); 5385 fcp->isp_retry_delay = 5386 ISP2100_NVRAM_RETRY_DELAY(nvram_data); 5387 fcp->isp_retry_count = 5388 ISP2100_NVRAM_RETRY_COUNT(nvram_data); 5389 fcp->isp_loopid = 5390 ISP2100_NVRAM_HARDLOOPID(nvram_data); 5391 fcp->isp_execthrottle = 5392 ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data); 5393 fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data); 5394 isp_prt(isp, ISP_LOGDEBUG0, 5395 "fwoptions from nvram are 0x%x", fcp->isp_fwoptions); 5396 } 5397
Indexes created Tue Sep 23 14:10:03 GMT 2025