isp.c revision 1.25
1 /* $Id: isp.c,v 1.25 1998/09/08 07:28:50 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 PRINTF("%s: initial ABOUT FIRMWARE command failed", 231 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 return (-1); 1086 } 1087 1088 /* 1089 * Interrupt Service Routine(s). 1090 * 1091 * External (OS) framework has done the appropriate locking, 1092 * and the locking will be held throughout this function. 1093 */ 1094 1095 int 1096 isp_intr(arg) 1097 void *arg; 1098 { 1099 ISP_SCSI_XFER_T *complist[RESULT_QUEUE_LEN], *xs; 1100 struct ispsoftc *isp = arg; 1101 u_int8_t iptr, optr; 1102 u_int16_t isr; 1103 int i, ndone = 0; 1104 1105 isr = ISP_READ(isp, BIU_ISR); 1106 if (isp->isp_type & ISP_HA_FC) { 1107 if (isr == 0 || (isr & BIU2100_ISR_RISC_INT) == 0) { 1108 if (isr) { 1109 IDPRINTF(4, ("%s: isp_intr isr=%x\n", 1110 isp->isp_name, isr)); 1111 } 1112 return (0); 1113 } 1114 } else { 1115 if (isr == 0 || (isr & BIU_ISR_RISC_INT) == 0) { 1116 if (isr) { 1117 IDPRINTF(4, ("%s: isp_intr isr=%x\n", 1118 isp->isp_name, isr)); 1119 } 1120 return (0); 1121 } 1122 } 1123 1124 if (ISP_READ(isp, BIU_SEMA) & 1) { 1125 u_int16_t mbox = ISP_READ(isp, OUTMAILBOX0); 1126 if (isp_parse_async(isp, mbox)) 1127 return (1); 1128 ISP_WRITE(isp, BIU_SEMA, 0); 1129 } 1130 1131 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 1132 1133 optr = isp->isp_residx; 1134 iptr = ISP_READ(isp, OUTMAILBOX5); 1135 1136 if (optr == iptr) { 1137 IDPRINTF(4, ("why intr? isr %x iptr %x optr %x\n", 1138 isr, optr, iptr)); 1139 } 1140 ENABLE_INTS(isp); 1141 1142 while (optr != iptr) { 1143 ispstatusreq_t *sp; 1144 u_int8_t oop; 1145 int buddaboom = 0; 1146 1147 sp = (ispstatusreq_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr); 1148 oop = optr; 1149 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN); 1150 1151 if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) { 1152 if (isp_handle_other_response(isp, sp, &optr) == 0) { 1153 ISP_WRITE(isp, INMAILBOX5, optr); 1154 continue; 1155 } 1156 /* 1157 * It really has to be a bounced request just copied 1158 * from the request queue to the response queue. 1159 */ 1160 1161 if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) { 1162 ISP_WRITE(isp, INMAILBOX5, optr); 1163 continue; 1164 } 1165 PRINTF("%s: not RESPONSE in RESPONSE Queue " 1166 "(type 0x%x) @ idx %d (next %d)\n", isp->isp_name, 1167 sp->req_header.rqs_entry_type, oop, optr); 1168 buddaboom = 1; 1169 } 1170 1171 if (sp->req_header.rqs_flags & 0xf) { 1172 if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) { 1173 ISP_WRITE(isp, INMAILBOX5, optr); 1174 continue; 1175 } 1176 PRINTF("%s: rqs_flags=%x", isp->isp_name, 1177 sp->req_header.rqs_flags & 0xf); 1178 if (sp->req_header.rqs_flags & RQSFLAG_FULL) { 1179 PRINTF("%s: internal queues full\n", 1180 isp->isp_name); 1181 /* XXXX: this command *could* get restarted */ 1182 buddaboom++; 1183 } 1184 if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) { 1185 PRINTF("%s: bad header\n", isp->isp_name); 1186 buddaboom++; 1187 } 1188 if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) { 1189 PRINTF("%s: bad request packet\n", 1190 isp->isp_name); 1191 buddaboom++; 1192 } 1193 } 1194 if (sp->req_handle > RQUEST_QUEUE_LEN || sp->req_handle < 1) { 1195 PRINTF("%s: bad request handle %d\n", isp->isp_name, 1196 sp->req_handle); 1197 ISP_WRITE(isp, INMAILBOX5, optr); 1198 continue; 1199 } 1200 xs = (ISP_SCSI_XFER_T *) isp->isp_xflist[sp->req_handle - 1]; 1201 if (xs == NULL) { 1202 PRINTF("%s: NULL xs in xflist (handle %x)\n", 1203 isp->isp_name, sp->req_handle); 1204 isp_dumpxflist(isp); 1205 ISP_WRITE(isp, INMAILBOX5, optr); 1206 continue; 1207 } 1208 isp->isp_xflist[sp->req_handle - 1] = NULL; 1209 if (sp->req_status_flags & RQSTF_BUS_RESET) { 1210 isp->isp_sendmarker = 1; 1211 } 1212 if (buddaboom) { 1213 XS_SETERR(xs, HBA_BOTCH); 1214 } 1215 XS_STS(xs) = sp->req_scsi_status & 0xff; 1216 if (isp->isp_type & ISP_HA_SCSI) { 1217 if (sp->req_state_flags & RQSF_GOT_SENSE) { 1218 bcopy(sp->req_sense_data, XS_SNSP(xs), 1219 XS_SNSLEN(xs)); 1220 XS_SNS_IS_VALID(xs); 1221 } 1222 } else { 1223 if (XS_STS(xs) == SCSI_CHECK) { 1224 XS_SNS_IS_VALID(xs); 1225 bcopy(sp->req_sense_data, XS_SNSP(xs), 1226 XS_SNSLEN(xs)); 1227 sp->req_state_flags |= RQSF_GOT_SENSE; 1228 } 1229 } 1230 if (XS_NOERR(xs) && XS_STS(xs) == SCSI_BUSY) { 1231 XS_SETERR(xs, HBA_TGTBSY); 1232 } 1233 1234 if (sp->req_header.rqs_entry_type == RQSTYPE_RESPONSE) { 1235 if (XS_NOERR(xs)) { 1236 if (sp->req_completion_status != RQCS_COMPLETE) { 1237 isp_parse_status(isp, sp, xs); 1238 } else { 1239 XS_SETERR(xs, HBA_NOERROR); 1240 } 1241 } 1242 } else { 1243 PRINTF("%s: unknown return %x\n", isp->isp_name, 1244 sp->req_header.rqs_entry_type); 1245 if (XS_NOERR(xs)) 1246 XS_SETERR(xs, HBA_BOTCH); 1247 } 1248 if (isp->isp_type & ISP_HA_SCSI) { 1249 XS_RESID(xs) = sp->req_resid; 1250 } else if (sp->req_scsi_status & RQCS_RU) { 1251 XS_RESID(xs) = sp->req_resid; 1252 IDPRINTF(4, ("%s: cnt %d rsd %d\n", isp->isp_name, 1253 XS_XFRLEN(xs), sp->req_resid)); 1254 } 1255 if (XS_XFRLEN(xs)) { 1256 ISP_DMAFREE(isp, xs, sp->req_handle - 1); 1257 } 1258 /* 1259 * XXX: If we have a check condition, but no Sense Data, 1260 * XXX: mark it as an error (ARQ failed). We need to 1261 * XXX: to do a more distinct job because there may 1262 * XXX: cases where ARQ is disabled. 1263 */ 1264 if (XS_STS(xs) == SCSI_CHECK && !(XS_IS_SNS_VALID(xs))) { 1265 if (XS_NOERR(xs)) { 1266 PRINTF("%s: ARQ Failure\n", isp->isp_name); 1267 XS_SETERR(xs, HBA_ARQFAIL); 1268 } 1269 } 1270 if ((isp->isp_dblev >= 5) || 1271 (isp->isp_dblev > 2 && !XS_NOERR(xs))) { 1272 PRINTF("%s(%d.%d): FIN%d dl%d resid%d STS %x", 1273 isp->isp_name, XS_TGT(xs), XS_LUN(xs), 1274 sp->req_header.rqs_seqno, XS_XFRLEN(xs), 1275 XS_RESID(xs), XS_STS(xs)); 1276 if (sp->req_state_flags & RQSF_GOT_SENSE) { 1277 PRINTF(" Skey: %x", XS_SNSKEY(xs)); 1278 if (!(XS_IS_SNS_VALID(xs))) { 1279 PRINTF(" BUT NOT SET"); 1280 } 1281 } 1282 PRINTF(" XS_ERR=0x%x\n", XS_ERR(xs)); 1283 } 1284 1285 ISP_WRITE(isp, INMAILBOX5, optr); 1286 isp->isp_nactive--; 1287 if (isp->isp_nactive < 0) 1288 isp->isp_nactive = 0; 1289 complist[ndone++] = xs; /* defer completion call until later */ 1290 } 1291 isp->isp_residx = optr; 1292 for (i = 0; i < ndone; i++) { 1293 xs = complist[i]; 1294 if (xs) { 1295 XS_CMD_DONE(xs); 1296 } 1297 } 1298 return (1); 1299 } 1300 1301 /* 1302 * Support routines. 1303 */ 1304 1305 static int 1306 isp_parse_async(isp, mbox) 1307 struct ispsoftc *isp; 1308 u_int16_t mbox; 1309 { 1310 switch (mbox) { 1311 case ASYNC_BUS_RESET: 1312 PRINTF("%s: SCSI bus reset detected\n", isp->isp_name); 1313 isp->isp_sendmarker = 1; 1314 break; 1315 1316 case ASYNC_SYSTEM_ERROR: 1317 mbox = ISP_READ(isp, OUTMAILBOX1); 1318 PRINTF("%s: Internal FW Error @ RISC Addr 0x%x\n", 1319 isp->isp_name, mbox); 1320 isp_restart(isp); 1321 /* no point continuing after this */ 1322 return (1); 1323 1324 case ASYNC_RQS_XFER_ERR: 1325 PRINTF("%s: Request Queue Transfer Error\n", isp->isp_name); 1326 break; 1327 1328 case ASYNC_RSP_XFER_ERR: 1329 PRINTF("%s: Response Queue Transfer Error\n", isp->isp_name); 1330 break; 1331 1332 case ASYNC_QWAKEUP: 1333 /* don't need to be chatty */ 1334 mbox = ISP_READ(isp, OUTMAILBOX4); 1335 break; 1336 1337 case ASYNC_TIMEOUT_RESET: 1338 PRINTF("%s: timeout initiated SCSI bus reset\n", isp->isp_name); 1339 isp->isp_sendmarker = 1; 1340 break; 1341 1342 case ASYNC_UNSPEC_TMODE: 1343 PRINTF("%s: mystery async target completion\n", isp->isp_name); 1344 break; 1345 1346 case ASYNC_EXTMSG_UNDERRUN: 1347 PRINTF("%s: extended message underrun\n", isp->isp_name); 1348 break; 1349 1350 case ASYNC_SCAM_INT: 1351 PRINTF("%s: SCAM interrupt\n", isp->isp_name); 1352 break; 1353 1354 case ASYNC_HUNG_SCSI: 1355 PRINTF("%s: stalled SCSI Bus after DATA Overrun\n", 1356 isp->isp_name); 1357 /* XXX: Need to issue SCSI reset at this point */ 1358 break; 1359 1360 case ASYNC_KILLED_BUS: 1361 PRINTF("%s: SCSI Bus reset after DATA Overrun\n", 1362 isp->isp_name); 1363 break; 1364 1365 case ASYNC_BUS_TRANSIT: 1366 PRINTF("%s: LBD->HVD Transition 0x%x\n", 1367 isp->isp_name, ISP_READ(isp, OUTMAILBOX1)); 1368 break; 1369 1370 case ASYNC_CMD_CMPLT: 1371 PRINTF("%s: fast post completion\n", isp->isp_name); 1372 #if 0 1373 fast_post_handle = (ISP_READ(isp, OUTMAILBOX1) << 16) | 1374 ISP_READ(isp, OUTMAILBOX2); 1375 #endif 1376 break; 1377 1378 case ASYNC_CTIO_DONE: 1379 PRINTF("%s: CTIO done\n", isp->isp_name); 1380 break; 1381 1382 case ASYNC_LIP_OCCURRED: 1383 PRINTF("%s: LIP occurred\n", isp->isp_name); 1384 break; 1385 1386 case ASYNC_LOOP_UP: 1387 PRINTF("%s: Loop UP\n", isp->isp_name); 1388 break; 1389 1390 case ASYNC_LOOP_DOWN: 1391 PRINTF("%s: Loop DOWN\n", isp->isp_name); 1392 break; 1393 1394 case ASYNC_LOOP_RESET: 1395 PRINTF("%s: Loop RESET\n", isp->isp_name); 1396 break; 1397 1398 case ASYNC_PDB_CHANGED: 1399 PRINTF("%s: Port Database Changed\n", isp->isp_name); 1400 break; 1401 1402 case ASYNC_CHANGE_NOTIFY: 1403 PRINTF("%s: Name Server Database Changed\n", isp->isp_name); 1404 break; 1405 1406 default: 1407 PRINTF("%s: async %x\n", isp->isp_name, mbox); 1408 break; 1409 } 1410 return (0); 1411 } 1412 1413 static int 1414 isp_handle_other_response(isp, sp, optrp) 1415 struct ispsoftc *isp; 1416 ispstatusreq_t *sp; 1417 u_int8_t *optrp; 1418 { 1419 switch (sp->req_header.rqs_entry_type) { 1420 case RQSTYPE_NOTIFY: 1421 { 1422 ispnotify_t *spx = (ispnotify_t *) sp; 1423 PRINTF("%s: Immediate Notify %d.%d Status 0x%x Sequence 0x%x\n", 1424 isp->isp_name, spx->req_initiator, spx->req_lun, 1425 spx->req_status, spx->req_sequence); 1426 break; 1427 } 1428 case RQSTYPE_REQUEST: 1429 return (-1); 1430 1431 default: 1432 PRINTF("%s: other response type %x\n", isp->isp_name, 1433 sp->req_header.rqs_entry_type); 1434 break; 1435 } 1436 return (0); 1437 } 1438 1439 1440 static void 1441 isp_parse_status(isp, sp, xs) 1442 struct ispsoftc *isp; 1443 ispstatusreq_t *sp; 1444 ISP_SCSI_XFER_T *xs; 1445 { 1446 switch (sp->req_completion_status) { 1447 case RQCS_COMPLETE: 1448 XS_SETERR(xs, HBA_NOERROR); 1449 return; 1450 1451 case RQCS_INCOMPLETE: 1452 if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) { 1453 IDPRINTF(3, ("Selection Timeout\n")); 1454 XS_SETERR(xs, HBA_SELTIMEOUT); 1455 return; 1456 } 1457 PRINTF("%s: command incomplete for target %d lun %d, state " 1458 "0x%x\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs), 1459 sp->req_state_flags); 1460 break; 1461 1462 case RQCS_DMA_ERROR: 1463 PRINTF("%s: DMA error for command on target %d, lun %d\n", 1464 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1465 break; 1466 1467 case RQCS_TRANSPORT_ERROR: 1468 PRINTF("%s: transport error\n", isp->isp_name); 1469 isp_prtstst(sp); 1470 break; 1471 1472 case RQCS_RESET_OCCURRED: 1473 IDPRINTF(2, ("%s: bus reset destroyed command for target %d " 1474 "lun %d\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs))); 1475 isp->isp_sendmarker = 1; 1476 XS_SETERR(xs, HBA_BUSRESET); 1477 return; 1478 1479 case RQCS_ABORTED: 1480 PRINTF("%s: command aborted for target %d lun %d\n", 1481 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1482 isp->isp_sendmarker = 1; 1483 XS_SETERR(xs, HBA_ABORTED); 1484 return; 1485 1486 case RQCS_TIMEOUT: 1487 IDPRINTF(2, ("%s: command timed out for target %d lun %d\n", 1488 isp->isp_name, XS_TGT(xs), XS_LUN(xs))); 1489 XS_SETERR(xs, HBA_CMDTIMEOUT); 1490 return; 1491 1492 case RQCS_DATA_OVERRUN: 1493 if (isp->isp_type & ISP_HA_FC) { 1494 XS_RESID(xs) = sp->req_resid; 1495 break; 1496 } 1497 XS_SETERR(xs, HBA_DATAOVR); 1498 return; 1499 1500 case RQCS_COMMAND_OVERRUN: 1501 PRINTF("%s: command overrun for command on target %d, lun %d\n", 1502 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1503 break; 1504 1505 case RQCS_STATUS_OVERRUN: 1506 PRINTF("%s: status overrun for command on target %d, lun %d\n", 1507 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1508 break; 1509 1510 case RQCS_BAD_MESSAGE: 1511 PRINTF("%s: message not COMMAND COMPLETE after status on " 1512 "target %d, lun %d\n", isp->isp_name, XS_TGT(xs), 1513 XS_LUN(xs)); 1514 break; 1515 1516 case RQCS_NO_MESSAGE_OUT: 1517 PRINTF("%s: No MESSAGE OUT phase after selection on " 1518 "target %d, lun %d\n", isp->isp_name, XS_TGT(xs), 1519 XS_LUN(xs)); 1520 break; 1521 1522 case RQCS_EXT_ID_FAILED: 1523 PRINTF("%s: EXTENDED IDENTIFY failed on target %d, lun %d\n", 1524 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1525 break; 1526 1527 case RQCS_IDE_MSG_FAILED: 1528 PRINTF("%s: target %d lun %d rejected INITIATOR DETECTED " 1529 "ERROR message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1530 break; 1531 1532 case RQCS_ABORT_MSG_FAILED: 1533 PRINTF("%s: target %d lun %d rejected ABORT message\n", 1534 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1535 break; 1536 1537 case RQCS_REJECT_MSG_FAILED: 1538 PRINTF("%s: target %d lun %d rejected MESSAGE REJECT message\n", 1539 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1540 break; 1541 1542 case RQCS_NOP_MSG_FAILED: 1543 PRINTF("%s: target %d lun %d rejected NOP message\n", 1544 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1545 break; 1546 1547 case RQCS_PARITY_ERROR_MSG_FAILED: 1548 PRINTF("%s: target %d lun %d rejected MESSAGE PARITY ERROR " 1549 "message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1550 break; 1551 1552 case RQCS_DEVICE_RESET_MSG_FAILED: 1553 PRINTF("%s: target %d lun %d rejected BUS DEVICE RESET " 1554 "message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1555 break; 1556 1557 case RQCS_ID_MSG_FAILED: 1558 PRINTF("%s: target %d lun %d rejected IDENTIFY " 1559 "message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1560 break; 1561 1562 case RQCS_UNEXP_BUS_FREE: 1563 PRINTF("%s: target %d lun %d had unexeptected bus free\n", 1564 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1565 break; 1566 1567 case RQCS_DATA_UNDERRUN: 1568 if (isp->isp_type & ISP_HA_FC) { 1569 XS_RESID(xs) = sp->req_resid; 1570 /* an UNDERRUN is not a botch ??? */ 1571 } 1572 XS_SETERR(xs, HBA_NOERROR); 1573 return; 1574 1575 case RQCS_XACT_ERR1: 1576 PRINTF("%s: HBA attempted queued transaction with disconnect " 1577 "not set for target %d lun %d\n", isp->isp_name, XS_TGT(xs), 1578 XS_LUN(xs)); 1579 break; 1580 1581 case RQCS_XACT_ERR2: 1582 PRINTF("%s: HBA attempted queued transaction to target " 1583 "routine %d on target %d\n", isp->isp_name, XS_LUN(xs), 1584 XS_TGT(xs)); 1585 break; 1586 1587 case RQCS_XACT_ERR3: 1588 PRINTF("%s: HBA attempted queued transaction for target %d lun " 1589 "%d when queueing disabled\n", isp->isp_name, XS_TGT(xs), 1590 XS_LUN(xs)); 1591 break; 1592 1593 case RQCS_BAD_ENTRY: 1594 PRINTF("%s: invalid IOCB entry type detected\n", isp->isp_name); 1595 break; 1596 1597 case RQCS_QUEUE_FULL: 1598 PRINTF("%s: internal queue full for this device\n", 1599 isp->isp_name); 1600 break; 1601 1602 case RQCS_PHASE_SKIPPED: 1603 PRINTF("%s: SCSI phase skipped (e.g., COMMAND COMPLETE w/o " 1604 "STATUS phase) for target %d lun %d\n", isp->isp_name, 1605 XS_TGT(xs), XS_LUN(xs)); 1606 break; 1607 1608 case RQCS_ARQS_FAILED: 1609 PRINTF("%s: Auto Request Sense failed for target %d lun %d\n", 1610 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1611 XS_SETERR(xs, HBA_ARQFAIL); 1612 return; 1613 1614 case RQCS_WIDE_FAILED: 1615 PRINTF("%s: Wide Negotiation failed for target %d lun %d\n", 1616 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1617 if (isp->isp_type & ISP_HA_SCSI) { 1618 sdparam *sdp = isp->isp_param; 1619 isp->isp_update = 1; 1620 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1; 1621 sdp->isp_devparam[XS_TGT(xs)].dev_flags &= ~DPARM_WIDE; 1622 } 1623 XS_SETERR(xs, HBA_NOERROR); 1624 return; 1625 1626 case RQCS_SYNCXFER_FAILED: 1627 PRINTF("%s: SDTR Message failed for target %d lun %d\n", 1628 isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1629 if (isp->isp_type & ISP_HA_SCSI) { 1630 sdparam *sdp = isp->isp_param; 1631 isp->isp_update = 1; 1632 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1; 1633 sdp->isp_devparam[XS_TGT(xs)].dev_flags &= ~DPARM_SYNC; 1634 } 1635 break; 1636 1637 case RQCS_LVD_BUSERR: 1638 PRINTF("%s: Bad LVD Bus condition while talking to target %d " 1639 "lun %d\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)); 1640 break; 1641 1642 case RQCS_PORT_UNAVAILABLE: 1643 /* 1644 * No such port on the loop. Moral equivalent of SELTIMEO 1645 */ 1646 XS_SETERR(xs, HBA_SELTIMEOUT); 1647 return; 1648 1649 case RQCS_PORT_LOGGED_OUT: 1650 PRINTF("%s: port logout for target %d\n", 1651 isp->isp_name, XS_TGT(xs)); 1652 break; 1653 1654 case RQCS_PORT_CHANGED: 1655 PRINTF("%s: port changed for target %d\n", 1656 isp->isp_name, XS_TGT(xs)); 1657 break; 1658 1659 case RQCS_PORT_BUSY: 1660 PRINTF("%s: port busy for target %d\n", 1661 isp->isp_name, XS_TGT(xs)); 1662 XS_SETERR(xs, HBA_TGTBSY); 1663 return; 1664 1665 default: 1666 PRINTF("%s: comp status %x\n", isp->isp_name, 1667 sp->req_completion_status); 1668 break; 1669 } 1670 XS_SETERR(xs, HBA_BOTCH); 1671 } 1672 1673 #define HINIB(x) ((x) >> 0x4) 1674 #define LONIB(x) ((x) & 0xf) 1675 #define MAKNIB(a, b) (((a) << 4) | (b)) 1676 static u_int8_t mbpcnt[] = { 1677 MAKNIB(1, 1), /* 0x00: MBOX_NO_OP */ 1678 MAKNIB(5, 5), /* 0x01: MBOX_LOAD_RAM */ 1679 MAKNIB(2, 0), /* 0x02: MBOX_EXEC_FIRMWARE */ 1680 MAKNIB(5, 5), /* 0x03: MBOX_DUMP_RAM */ 1681 MAKNIB(3, 3), /* 0x04: MBOX_WRITE_RAM_WORD */ 1682 MAKNIB(2, 3), /* 0x05: MBOX_READ_RAM_WORD */ 1683 MAKNIB(6, 6), /* 0x06: MBOX_MAILBOX_REG_TEST */ 1684 MAKNIB(2, 3), /* 0x07: MBOX_VERIFY_CHECKSUM */ 1685 MAKNIB(1, 3), /* 0x08: MBOX_ABOUT_FIRMWARE */ 1686 MAKNIB(0, 0), /* 0x09: */ 1687 MAKNIB(0, 0), /* 0x0a: */ 1688 MAKNIB(0, 0), /* 0x0b: */ 1689 MAKNIB(0, 0), /* 0x0c: */ 1690 MAKNIB(0, 0), /* 0x0d: */ 1691 MAKNIB(1, 2), /* 0x0e: MBOX_CHECK_FIRMWARE */ 1692 MAKNIB(0, 0), /* 0x0f: */ 1693 MAKNIB(5, 5), /* 0x10: MBOX_INIT_REQ_QUEUE */ 1694 MAKNIB(6, 6), /* 0x11: MBOX_INIT_RES_QUEUE */ 1695 MAKNIB(4, 4), /* 0x12: MBOX_EXECUTE_IOCB */ 1696 MAKNIB(2, 2), /* 0x13: MBOX_WAKE_UP */ 1697 MAKNIB(1, 6), /* 0x14: MBOX_STOP_FIRMWARE */ 1698 MAKNIB(4, 4), /* 0x15: MBOX_ABORT */ 1699 MAKNIB(2, 2), /* 0x16: MBOX_ABORT_DEVICE */ 1700 MAKNIB(3, 3), /* 0x17: MBOX_ABORT_TARGET */ 1701 MAKNIB(2, 2), /* 0x18: MBOX_BUS_RESET */ 1702 MAKNIB(2, 3), /* 0x19: MBOX_STOP_QUEUE */ 1703 MAKNIB(2, 3), /* 0x1a: MBOX_START_QUEUE */ 1704 MAKNIB(2, 3), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */ 1705 MAKNIB(2, 3), /* 0x1c: MBOX_ABORT_QUEUE */ 1706 MAKNIB(2, 4), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */ 1707 MAKNIB(0, 0), /* 0x1e: */ 1708 MAKNIB(1, 3), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */ 1709 MAKNIB(1, 2), /* 0x20: MBOX_GET_INIT_SCSI_ID */ 1710 MAKNIB(1, 2), /* 0x21: MBOX_GET_SELECT_TIMEOUT */ 1711 MAKNIB(1, 3), /* 0x22: MBOX_GET_RETRY_COUNT */ 1712 MAKNIB(1, 2), /* 0x23: MBOX_GET_TAG_AGE_LIMIT */ 1713 MAKNIB(1, 2), /* 0x24: MBOX_GET_CLOCK_RATE */ 1714 MAKNIB(1, 2), /* 0x25: MBOX_GET_ACT_NEG_STATE */ 1715 MAKNIB(1, 2), /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */ 1716 MAKNIB(1, 3), /* 0x27: MBOX_GET_PCI_PARAMS */ 1717 MAKNIB(2, 4), /* 0x28: MBOX_GET_TARGET_PARAMS */ 1718 MAKNIB(2, 4), /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */ 1719 MAKNIB(0, 0), /* 0x2a: */ 1720 MAKNIB(0, 0), /* 0x2b: */ 1721 MAKNIB(0, 0), /* 0x2c: */ 1722 MAKNIB(0, 0), /* 0x2d: */ 1723 MAKNIB(0, 0), /* 0x2e: */ 1724 MAKNIB(0, 0), /* 0x2f: */ 1725 MAKNIB(2, 2), /* 0x30: MBOX_SET_INIT_SCSI_ID */ 1726 MAKNIB(2, 2), /* 0x31: MBOX_SET_SELECT_TIMEOUT */ 1727 MAKNIB(3, 3), /* 0x32: MBOX_SET_RETRY_COUNT */ 1728 MAKNIB(2, 2), /* 0x33: MBOX_SET_TAG_AGE_LIMIT */ 1729 MAKNIB(2, 2), /* 0x34: MBOX_SET_CLOCK_RATE */ 1730 MAKNIB(2, 2), /* 0x35: MBOX_SET_ACTIVE_NEG_STATE */ 1731 MAKNIB(2, 2), /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */ 1732 MAKNIB(3, 3), /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */ 1733 MAKNIB(4, 4), /* 0x38: MBOX_SET_TARGET_PARAMS */ 1734 MAKNIB(4, 4), /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */ 1735 MAKNIB(0, 0), /* 0x3a: */ 1736 MAKNIB(0, 0), /* 0x3b: */ 1737 MAKNIB(0, 0), /* 0x3c: */ 1738 MAKNIB(0, 0), /* 0x3d: */ 1739 MAKNIB(0, 0), /* 0x3e: */ 1740 MAKNIB(0, 0), /* 0x3f: */ 1741 MAKNIB(1, 2), /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */ 1742 MAKNIB(6, 1), /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */ 1743 MAKNIB(2, 3), /* 0x42: MBOX_EXEC_BIOS_IOCB */ 1744 MAKNIB(0, 0), /* 0x43: */ 1745 MAKNIB(0, 0), /* 0x44: */ 1746 MAKNIB(0, 0), /* 0x45: */ 1747 MAKNIB(0, 0), /* 0x46: */ 1748 MAKNIB(0, 0), /* 0x47: */ 1749 MAKNIB(0, 0), /* 0x48: */ 1750 MAKNIB(0, 0), /* 0x49: */ 1751 MAKNIB(0, 0), /* 0x4a: */ 1752 MAKNIB(0, 0), /* 0x4b: */ 1753 MAKNIB(0, 0), /* 0x4c: */ 1754 MAKNIB(0, 0), /* 0x4d: */ 1755 MAKNIB(0, 0), /* 0x4e: */ 1756 MAKNIB(0, 0), /* 0x4f: */ 1757 MAKNIB(0, 0), /* 0x50: */ 1758 MAKNIB(0, 0), /* 0x51: */ 1759 MAKNIB(0, 0), /* 0x52: */ 1760 MAKNIB(0, 0), /* 0x53: */ 1761 MAKNIB(8, 0), /* 0x54: MBOX_EXEC_COMMAND_IOCB_A64 */ 1762 MAKNIB(0, 0), /* 0x55: */ 1763 MAKNIB(0, 0), /* 0x56: */ 1764 MAKNIB(0, 0), /* 0x57: */ 1765 MAKNIB(0, 0), /* 0x58: */ 1766 MAKNIB(0, 0), /* 0x59: */ 1767 MAKNIB(0, 0), /* 0x5a: */ 1768 MAKNIB(0, 0), /* 0x5b: */ 1769 MAKNIB(0, 0), /* 0x5c: */ 1770 MAKNIB(0, 0), /* 0x5d: */ 1771 MAKNIB(0, 0), /* 0x5e: */ 1772 MAKNIB(0, 0), /* 0x5f: */ 1773 MAKNIB(8, 6), /* 0x60: MBOX_INIT_FIRMWARE */ 1774 MAKNIB(0, 0), /* 0x60: MBOX_GET_INIT_CONTROL_BLOCK (FORMAT?) */ 1775 MAKNIB(2, 1), /* 0x62: MBOX_INIT_LIP */ 1776 MAKNIB(8, 1), /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */ 1777 MAKNIB(8, 1), /* 0x64: MBOX_GET_PORT_DB */ 1778 MAKNIB(3, 1), /* 0x65: MBOX_CLEAR_ACA */ 1779 MAKNIB(3, 1), /* 0x66: MBOX_TARGET_RESET */ 1780 MAKNIB(3, 1), /* 0x67: MBOX_CLEAR_TASK_SET */ 1781 MAKNIB(3, 1), /* 0x69: MBOX_ABORT_TASK_SET */ 1782 MAKNIB(1, 2) /* 0x69: MBOX_GET_FW_STATE */ 1783 }; 1784 #define NMBCOM (sizeof (mbpcnt) / sizeof (mbpcnt[0])) 1785 1786 static void 1787 isp_mboxcmd(isp, mbp) 1788 struct ispsoftc *isp; 1789 mbreg_t *mbp; 1790 { 1791 int outparam, inparam; 1792 int loops, dld = 0; 1793 u_int8_t opcode; 1794 1795 if (mbp->param[0] == ISP2100_SET_PCI_PARAM) { 1796 opcode = mbp->param[0] = MBOX_SET_PCI_PARAMETERS; 1797 inparam = 4; 1798 outparam = 4; 1799 goto command_known; 1800 } else if (mbp->param[0] > NMBCOM) { 1801 PRINTF("%s: bad command %x\n", isp->isp_name, mbp->param[0]); 1802 return; 1803 } 1804 1805 opcode = mbp->param[0]; 1806 inparam = HINIB(mbpcnt[mbp->param[0]]); 1807 outparam = LONIB(mbpcnt[mbp->param[0]]); 1808 1809 if (inparam == 0 && outparam == 0) { 1810 PRINTF("%s: no parameters for %x\n", isp->isp_name, 1811 mbp->param[0]); 1812 return; 1813 } 1814 1815 1816 command_known: 1817 1818 /* 1819 * Make sure we can send some words.. 1820 */ 1821 1822 loops = MBOX_DELAY_COUNT; 1823 while ((ISP_READ(isp, HCCR) & HCCR_HOST_INT) != 0) { 1824 SYS_DELAY(100); 1825 if (--loops < 0) { 1826 PRINTF("%s: isp_mboxcmd timeout #1\n", isp->isp_name); 1827 if (dld++) { 1828 return; 1829 } 1830 PRINTF("%s: but we'll try again, isr=%x\n", 1831 isp->isp_name, ISP_READ(isp, BIU_ISR)); 1832 if (ISP_READ(isp, BIU_SEMA) & 1) { 1833 u_int16_t mbox = ISP_READ(isp, OUTMAILBOX0); 1834 if (isp_parse_async(isp, mbox)) 1835 return; 1836 ISP_WRITE(isp, BIU_SEMA, 0); 1837 } 1838 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 1839 goto command_known; 1840 } 1841 } 1842 1843 /* 1844 * Write input parameters 1845 */ 1846 switch (inparam) { 1847 case 8: ISP_WRITE(isp, INMAILBOX7, mbp->param[7]); mbp->param[7] = 0; 1848 case 7: ISP_WRITE(isp, INMAILBOX6, mbp->param[6]); mbp->param[6] = 0; 1849 case 6: ISP_WRITE(isp, INMAILBOX5, mbp->param[5]); mbp->param[5] = 0; 1850 case 5: ISP_WRITE(isp, INMAILBOX4, mbp->param[4]); mbp->param[4] = 0; 1851 case 4: ISP_WRITE(isp, INMAILBOX3, mbp->param[3]); mbp->param[3] = 0; 1852 case 3: ISP_WRITE(isp, INMAILBOX2, mbp->param[2]); mbp->param[2] = 0; 1853 case 2: ISP_WRITE(isp, INMAILBOX1, mbp->param[1]); mbp->param[1] = 0; 1854 case 1: ISP_WRITE(isp, INMAILBOX0, mbp->param[0]); mbp->param[0] = 0; 1855 } 1856 1857 /* 1858 * Clear semaphore on mailbox registers 1859 */ 1860 ISP_WRITE(isp, BIU_SEMA, 0); 1861 1862 /* 1863 * Clear RISC int condition. 1864 */ 1865 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 1866 1867 /* 1868 * Set Host Interrupt condition so that RISC will pick up mailbox regs. 1869 */ 1870 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT); 1871 1872 /* 1873 * Wait until RISC int is set, except 2100 1874 */ 1875 if ((isp->isp_type & ISP_HA_FC) == 0) { 1876 loops = MBOX_DELAY_COUNT; 1877 while ((ISP_READ(isp, BIU_ISR) & BIU_ISR_RISC_INT) == 0) { 1878 SYS_DELAY(100); 1879 if (--loops < 0) { 1880 PRINTF("%s: isp_mboxcmd timeout #2\n", 1881 isp->isp_name); 1882 return; 1883 } 1884 } 1885 } 1886 1887 /* 1888 * Check to make sure that the semaphore has been set. 1889 */ 1890 loops = MBOX_DELAY_COUNT; 1891 while ((ISP_READ(isp, BIU_SEMA) & 1) == 0) { 1892 SYS_DELAY(100); 1893 if (--loops < 0) { 1894 PRINTF("%s: isp_mboxcmd timeout #3\n", isp->isp_name); 1895 return; 1896 } 1897 } 1898 1899 /* 1900 * Make sure that the MBOX_BUSY has gone away 1901 */ 1902 loops = MBOX_DELAY_COUNT; 1903 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) { 1904 SYS_DELAY(100); 1905 if (--loops < 0) { 1906 PRINTF("%s: isp_mboxcmd timeout #4\n", isp->isp_name); 1907 return; 1908 } 1909 } 1910 1911 1912 /* 1913 * Pick up output parameters. 1914 */ 1915 switch (outparam) { 1916 case 8: mbp->param[7] = ISP_READ(isp, OUTMAILBOX7); 1917 case 7: mbp->param[6] = ISP_READ(isp, OUTMAILBOX6); 1918 case 6: mbp->param[5] = ISP_READ(isp, OUTMAILBOX5); 1919 case 5: mbp->param[4] = ISP_READ(isp, OUTMAILBOX4); 1920 case 4: mbp->param[3] = ISP_READ(isp, OUTMAILBOX3); 1921 case 3: mbp->param[2] = ISP_READ(isp, OUTMAILBOX2); 1922 case 2: mbp->param[1] = ISP_READ(isp, OUTMAILBOX1); 1923 case 1: mbp->param[0] = ISP_READ(isp, OUTMAILBOX0); 1924 } 1925 1926 /* 1927 * Clear RISC int. 1928 */ 1929 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); 1930 1931 /* 1932 * Release semaphore on mailbox registers 1933 */ 1934 ISP_WRITE(isp, BIU_SEMA, 0); 1935 1936 /* 1937 * Just to be chatty here... 1938 */ 1939 switch(mbp->param[0]) { 1940 case MBOX_COMMAND_COMPLETE: 1941 break; 1942 case MBOX_INVALID_COMMAND: 1943 IDPRINTF(2, ("%s: mbox cmd %x failed with INVALID_COMMAND\n", 1944 isp->isp_name, opcode)); 1945 break; 1946 case MBOX_HOST_INTERFACE_ERROR: 1947 PRINTF("%s: mbox cmd %x failed with HOST_INTERFACE_ERROR\n", 1948 isp->isp_name, opcode); 1949 break; 1950 case MBOX_TEST_FAILED: 1951 PRINTF("%s: mbox cmd %x failed with TEST_FAILED\n", 1952 isp->isp_name, opcode); 1953 break; 1954 case MBOX_COMMAND_ERROR: 1955 PRINTF("%s: mbox cmd %x failed with COMMAND_ERROR\n", 1956 isp->isp_name, opcode); 1957 break; 1958 case MBOX_COMMAND_PARAM_ERROR: 1959 PRINTF("%s: mbox cmd %x failed with COMMAND_PARAM_ERROR\n", 1960 isp->isp_name, opcode); 1961 break; 1962 1963 case ASYNC_LOOP_UP: 1964 case ASYNC_LIP_OCCURRED: 1965 break; 1966 1967 default: 1968 /* 1969 * The expected return of EXEC_FIRMWARE is zero. 1970 */ 1971 if ((opcode == MBOX_EXEC_FIRMWARE && mbp->param[0] != 0) || 1972 (opcode != MBOX_EXEC_FIRMWARE)) { 1973 PRINTF("%s: mbox cmd %x failed with error %x\n", 1974 isp->isp_name, opcode, mbp->param[0]); 1975 } 1976 break; 1977 } 1978 } 1979 1980 void 1981 isp_lostcmd(isp, xs) 1982 struct ispsoftc *isp; 1983 ISP_SCSI_XFER_T *xs; 1984 { 1985 mbreg_t mbs; 1986 1987 mbs.param[0] = MBOX_GET_FIRMWARE_STATUS; 1988 isp_mboxcmd(isp, &mbs); 1989 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 1990 isp_dumpregs(isp, "couldn't GET FIRMWARE STATUS"); 1991 return; 1992 } 1993 if (mbs.param[1]) { 1994 PRINTF("%s: %d commands on completion queue\n", 1995 isp->isp_name, mbs.param[1]); 1996 } 1997 if (XS_NULL(xs)) 1998 return; 1999 2000 mbs.param[0] = MBOX_GET_DEV_QUEUE_STATUS; 2001 mbs.param[1] = (XS_TGT(xs) << 8) | XS_LUN(xs); 2002 isp_mboxcmd(isp, &mbs); 2003 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 2004 isp_dumpregs(isp, "couldn't GET DEVICE QUEUE STATUS"); 2005 return; 2006 } 2007 PRINTF("%s: lost command for target %d lun %d, %d active of %d, " 2008 "Queue State: %x\n", isp->isp_name, XS_TGT(xs), 2009 XS_LUN(xs), mbs.param[2], mbs.param[3], mbs.param[1]); 2010 2011 isp_dumpregs(isp, "lost command"); 2012 /* 2013 * XXX: Need to try and do something to recover. 2014 */ 2015 } 2016 2017 static void 2018 isp_dumpregs(isp, msg) 2019 struct ispsoftc *isp; 2020 const char *msg; 2021 { 2022 PRINTF("%s: %s\n", isp->isp_name, msg); 2023 if (isp->isp_type & ISP_HA_SCSI) 2024 PRINTF(" biu_conf1=%x", ISP_READ(isp, BIU_CONF1)); 2025 else 2026 PRINTF(" biu_csr=%x", ISP_READ(isp, BIU2100_CSR)); 2027 PRINTF(" biu_icr=%x biu_isr=%x biu_sema=%x ", ISP_READ(isp, BIU_ICR), 2028 ISP_READ(isp, BIU_ISR), ISP_READ(isp, BIU_SEMA)); 2029 PRINTF("risc_hccr=%x\n", ISP_READ(isp, HCCR)); 2030 2031 if (isp->isp_type & ISP_HA_SCSI) { 2032 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE); 2033 PRINTF(" cdma_conf=%x cdma_sts=%x cdma_fifostat=%x\n", 2034 ISP_READ(isp, CDMA_CONF), ISP_READ(isp, CDMA_STATUS), 2035 ISP_READ(isp, CDMA_FIFO_STS)); 2036 PRINTF(" ddma_conf=%x ddma_sts=%x ddma_fifostat=%x\n", 2037 ISP_READ(isp, DDMA_CONF), ISP_READ(isp, DDMA_STATUS), 2038 ISP_READ(isp, DDMA_FIFO_STS)); 2039 PRINTF(" sxp_int=%x sxp_gross=%x sxp(scsi_ctrl)=%x\n", 2040 ISP_READ(isp, SXP_INTERRUPT), 2041 ISP_READ(isp, SXP_GROSS_ERR), 2042 ISP_READ(isp, SXP_PINS_CONTROL)); 2043 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); 2044 } 2045 ISP_DUMPREGS(isp); 2046 } 2047 2048 static void 2049 isp_dumpxflist(isp) 2050 struct ispsoftc *isp; 2051 { 2052 volatile ISP_SCSI_XFER_T *xs; 2053 int i, hdp; 2054 2055 for (hdp = i = 0; i < RQUEST_QUEUE_LEN; i++) { 2056 xs = isp->isp_xflist[i]; 2057 if (xs == NULL) { 2058 continue; 2059 } 2060 if (hdp == 0) { 2061 PRINTF("%s: active requests\n", isp->isp_name); 2062 hdp++; 2063 } 2064 PRINTF(" Active Handle %d: tgt %d lun %d dlen %d\n", 2065 i+1, XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs)); 2066 } 2067 } 2068 2069 static void 2070 isp_fw_state(isp) 2071 struct ispsoftc *isp; 2072 { 2073 mbreg_t mbs; 2074 if (isp->isp_type & ISP_HA_FC) { 2075 int once = 0; 2076 fcparam *fcp = isp->isp_param; 2077 again: 2078 mbs.param[0] = MBOX_GET_FW_STATE; 2079 isp_mboxcmd(isp, &mbs); 2080 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 2081 if (mbs.param[0] == ASYNC_LIP_OCCURRED || 2082 mbs.param[0] == ASYNC_LOOP_UP) { 2083 if (once++ < 2) { 2084 goto again; 2085 } 2086 } 2087 isp_dumpregs(isp, "GET FIRMWARE STATE failed"); 2088 return; 2089 } 2090 fcp->isp_fwstate = mbs.param[1]; 2091 } 2092 } 2093 2094 static void 2095 isp_update(isp) 2096 struct ispsoftc *isp; 2097 { 2098 int tgt; 2099 mbreg_t mbs; 2100 sdparam *sdp; 2101 2102 isp->isp_update = 0; 2103 2104 if (isp->isp_type & ISP_HA_FC) { 2105 return; 2106 } 2107 2108 sdp = isp->isp_param; 2109 for (tgt = 0; tgt < MAX_TARGETS; tgt++) { 2110 if (sdp->isp_devparam[tgt].dev_enable == 0) { 2111 continue; 2112 } 2113 if (sdp->isp_devparam[tgt].dev_update == 0) { 2114 continue; 2115 } 2116 2117 mbs.param[0] = MBOX_SET_TARGET_PARAMS; 2118 mbs.param[1] = tgt << 8; 2119 mbs.param[2] = sdp->isp_devparam[tgt].dev_flags; 2120 mbs.param[3] = 2121 (sdp->isp_devparam[tgt].sync_offset << 8) | 2122 (sdp->isp_devparam[tgt].sync_period); 2123 2124 IDPRINTF(3, ("\n%s: tgt %d cflags %x offset %x period %x\n", 2125 isp->isp_name, tgt, mbs.param[2], mbs.param[3] >> 8, 2126 mbs.param[3] & 0xff)); 2127 2128 isp_mboxcmd(isp, &mbs); 2129 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 2130 PRINTF("%s: failed to change SCSI parameters for " 2131 "target %d\n", isp->isp_name, tgt); 2132 } else { 2133 char *wt; 2134 int x, flags; 2135 2136 flags = sdp->isp_devparam[tgt].cur_dflags = 2137 sdp->isp_devparam[tgt].dev_flags; 2138 2139 x = sdp->isp_devparam[tgt].sync_period & 0xff; 2140 if (flags & DPARM_SYNC) { 2141 if (x == (ISP_20M_SYNCPARMS & 0xff)) { 2142 x = 20; 2143 } else if (x == (ISP_10M_SYNCPARMS & 0xff)) { 2144 x = 10; 2145 } else if (x == (ISP_08M_SYNCPARMS & 0xff)) { 2146 x = 8; 2147 } else if (x == (ISP_05M_SYNCPARMS & 0xff)) { 2148 x = 5; 2149 } else if (x == (ISP_04M_SYNCPARMS & 0xff)) { 2150 x = 4; 2151 } else { 2152 x = 0; 2153 } 2154 } else { 2155 x = 0; 2156 } 2157 switch (flags & (DPARM_WIDE|DPARM_TQING)) { 2158 case DPARM_WIDE: 2159 wt = ", 16 bit wide\n"; 2160 break; 2161 case DPARM_TQING: 2162 wt = ", Tagged Queueing Enabled\n"; 2163 break; 2164 case DPARM_WIDE|DPARM_TQING: 2165 wt = ", 16 bit wide, Tagged Queueing Enabled\n"; 2166 break; 2167 2168 default: 2169 wt = "\n"; 2170 break; 2171 } 2172 if (x) { 2173 IDPRINTF(2, ("%s: Target %d maximum Sync Mode " 2174 "at %dMHz%s", isp->isp_name, tgt, x, wt)); 2175 } else { 2176 IDPRINTF(2, ("%s: Target %d Async Mode%s", 2177 isp->isp_name, tgt, wt)); 2178 } 2179 } 2180 sdp->isp_devparam[tgt].dev_update = 0; 2181 } 2182 } 2183 2184 static void 2185 isp_setdfltparm(isp) 2186 struct ispsoftc *isp; 2187 { 2188 int i, use_nvram; 2189 mbreg_t mbs; 2190 sdparam *sdp; 2191 2192 /* 2193 * Been there, done that, got the T-shirt... 2194 */ 2195 if (isp->isp_gotdparms) { 2196 IDPRINTF(3, ("%s: already have dparms\n", isp->isp_name)); 2197 return; 2198 } 2199 isp->isp_gotdparms = 1; 2200 2201 use_nvram = (isp_read_nvram(isp) == 0); 2202 if (use_nvram) { 2203 return; 2204 } 2205 if (isp->isp_type & ISP_HA_FC) { 2206 fcparam *fcp = (fcparam *) isp->isp_param; 2207 fcp->isp_maxfrmlen = ICB_DFLT_FRMLEN; 2208 fcp->isp_maxalloc = 256; 2209 fcp->isp_execthrottle = 16; 2210 fcp->isp_retry_delay = 5; 2211 fcp->isp_retry_count = 0; 2212 /* 2213 * It would be nice to fake up a WWN in case we don't 2214 * get one out of NVRAM. Solaris does this for SOCAL 2215 * cards that don't have SBus properties- it sets up 2216 * a WWN based upon the system MAC Address. 2217 */ 2218 fcp->isp_wwn = 0; 2219 return; 2220 } 2221 2222 sdp = (sdparam *) isp->isp_param; 2223 mbs.param[0] = MBOX_GET_ACT_NEG_STATE; 2224 isp_mboxcmd(isp, &mbs); 2225 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 2226 IDPRINTF(2, ("could not GET ACT NEG STATE\n")); 2227 sdp->isp_req_ack_active_neg = 1; 2228 sdp->isp_data_line_active_neg = 1; 2229 } else { 2230 sdp->isp_req_ack_active_neg = (mbs.param[1] >> 4) & 0x1; 2231 sdp->isp_data_line_active_neg = (mbs.param[1] >> 5) & 0x1; 2232 } 2233 for (i = 0; i < MAX_TARGETS; i++) { 2234 2235 mbs.param[0] = MBOX_GET_TARGET_PARAMS; 2236 mbs.param[1] = i << 8; 2237 isp_mboxcmd(isp, &mbs); 2238 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { 2239 PRINTF("%s: can't get SCSI parameters for target %d\n", 2240 isp->isp_name, i); 2241 sdp->isp_devparam[i].sync_period = 0; 2242 sdp->isp_devparam[i].sync_offset = 0; 2243 sdp->isp_devparam[i].dev_flags = DPARM_SAFE_DFLT; 2244 continue; 2245 } 2246 sdp->isp_devparam[i].dev_flags = mbs.param[2]; 2247 2248 /* 2249 * The maximum period we can really see 2250 * here is 100 (decimal), or 400 ns. 2251 * For some unknown reason we sometimes 2252 * get back wildass numbers from the 2253 * boot device's parameters. 2254 * 2255 * XXX: Hmm- this may be based on a different 2256 * XXX: clock rate. 2257 */ 2258 if ((mbs.param[3] & 0xff) <= 0x64) { 2259 sdp->isp_devparam[i].sync_period = mbs.param[3] & 0xff; 2260 sdp->isp_devparam[i].sync_offset = mbs.param[3] >> 8; 2261 } 2262 2263 /* 2264 * It is not safe to run Ultra Mode with a clock < 60. 2265 */ 2266 if (((sdp->isp_clock && sdp->isp_clock < 60) || 2267 (isp->isp_type < ISP_HA_SCSI_1020A)) && 2268 (sdp->isp_devparam[i].sync_period == 2269 (ISP_20M_SYNCPARMS & 0xff))) { 2270 sdp->isp_devparam[i].sync_offset = 2271 ISP_10M_SYNCPARMS >> 8; 2272 sdp->isp_devparam[i].sync_period = 2273 ISP_10M_SYNCPARMS & 0xff; 2274 } 2275 2276 } 2277 2278 /* 2279 * Set Default Host Adapter Parameters 2280 */ 2281 sdp->isp_cmd_dma_burst_enable = 1; 2282 sdp->isp_data_dma_burst_enabl = 1; 2283 sdp->isp_fifo_threshold = 0; 2284 sdp->isp_initiator_id = 7; 2285 if (isp->isp_type >= ISP_HA_SCSI_1040) { 2286 sdp->isp_async_data_setup = 9; 2287 } else { 2288 sdp->isp_async_data_setup = 6; 2289 } 2290 sdp->isp_selection_timeout = 250; 2291 sdp->isp_max_queue_depth = 128; 2292 sdp->isp_tag_aging = 8; 2293 sdp->isp_bus_reset_delay = 3; 2294 sdp->isp_retry_count = 0; 2295 sdp->isp_retry_delay = 1; 2296 2297 for (i = 0; i < MAX_TARGETS; i++) { 2298 sdp->isp_devparam[i].exc_throttle = 16; 2299 sdp->isp_devparam[i].dev_enable = 1; 2300 } 2301 } 2302 2303 /* 2304 * Re-initialize the ISP and complete all orphaned commands 2305 * with a 'botched' notice. 2306 * 2307 * Locks held prior to coming here. 2308 */ 2309 2310 void 2311 isp_restart(isp) 2312 struct ispsoftc *isp; 2313 { 2314 ISP_SCSI_XFER_T *tlist[RQUEST_QUEUE_LEN], *xs; 2315 int i; 2316 2317 for (i = 0; i < RQUEST_QUEUE_LEN; i++) { 2318 tlist[i] = (ISP_SCSI_XFER_T *) isp->isp_xflist[i]; 2319 } 2320 isp_reset(isp); 2321 if (isp->isp_state == ISP_RESETSTATE) { 2322 isp_init(isp); 2323 if (isp->isp_state == ISP_INITSTATE) { 2324 isp->isp_state = ISP_RUNSTATE; 2325 } 2326 } 2327 if (isp->isp_state != ISP_RUNSTATE) { 2328 PRINTF("%s: isp_restart cannot restart ISP\n", isp->isp_name); 2329 } 2330 2331 for (i = 0; i < RQUEST_QUEUE_LEN; i++) { 2332 xs = tlist[i]; 2333 if (XS_NULL(xs)) 2334 continue; 2335 isp->isp_nactive--; 2336 if (isp->isp_nactive < 0) 2337 isp->isp_nactive = 0; 2338 XS_RESID(xs) = XS_XFRLEN(xs); 2339 XS_SETERR(xs, HBA_BOTCH); 2340 XS_CMD_DONE(xs); 2341 } 2342 } 2343 2344 void 2345 isp_watch(arg) 2346 void *arg; 2347 { 2348 int i; 2349 struct ispsoftc *isp = arg; 2350 ISP_SCSI_XFER_T *xs; 2351 ISP_LOCKVAL_DECL; 2352 2353 /* 2354 * Look for completely dead commands (but not polled ones). 2355 */ 2356 ISP_ILOCK(isp); 2357 for (i = 0; i < RQUEST_QUEUE_LEN; i++) { 2358 if ((xs = (ISP_SCSI_XFER_T *) isp->isp_xflist[i]) == NULL) { 2359 continue; 2360 } 2361 if (XS_TIME(xs) == 0) { 2362 continue; 2363 } 2364 XS_TIME(xs) -= (WATCH_INTERVAL * 1000); 2365 /* 2366 * Avoid later thinking that this 2367 * transaction is not being timed. 2368 * Then give ourselves to watchdog 2369 * periods of grace. 2370 */ 2371 if (XS_TIME(xs) == 0) 2372 XS_TIME(xs) = 1; 2373 else if (XS_TIME(xs) > -(2 * WATCH_INTERVAL * 1000)) { 2374 continue; 2375 } 2376 if (isp_control(isp, ISPCTL_ABORT_CMD, xs)) { 2377 PRINTF("%s: isp_watch failed to abort command\n", 2378 isp->isp_name); 2379 isp_restart(isp); 2380 break; 2381 } 2382 } 2383 ISP_IUNLOCK(isp); 2384 RESTART_WATCHDOG(isp_watch, isp); 2385 } 2386 2387 static void 2388 isp_prtstst(sp) 2389 ispstatusreq_t *sp; 2390 { 2391 PRINTF("states->"); 2392 if (sp->req_state_flags & RQSF_GOT_BUS) 2393 PRINTF("GOT_BUS "); 2394 if (sp->req_state_flags & RQSF_GOT_TARGET) 2395 PRINTF("GOT_TGT "); 2396 if (sp->req_state_flags & RQSF_SENT_CDB) 2397 PRINTF("SENT_CDB "); 2398 if (sp->req_state_flags & RQSF_XFRD_DATA) 2399 PRINTF("XFRD_DATA "); 2400 if (sp->req_state_flags & RQSF_GOT_STATUS) 2401 PRINTF("GOT_STS "); 2402 if (sp->req_state_flags & RQSF_GOT_SENSE) 2403 PRINTF("GOT_SNS "); 2404 if (sp->req_state_flags & RQSF_XFER_COMPLETE) 2405 PRINTF("XFR_CMPLT "); 2406 PRINTF("\n"); 2407 PRINTF("status->"); 2408 if (sp->req_status_flags & RQSTF_DISCONNECT) 2409 PRINTF("Disconnect "); 2410 if (sp->req_status_flags & RQSTF_SYNCHRONOUS) 2411 PRINTF("Sync_xfr "); 2412 if (sp->req_status_flags & RQSTF_PARITY_ERROR) 2413 PRINTF("Parity "); 2414 if (sp->req_status_flags & RQSTF_BUS_RESET) 2415 PRINTF("Bus_Reset "); 2416 if (sp->req_status_flags & RQSTF_DEVICE_RESET) 2417 PRINTF("Device_Reset "); 2418 if (sp->req_status_flags & RQSTF_ABORTED) 2419 PRINTF("Aborted "); 2420 if (sp->req_status_flags & RQSTF_TIMEOUT) 2421 PRINTF("Timeout "); 2422 if (sp->req_status_flags & RQSTF_NEGOTIATION) 2423 PRINTF("Negotiation "); 2424 PRINTF("\n"); 2425 } 2426 2427 /* 2428 * NVRAM Routines 2429 */ 2430 2431 static int 2432 isp_read_nvram(isp) 2433 struct ispsoftc *isp; 2434 { 2435 int i, amt; 2436 u_int8_t csum, minversion; 2437 union { 2438 u_int8_t _x[ISP2100_NVRAM_SIZE]; 2439 u_int16_t _s[ISP2100_NVRAM_SIZE>>1]; 2440 } _n; 2441 #define nvram_data _n._x 2442 #define nvram_words _n._s 2443 2444 if (isp->isp_type & ISP_HA_FC) { 2445 amt = ISP2100_NVRAM_SIZE; 2446 minversion = 1; 2447 } else { 2448 amt = ISP_NVRAM_SIZE; 2449 minversion = 2; 2450 } 2451 2452 /* 2453 * Just read the first two words first to see if we have a valid 2454 * NVRAM to continue reading the rest with. 2455 */ 2456 for (i = 0; i < 2; i++) { 2457 isp_rdnvram_word(isp, i, &nvram_words[i]); 2458 } 2459 if (nvram_data[0] != 'I' || nvram_data[1] != 'S' || 2460 nvram_data[2] != 'P') { 2461 if (isp->isp_bustype != ISP_BT_SBUS) { 2462 PRINTF("%s: invalid NVRAM header\n", isp->isp_name); 2463 } 2464 return (-1); 2465 } 2466 for (i = 2; i < amt>>1; i++) { 2467 isp_rdnvram_word(isp, i, &nvram_words[i]); 2468 } 2469 for (csum = 0, i = 0; i < amt; i++) { 2470 csum += nvram_data[i]; 2471 } 2472 if (csum != 0) { 2473 PRINTF("%s: invalid NVRAM checksum\n", isp->isp_name); 2474 return (-1); 2475 } 2476 if (ISP_NVRAM_VERSION(nvram_data) < minversion) { 2477 PRINTF("%s: version %d NVRAM not understood\n", isp->isp_name, 2478 ISP_NVRAM_VERSION(nvram_data)); 2479 return (-1); 2480 } 2481 2482 if (isp->isp_type & ISP_HA_SCSI) { 2483 sdparam *sdp = (sdparam *) isp->isp_param; 2484 2485 /* XXX CHECK THIS FOR SANITY XXX */ 2486 sdp->isp_fifo_threshold = 2487 ISP_NVRAM_FIFO_THRESHOLD(nvram_data); 2488 2489 sdp->isp_initiator_id = 2490 ISP_NVRAM_INITIATOR_ID(nvram_data); 2491 2492 sdp->isp_bus_reset_delay = 2493 ISP_NVRAM_BUS_RESET_DELAY(nvram_data); 2494 2495 sdp->isp_retry_count = 2496 ISP_NVRAM_BUS_RETRY_COUNT(nvram_data); 2497 2498 sdp->isp_retry_delay = 2499 ISP_NVRAM_BUS_RETRY_DELAY(nvram_data); 2500 2501 sdp->isp_async_data_setup = 2502 ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data); 2503 2504 if (isp->isp_type >= ISP_HA_SCSI_1040) { 2505 if (sdp->isp_async_data_setup < 9) { 2506 sdp->isp_async_data_setup = 9; 2507 } 2508 } else { 2509 if (sdp->isp_async_data_setup != 6) { 2510 sdp->isp_async_data_setup = 6; 2511 } 2512 } 2513 2514 sdp->isp_req_ack_active_neg = 2515 ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data); 2516 2517 sdp->isp_data_line_active_neg = 2518 ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data); 2519 2520 sdp->isp_data_dma_burst_enabl = 2521 ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data); 2522 2523 sdp->isp_cmd_dma_burst_enable = 2524 ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data); 2525 2526 sdp->isp_tag_aging = 2527 ISP_NVRAM_TAG_AGE_LIMIT(nvram_data); 2528 2529 /* XXX ISP_NVRAM_FIFO_THRESHOLD_128 XXX */ 2530 2531 sdp->isp_selection_timeout = 2532 ISP_NVRAM_SELECTION_TIMEOUT(nvram_data); 2533 2534 sdp->isp_max_queue_depth = 2535 ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data); 2536 2537 sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data); 2538 2539 for (i = 0; i < 16; i++) { 2540 sdp->isp_devparam[i].dev_enable = 2541 ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, i); 2542 sdp->isp_devparam[i].exc_throttle = 2543 ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, i); 2544 sdp->isp_devparam[i].sync_offset = 2545 ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, i); 2546 sdp->isp_devparam[i].sync_period = 2547 ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, i); 2548 2549 if (isp->isp_type < ISP_HA_SCSI_1040) { 2550 /* 2551 * If we're not ultra, we can't possibly 2552 * be a shorter period than this. 2553 */ 2554 if (sdp->isp_devparam[i].sync_period < 0x19) { 2555 sdp->isp_devparam[i].sync_period = 2556 0x19; 2557 } 2558 if (sdp->isp_devparam[i].sync_offset > 0xc) { 2559 sdp->isp_devparam[i].sync_offset = 2560 0x0c; 2561 } 2562 } else { 2563 if (sdp->isp_devparam[i].sync_offset > 0x8) { 2564 sdp->isp_devparam[i].sync_offset = 0x8; 2565 } 2566 } 2567 2568 sdp->isp_devparam[i].dev_flags = 0; 2569 2570 if (ISP_NVRAM_TGT_RENEG(nvram_data, i)) 2571 sdp->isp_devparam[i].dev_flags |= DPARM_RENEG; 2572 if (ISP_NVRAM_TGT_QFRZ(nvram_data, i)) { 2573 PRINTF("%s: not supporting QFRZ option for " 2574 "target %d\n", isp->isp_name, i); 2575 } 2576 sdp->isp_devparam[i].dev_flags |= DPARM_ARQ; 2577 if (ISP_NVRAM_TGT_ARQ(nvram_data, i) == 0) { 2578 PRINTF("%s: not disabling ARQ option for " 2579 "target %d\n", isp->isp_name, i); 2580 } 2581 if (ISP_NVRAM_TGT_TQING(nvram_data, i)) 2582 sdp->isp_devparam[i].dev_flags |= DPARM_TQING; 2583 if (ISP_NVRAM_TGT_SYNC(nvram_data, i)) 2584 sdp->isp_devparam[i].dev_flags |= DPARM_SYNC; 2585 if (ISP_NVRAM_TGT_WIDE(nvram_data, i)) 2586 sdp->isp_devparam[i].dev_flags |= DPARM_WIDE; 2587 if (ISP_NVRAM_TGT_PARITY(nvram_data, i)) 2588 sdp->isp_devparam[i].dev_flags |= DPARM_PARITY; 2589 if (ISP_NVRAM_TGT_DISC(nvram_data, i)) 2590 sdp->isp_devparam[i].dev_flags |= DPARM_DISC; 2591 } 2592 } else { 2593 fcparam *fcp = (fcparam *) isp->isp_param; 2594 union { 2595 struct { 2596 #if BYTE_ORDER == BIG_ENDIAN 2597 u_int32_t hi32; 2598 u_int32_t lo32; 2599 #else 2600 u_int32_t lo32; 2601 u_int32_t hi32; 2602 #endif 2603 } wds; 2604 u_int64_t full64; 2605 } wwnstore; 2606 2607 wwnstore.full64 = ISP2100_NVRAM_NODE_NAME(nvram_data); 2608 PRINTF("%s: Adapter WWN 0x%08x%08x\n", isp->isp_name, 2609 wwnstore.wds.hi32, wwnstore.wds.lo32); 2610 fcp->isp_wwn = wwnstore.full64; 2611 wwnstore.full64 = ISP2100_NVRAM_BOOT_NODE_NAME(nvram_data); 2612 if (wwnstore.full64 != 0) { 2613 PRINTF("%s: BOOT DEVICE WWN 0x%08x%08x\n", isp->isp_name, 2614 wwnstore.wds.hi32, wwnstore.wds.lo32); 2615 } 2616 fcp->isp_maxalloc = 2617 ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data); 2618 fcp->isp_maxfrmlen = 2619 ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data); 2620 fcp->isp_retry_delay = 2621 ISP2100_NVRAM_RETRY_DELAY(nvram_data); 2622 fcp->isp_retry_count = 2623 ISP2100_NVRAM_RETRY_COUNT(nvram_data); 2624 fcp->isp_loopid = 2625 ISP2100_NVRAM_HARDLOOPID(nvram_data); 2626 fcp->isp_execthrottle = 2627 ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data); 2628 } 2629 return (0); 2630 } 2631 2632 static void 2633 isp_rdnvram_word(isp, wo, rp) 2634 struct ispsoftc *isp; 2635 int wo; 2636 u_int16_t *rp; 2637 { 2638 int i, cbits; 2639 u_int16_t bit, rqst; 2640 2641 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT); 2642 SYS_DELAY(2); 2643 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK); 2644 SYS_DELAY(2); 2645 2646 if (isp->isp_type & ISP_HA_FC) { 2647 wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1); 2648 rqst = (ISP_NVRAM_READ << 8) | wo; 2649 cbits = 10; 2650 } else { 2651 wo &= ((ISP_NVRAM_SIZE >> 1) - 1); 2652 rqst = (ISP_NVRAM_READ << 6) | wo; 2653 cbits = 8; 2654 } 2655 2656 /* 2657 * Clock the word select request out... 2658 */ 2659 for (i = cbits; i >= 0; i--) { 2660 if ((rqst >> i) & 1) { 2661 bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT; 2662 } else { 2663 bit = BIU_NVRAM_SELECT; 2664 } 2665 ISP_WRITE(isp, BIU_NVRAM, bit); 2666 SYS_DELAY(2); 2667 ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK); 2668 SYS_DELAY(2); 2669 ISP_WRITE(isp, BIU_NVRAM, bit); 2670 SYS_DELAY(2); 2671 } 2672 /* 2673 * Now read the result back in (bits come back in MSB format). 2674 */ 2675 *rp = 0; 2676 for (i = 0; i < 16; i++) { 2677 u_int16_t rv; 2678 *rp <<= 1; 2679 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK); 2680 SYS_DELAY(2); 2681 rv = ISP_READ(isp, BIU_NVRAM); 2682 if (rv & BIU_NVRAM_DATAIN) { 2683 *rp |= 1; 2684 } 2685 SYS_DELAY(2); 2686 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT); 2687 SYS_DELAY(2); 2688 } 2689 ISP_WRITE(isp, BIU_NVRAM, 0); 2690 SYS_DELAY(2); 2691 #if BYTE_ORDER == BIG_ENDIAN 2692 *rp = ((*rp >> 8) | ((*rp & 0xff) << 8)); 2693 #endif 2694 } 2695
Indexes created Wed Sep 24 05:09:52 GMT 2025