isp.c revision 1.26
1 /* $NetBSD: isp.c,v 1.26 1998/09/10 17:10:27 mjacob Exp $ */ 2 /* 3 * Machine and OS Independent (well, as best as possible) 4 * code for the Qlogic ISP SCSI adapters. 5 * 6 *--------------------------------------- 7 * Copyright (c) 1997, 1998 by Matthew Jacob 8 * NASA/Ames Research Center 9 * All rights reserved. 10 *--------------------------------------- 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice immediately at the beginning of the file, without modification, 17 * this list of conditions, and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. The name of the author may not be used to endorse or promote products 22 * derived from this software without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 28 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 */ 36 37 /* 38 * Inspiration and ideas about this driver are from Erik Moe's Linux driver 39 * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some 40 * ideas dredged from the Solaris driver. 41 */ 42 43 /* 44 * Include header file appropriate for platform we're building on. 45 */ 46 47 #ifdef __NetBSD__ 48 #include <dev/ic/isp_netbsd.h> 49 #endif 50 #ifdef __FreeBSD__ 51 #include <dev/isp/isp_freebsd.h> 52 #endif 53 #ifdef __linux__ 54 #include <isp_linux.h> 55 #endif 56 57 /* 58 * General defines 59 */ 60 61 #define MBOX_DELAY_COUNT 1000000 / 100 62 63 /* 64 * Local function prototypes. 65 */ 66 static int isp_parse_async __P((struct ispsoftc *, u_int16_t)); 67 static int isp_handle_other_response 68 __P((struct ispsoftc *, ispstatusreq_t *, u_int8_t *)); 69 static void isp_parse_status 70 __P((struct ispsoftc *, ispstatusreq_t *, ISP_SCSI_XFER_T *)); 71 static void isp_fibre_init __P((struct ispsoftc *)); 72 static void isp_fw_state __P((struct ispsoftc *)); 73 static void isp_dumpregs __P((struct ispsoftc *, const char *)); 74 static void isp_dumpxflist __P((struct ispsoftc *)); 75 static void isp_prtstst __P((ispstatusreq_t *)); 76 static void isp_mboxcmd __P((struct ispsoftc *, mbreg_t *)); 77 78 static void isp_update __P((struct ispsoftc *)); 79 static void isp_setdfltparm __P((struct ispsoftc *)); 80 static int isp_read_nvram __P((struct ispsoftc *)); 81 static void isp_rdnvram_word __P((struct ispsoftc *, int, u_int16_t *)); 82 83 /* 84 * Reset Hardware. 85 * 86 * Hit the chip over the head, download new f/w. 87 * 88 * Locking done elsewhere. 89 */ 90 void 91 isp_reset(isp) 92 struct ispsoftc *isp; 93 { 94 static char once = 1; 95 mbreg_t mbs; 96 int loops, i, dodnld = 1; 97 char *revname; 98 99 isp->isp_state = ISP_NILSTATE; 100 101 /* 102 * Basic types (SCSI, FibreChannel and PCI or SBus) 103 * have been set in the MD code. We figure out more 104 * here. 105 */ 106 isp->isp_dblev = DFLT_DBLEVEL; 107 if (isp->isp_type & ISP_HA_FC) { 108 revname = "2100"; 109 } else { 110 sdparam *sdp = isp->isp_param; 111 112 int rev = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK; 113 switch (rev) { 114 default: 115 PRINTF("%s: unknown chip rev. 0x%x- assuming a 1020\n", 116 isp->isp_name, rev); 117 /* FALLTHROUGH */ 118 case 1: 119 revname = "1020"; 120 isp->isp_type = ISP_HA_SCSI_1020; 121 sdp->isp_clock = 40; 122 break; 123 case 2: 124 /* 125 * Some 1020A chips are Ultra Capable, but don't 126 * run the clock rate up for that unless told to 127 * do so by the Ultra Capable bits being set. 128 */ 129 revname = "1020A"; 130 isp->isp_type = ISP_HA_SCSI_1020A; 131 sdp->isp_clock = 40; 132 break; 133 case 3: 134 revname = "1040"; 135 isp->isp_type = ISP_HA_SCSI_1040; 136 sdp->isp_clock = 60; 137 break; 138 case 4: 139 revname = "1040A"; 140 isp->isp_type = ISP_HA_SCSI_1040A; 141 sdp->isp_clock = 60; 142 break; 143 case 5: 144 revname = "1040B"; 145 isp->isp_type = ISP_HA_SCSI_1040B; 146 sdp->isp_clock = 60; 147 break; 148 } 149 /* 150 * Try and figure out if we're connected to a differential bus. 151 * You have to pause the RISC processor to read SXP registers. 152 */ 153 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE); 154 i = 100; 155 while ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) { 156 SYS_DELAY(20); 157 if (--i == 0) { 158 PRINTF("%s: unable to pause RISC processor\n", 159 isp->isp_name); 160 i = -1; 161 break; 162 } 163 } 164 if (i > 0) { 165 if (isp->isp_bustype != ISP_BT_SBUS) { 166 ISP_SETBITS(isp, BIU_CONF1, BIU_PCI_CONF1_SXP); 167 } 168 if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) { 169 IDPRINTF(2, ("%s: Differential Mode Set\n", 170 isp->isp_name)); 171 sdp->isp_diffmode = 1; 172 } else { 173 sdp->isp_diffmode = 0; 174 } 175 176 if (isp->isp_bustype != ISP_BT_SBUS) { 177 ISP_CLRBITS(isp, BIU_CONF1, BIU_PCI_CONF1_SXP); 178 } 179 180 /* 181 * Figure out whether we're ultra capable. 182 */ 183 i = ISP_READ(isp, RISC_PSR); 184 if (isp->isp_bustype != ISP_BT_SBUS) { 185 i &= RISC_PSR_PCI_ULTRA; 186 } else { 187 i &= RISC_PSR_SBUS_ULTRA; 188 } 189 if (i) { 190 IDPRINTF(2, ("%s: Ultra Mode Capable\n", 191 isp->isp_name)); 192 sdp->isp_clock = 60; 193 } else { 194 sdp->isp_clock = 40; 195 } 196 /* 197 * Restart processor 198 */ 199 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); 200 } 201 /* 202 * Machine dependent clock (if set) overrides 203 * our generic determinations. 204 */ 205 if (isp->isp_mdvec->dv_clock) { 206 if (isp->isp_mdvec->dv_clock < sdp->isp_clock) { 207 sdp->isp_clock = isp->isp_mdvec->dv_clock; 208 } 209 } 210 } 211 212 /* 213 * Do MD specific pre initialization 214 */ 215 ISP_RESET0(isp); 216 217 if (once == 1) { 218 once = 0; 219 /* 220 * Get the current running firmware revision out of the 221 * chip before we hit it over the head (if this is our 222 * first time through). Note that we store this as the 223 * 'ROM' firmware revision- which it may not be. In any 224 * case, we don't really use this yet, but we may in 225 * the future. 226 */ 227 mbs.param[0] = MBOX_ABOUT_FIRMWARE; 228 isp_mboxcmd(isp, &mbs); 229 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 230 IDPRINTF(3, ("%s: initial ABOUT FIRMWARE command " 231 "failed\n", isp->isp_name)); 232 } else { 233 isp->isp_romfw_rev = 234 (((u_int16_t) mbs.param[1]) << 10) + mbs.param[2]; 235 } 236 } 237 238 /* 239 * Hit the chip over the head with hammer, 240 * and give the ISP a chance to recover. 241 */ 242 243 if (isp->isp_type & ISP_HA_SCSI) { 244 ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET); 245 /* 246 * A slight delay... 247 */ 248 SYS_DELAY(100); 249 250 /* 251 * Clear data && control DMA engines. 252 */ 253 ISP_WRITE(isp, CDMA_CONTROL, 254 DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT); 255 ISP_WRITE(isp, DDMA_CONTROL, 256 DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT); 257 } else { 258 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET); 259 /* 260 * A slight delay... 261 */ 262 SYS_DELAY(100); 263 ISP_WRITE(isp, CDMA2100_CONTROL, 264 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT); 265 ISP_WRITE(isp, TDMA2100_CONTROL, 266 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT); 267 ISP_WRITE(isp, RDMA2100_CONTROL, 268 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT); 269 } 270 271 /* 272 * Wait for ISP to be ready to go... 273 */ 274 loops = MBOX_DELAY_COUNT; 275 for (;;) { 276 if (isp->isp_type & ISP_HA_SCSI) { 277 if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) 278 break; 279 } else { 280 if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET)) 281 break; 282 } 283 SYS_DELAY(100); 284 if (--loops < 0) { 285 isp_dumpregs(isp, "chip reset timed out"); 286 return; 287 } 288 } 289 /* 290 * More initialization 291 */ 292 if (isp->isp_type & ISP_HA_SCSI) { 293 ISP_WRITE(isp, BIU_CONF1, 0); 294 } else { 295 ISP_WRITE(isp, BIU2100_CSR, 0); 296 /* 297 * All 2100's are 60Mhz with fast rams onboard. 298 */ 299 ISP_WRITE(isp, RISC_MTR2100, 0x1212); 300 } 301 302 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET); 303 SYS_DELAY(100); 304 305 if (isp->isp_type & ISP_HA_SCSI) { 306 ISP_SETBITS(isp, BIU_CONF1, isp->isp_mdvec->dv_conf1); 307 if (isp->isp_mdvec->dv_conf1 & BIU_BURST_ENABLE) { 308 ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST); 309 ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST); 310 } 311 } 312 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */ 313 314 /* 315 * Do MD specific post initialization 316 */ 317 ISP_RESET1(isp); 318 319 /* 320 * Enable interrupts 321 */ 322 ENABLE_INTS(isp); 323 324 /* 325 * Do some sanity checking. 326 */ 327 mbs.param[0] = MBOX_NO_OP; 328 isp_mboxcmd(isp, &mbs); 329 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 330 isp_dumpregs(isp, "NOP test failed"); 331 return; 332 } 333 334 if (isp->isp_type & ISP_HA_SCSI) { 335 mbs.param[0] = MBOX_MAILBOX_REG_TEST; 336 mbs.param[1] = 0xdead; 337 mbs.param[2] = 0xbeef; 338 mbs.param[3] = 0xffff; 339 mbs.param[4] = 0x1111; 340 mbs.param[5] = 0xa5a5; 341 isp_mboxcmd(isp, &mbs); 342 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 343 isp_dumpregs(isp, 344 "Mailbox Register test didn't complete"); 345 return; 346 } 347 if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef || 348 mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 || 349 mbs.param[5] != 0xa5a5) { 350 isp_dumpregs(isp, "Register Test Failed"); 351 return; 352 } 353 354 } 355 356 /* 357 * Download new Firmware, unless requested not to do so. 358 * This is made slightly trickier in some cases where the 359 * firmware of the ROM revision is newer than the revision 360 * compiled into the driver. So, where we used to compare 361 * versions of our f/w and the ROM f/w, now we just see 362 * whether we have f/w at all and whether a config flag 363 * has disabled our download. 364 */ 365 if ((isp->isp_mdvec->dv_fwlen == 0) || 366 (isp->isp_confopts & ISP_CFG_NORELOAD)) { 367 dodnld = 0; 368 } 369 370 if (dodnld) { 371 for (i = 0; i < isp->isp_mdvec->dv_fwlen; i++) { 372 mbs.param[0] = MBOX_WRITE_RAM_WORD; 373 mbs.param[1] = isp->isp_mdvec->dv_codeorg + i; 374 mbs.param[2] = isp->isp_mdvec->dv_ispfw[i]; 375 isp_mboxcmd(isp, &mbs); 376 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 377 isp_dumpregs(isp, "f/w download failed"); 378 return; 379 } 380 } 381 382 if (isp->isp_mdvec->dv_fwlen) { 383 /* 384 * Verify that it downloaded correctly. 385 */ 386 mbs.param[0] = MBOX_VERIFY_CHECKSUM; 387 mbs.param[1] = isp->isp_mdvec->dv_codeorg; 388 isp_mboxcmd(isp, &mbs); 389 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 390 isp_dumpregs(isp, "ram checksum failure"); 391 return; 392 } 393 } 394 } else { 395 IDPRINTF(3, ("%s: skipping f/w download\n", isp->isp_name)); 396 } 397 398 /* 399 * Now start it rolling. 400 * 401 * If we didn't actually download f/w, 402 * we still need to (re)start it. 403 */ 404 405 mbs.param[0] = MBOX_EXEC_FIRMWARE; 406 mbs.param[1] = isp->isp_mdvec->dv_codeorg; 407 isp_mboxcmd(isp, &mbs); 408 409 if (isp->isp_type & ISP_HA_SCSI) { 410 sdparam *sdp = isp->isp_param; 411 /* 412 * Set CLOCK RATE, but only if asked to. 413 */ 414 if (sdp->isp_clock) { 415 mbs.param[0] = MBOX_SET_CLOCK_RATE; 416 mbs.param[1] = sdp->isp_clock; 417 isp_mboxcmd(isp, &mbs); 418 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 419 isp_dumpregs(isp, "failed to set CLOCKRATE"); 420 /* but continue */ 421 } else { 422 IDPRINTF(3, ("%s: setting input clock to %d\n", 423 isp->isp_name, sdp->isp_clock)); 424 } 425 } 426 } 427 mbs.param[0] = MBOX_ABOUT_FIRMWARE; 428 isp_mboxcmd(isp, &mbs); 429 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 430 isp_dumpregs(isp, "ABOUT FIRMWARE command failed"); 431 return; 432 } 433 PRINTF("%s: Board Revision %s, %s F/W Revision %d.%d\n", 434 isp->isp_name, revname, dodnld? "loaded" : "resident", 435 mbs.param[1], mbs.param[2]); 436 isp->isp_fwrev = (((u_int16_t) mbs.param[1]) << 10) + mbs.param[2]; 437 if (isp->isp_romfw_rev && dodnld) { 438 PRINTF("%s: Last F/W revision was %d.%d\n", isp->isp_name, 439 isp->isp_romfw_rev >> 10, isp->isp_romfw_rev & 0x3ff); 440 } 441 isp_fw_state(isp); 442 isp->isp_state = ISP_RESETSTATE; 443 } 444 445 /* 446 * Initialize Hardware to known state 447 * 448 * Locks are held before coming here. 449 */ 450 451 void 452 isp_init(isp) 453 struct ispsoftc *isp; 454 { 455 sdparam *sdp; 456 mbreg_t mbs; 457 int tgt; 458 459 /* 460 * Must do first. 461 */ 462 isp_setdfltparm(isp); 463 464 /* 465 * If we're fibre, we have a completely different 466 * initialization method. 467 */ 468 469 if (isp->isp_type & ISP_HA_FC) { 470 isp_fibre_init(isp); 471 return; 472 } 473 sdp = isp->isp_param; 474 475 /* 476 * Set (possibly new) Initiator ID. 477 */ 478 mbs.param[0] = MBOX_SET_INIT_SCSI_ID; 479 mbs.param[1] = sdp->isp_initiator_id; 480 isp_mboxcmd(isp, &mbs); 481 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 482 isp_dumpregs(isp, "failed to set initiator id"); 483 return; 484 } 485 486 /* 487 * Set Retry Delay and Count 488 */ 489 mbs.param[0] = MBOX_SET_RETRY_COUNT; 490 mbs.param[1] = sdp->isp_retry_count; 491 mbs.param[2] = sdp->isp_retry_delay; 492 isp_mboxcmd(isp, &mbs); 493 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 494 isp_dumpregs(isp, "failed to set retry count and delay"); 495 return; 496 } 497 498 /* 499 * Set ASYNC DATA SETUP time. This is very important. 500 */ 501 mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME; 502 mbs.param[1] = sdp->isp_async_data_setup; 503 isp_mboxcmd(isp, &mbs); 504 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 505 isp_dumpregs(isp, "failed to set async data setup time"); 506 return; 507 } 508 509 /* 510 * Set ACTIVE Negation State. 511 */ 512 mbs.param[0] = MBOX_SET_ACTIVE_NEG_STATE; 513 mbs.param[1] = 514 (sdp->isp_req_ack_active_neg << 4) | 515 (sdp->isp_data_line_active_neg << 5); 516 isp_mboxcmd(isp, &mbs); 517 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 518 isp_dumpregs(isp, "failed to set active neg state"); 519 return; 520 } 521 522 /* 523 * Set the Tag Aging limit 524 */ 525 526 mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT; 527 mbs.param[1] = sdp->isp_tag_aging; 528 isp_mboxcmd(isp, &mbs); 529 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 530 isp_dumpregs(isp, "failed to set tag age limit"); 531 return; 532 } 533 534 /* 535 * Set selection timeout. 536 */ 537 538 mbs.param[0] = MBOX_SET_SELECT_TIMEOUT; 539 mbs.param[1] = sdp->isp_selection_timeout; 540 isp_mboxcmd(isp, &mbs); 541 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 542 isp_dumpregs(isp, "failed to set selection timeout"); 543 return; 544 } 545 546 /* 547 * Set per-target parameters to a safe minimum. 548 */ 549 550 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 551 int maxlun, lun; 552 553 if (sdp->isp_devparam[tgt].dev_enable == 0) 554 continue; 555 556 mbs.param[0] = MBOX_SET_TARGET_PARAMS; 557 mbs.param[1] = tgt << 8; 558 mbs.param[2] = DPARM_SAFE_DFLT; 559 mbs.param[3] = 0; 560 /* 561 * It is not quite clear when this changed over so that 562 * we could force narrow and async, so assume >= 7.55. 563 * 564 * Otherwise, a SCSI bus reset issued below will force 565 * the back to the narrow, async state (but see note 566 * below also). Technically we should also do without 567 * Parity. 568 */ 569 if (isp->isp_fwrev >= ISP_FW_REV(7, 55)) { 570 mbs.param[2] |= DPARM_NARROW | DPARM_ASYNC; 571 } 572 sdp->isp_devparam[tgt].cur_dflags = mbs.param[2] >> 8; 573 574 IDPRINTF(3, ("\n%s: tgt %d cflags %x offset %x period %x\n", 575 isp->isp_name, tgt, mbs.param[2], mbs.param[3] >> 8, 576 mbs.param[3] & 0xff)); 577 isp_mboxcmd(isp, &mbs); 578 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 579 580 PRINTF("%s: failed to set parameters for tgt %d\n", 581 isp->isp_name, tgt); 582 583 PRINTF("%s: flags %x offset %x period %x\n", 584 isp->isp_name, sdp->isp_devparam[tgt].dev_flags, 585 sdp->isp_devparam[tgt].sync_offset, 586 sdp->isp_devparam[tgt].sync_period); 587 588 mbs.param[0] = MBOX_SET_TARGET_PARAMS; 589 mbs.param[1] = tgt << 8; 590 mbs.param[2] = DPARM_SAFE_DFLT; 591 mbs.param[3] = 0; 592 isp_mboxcmd(isp, &mbs); 593 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 594 PRINTF("%s: failed even to set defaults for " 595 "target %d\n", isp->isp_name, tgt); 596 continue; 597 } 598 } 599 600 maxlun = (isp->isp_fwrev >= ISP_FW_REV(7, 55))? 32 : 8; 601 for (lun = 0; lun < maxlun; lun++) { 602 mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS; 603 mbs.param[1] = (tgt << 8) | lun; 604 mbs.param[2] = sdp->isp_max_queue_depth; 605 mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle; 606 isp_mboxcmd(isp, &mbs); 607 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 608 PRINTF("%s: failed to set device queue " 609 "parameters for target %d, lun %d\n", 610 isp->isp_name, tgt, lun); 611 break; 612 } 613 } 614 } 615 616 /* 617 * Set up DMA for the request and result mailboxes. 618 */ 619 if (ISP_MBOXDMASETUP(isp)) { 620 PRINTF("%s: can't setup dma mailboxes\n", isp->isp_name); 621 return; 622 } 623 624 mbs.param[0] = MBOX_INIT_RES_QUEUE; 625 mbs.param[1] = RESULT_QUEUE_LEN; 626 mbs.param[2] = (u_int16_t) (isp->isp_result_dma >> 16); 627 mbs.param[3] = (u_int16_t) (isp->isp_result_dma & 0xffff); 628 mbs.param[4] = 0; 629 mbs.param[5] = 0; 630 isp_mboxcmd(isp, &mbs); 631 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 632 isp_dumpregs(isp, "set of response queue failed"); 633 return; 634 } 635 isp->isp_residx = 0; 636 637 mbs.param[0] = MBOX_INIT_REQ_QUEUE; 638 mbs.param[1] = RQUEST_QUEUE_LEN; 639 mbs.param[2] = (u_int16_t) (isp->isp_rquest_dma >> 16); 640 mbs.param[3] = (u_int16_t) (isp->isp_rquest_dma & 0xffff); 641 mbs.param[4] = 0; 642 mbs.param[5] = 0; 643 isp_mboxcmd(isp, &mbs); 644 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 645 isp_dumpregs(isp, "set of request queue failed"); 646 return; 647 } 648 isp->isp_reqidx = isp->isp_reqodx = 0; 649 650 /* 651 * XXX: See whether or not for 7.55 F/W or later we 652 * XXX: can do without this, and see whether we should 653 * XXX: honor the NVRAM SCSI_RESET_DISABLE token. 654 */ 655 mbs.param[0] = MBOX_BUS_RESET; 656 mbs.param[1] = 3; 657 isp_mboxcmd(isp, &mbs); 658 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 659 isp_dumpregs(isp, "SCSI bus reset failed"); 660 } 661 /* 662 * This is really important to have set after a bus reset. 663 */ 664 isp->isp_sendmarker = 1; 665 isp->isp_state = ISP_INITSTATE; 666 } 667 668 /* 669 * Fibre Channel specific initialization. 670 * 671 * Locks are held before coming here. 672 */ 673 static void 674 isp_fibre_init(isp) 675 struct ispsoftc *isp; 676 { 677 fcparam *fcp; 678 isp_icb_t *icbp; 679 mbreg_t mbs; 680 int count; 681 u_int8_t lwfs; 682 683 fcp = isp->isp_param; 684 685 if (ISP_MBOXDMASETUP(isp)) { 686 PRINTF("%s: can't setup DMA for mailboxes\n", isp->isp_name); 687 return; 688 } 689 690 icbp = (isp_icb_t *) fcp->isp_scratch; 691 bzero(icbp, sizeof (*icbp)); 692 693 icbp->icb_version = ICB_VERSION1; 694 fcp->isp_fwoptions = icbp->icb_fwoptions = 695 ICBOPT_TGT_ENABLE|ICBOPT_INI_TGTTYPE; 696 icbp->icb_iqdevtype = 0x23; /* DPQ_SUPPORTED/PROCESSOR */ 697 698 icbp->icb_maxfrmlen = fcp->isp_maxfrmlen; 699 if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN || 700 icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) { 701 PRINTF("%s: bad frame length (%d) from NVRAM- using %d\n", 702 isp->isp_name, fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN); 703 } 704 icbp->icb_maxalloc = fcp->isp_maxalloc; 705 icbp->icb_execthrottle = fcp->isp_execthrottle; 706 icbp->icb_retry_delay = fcp->isp_retry_delay; 707 icbp->icb_retry_count = fcp->isp_retry_count; 708 709 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwn); 710 711 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN; 712 icbp->icb_rsltqlen = RESULT_QUEUE_LEN; 713 icbp->icb_rqstaddr[RQRSP_ADDR0015] = 714 (u_int16_t) (isp->isp_rquest_dma & 0xffff); 715 icbp->icb_rqstaddr[RQRSP_ADDR1631] = 716 (u_int16_t) (isp->isp_rquest_dma >> 16); 717 icbp->icb_respaddr[RQRSP_ADDR0015] = 718 (u_int16_t) (isp->isp_result_dma & 0xffff); 719 icbp->icb_respaddr[RQRSP_ADDR1631] = 720 (u_int16_t) (isp->isp_result_dma >> 16); 721 722 mbs.param[0] = MBOX_INIT_FIRMWARE; 723 mbs.param[1] = 0; 724 mbs.param[2] = (u_int16_t) (fcp->isp_scdma >> 16); 725 mbs.param[3] = (u_int16_t) (fcp->isp_scdma & 0xffff); 726 mbs.param[4] = 0; 727 mbs.param[5] = 0; 728 mbs.param[6] = 0; 729 mbs.param[7] = 0; 730 isp_mboxcmd(isp, &mbs); 731 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 732 isp_dumpregs(isp, "INIT FIRMWARE failed"); 733 return; 734 } 735 isp->isp_reqidx = isp->isp_reqodx = 0; 736 isp->isp_residx = 0; 737 738 /* 739 * Wait up to 12 seconds for FW to go to READY state. 740 * This used to be 3 seconds, but that lost. 741 * 742 * This is all very much not right. The problem here 743 * is that the cable may not be plugged in, or there 744 * may be many many members of the loop that haven't 745 * been logged into. 746 * 747 * This model of doing things doesn't support dynamic 748 * attachment, so we just plain lose (for now). 749 */ 750 lwfs = FW_CONFIG_WAIT; 751 for (count = 0; count < 12000; count++) { 752 isp_fw_state(isp); 753 if (lwfs != fcp->isp_fwstate) { 754 PRINTF("%s: Firmware State %s -> %s\n", isp->isp_name, 755 fw_statename(lwfs), fw_statename(fcp->isp_fwstate)); 756 lwfs = fcp->isp_fwstate; 757 } 758 if (fcp->isp_fwstate == FW_READY) { 759 break; 760 } 761 SYS_DELAY(1000); /* wait one millisecond */ 762 } 763 isp->isp_sendmarker = 1; 764 765 /* 766 * Get our Loop ID 767 * (if possible) 768 */ 769 if (fcp->isp_fwstate == FW_READY) { 770 mbs.param[0] = MBOX_GET_LOOP_ID; 771 isp_mboxcmd(isp, &mbs); 772 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 773 isp_dumpregs(isp, "GET LOOP ID failed"); 774 return; 775 } 776 fcp->isp_loopid = mbs.param[1]; 777 fcp->isp_alpa = mbs.param[2]; 778 if (fcp->isp_loopid) { 779 PRINTF("%s: Loop ID 0x%x\n", isp->isp_name, 780 fcp->isp_loopid); 781 } 782 if (fcp->isp_alpa) { 783 PRINTF("%s: ALPA 0x%x\n", isp->isp_name, fcp->isp_alpa); 784 } 785 isp->isp_state = ISP_INITSTATE; 786 } else { 787 PRINTF("%s: failed to go to FW READY state- will not attach\n", 788 isp->isp_name); 789 } 790 } 791 792 /* 793 * Free any associated resources prior to decommissioning and 794 * set the card to a known state (so it doesn't wake up and kick 795 * us when we aren't expecting it to). 796 * 797 * Locks are held before coming here. 798 */ 799 void 800 isp_uninit(isp) 801 struct ispsoftc *isp; 802 { 803 /* 804 * Leave with interrupts disabled. 805 */ 806 DISABLE_INTS(isp); 807 808 /* 809 * Stop the watchdog timer (if started). 810 */ 811 STOP_WATCHDOG(isp_watch, isp); 812 } 813 814 815 /* 816 * Start a command. Locking is assumed done in the caller. 817 */ 818 819 int32_t 820 ispscsicmd(xs) 821 ISP_SCSI_XFER_T *xs; 822 { 823 struct ispsoftc *isp; 824 u_int8_t iptr, optr; 825 union { 826 ispreq_t *_reqp; 827 ispreqt2_t *_t2reqp; 828 } _u; 829 #define reqp _u._reqp 830 #define t2reqp _u._t2reqp 831 #define UZSIZE max(sizeof (ispreq_t), sizeof (ispreqt2_t)) 832 int i; 833 834 XS_INITERR(xs); 835 isp = XS_ISP(xs); 836 837 if (isp->isp_state != ISP_RUNSTATE) { 838 PRINTF("%s: adapter not ready\n", isp->isp_name); 839 XS_SETERR(xs, HBA_BOTCH); 840 return (CMD_COMPLETE); 841 } 842 843 /* 844 * We *could* do the different sequence type that has clos 845 * to the whole Queue Entry for the command,. 846 */ 847 if (XS_CDBLEN(xs) > ((isp->isp_type & ISP_HA_FC)? 16 : 12)) { 848 PRINTF("%s: unsupported cdb length (%d)\n", 849 isp->isp_name, XS_CDBLEN(xs)); 850 XS_SETERR(xs, HBA_BOTCH); 851 return (CMD_COMPLETE); 852 } 853 854 /* 855 * First check to see if any HBA or Device 856 * parameters need to be updated. 857 */ 858 if (isp->isp_update) { 859 isp_update(isp); 860 } 861 862 optr = isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4); 863 iptr = isp->isp_reqidx; 864 865 reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr); 866 iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN); 867 if (iptr == optr) { 868 PRINTF("%s: Request Queue Overflow\n", isp->isp_name); 869 XS_SETERR(xs, HBA_BOTCH); 870 return (CMD_EAGAIN); 871 } 872 if (isp->isp_type & ISP_HA_FC) { 873 DISABLE_INTS(isp); 874 } 875 876 if (isp->isp_sendmarker) { 877 u_int8_t niptr; 878 ispmarkreq_t *marker = (ispmarkreq_t *) reqp; 879 880 bzero((void *) marker, sizeof (*marker)); 881 marker->req_header.rqs_entry_count = 1; 882 marker->req_header.rqs_entry_type = RQSTYPE_MARKER; 883 marker->req_modifier = SYNC_ALL; 884 885 isp->isp_sendmarker = 0; 886 887 niptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN); 888 if (niptr == optr) { 889 ISP_WRITE(isp, INMAILBOX4, iptr); 890 isp->isp_reqidx = iptr; 891 if (isp->isp_type & ISP_HA_FC) { 892 ENABLE_INTS(isp); 893 } 894 PRINTF("%s: Request Queue Overflow+\n", isp->isp_name); 895 XS_SETERR(xs, HBA_BOTCH); 896 return (CMD_EAGAIN); 897 } 898 reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr); 899 iptr = niptr; 900 } 901 902 bzero((void *) reqp, UZSIZE); 903 reqp->req_header.rqs_entry_count = 1; 904 if (isp->isp_type & ISP_HA_FC) { 905 reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS; 906 } else { 907 reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST; 908 } 909 reqp->req_header.rqs_flags = 0; 910 reqp->req_header.rqs_seqno = isp->isp_seqno++; 911 912 for (i = 0; i < RQUEST_QUEUE_LEN; i++) { 913 if (isp->isp_xflist[i] == NULL) 914 break; 915 } 916 if (i == RQUEST_QUEUE_LEN) { 917 if (isp->isp_type & ISP_HA_FC) 918 ENABLE_INTS(isp); 919 PRINTF("%s: ran out of xflist pointers?????\n", isp->isp_name); 920 XS_SETERR(xs, HBA_BOTCH); 921 return (CMD_EAGAIN); 922 } else { 923 /* 924 * Never have a handle that is zero, so 925 * set req_handle off by one. 926 */ 927 isp->isp_xflist[i] = xs; 928 reqp->req_handle = i+1; 929 } 930 931 if (isp->isp_type & ISP_HA_FC) { 932 /* 933 * See comment in isp_intr 934 */ 935 XS_RESID(xs) = 0; 936 /* 937 * Fibre Channel always requires some kind of tag. 938 * If we're marked as "Can't Tag", just do simple 939 * instead of ordered tags. It's pretty clear to me 940 * that we shouldn't do head of queue tagging in 941 * this case. 942 */ 943 if (XS_CANTAG(xs)) { 944 t2reqp->req_flags = XS_KINDOF_TAG(xs); 945 } else { 946 t2reqp->req_flags = REQFLAG_STAG; 947 } 948 } else { 949 sdparam *sdp = (sdparam *)isp->isp_param; 950 if ((sdp->isp_devparam[XS_TGT(xs)].cur_dflags & DPARM_TQING) && 951 XS_CANTAG(xs)) { 952 reqp->req_flags = XS_KINDOF_TAG(xs); 953 } else { 954 reqp->req_flags = 0; 955 } 956 } 957 reqp->req_lun_trn = XS_LUN(xs); 958 reqp->req_target = XS_TGT(xs); 959 if (isp->isp_type & ISP_HA_SCSI) { 960 reqp->req_cdblen = XS_CDBLEN(xs); 961 } 962 bcopy((void *)XS_CDBP(xs), reqp->req_cdb, XS_CDBLEN(xs)); 963 964 IDPRINTF(5, ("%s(%d.%d): START%d cmd 0x%x datalen %d\n", isp->isp_name, 965 XS_TGT(xs), XS_LUN(xs), reqp->req_header.rqs_seqno, 966 reqp->req_cdb[0], XS_XFRLEN(xs))); 967 968 reqp->req_time = XS_TIME(xs) / 1000; 969 if (reqp->req_time == 0 && XS_TIME(xs)) 970 reqp->req_time = 1; 971 if (ISP_DMASETUP(isp, xs, reqp, &iptr, optr)) { 972 if (isp->isp_type & ISP_HA_FC) 973 ENABLE_INTS(isp); 974 /* dmasetup sets actual error */ 975 return (CMD_COMPLETE); 976 } 977 XS_SETERR(xs, HBA_NOERROR); 978 ISP_WRITE(isp, INMAILBOX4, iptr); 979 isp->isp_reqidx = iptr; 980 if (isp->isp_type & ISP_HA_FC) { 981 ENABLE_INTS(isp); 982 } 983 isp->isp_nactive++; 984 return (CMD_QUEUED); 985 #undef reqp 986 #undef t2reqp 987 } 988 989 /* 990 * isp control 991 * Locks (ints blocked) assumed held. 992 */ 993 994 int 995 isp_control(isp, ctl, arg) 996 struct ispsoftc *isp; 997 ispctl_t ctl; 998 void *arg; 999 { 1000 ISP_SCSI_XFER_T *xs; 1001 mbreg_t mbs; 1002 int i; 1003 1004 switch (ctl) { 1005 default: 1006 PRINTF("%s: isp_control unknown control op %x\n", 1007 isp->isp_name, ctl); 1008 break; 1009 1010 case ISPCTL_RESET_BUS: 1011 /* 1012 * Right now, for Fibre, we'll punt on loop reset. 1013 * The reason is that it takes a really long time 1014 * to go through the renegotiation after a LIP, 1015 * and we really have to hang out until it's done 1016 * to see what's there after a LIP- until the 1017 * LIP is done and the loop comes back up, 1018 * commands just fail (and, yes, we could handle 1019 * that a little better). 1020 */ 1021 if (isp->isp_type & ISP_HA_FC) { 1022 PRINTF("%s: Skipping FC resets\n", isp->isp_name); 1023 return (0); 1024 } 1025 mbs.param[0] = MBOX_BUS_RESET; 1026 mbs.param[1] = 2; /* 'delay', in seconds */ 1027 isp_mboxcmd(isp, &mbs); 1028 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1029 isp_dumpregs(isp, "isp_control SCSI bus reset failed"); 1030 break; 1031 } 1032 /* 1033 * This is really important to have set after a bus reset. 1034 */ 1035 isp->isp_sendmarker = 1; 1036 PRINTF("%s: driver initiated bus reset\n", isp->isp_name); 1037 return (0); 1038 1039 case ISPCTL_RESET_DEV: 1040 /* 1041 * Note that under parallel SCSI, this issues a BDR message. 1042 * Under FC, we could probably be using ABORT TASK SET 1043 * command. 1044 */ 1045 1046 mbs.param[0] = MBOX_ABORT_TARGET; 1047 mbs.param[1] = ((long)arg) << 8; 1048 mbs.param[2] = 2; /* 'delay', in seconds */ 1049 isp_mboxcmd(isp, &mbs); 1050 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1051 isp_dumpregs(isp, "SCSI Target reset failed"); 1052 break; 1053 } 1054 PRINTF("%s: Target %d Reset Succeeded\n", isp->isp_name, 1055 (int) ((long) arg)); 1056 isp->isp_sendmarker = 1; 1057 return (0); 1058 1059 case ISPCTL_ABORT_CMD: 1060 xs = (ISP_SCSI_XFER_T *) arg; 1061 for (i = 0; i < RQUEST_QUEUE_LEN; i++) { 1062 if (xs == isp->isp_xflist[i]) { 1063 break; 1064 } 1065 } 1066 if (i == RQUEST_QUEUE_LEN) { 1067 PRINTF("%s: isp_control- cannot find command to abort " 1068 "in active list\n", isp->isp_name); 1069 break; 1070 } 1071 mbs.param[0] = MBOX_ABORT; 1072 mbs.param[1] = XS_TGT(xs) | XS_LUN(xs); 1073 mbs.param[2] = (i+1) >> 16; 1074 mbs.param[3] = (i+1) & 0xffff; 1075 isp_mboxcmd(isp, &mbs); 1076 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1077 PRINTF("%s: isp_control MBOX_ABORT failure (code %x)\n", 1078 isp->isp_name, mbs.param[0]); 1079 break; 1080 } 1081 PRINTF("%s: command for target %d lun %d was aborted\n", 1082 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1083 return (0); 1084 1085 case ISPCTL_UPDATE_PARAMS: 1086 isp_update(isp); 1087 return(0); 1088 } 1089 return (-1); 1090 } 1091 1092 /* 1093 * Interrupt Service Routine(s). 1094 * 1095 * External (OS) framework has done the appropriate locking, 1096 * and the locking will be held throughout this function. 1097 */ 1098 1099 int 1100 isp_intr(arg) 1101 void *arg; 1102 { 1103 ISP_SCSI_XFER_T *complist[RESULT_QUEUE_LEN], *xs; 1104 struct ispsoftc *isp = arg; 1105 u_int8_t iptr, optr; 1106 u_int16_t isr; 1107 int i, ndone = 0; 1108 1109 isr = ISP_READ(isp, BIU_ISR); 1110 if (isp->isp_type & ISP_HA_FC) { 1111 if (isr == 0 || (isr & BIU2100_ISR_RISC_INT) == 0) { 1112 if (isr) { 1113 IDPRINTF(4, ("%s: isp_intr isr=%x\n", 1114 isp->isp_name, isr)); 1115 } 1116 return (0); 1117 } 1118 } else { 1119 if (isr == 0 || (isr & BIU_ISR_RISC_INT) == 0) { 1120 if (isr) { 1121 IDPRINTF(4, ("%s: isp_intr isr=%x\n", 1122 isp->isp_name, isr)); 1123 } 1124 return (0); 1125 } 1126 } 1127 1128 if (ISP_READ(isp, BIU_SEMA) & 1) { 1129 u_int16_t mbox = ISP_READ(isp, OUTMAILBOX0); 1130 if (isp_parse_async(isp, mbox)) 1131 return (1); 1132 ISP_WRITE(isp, BIU_SEMA, 0); 1133 } 1134 1135 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 1136 1137 optr = isp->isp_residx; 1138 iptr = ISP_READ(isp, OUTMAILBOX5); 1139 1140 if (optr == iptr) { 1141 IDPRINTF(4, ("why intr? isr %x iptr %x optr %x\n", 1142 isr, optr, iptr)); 1143 } 1144 ENABLE_INTS(isp); 1145 1146 while (optr != iptr) { 1147 ispstatusreq_t *sp; 1148 u_int8_t oop; 1149 int buddaboom = 0; 1150 1151 sp = (ispstatusreq_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr); 1152 oop = optr; 1153 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN); 1154 1155 if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) { 1156 if (isp_handle_other_response(isp, sp, &optr) == 0) { 1157 ISP_WRITE(isp, INMAILBOX5, optr); 1158 continue; 1159 } 1160 /* 1161 * It really has to be a bounced request just copied 1162 * from the request queue to the response queue. 1163 */ 1164 1165 if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) { 1166 ISP_WRITE(isp, INMAILBOX5, optr); 1167 continue; 1168 } 1169 PRINTF("%s: not RESPONSE in RESPONSE Queue " 1170 "(type 0x%x) @ idx %d (next %d)\n", isp->isp_name, 1171 sp->req_header.rqs_entry_type, oop, optr); 1172 buddaboom = 1; 1173 } 1174 1175 if (sp->req_header.rqs_flags & 0xf) { 1176 if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) { 1177 ISP_WRITE(isp, INMAILBOX5, optr); 1178 continue; 1179 } 1180 PRINTF("%s: rqs_flags=%x", isp->isp_name, 1181 sp->req_header.rqs_flags & 0xf); 1182 if (sp->req_header.rqs_flags & RQSFLAG_FULL) { 1183 PRINTF("%s: internal queues full\n", 1184 isp->isp_name); 1185 /* XXXX: this command *could* get restarted */ 1186 buddaboom++; 1187 } 1188 if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) { 1189 PRINTF("%s: bad header\n", isp->isp_name); 1190 buddaboom++; 1191 } 1192 if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) { 1193 PRINTF("%s: bad request packet\n", 1194 isp->isp_name); 1195 buddaboom++; 1196 } 1197 } 1198 if (sp->req_handle > RQUEST_QUEUE_LEN || sp->req_handle < 1) { 1199 PRINTF("%s: bad request handle %d\n", isp->isp_name, 1200 sp->req_handle); 1201 ISP_WRITE(isp, INMAILBOX5, optr); 1202 continue; 1203 } 1204 xs = (ISP_SCSI_XFER_T *) isp->isp_xflist[sp->req_handle - 1]; 1205 if (xs == NULL) { 1206 PRINTF("%s: NULL xs in xflist (handle %x)\n", 1207 isp->isp_name, sp->req_handle); 1208 isp_dumpxflist(isp); 1209 ISP_WRITE(isp, INMAILBOX5, optr); 1210 continue; 1211 } 1212 isp->isp_xflist[sp->req_handle - 1] = NULL; 1213 if (sp->req_status_flags & RQSTF_BUS_RESET) { 1214 isp->isp_sendmarker = 1; 1215 } 1216 if (buddaboom) { 1217 XS_SETERR(xs, HBA_BOTCH); 1218 } 1219 XS_STS(xs) = sp->req_scsi_status & 0xff; 1220 if (isp->isp_type & ISP_HA_SCSI) { 1221 if (sp->req_state_flags & RQSF_GOT_SENSE) { 1222 bcopy(sp->req_sense_data, XS_SNSP(xs), 1223 XS_SNSLEN(xs)); 1224 XS_SNS_IS_VALID(xs); 1225 } 1226 } else { 1227 if (XS_STS(xs) == SCSI_CHECK) { 1228 XS_SNS_IS_VALID(xs); 1229 bcopy(sp->req_sense_data, XS_SNSP(xs), 1230 XS_SNSLEN(xs)); 1231 sp->req_state_flags |= RQSF_GOT_SENSE; 1232 } 1233 } 1234 if (XS_NOERR(xs) && XS_STS(xs) == SCSI_BUSY) { 1235 XS_SETERR(xs, HBA_TGTBSY); 1236 } 1237 1238 if (sp->req_header.rqs_entry_type == RQSTYPE_RESPONSE) { 1239 if (XS_NOERR(xs)) { 1240 if (sp->req_completion_status != RQCS_COMPLETE) { 1241 isp_parse_status(isp, sp, xs); 1242 } else { 1243 XS_SETERR(xs, HBA_NOERROR); 1244 } 1245 } 1246 } else { 1247 PRINTF("%s: unknown return %x\n", isp->isp_name, 1248 sp->req_header.rqs_entry_type); 1249 if (XS_NOERR(xs)) 1250 XS_SETERR(xs, HBA_BOTCH); 1251 } 1252 if (isp->isp_type & ISP_HA_SCSI) { 1253 XS_RESID(xs) = sp->req_resid; 1254 } else if (sp->req_scsi_status & RQCS_RU) { 1255 XS_RESID(xs) = sp->req_resid; 1256 IDPRINTF(4, ("%s: cnt %d rsd %d\n", isp->isp_name, 1257 XS_XFRLEN(xs), sp->req_resid)); 1258 } 1259 if (XS_XFRLEN(xs)) { 1260 ISP_DMAFREE(isp, xs, sp->req_handle - 1); 1261 } 1262 /* 1263 * XXX: If we have a check condition, but no Sense Data, 1264 * XXX: mark it as an error (ARQ failed). We need to 1265 * XXX: to do a more distinct job because there may 1266 * XXX: cases where ARQ is disabled. 1267 */ 1268 if (XS_STS(xs) == SCSI_CHECK && !(XS_IS_SNS_VALID(xs))) { 1269 if (XS_NOERR(xs)) { 1270 PRINTF("%s: ARQ Failure\n", isp->isp_name); 1271 XS_SETERR(xs, HBA_ARQFAIL); 1272 } 1273 } 1274 if ((isp->isp_dblev >= 5) || 1275 (isp->isp_dblev > 2 && !XS_NOERR(xs))) { 1276 PRINTF("%s(%d.%d): FIN%d dl%d resid%d STS %x", 1277 isp->isp_name, XS_TGT(xs), XS_LUN(xs), 1278 sp->req_header.rqs_seqno, XS_XFRLEN(xs), 1279 XS_RESID(xs), XS_STS(xs)); 1280 if (sp->req_state_flags & RQSF_GOT_SENSE) { 1281 PRINTF(" Skey: %x", XS_SNSKEY(xs)); 1282 if (!(XS_IS_SNS_VALID(xs))) { 1283 PRINTF(" BUT NOT SET"); 1284 } 1285 } 1286 PRINTF(" XS_ERR=0x%x\n", XS_ERR(xs)); 1287 } 1288 1289 ISP_WRITE(isp, INMAILBOX5, optr); 1290 isp->isp_nactive--; 1291 if (isp->isp_nactive < 0) 1292 isp->isp_nactive = 0; 1293 complist[ndone++] = xs; /* defer completion call until later */ 1294 } 1295 isp->isp_residx = optr; 1296 for (i = 0; i < ndone; i++) { 1297 xs = complist[i]; 1298 if (xs) { 1299 XS_CMD_DONE(xs); 1300 } 1301 } 1302 return (1); 1303 } 1304 1305 /* 1306 * Support routines. 1307 */ 1308 1309 static int 1310 isp_parse_async(isp, mbox) 1311 struct ispsoftc *isp; 1312 u_int16_t mbox; 1313 { 1314 switch (mbox) { 1315 case ASYNC_BUS_RESET: 1316 PRINTF("%s: SCSI bus reset detected\n", isp->isp_name); 1317 isp->isp_sendmarker = 1; 1318 break; 1319 1320 case ASYNC_SYSTEM_ERROR: 1321 mbox = ISP_READ(isp, OUTMAILBOX1); 1322 PRINTF("%s: Internal FW Error @ RISC Addr 0x%x\n", 1323 isp->isp_name, mbox); 1324 isp_restart(isp); 1325 /* no point continuing after this */ 1326 return (1); 1327 1328 case ASYNC_RQS_XFER_ERR: 1329 PRINTF("%s: Request Queue Transfer Error\n", isp->isp_name); 1330 break; 1331 1332 case ASYNC_RSP_XFER_ERR: 1333 PRINTF("%s: Response Queue Transfer Error\n", isp->isp_name); 1334 break; 1335 1336 case ASYNC_QWAKEUP: 1337 /* don't need to be chatty */ 1338 mbox = ISP_READ(isp, OUTMAILBOX4); 1339 break; 1340 1341 case ASYNC_TIMEOUT_RESET: 1342 PRINTF("%s: timeout initiated SCSI bus reset\n", isp->isp_name); 1343 isp->isp_sendmarker = 1; 1344 break; 1345 1346 case ASYNC_UNSPEC_TMODE: 1347 PRINTF("%s: mystery async target completion\n", isp->isp_name); 1348 break; 1349 1350 case ASYNC_EXTMSG_UNDERRUN: 1351 PRINTF("%s: extended message underrun\n", isp->isp_name); 1352 break; 1353 1354 case ASYNC_SCAM_INT: 1355 PRINTF("%s: SCAM interrupt\n", isp->isp_name); 1356 break; 1357 1358 case ASYNC_HUNG_SCSI: 1359 PRINTF("%s: stalled SCSI Bus after DATA Overrun\n", 1360 isp->isp_name); 1361 /* XXX: Need to issue SCSI reset at this point */ 1362 break; 1363 1364 case ASYNC_KILLED_BUS: 1365 PRINTF("%s: SCSI Bus reset after DATA Overrun\n", 1366 isp->isp_name); 1367 break; 1368 1369 case ASYNC_BUS_TRANSIT: 1370 PRINTF("%s: LBD->HVD Transition 0x%x\n", 1371 isp->isp_name, ISP_READ(isp, OUTMAILBOX1)); 1372 break; 1373 1374 case ASYNC_CMD_CMPLT: 1375 PRINTF("%s: fast post completion\n", isp->isp_name); 1376 #if 0 1377 fast_post_handle = (ISP_READ(isp, OUTMAILBOX1) << 16) | 1378 ISP_READ(isp, OUTMAILBOX2); 1379 #endif 1380 break; 1381 1382 case ASYNC_CTIO_DONE: 1383 PRINTF("%s: CTIO done\n", isp->isp_name); 1384 break; 1385 1386 case ASYNC_LIP_OCCURRED: 1387 PRINTF("%s: LIP occurred\n", isp->isp_name); 1388 break; 1389 1390 case ASYNC_LOOP_UP: 1391 PRINTF("%s: Loop UP\n", isp->isp_name); 1392 break; 1393 1394 case ASYNC_LOOP_DOWN: 1395 PRINTF("%s: Loop DOWN\n", isp->isp_name); 1396 break; 1397 1398 case ASYNC_LOOP_RESET: 1399 PRINTF("%s: Loop RESET\n", isp->isp_name); 1400 break; 1401 1402 case ASYNC_PDB_CHANGED: 1403 PRINTF("%s: Port Database Changed\n", isp->isp_name); 1404 break; 1405 1406 case ASYNC_CHANGE_NOTIFY: 1407 PRINTF("%s: Name Server Database Changed\n", isp->isp_name); 1408 break; 1409 1410 default: 1411 PRINTF("%s: async %x\n", isp->isp_name, mbox); 1412 break; 1413 } 1414 return (0); 1415 } 1416 1417 static int 1418 isp_handle_other_response(isp, sp, optrp) 1419 struct ispsoftc *isp; 1420 ispstatusreq_t *sp; 1421 u_int8_t *optrp; 1422 { 1423 switch (sp->req_header.rqs_entry_type) { 1424 case RQSTYPE_NOTIFY: 1425 { 1426 ispnotify_t *spx = (ispnotify_t *) sp; 1427 PRINTF("%s: Immediate Notify %d.%d Status 0x%x Sequence 0x%x\n", 1428 isp->isp_name, spx->req_initiator, spx->req_lun, 1429 spx->req_status, spx->req_sequence); 1430 break; 1431 } 1432 case RQSTYPE_REQUEST: 1433 return (-1); 1434 1435 default: 1436 PRINTF("%s: other response type %x\n", isp->isp_name, 1437 sp->req_header.rqs_entry_type); 1438 break; 1439 } 1440 return (0); 1441 } 1442 1443 1444 static void 1445 isp_parse_status(isp, sp, xs) 1446 struct ispsoftc *isp; 1447 ispstatusreq_t *sp; 1448 ISP_SCSI_XFER_T *xs; 1449 { 1450 switch (sp->req_completion_status) { 1451 case RQCS_COMPLETE: 1452 XS_SETERR(xs, HBA_NOERROR); 1453 return; 1454 1455 case RQCS_INCOMPLETE: 1456 if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) { 1457 IDPRINTF(3, ("Selection Timeout\n")); 1458 XS_SETERR(xs, HBA_SELTIMEOUT); 1459 return; 1460 } 1461 PRINTF("%s: command incomplete for target %d lun %d, state " 1462 "0x%x\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs), 1463 sp->req_state_flags); 1464 break; 1465 1466 case RQCS_DMA_ERROR: 1467 PRINTF("%s: DMA error for command on target %d, lun %d\n", 1468 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1469 break; 1470 1471 case RQCS_TRANSPORT_ERROR: 1472 PRINTF("%s: transport error\n", isp->isp_name); 1473 isp_prtstst(sp); 1474 break; 1475 1476 case RQCS_RESET_OCCURRED: 1477 IDPRINTF(2, ("%s: bus reset destroyed command for target %d " 1478 "lun %d\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs))); 1479 isp->isp_sendmarker = 1; 1480 XS_SETERR(xs, HBA_BUSRESET); 1481 return; 1482 1483 case RQCS_ABORTED: 1484 PRINTF("%s: command aborted for target %d lun %d\n", 1485 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1486 isp->isp_sendmarker = 1; 1487 XS_SETERR(xs, HBA_ABORTED); 1488 return; 1489 1490 case RQCS_TIMEOUT: 1491 IDPRINTF(2, ("%s: command timed out for target %d lun %d\n", 1492 isp->isp_name, XS_TGT(xs), XS_LUN(xs))); 1493 XS_SETERR(xs, HBA_CMDTIMEOUT); 1494 return; 1495 1496 case RQCS_DATA_OVERRUN: 1497 if (isp->isp_type & ISP_HA_FC) { 1498 XS_RESID(xs) = sp->req_resid; 1499 break; 1500 } 1501 XS_SETERR(xs, HBA_DATAOVR); 1502 return; 1503 1504 case RQCS_COMMAND_OVERRUN: 1505 PRINTF("%s: command overrun for command on target %d, lun %d\n", 1506 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1507 break; 1508 1509 case RQCS_STATUS_OVERRUN: 1510 PRINTF("%s: status overrun for command on target %d, lun %d\n", 1511 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1512 break; 1513 1514 case RQCS_BAD_MESSAGE: 1515 PRINTF("%s: message not COMMAND COMPLETE after status on " 1516 "target %d, lun %d\n", isp->isp_name, XS_TGT(xs), 1517 XS_LUN(xs)); 1518 break; 1519 1520 case RQCS_NO_MESSAGE_OUT: 1521 PRINTF("%s: No MESSAGE OUT phase after selection on " 1522 "target %d, lun %d\n", isp->isp_name, XS_TGT(xs), 1523 XS_LUN(xs)); 1524 break; 1525 1526 case RQCS_EXT_ID_FAILED: 1527 PRINTF("%s: EXTENDED IDENTIFY failed on target %d, lun %d\n", 1528 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1529 break; 1530 1531 case RQCS_IDE_MSG_FAILED: 1532 PRINTF("%s: target %d lun %d rejected INITIATOR DETECTED " 1533 "ERROR message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1534 break; 1535 1536 case RQCS_ABORT_MSG_FAILED: 1537 PRINTF("%s: target %d lun %d rejected ABORT message\n", 1538 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1539 break; 1540 1541 case RQCS_REJECT_MSG_FAILED: 1542 PRINTF("%s: target %d lun %d rejected MESSAGE REJECT message\n", 1543 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1544 break; 1545 1546 case RQCS_NOP_MSG_FAILED: 1547 PRINTF("%s: target %d lun %d rejected NOP message\n", 1548 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1549 break; 1550 1551 case RQCS_PARITY_ERROR_MSG_FAILED: 1552 PRINTF("%s: target %d lun %d rejected MESSAGE PARITY ERROR " 1553 "message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1554 break; 1555 1556 case RQCS_DEVICE_RESET_MSG_FAILED: 1557 PRINTF("%s: target %d lun %d rejected BUS DEVICE RESET " 1558 "message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1559 break; 1560 1561 case RQCS_ID_MSG_FAILED: 1562 PRINTF("%s: target %d lun %d rejected IDENTIFY " 1563 "message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1564 break; 1565 1566 case RQCS_UNEXP_BUS_FREE: 1567 PRINTF("%s: target %d lun %d had unexeptected bus free\n", 1568 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1569 break; 1570 1571 case RQCS_DATA_UNDERRUN: 1572 if (isp->isp_type & ISP_HA_FC) { 1573 XS_RESID(xs) = sp->req_resid; 1574 /* an UNDERRUN is not a botch ??? */ 1575 } 1576 XS_SETERR(xs, HBA_NOERROR); 1577 return; 1578 1579 case RQCS_XACT_ERR1: 1580 PRINTF("%s: HBA attempted queued transaction with disconnect " 1581 "not set for target %d lun %d\n", isp->isp_name, XS_TGT(xs), 1582 XS_LUN(xs)); 1583 break; 1584 1585 case RQCS_XACT_ERR2: 1586 PRINTF("%s: HBA attempted queued transaction to target " 1587 "routine %d on target %d\n", isp->isp_name, XS_LUN(xs), 1588 XS_TGT(xs)); 1589 break; 1590 1591 case RQCS_XACT_ERR3: 1592 PRINTF("%s: HBA attempted queued transaction for target %d lun " 1593 "%d when queueing disabled\n", isp->isp_name, XS_TGT(xs), 1594 XS_LUN(xs)); 1595 break; 1596 1597 case RQCS_BAD_ENTRY: 1598 PRINTF("%s: invalid IOCB entry type detected\n", isp->isp_name); 1599 break; 1600 1601 case RQCS_QUEUE_FULL: 1602 PRINTF("%s: internal queue full for this device\n", 1603 isp->isp_name); 1604 break; 1605 1606 case RQCS_PHASE_SKIPPED: 1607 PRINTF("%s: SCSI phase skipped (e.g., COMMAND COMPLETE w/o " 1608 "STATUS phase) for target %d lun %d\n", isp->isp_name, 1609 XS_TGT(xs), XS_LUN(xs)); 1610 break; 1611 1612 case RQCS_ARQS_FAILED: 1613 PRINTF("%s: Auto Request Sense failed for target %d lun %d\n", 1614 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1615 XS_SETERR(xs, HBA_ARQFAIL); 1616 return; 1617 1618 case RQCS_WIDE_FAILED: 1619 PRINTF("%s: Wide Negotiation failed for target %d lun %d\n", 1620 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1621 if (isp->isp_type & ISP_HA_SCSI) { 1622 sdparam *sdp = isp->isp_param; 1623 isp->isp_update = 1; 1624 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1; 1625 sdp->isp_devparam[XS_TGT(xs)].dev_flags &= ~DPARM_WIDE; 1626 } 1627 XS_SETERR(xs, HBA_NOERROR); 1628 return; 1629 1630 case RQCS_SYNCXFER_FAILED: 1631 PRINTF("%s: SDTR Message failed for target %d lun %d\n", 1632 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1633 if (isp->isp_type & ISP_HA_SCSI) { 1634 sdparam *sdp = isp->isp_param; 1635 isp->isp_update = 1; 1636 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1; 1637 sdp->isp_devparam[XS_TGT(xs)].dev_flags &= ~DPARM_SYNC; 1638 } 1639 break; 1640 1641 case RQCS_LVD_BUSERR: 1642 PRINTF("%s: Bad LVD Bus condition while talking to target %d " 1643 "lun %d\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1644 break; 1645 1646 case RQCS_PORT_UNAVAILABLE: 1647 /* 1648 * No such port on the loop. Moral equivalent of SELTIMEO 1649 */ 1650 XS_SETERR(xs, HBA_SELTIMEOUT); 1651 return; 1652 1653 case RQCS_PORT_LOGGED_OUT: 1654 PRINTF("%s: port logout for target %d\n", 1655 isp->isp_name, XS_TGT(xs)); 1656 break; 1657 1658 case RQCS_PORT_CHANGED: 1659 PRINTF("%s: port changed for target %d\n", 1660 isp->isp_name, XS_TGT(xs)); 1661 break; 1662 1663 case RQCS_PORT_BUSY: 1664 PRINTF("%s: port busy for target %d\n", 1665 isp->isp_name, XS_TGT(xs)); 1666 XS_SETERR(xs, HBA_TGTBSY); 1667 return; 1668 1669 default: 1670 PRINTF("%s: comp status %x\n", isp->isp_name, 1671 sp->req_completion_status); 1672 break; 1673 } 1674 XS_SETERR(xs, HBA_BOTCH); 1675 } 1676 1677 #define HINIB(x) ((x) >> 0x4) 1678 #define LONIB(x) ((x) & 0xf) 1679 #define MAKNIB(a, b) (((a) << 4) | (b)) 1680 static u_int8_t mbpcnt[] = { 1681 MAKNIB(1, 1), /* 0x00: MBOX_NO_OP */ 1682 MAKNIB(5, 5), /* 0x01: MBOX_LOAD_RAM */ 1683 MAKNIB(2, 0), /* 0x02: MBOX_EXEC_FIRMWARE */ 1684 MAKNIB(5, 5), /* 0x03: MBOX_DUMP_RAM */ 1685 MAKNIB(3, 3), /* 0x04: MBOX_WRITE_RAM_WORD */ 1686 MAKNIB(2, 3), /* 0x05: MBOX_READ_RAM_WORD */ 1687 MAKNIB(6, 6), /* 0x06: MBOX_MAILBOX_REG_TEST */ 1688 MAKNIB(2, 3), /* 0x07: MBOX_VERIFY_CHECKSUM */ 1689 MAKNIB(1, 3), /* 0x08: MBOX_ABOUT_FIRMWARE */ 1690 MAKNIB(0, 0), /* 0x09: */ 1691 MAKNIB(0, 0), /* 0x0a: */ 1692 MAKNIB(0, 0), /* 0x0b: */ 1693 MAKNIB(0, 0), /* 0x0c: */ 1694 MAKNIB(0, 0), /* 0x0d: */ 1695 MAKNIB(1, 2), /* 0x0e: MBOX_CHECK_FIRMWARE */ 1696 MAKNIB(0, 0), /* 0x0f: */ 1697 MAKNIB(5, 5), /* 0x10: MBOX_INIT_REQ_QUEUE */ 1698 MAKNIB(6, 6), /* 0x11: MBOX_INIT_RES_QUEUE */ 1699 MAKNIB(4, 4), /* 0x12: MBOX_EXECUTE_IOCB */ 1700 MAKNIB(2, 2), /* 0x13: MBOX_WAKE_UP */ 1701 MAKNIB(1, 6), /* 0x14: MBOX_STOP_FIRMWARE */ 1702 MAKNIB(4, 4), /* 0x15: MBOX_ABORT */ 1703 MAKNIB(2, 2), /* 0x16: MBOX_ABORT_DEVICE */ 1704 MAKNIB(3, 3), /* 0x17: MBOX_ABORT_TARGET */ 1705 MAKNIB(2, 2), /* 0x18: MBOX_BUS_RESET */ 1706 MAKNIB(2, 3), /* 0x19: MBOX_STOP_QUEUE */ 1707 MAKNIB(2, 3), /* 0x1a: MBOX_START_QUEUE */ 1708 MAKNIB(2, 3), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */ 1709 MAKNIB(2, 3), /* 0x1c: MBOX_ABORT_QUEUE */ 1710 MAKNIB(2, 4), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */ 1711 MAKNIB(0, 0), /* 0x1e: */ 1712 MAKNIB(1, 3), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */ 1713 MAKNIB(1, 2), /* 0x20: MBOX_GET_INIT_SCSI_ID */ 1714 MAKNIB(1, 2), /* 0x21: MBOX_GET_SELECT_TIMEOUT */ 1715 MAKNIB(1, 3), /* 0x22: MBOX_GET_RETRY_COUNT */ 1716 MAKNIB(1, 2), /* 0x23: MBOX_GET_TAG_AGE_LIMIT */ 1717 MAKNIB(1, 2), /* 0x24: MBOX_GET_CLOCK_RATE */ 1718 MAKNIB(1, 2), /* 0x25: MBOX_GET_ACT_NEG_STATE */ 1719 MAKNIB(1, 2), /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */ 1720 MAKNIB(1, 3), /* 0x27: MBOX_GET_PCI_PARAMS */ 1721 MAKNIB(2, 4), /* 0x28: MBOX_GET_TARGET_PARAMS */ 1722 MAKNIB(2, 4), /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */ 1723 MAKNIB(0, 0), /* 0x2a: */ 1724 MAKNIB(0, 0), /* 0x2b: */ 1725 MAKNIB(0, 0), /* 0x2c: */ 1726 MAKNIB(0, 0), /* 0x2d: */ 1727 MAKNIB(0, 0), /* 0x2e: */ 1728 MAKNIB(0, 0), /* 0x2f: */ 1729 MAKNIB(2, 2), /* 0x30: MBOX_SET_INIT_SCSI_ID */ 1730 MAKNIB(2, 2), /* 0x31: MBOX_SET_SELECT_TIMEOUT */ 1731 MAKNIB(3, 3), /* 0x32: MBOX_SET_RETRY_COUNT */ 1732 MAKNIB(2, 2), /* 0x33: MBOX_SET_TAG_AGE_LIMIT */ 1733 MAKNIB(2, 2), /* 0x34: MBOX_SET_CLOCK_RATE */ 1734 MAKNIB(2, 2), /* 0x35: MBOX_SET_ACTIVE_NEG_STATE */ 1735 MAKNIB(2, 2), /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */ 1736 MAKNIB(3, 3), /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */ 1737 MAKNIB(4, 4), /* 0x38: MBOX_SET_TARGET_PARAMS */ 1738 MAKNIB(4, 4), /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */ 1739 MAKNIB(0, 0), /* 0x3a: */ 1740 MAKNIB(0, 0), /* 0x3b: */ 1741 MAKNIB(0, 0), /* 0x3c: */ 1742 MAKNIB(0, 0), /* 0x3d: */ 1743 MAKNIB(0, 0), /* 0x3e: */ 1744 MAKNIB(0, 0), /* 0x3f: */ 1745 MAKNIB(1, 2), /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */ 1746 MAKNIB(6, 1), /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */ 1747 MAKNIB(2, 3), /* 0x42: MBOX_EXEC_BIOS_IOCB */ 1748 MAKNIB(0, 0), /* 0x43: */ 1749 MAKNIB(0, 0), /* 0x44: */ 1750 MAKNIB(0, 0), /* 0x45: */ 1751 MAKNIB(0, 0), /* 0x46: */ 1752 MAKNIB(0, 0), /* 0x47: */ 1753 MAKNIB(0, 0), /* 0x48: */ 1754 MAKNIB(0, 0), /* 0x49: */ 1755 MAKNIB(0, 0), /* 0x4a: */ 1756 MAKNIB(0, 0), /* 0x4b: */ 1757 MAKNIB(0, 0), /* 0x4c: */ 1758 MAKNIB(0, 0), /* 0x4d: */ 1759 MAKNIB(0, 0), /* 0x4e: */ 1760 MAKNIB(0, 0), /* 0x4f: */ 1761 MAKNIB(0, 0), /* 0x50: */ 1762 MAKNIB(0, 0), /* 0x51: */ 1763 MAKNIB(0, 0), /* 0x52: */ 1764 MAKNIB(0, 0), /* 0x53: */ 1765 MAKNIB(8, 0), /* 0x54: MBOX_EXEC_COMMAND_IOCB_A64 */ 1766 MAKNIB(0, 0), /* 0x55: */ 1767 MAKNIB(0, 0), /* 0x56: */ 1768 MAKNIB(0, 0), /* 0x57: */ 1769 MAKNIB(0, 0), /* 0x58: */ 1770 MAKNIB(0, 0), /* 0x59: */ 1771 MAKNIB(0, 0), /* 0x5a: */ 1772 MAKNIB(0, 0), /* 0x5b: */ 1773 MAKNIB(0, 0), /* 0x5c: */ 1774 MAKNIB(0, 0), /* 0x5d: */ 1775 MAKNIB(0, 0), /* 0x5e: */ 1776 MAKNIB(0, 0), /* 0x5f: */ 1777 MAKNIB(8, 6), /* 0x60: MBOX_INIT_FIRMWARE */ 1778 MAKNIB(0, 0), /* 0x60: MBOX_GET_INIT_CONTROL_BLOCK (FORMAT?) */ 1779 MAKNIB(2, 1), /* 0x62: MBOX_INIT_LIP */ 1780 MAKNIB(8, 1), /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */ 1781 MAKNIB(8, 1), /* 0x64: MBOX_GET_PORT_DB */ 1782 MAKNIB(3, 1), /* 0x65: MBOX_CLEAR_ACA */ 1783 MAKNIB(3, 1), /* 0x66: MBOX_TARGET_RESET */ 1784 MAKNIB(3, 1), /* 0x67: MBOX_CLEAR_TASK_SET */ 1785 MAKNIB(3, 1), /* 0x69: MBOX_ABORT_TASK_SET */ 1786 MAKNIB(1, 2) /* 0x69: MBOX_GET_FW_STATE */ 1787 }; 1788 #define NMBCOM (sizeof (mbpcnt) / sizeof (mbpcnt[0])) 1789 1790 static void 1791 isp_mboxcmd(isp, mbp) 1792 struct ispsoftc *isp; 1793 mbreg_t *mbp; 1794 { 1795 int outparam, inparam; 1796 int loops, dld = 0; 1797 u_int8_t opcode; 1798 1799 if (mbp->param[0] == ISP2100_SET_PCI_PARAM) { 1800 opcode = mbp->param[0] = MBOX_SET_PCI_PARAMETERS; 1801 inparam = 4; 1802 outparam = 4; 1803 goto command_known; 1804 } else if (mbp->param[0] > NMBCOM) { 1805 PRINTF("%s: bad command %x\n", isp->isp_name, mbp->param[0]); 1806 return; 1807 } 1808 1809 opcode = mbp->param[0]; 1810 inparam = HINIB(mbpcnt[mbp->param[0]]); 1811 outparam = LONIB(mbpcnt[mbp->param[0]]); 1812 1813 if (inparam == 0 && outparam == 0) { 1814 PRINTF("%s: no parameters for %x\n", isp->isp_name, 1815 mbp->param[0]); 1816 return; 1817 } 1818 1819 1820 command_known: 1821 1822 /* 1823 * Make sure we can send some words.. 1824 */ 1825 1826 loops = MBOX_DELAY_COUNT; 1827 while ((ISP_READ(isp, HCCR) & HCCR_HOST_INT) != 0) { 1828 SYS_DELAY(100); 1829 if (--loops < 0) { 1830 PRINTF("%s: isp_mboxcmd timeout #1\n", isp->isp_name); 1831 if (dld++) { 1832 return; 1833 } 1834 PRINTF("%s: but we'll try again, isr=%x\n", 1835 isp->isp_name, ISP_READ(isp, BIU_ISR)); 1836 if (ISP_READ(isp, BIU_SEMA) & 1) { 1837 u_int16_t mbox = ISP_READ(isp, OUTMAILBOX0); 1838 if (isp_parse_async(isp, mbox)) 1839 return; 1840 ISP_WRITE(isp, BIU_SEMA, 0); 1841 } 1842 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 1843 goto command_known; 1844 } 1845 } 1846 1847 /* 1848 * Write input parameters 1849 */ 1850 switch (inparam) { 1851 case 8: ISP_WRITE(isp, INMAILBOX7, mbp->param[7]); mbp->param[7] = 0; 1852 case 7: ISP_WRITE(isp, INMAILBOX6, mbp->param[6]); mbp->param[6] = 0; 1853 case 6: ISP_WRITE(isp, INMAILBOX5, mbp->param[5]); mbp->param[5] = 0; 1854 case 5: ISP_WRITE(isp, INMAILBOX4, mbp->param[4]); mbp->param[4] = 0; 1855 case 4: ISP_WRITE(isp, INMAILBOX3, mbp->param[3]); mbp->param[3] = 0; 1856 case 3: ISP_WRITE(isp, INMAILBOX2, mbp->param[2]); mbp->param[2] = 0; 1857 case 2: ISP_WRITE(isp, INMAILBOX1, mbp->param[1]); mbp->param[1] = 0; 1858 case 1: ISP_WRITE(isp, INMAILBOX0, mbp->param[0]); mbp->param[0] = 0; 1859 } 1860 1861 /* 1862 * Clear semaphore on mailbox registers 1863 */ 1864 ISP_WRITE(isp, BIU_SEMA, 0); 1865 1866 /* 1867 * Clear RISC int condition. 1868 */ 1869 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 1870 1871 /* 1872 * Set Host Interrupt condition so that RISC will pick up mailbox regs. 1873 */ 1874 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT); 1875 1876 /* 1877 * Wait until RISC int is set, except 2100 1878 */ 1879 if ((isp->isp_type & ISP_HA_FC) == 0) { 1880 loops = MBOX_DELAY_COUNT; 1881 while ((ISP_READ(isp, BIU_ISR) & BIU_ISR_RISC_INT) == 0) { 1882 SYS_DELAY(100); 1883 if (--loops < 0) { 1884 PRINTF("%s: isp_mboxcmd timeout #2\n", 1885 isp->isp_name); 1886 return; 1887 } 1888 } 1889 } 1890 1891 /* 1892 * Check to make sure that the semaphore has been set. 1893 */ 1894 loops = MBOX_DELAY_COUNT; 1895 while ((ISP_READ(isp, BIU_SEMA) & 1) == 0) { 1896 SYS_DELAY(100); 1897 if (--loops < 0) { 1898 PRINTF("%s: isp_mboxcmd timeout #3\n", isp->isp_name); 1899 return; 1900 } 1901 } 1902 1903 /* 1904 * Make sure that the MBOX_BUSY has gone away 1905 */ 1906 loops = MBOX_DELAY_COUNT; 1907 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) { 1908 SYS_DELAY(100); 1909 if (--loops < 0) { 1910 PRINTF("%s: isp_mboxcmd timeout #4\n", isp->isp_name); 1911 return; 1912 } 1913 } 1914 1915 1916 /* 1917 * Pick up output parameters. 1918 */ 1919 switch (outparam) { 1920 case 8: mbp->param[7] = ISP_READ(isp, OUTMAILBOX7); 1921 case 7: mbp->param[6] = ISP_READ(isp, OUTMAILBOX6); 1922 case 6: mbp->param[5] = ISP_READ(isp, OUTMAILBOX5); 1923 case 5: mbp->param[4] = ISP_READ(isp, OUTMAILBOX4); 1924 case 4: mbp->param[3] = ISP_READ(isp, OUTMAILBOX3); 1925 case 3: mbp->param[2] = ISP_READ(isp, OUTMAILBOX2); 1926 case 2: mbp->param[1] = ISP_READ(isp, OUTMAILBOX1); 1927 case 1: mbp->param[0] = ISP_READ(isp, OUTMAILBOX0); 1928 } 1929 1930 /* 1931 * Clear RISC int. 1932 */ 1933 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 1934 1935 /* 1936 * Release semaphore on mailbox registers 1937 */ 1938 ISP_WRITE(isp, BIU_SEMA, 0); 1939 1940 /* 1941 * Just to be chatty here... 1942 */ 1943 switch(mbp->param[0]) { 1944 case MBOX_COMMAND_COMPLETE: 1945 break; 1946 case MBOX_INVALID_COMMAND: 1947 IDPRINTF(2, ("%s: mbox cmd %x failed with INVALID_COMMAND\n", 1948 isp->isp_name, opcode)); 1949 break; 1950 case MBOX_HOST_INTERFACE_ERROR: 1951 PRINTF("%s: mbox cmd %x failed with HOST_INTERFACE_ERROR\n", 1952 isp->isp_name, opcode); 1953 break; 1954 case MBOX_TEST_FAILED: 1955 PRINTF("%s: mbox cmd %x failed with TEST_FAILED\n", 1956 isp->isp_name, opcode); 1957 break; 1958 case MBOX_COMMAND_ERROR: 1959 PRINTF("%s: mbox cmd %x failed with COMMAND_ERROR\n", 1960 isp->isp_name, opcode); 1961 break; 1962 case MBOX_COMMAND_PARAM_ERROR: 1963 PRINTF("%s: mbox cmd %x failed with COMMAND_PARAM_ERROR\n", 1964 isp->isp_name, opcode); 1965 break; 1966 1967 case ASYNC_LOOP_UP: 1968 case ASYNC_LIP_OCCURRED: 1969 break; 1970 1971 default: 1972 /* 1973 * The expected return of EXEC_FIRMWARE is zero. 1974 */ 1975 if ((opcode == MBOX_EXEC_FIRMWARE && mbp->param[0] != 0) || 1976 (opcode != MBOX_EXEC_FIRMWARE)) { 1977 PRINTF("%s: mbox cmd %x failed with error %x\n", 1978 isp->isp_name, opcode, mbp->param[0]); 1979 } 1980 break; 1981 } 1982 } 1983 1984 void 1985 isp_lostcmd(isp, xs) 1986 struct ispsoftc *isp; 1987 ISP_SCSI_XFER_T *xs; 1988 { 1989 mbreg_t mbs; 1990 1991 mbs.param[0] = MBOX_GET_FIRMWARE_STATUS; 1992 isp_mboxcmd(isp, &mbs); 1993 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1994 isp_dumpregs(isp, "couldn't GET FIRMWARE STATUS"); 1995 return; 1996 } 1997 if (mbs.param[1]) { 1998 PRINTF("%s: %d commands on completion queue\n", 1999 isp->isp_name, mbs.param[1]); 2000 } 2001 if (XS_NULL(xs)) 2002 return; 2003 2004 mbs.param[0] = MBOX_GET_DEV_QUEUE_STATUS; 2005 mbs.param[1] = (XS_TGT(xs) << 8) | XS_LUN(xs); 2006 isp_mboxcmd(isp, &mbs); 2007 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 2008 isp_dumpregs(isp, "couldn't GET DEVICE QUEUE STATUS"); 2009 return; 2010 } 2011 PRINTF("%s: lost command for target %d lun %d, %d active of %d, " 2012 "Queue State: %x\n", isp->isp_name, XS_TGT(xs), 2013 XS_LUN(xs), mbs.param[2], mbs.param[3], mbs.param[1]); 2014 2015 isp_dumpregs(isp, "lost command"); 2016 /* 2017 * XXX: Need to try and do something to recover. 2018 */ 2019 } 2020 2021 static void 2022 isp_dumpregs(isp, msg) 2023 struct ispsoftc *isp; 2024 const char *msg; 2025 { 2026 PRINTF("%s: %s\n", isp->isp_name, msg); 2027 if (isp->isp_type & ISP_HA_SCSI) 2028 PRINTF(" biu_conf1=%x", ISP_READ(isp, BIU_CONF1)); 2029 else 2030 PRINTF(" biu_csr=%x", ISP_READ(isp, BIU2100_CSR)); 2031 PRINTF(" biu_icr=%x biu_isr=%x biu_sema=%x ", ISP_READ(isp, BIU_ICR), 2032 ISP_READ(isp, BIU_ISR), ISP_READ(isp, BIU_SEMA)); 2033 PRINTF("risc_hccr=%x\n", ISP_READ(isp, HCCR)); 2034 2035 if (isp->isp_type & ISP_HA_SCSI) { 2036 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE); 2037 PRINTF(" cdma_conf=%x cdma_sts=%x cdma_fifostat=%x\n", 2038 ISP_READ(isp, CDMA_CONF), ISP_READ(isp, CDMA_STATUS), 2039 ISP_READ(isp, CDMA_FIFO_STS)); 2040 PRINTF(" ddma_conf=%x ddma_sts=%x ddma_fifostat=%x\n", 2041 ISP_READ(isp, DDMA_CONF), ISP_READ(isp, DDMA_STATUS), 2042 ISP_READ(isp, DDMA_FIFO_STS)); 2043 PRINTF(" sxp_int=%x sxp_gross=%x sxp(scsi_ctrl)=%x\n", 2044 ISP_READ(isp, SXP_INTERRUPT), 2045 ISP_READ(isp, SXP_GROSS_ERR), 2046 ISP_READ(isp, SXP_PINS_CONTROL)); 2047 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); 2048 } 2049 ISP_DUMPREGS(isp); 2050 } 2051 2052 static void 2053 isp_dumpxflist(isp) 2054 struct ispsoftc *isp; 2055 { 2056 volatile ISP_SCSI_XFER_T *xs; 2057 int i, hdp; 2058 2059 for (hdp = i = 0; i < RQUEST_QUEUE_LEN; i++) { 2060 xs = isp->isp_xflist[i]; 2061 if (xs == NULL) { 2062 continue; 2063 } 2064 if (hdp == 0) { 2065 PRINTF("%s: active requests\n", isp->isp_name); 2066 hdp++; 2067 } 2068 PRINTF(" Active Handle %d: tgt %d lun %d dlen %d\n", 2069 i+1, XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs)); 2070 } 2071 } 2072 2073 static void 2074 isp_fw_state(isp) 2075 struct ispsoftc *isp; 2076 { 2077 mbreg_t mbs; 2078 if (isp->isp_type & ISP_HA_FC) { 2079 int once = 0; 2080 fcparam *fcp = isp->isp_param; 2081 again: 2082 mbs.param[0] = MBOX_GET_FW_STATE; 2083 isp_mboxcmd(isp, &mbs); 2084 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 2085 if (mbs.param[0] == ASYNC_LIP_OCCURRED || 2086 mbs.param[0] == ASYNC_LOOP_UP) { 2087 if (once++ < 2) { 2088 goto again; 2089 } 2090 } 2091 isp_dumpregs(isp, "GET FIRMWARE STATE failed"); 2092 return; 2093 } 2094 fcp->isp_fwstate = mbs.param[1]; 2095 } 2096 } 2097 2098 static void 2099 isp_update(isp) 2100 struct ispsoftc *isp; 2101 { 2102 int tgt; 2103 mbreg_t mbs; 2104 sdparam *sdp; 2105 2106 isp->isp_update = 0; 2107 2108 if (isp->isp_type & ISP_HA_FC) { 2109 return; 2110 } 2111 2112 sdp = isp->isp_param; 2113 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 2114 if (sdp->isp_devparam[tgt].dev_enable == 0) { 2115 continue; 2116 } 2117 if (sdp->isp_devparam[tgt].dev_update == 0) { 2118 continue; 2119 } 2120 2121 mbs.param[0] = MBOX_SET_TARGET_PARAMS; 2122 mbs.param[1] = tgt << 8; 2123 mbs.param[2] = sdp->isp_devparam[tgt].dev_flags; 2124 mbs.param[3] = 2125 (sdp->isp_devparam[tgt].sync_offset << 8) | 2126 (sdp->isp_devparam[tgt].sync_period); 2127 2128 IDPRINTF(3, ("\n%s: tgt %d cflags %x offset %x period %x\n", 2129 isp->isp_name, tgt, mbs.param[2], mbs.param[3] >> 8, 2130 mbs.param[3] & 0xff)); 2131 2132 isp_mboxcmd(isp, &mbs); 2133 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 2134 PRINTF("%s: failed to change SCSI parameters for " 2135 "target %d\n", isp->isp_name, tgt); 2136 } else { 2137 char *wt; 2138 int x, flags; 2139 2140 flags = sdp->isp_devparam[tgt].cur_dflags = 2141 sdp->isp_devparam[tgt].dev_flags; 2142 2143 x = sdp->isp_devparam[tgt].sync_period & 0xff; 2144 if (flags & DPARM_SYNC) { 2145 if (x == (ISP_20M_SYNCPARMS & 0xff)) { 2146 x = 20; 2147 } else if (x == (ISP_10M_SYNCPARMS & 0xff)) { 2148 x = 10; 2149 } else if (x == (ISP_08M_SYNCPARMS & 0xff)) { 2150 x = 8; 2151 } else if (x == (ISP_05M_SYNCPARMS & 0xff)) { 2152 x = 5; 2153 } else if (x == (ISP_04M_SYNCPARMS & 0xff)) { 2154 x = 4; 2155 } else { 2156 x = 0; 2157 } 2158 } else { 2159 x = 0; 2160 } 2161 switch (flags & (DPARM_WIDE|DPARM_TQING)) { 2162 case DPARM_WIDE: 2163 wt = ", 16 bit wide\n"; 2164 break; 2165 case DPARM_TQING: 2166 wt = ", Tagged Queueing Enabled\n"; 2167 break; 2168 case DPARM_WIDE|DPARM_TQING: 2169 wt = ", 16 bit wide, Tagged Queueing Enabled\n"; 2170 break; 2171 2172 default: 2173 wt = "\n"; 2174 break; 2175 } 2176 if (x) { 2177 IDPRINTF(3, ("%s: Target %d maximum Sync Mode " 2178 "at %dMHz%s", isp->isp_name, tgt, x, wt)); 2179 } else { 2180 IDPRINTF(3, ("%s: Target %d Async Mode%s", 2181 isp->isp_name, tgt, wt)); 2182 } 2183 } 2184 sdp->isp_devparam[tgt].dev_update = 0; 2185 } 2186 } 2187 2188 static void 2189 isp_setdfltparm(isp) 2190 struct ispsoftc *isp; 2191 { 2192 int i, use_nvram; 2193 mbreg_t mbs; 2194 sdparam *sdp; 2195 2196 /* 2197 * Been there, done that, got the T-shirt... 2198 */ 2199 if (isp->isp_gotdparms) { 2200 IDPRINTF(3, ("%s: already have dparms\n", isp->isp_name)); 2201 return; 2202 } 2203 isp->isp_gotdparms = 1; 2204 2205 use_nvram = (isp_read_nvram(isp) == 0); 2206 if (use_nvram) { 2207 return; 2208 } 2209 if (isp->isp_type & ISP_HA_FC) { 2210 fcparam *fcp = (fcparam *) isp->isp_param; 2211 fcp->isp_maxfrmlen = ICB_DFLT_FRMLEN; 2212 fcp->isp_maxalloc = 256; 2213 fcp->isp_execthrottle = 16; 2214 fcp->isp_retry_delay = 5; 2215 fcp->isp_retry_count = 0; 2216 /* 2217 * It would be nice to fake up a WWN in case we don't 2218 * get one out of NVRAM. Solaris does this for SOCAL 2219 * cards that don't have SBus properties- it sets up 2220 * a WWN based upon the system MAC Address. 2221 */ 2222 fcp->isp_wwn = 0; 2223 return; 2224 } 2225 2226 sdp = (sdparam *) isp->isp_param; 2227 mbs.param[0] = MBOX_GET_ACT_NEG_STATE; 2228 isp_mboxcmd(isp, &mbs); 2229 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 2230 IDPRINTF(2, ("could not GET ACT NEG STATE\n")); 2231 sdp->isp_req_ack_active_neg = 1; 2232 sdp->isp_data_line_active_neg = 1; 2233 } else { 2234 sdp->isp_req_ack_active_neg = (mbs.param[1] >> 4) & 0x1; 2235 sdp->isp_data_line_active_neg = (mbs.param[1] >> 5) & 0x1; 2236 } 2237 for (i = 0; i < MAX_TARGETS; i++) { 2238 2239 mbs.param[0] = MBOX_GET_TARGET_PARAMS; 2240 mbs.param[1] = i << 8; 2241 isp_mboxcmd(isp, &mbs); 2242 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 2243 PRINTF("%s: can't get SCSI parameters for target %d\n", 2244 isp->isp_name, i); 2245 sdp->isp_devparam[i].sync_period = 0; 2246 sdp->isp_devparam[i].sync_offset = 0; 2247 sdp->isp_devparam[i].dev_flags = DPARM_SAFE_DFLT; 2248 continue; 2249 } 2250 sdp->isp_devparam[i].dev_flags = mbs.param[2]; 2251 2252 /* 2253 * The maximum period we can really see 2254 * here is 100 (decimal), or 400 ns. 2255 * For some unknown reason we sometimes 2256 * get back wildass numbers from the 2257 * boot device's parameters. 2258 * 2259 * XXX: Hmm- this may be based on a different 2260 * XXX: clock rate. 2261 */ 2262 if ((mbs.param[3] & 0xff) <= 0x64) { 2263 sdp->isp_devparam[i].sync_period = mbs.param[3] & 0xff; 2264 sdp->isp_devparam[i].sync_offset = mbs.param[3] >> 8; 2265 } 2266 2267 /* 2268 * It is not safe to run Ultra Mode with a clock < 60. 2269 */ 2270 if (((sdp->isp_clock && sdp->isp_clock < 60) || 2271 (isp->isp_type < ISP_HA_SCSI_1020A)) && 2272 (sdp->isp_devparam[i].sync_period == 2273 (ISP_20M_SYNCPARMS & 0xff))) { 2274 sdp->isp_devparam[i].sync_offset = 2275 ISP_10M_SYNCPARMS >> 8; 2276 sdp->isp_devparam[i].sync_period = 2277 ISP_10M_SYNCPARMS & 0xff; 2278 } 2279 2280 } 2281 2282 /* 2283 * Set Default Host Adapter Parameters 2284 */ 2285 sdp->isp_cmd_dma_burst_enable = 1; 2286 sdp->isp_data_dma_burst_enabl = 1; 2287 sdp->isp_fifo_threshold = 0; 2288 sdp->isp_initiator_id = 7; 2289 if (isp->isp_type >= ISP_HA_SCSI_1040) { 2290 sdp->isp_async_data_setup = 9; 2291 } else { 2292 sdp->isp_async_data_setup = 6; 2293 } 2294 sdp->isp_selection_timeout = 250; 2295 sdp->isp_max_queue_depth = 128; 2296 sdp->isp_tag_aging = 8; 2297 sdp->isp_bus_reset_delay = 3; 2298 sdp->isp_retry_count = 0; 2299 sdp->isp_retry_delay = 1; 2300 2301 for (i = 0; i < MAX_TARGETS; i++) { 2302 sdp->isp_devparam[i].exc_throttle = 16; 2303 sdp->isp_devparam[i].dev_enable = 1; 2304 } 2305 } 2306 2307 /* 2308 * Re-initialize the ISP and complete all orphaned commands 2309 * with a 'botched' notice. 2310 * 2311 * Locks held prior to coming here. 2312 */ 2313 2314 void 2315 isp_restart(isp) 2316 struct ispsoftc *isp; 2317 { 2318 ISP_SCSI_XFER_T *tlist[RQUEST_QUEUE_LEN], *xs; 2319 int i; 2320 2321 for (i = 0; i < RQUEST_QUEUE_LEN; i++) { 2322 tlist[i] = (ISP_SCSI_XFER_T *) isp->isp_xflist[i]; 2323 } 2324 isp_reset(isp); 2325 if (isp->isp_state == ISP_RESETSTATE) { 2326 isp_init(isp); 2327 if (isp->isp_state == ISP_INITSTATE) { 2328 isp->isp_state = ISP_RUNSTATE; 2329 } 2330 } 2331 if (isp->isp_state != ISP_RUNSTATE) { 2332 PRINTF("%s: isp_restart cannot restart ISP\n", isp->isp_name); 2333 } 2334 2335 for (i = 0; i < RQUEST_QUEUE_LEN; i++) { 2336 xs = tlist[i]; 2337 if (XS_NULL(xs)) 2338 continue; 2339 isp->isp_nactive--; 2340 if (isp->isp_nactive < 0) 2341 isp->isp_nactive = 0; 2342 XS_RESID(xs) = XS_XFRLEN(xs); 2343 XS_SETERR(xs, HBA_BOTCH); 2344 XS_CMD_DONE(xs); 2345 } 2346 } 2347 2348 void 2349 isp_watch(arg) 2350 void *arg; 2351 { 2352 int i; 2353 struct ispsoftc *isp = arg; 2354 ISP_SCSI_XFER_T *xs; 2355 ISP_LOCKVAL_DECL; 2356 2357 /* 2358 * Look for completely dead commands (but not polled ones). 2359 */ 2360 ISP_ILOCK(isp); 2361 for (i = 0; i < RQUEST_QUEUE_LEN; i++) { 2362 if ((xs = (ISP_SCSI_XFER_T *) isp->isp_xflist[i]) == NULL) { 2363 continue; 2364 } 2365 if (XS_TIME(xs) == 0) { 2366 continue; 2367 } 2368 XS_TIME(xs) -= (WATCH_INTERVAL * 1000); 2369 /* 2370 * Avoid later thinking that this 2371 * transaction is not being timed. 2372 * Then give ourselves to watchdog 2373 * periods of grace. 2374 */ 2375 if (XS_TIME(xs) == 0) 2376 XS_TIME(xs) = 1; 2377 else if (XS_TIME(xs) > -(2 * WATCH_INTERVAL * 1000)) { 2378 continue; 2379 } 2380 if (isp_control(isp, ISPCTL_ABORT_CMD, xs)) { 2381 PRINTF("%s: isp_watch failed to abort command\n", 2382 isp->isp_name); 2383 isp_restart(isp); 2384 break; 2385 } 2386 } 2387 ISP_IUNLOCK(isp); 2388 RESTART_WATCHDOG(isp_watch, isp); 2389 } 2390 2391 static void 2392 isp_prtstst(sp) 2393 ispstatusreq_t *sp; 2394 { 2395 PRINTF("states->"); 2396 if (sp->req_state_flags & RQSF_GOT_BUS) 2397 PRINTF("GOT_BUS "); 2398 if (sp->req_state_flags & RQSF_GOT_TARGET) 2399 PRINTF("GOT_TGT "); 2400 if (sp->req_state_flags & RQSF_SENT_CDB) 2401 PRINTF("SENT_CDB "); 2402 if (sp->req_state_flags & RQSF_XFRD_DATA) 2403 PRINTF("XFRD_DATA "); 2404 if (sp->req_state_flags & RQSF_GOT_STATUS) 2405 PRINTF("GOT_STS "); 2406 if (sp->req_state_flags & RQSF_GOT_SENSE) 2407 PRINTF("GOT_SNS "); 2408 if (sp->req_state_flags & RQSF_XFER_COMPLETE) 2409 PRINTF("XFR_CMPLT "); 2410 PRINTF("\n"); 2411 PRINTF("status->"); 2412 if (sp->req_status_flags & RQSTF_DISCONNECT) 2413 PRINTF("Disconnect "); 2414 if (sp->req_status_flags & RQSTF_SYNCHRONOUS) 2415 PRINTF("Sync_xfr "); 2416 if (sp->req_status_flags & RQSTF_PARITY_ERROR) 2417 PRINTF("Parity "); 2418 if (sp->req_status_flags & RQSTF_BUS_RESET) 2419 PRINTF("Bus_Reset "); 2420 if (sp->req_status_flags & RQSTF_DEVICE_RESET) 2421 PRINTF("Device_Reset "); 2422 if (sp->req_status_flags & RQSTF_ABORTED) 2423 PRINTF("Aborted "); 2424 if (sp->req_status_flags & RQSTF_TIMEOUT) 2425 PRINTF("Timeout "); 2426 if (sp->req_status_flags & RQSTF_NEGOTIATION) 2427 PRINTF("Negotiation "); 2428 PRINTF("\n"); 2429 } 2430 2431 /* 2432 * NVRAM Routines 2433 */ 2434 2435 static int 2436 isp_read_nvram(isp) 2437 struct ispsoftc *isp; 2438 { 2439 int i, amt; 2440 u_int8_t csum, minversion; 2441 union { 2442 u_int8_t _x[ISP2100_NVRAM_SIZE]; 2443 u_int16_t _s[ISP2100_NVRAM_SIZE>>1]; 2444 } _n; 2445 #define nvram_data _n._x 2446 #define nvram_words _n._s 2447 2448 if (isp->isp_type & ISP_HA_FC) { 2449 amt = ISP2100_NVRAM_SIZE; 2450 minversion = 1; 2451 } else { 2452 amt = ISP_NVRAM_SIZE; 2453 minversion = 2; 2454 } 2455 2456 /* 2457 * Just read the first two words first to see if we have a valid 2458 * NVRAM to continue reading the rest with. 2459 */ 2460 for (i = 0; i < 2; i++) { 2461 isp_rdnvram_word(isp, i, &nvram_words[i]); 2462 } 2463 if (nvram_data[0] != 'I' || nvram_data[1] != 'S' || 2464 nvram_data[2] != 'P') { 2465 if (isp->isp_bustype != ISP_BT_SBUS) { 2466 PRINTF("%s: invalid NVRAM header\n", isp->isp_name); 2467 } 2468 return (-1); 2469 } 2470 for (i = 2; i < amt>>1; i++) { 2471 isp_rdnvram_word(isp, i, &nvram_words[i]); 2472 } 2473 for (csum = 0, i = 0; i < amt; i++) { 2474 csum += nvram_data[i]; 2475 } 2476 if (csum != 0) { 2477 PRINTF("%s: invalid NVRAM checksum\n", isp->isp_name); 2478 return (-1); 2479 } 2480 if (ISP_NVRAM_VERSION(nvram_data) < minversion) { 2481 PRINTF("%s: version %d NVRAM not understood\n", isp->isp_name, 2482 ISP_NVRAM_VERSION(nvram_data)); 2483 return (-1); 2484 } 2485 2486 if (isp->isp_type & ISP_HA_SCSI) { 2487 sdparam *sdp = (sdparam *) isp->isp_param; 2488 2489 /* XXX CHECK THIS FOR SANITY XXX */ 2490 sdp->isp_fifo_threshold = 2491 ISP_NVRAM_FIFO_THRESHOLD(nvram_data); 2492 2493 sdp->isp_initiator_id = 2494 ISP_NVRAM_INITIATOR_ID(nvram_data); 2495 2496 sdp->isp_bus_reset_delay = 2497 ISP_NVRAM_BUS_RESET_DELAY(nvram_data); 2498 2499 sdp->isp_retry_count = 2500 ISP_NVRAM_BUS_RETRY_COUNT(nvram_data); 2501 2502 sdp->isp_retry_delay = 2503 ISP_NVRAM_BUS_RETRY_DELAY(nvram_data); 2504 2505 sdp->isp_async_data_setup = 2506 ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data); 2507 2508 if (isp->isp_type >= ISP_HA_SCSI_1040) { 2509 if (sdp->isp_async_data_setup < 9) { 2510 sdp->isp_async_data_setup = 9; 2511 } 2512 } else { 2513 if (sdp->isp_async_data_setup != 6) { 2514 sdp->isp_async_data_setup = 6; 2515 } 2516 } 2517 2518 sdp->isp_req_ack_active_neg = 2519 ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data); 2520 2521 sdp->isp_data_line_active_neg = 2522 ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data); 2523 2524 sdp->isp_data_dma_burst_enabl = 2525 ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data); 2526 2527 sdp->isp_cmd_dma_burst_enable = 2528 ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data); 2529 2530 sdp->isp_tag_aging = 2531 ISP_NVRAM_TAG_AGE_LIMIT(nvram_data); 2532 2533 /* XXX ISP_NVRAM_FIFO_THRESHOLD_128 XXX */ 2534 2535 sdp->isp_selection_timeout = 2536 ISP_NVRAM_SELECTION_TIMEOUT(nvram_data); 2537 2538 sdp->isp_max_queue_depth = 2539 ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data); 2540 2541 sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data); 2542 2543 for (i = 0; i < 16; i++) { 2544 sdp->isp_devparam[i].dev_enable = 2545 ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, i); 2546 sdp->isp_devparam[i].exc_throttle = 2547 ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, i); 2548 sdp->isp_devparam[i].sync_offset = 2549 ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, i); 2550 sdp->isp_devparam[i].sync_period = 2551 ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, i); 2552 2553 if (isp->isp_type < ISP_HA_SCSI_1040) { 2554 /* 2555 * If we're not ultra, we can't possibly 2556 * be a shorter period than this. 2557 */ 2558 if (sdp->isp_devparam[i].sync_period < 0x19) { 2559 sdp->isp_devparam[i].sync_period = 2560 0x19; 2561 } 2562 if (sdp->isp_devparam[i].sync_offset > 0xc) { 2563 sdp->isp_devparam[i].sync_offset = 2564 0x0c; 2565 } 2566 } else { 2567 if (sdp->isp_devparam[i].sync_offset > 0x8) { 2568 sdp->isp_devparam[i].sync_offset = 0x8; 2569 } 2570 } 2571 2572 sdp->isp_devparam[i].dev_flags = 0; 2573 2574 if (ISP_NVRAM_TGT_RENEG(nvram_data, i)) 2575 sdp->isp_devparam[i].dev_flags |= DPARM_RENEG; 2576 if (ISP_NVRAM_TGT_QFRZ(nvram_data, i)) { 2577 PRINTF("%s: not supporting QFRZ option for " 2578 "target %d\n", isp->isp_name, i); 2579 } 2580 sdp->isp_devparam[i].dev_flags |= DPARM_ARQ; 2581 if (ISP_NVRAM_TGT_ARQ(nvram_data, i) == 0) { 2582 PRINTF("%s: not disabling ARQ option for " 2583 "target %d\n", isp->isp_name, i); 2584 } 2585 if (ISP_NVRAM_TGT_TQING(nvram_data, i)) 2586 sdp->isp_devparam[i].dev_flags |= DPARM_TQING; 2587 if (ISP_NVRAM_TGT_SYNC(nvram_data, i)) 2588 sdp->isp_devparam[i].dev_flags |= DPARM_SYNC; 2589 if (ISP_NVRAM_TGT_WIDE(nvram_data, i)) 2590 sdp->isp_devparam[i].dev_flags |= DPARM_WIDE; 2591 if (ISP_NVRAM_TGT_PARITY(nvram_data, i)) 2592 sdp->isp_devparam[i].dev_flags |= DPARM_PARITY; 2593 if (ISP_NVRAM_TGT_DISC(nvram_data, i)) 2594 sdp->isp_devparam[i].dev_flags |= DPARM_DISC; 2595 } 2596 } else { 2597 fcparam *fcp = (fcparam *) isp->isp_param; 2598 union { 2599 struct { 2600 #if BYTE_ORDER == BIG_ENDIAN 2601 u_int32_t hi32; 2602 u_int32_t lo32; 2603 #else 2604 u_int32_t lo32; 2605 u_int32_t hi32; 2606 #endif 2607 } wds; 2608 u_int64_t full64; 2609 } wwnstore; 2610 2611 wwnstore.full64 = ISP2100_NVRAM_NODE_NAME(nvram_data); 2612 PRINTF("%s: Adapter WWN 0x%08x%08x\n", isp->isp_name, 2613 wwnstore.wds.hi32, wwnstore.wds.lo32); 2614 fcp->isp_wwn = wwnstore.full64; 2615 wwnstore.full64 = ISP2100_NVRAM_BOOT_NODE_NAME(nvram_data); 2616 if (wwnstore.full64 != 0) { 2617 PRINTF("%s: BOOT DEVICE WWN 0x%08x%08x\n", isp->isp_name, 2618 wwnstore.wds.hi32, wwnstore.wds.lo32); 2619 } 2620 fcp->isp_maxalloc = 2621 ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data); 2622 fcp->isp_maxfrmlen = 2623 ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data); 2624 fcp->isp_retry_delay = 2625 ISP2100_NVRAM_RETRY_DELAY(nvram_data); 2626 fcp->isp_retry_count = 2627 ISP2100_NVRAM_RETRY_COUNT(nvram_data); 2628 fcp->isp_loopid = 2629 ISP2100_NVRAM_HARDLOOPID(nvram_data); 2630 fcp->isp_execthrottle = 2631 ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data); 2632 } 2633 return (0); 2634 } 2635 2636 static void 2637 isp_rdnvram_word(isp, wo, rp) 2638 struct ispsoftc *isp; 2639 int wo; 2640 u_int16_t *rp; 2641 { 2642 int i, cbits; 2643 u_int16_t bit, rqst; 2644 2645 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT); 2646 SYS_DELAY(2); 2647 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK); 2648 SYS_DELAY(2); 2649 2650 if (isp->isp_type & ISP_HA_FC) { 2651 wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1); 2652 rqst = (ISP_NVRAM_READ << 8) | wo; 2653 cbits = 10; 2654 } else { 2655 wo &= ((ISP_NVRAM_SIZE >> 1) - 1); 2656 rqst = (ISP_NVRAM_READ << 6) | wo; 2657 cbits = 8; 2658 } 2659 2660 /* 2661 * Clock the word select request out... 2662 */ 2663 for (i = cbits; i >= 0; i--) { 2664 if ((rqst >> i) & 1) { 2665 bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT; 2666 } else { 2667 bit = BIU_NVRAM_SELECT; 2668 } 2669 ISP_WRITE(isp, BIU_NVRAM, bit); 2670 SYS_DELAY(2); 2671 ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK); 2672 SYS_DELAY(2); 2673 ISP_WRITE(isp, BIU_NVRAM, bit); 2674 SYS_DELAY(2); 2675 } 2676 /* 2677 * Now read the result back in (bits come back in MSB format). 2678 */ 2679 *rp = 0; 2680 for (i = 0; i < 16; i++) { 2681 u_int16_t rv; 2682 *rp <<= 1; 2683 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK); 2684 SYS_DELAY(2); 2685 rv = ISP_READ(isp, BIU_NVRAM); 2686 if (rv & BIU_NVRAM_DATAIN) { 2687 *rp |= 1; 2688 } 2689 SYS_DELAY(2); 2690 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT); 2691 SYS_DELAY(2); 2692 } 2693 ISP_WRITE(isp, BIU_NVRAM, 0); 2694 SYS_DELAY(2); 2695 #if BYTE_ORDER == BIG_ENDIAN 2696 *rp = ((*rp >> 8) | ((*rp & 0xff) << 8)); 2697 #endif 2698 } 2699
Indexes created Tue Sep 23 14:10:03 GMT 2025