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