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