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