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