Lines Matching defs:isp
54 #include <dev/isp/isp_freebsd.h>
149 isp_change_fw_state(ispsoftc_t *isp, int chan, int state)
151 fcparam *fcp = FCPARAM(isp, chan);
155 isp_prt(isp, ISP_LOGCONFIG|ISP_LOG_SANCFG,
170 isp_reset(ispsoftc_t *isp, int do_load_defaults)
190 isp->isp_state = ISP_NILSTATE;
191 ISP_DISABLE_INTS(isp);
197 if (IS_24XX(isp)) {
198 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_HOST_INT);
199 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
200 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
202 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
205 if (IS_FC(isp)) {
206 switch (isp->isp_type) {
238 if (!IS_24XX(isp)) {
243 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
244 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
245 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
246 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
247 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
249 } else if (IS_1240(isp)) {
253 isp->isp_clock = 60;
254 sdp = SDPARAM(isp, 0);
256 sdp = SDPARAM(isp, 1);
261 } else if (IS_ULTRA3(isp)) {
262 sdparam *sdp = isp->isp_param;
264 isp->isp_clock = 100;
266 if (IS_10160(isp))
268 else if (IS_12160(isp))
274 if (IS_DUALBUS(isp)) {
278 } else if (IS_ULTRA2(isp)) {
281 sdparam *sdp = SDPARAM(isp, 0);
283 isp->isp_clock = 100;
285 if (IS_1280(isp))
287 else if (IS_1080(isp))
292 l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK;
296 isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD");
300 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential");
304 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended");
307 isp_prt(isp, ISP_LOGERR,
312 if (IS_DUALBUS(isp)) {
313 sdp = SDPARAM(isp, 1);
314 l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT);
319 isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD");
323 isp_prt(isp, ISP_LOGCONFIG,
328 isp_prt(isp, ISP_LOGCONFIG,
332 isp_prt(isp, ISP_LOGERR,
338 sdparam *sdp = SDPARAM(isp, 0);
339 i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
342 isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i);
346 isp->isp_type = ISP_HA_SCSI_1020;
347 isp->isp_clock = 40;
356 isp->isp_type = ISP_HA_SCSI_1020A;
357 isp->isp_clock = 40;
361 isp->isp_type = ISP_HA_SCSI_1040;
362 isp->isp_clock = 60;
366 isp->isp_type = ISP_HA_SCSI_1040A;
367 isp->isp_clock = 60;
371 isp->isp_type = ISP_HA_SCSI_1040B;
372 isp->isp_clock = 60;
376 isp->isp_type = ISP_HA_SCSI_1040C;
377 isp->isp_clock = 60;
384 if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
385 isp_prt(isp, ISP_LOGCONFIG, "Differential Mode");
390 i = ISP_READ(isp, RISC_PSR);
391 if (isp->isp_bustype == ISP_BT_SBUS) {
397 isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable");
403 isp->isp_clock = 60;
415 if (isp->isp_mdvec->dv_clock) {
416 if (isp->isp_mdvec->dv_clock < isp->isp_clock) {
417 isp->isp_clock = isp->isp_mdvec->dv_clock;
427 if (IS_SCSI(isp)) {
428 ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
437 ISP_WRITE(isp, CDMA_CONTROL, DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
438 ISP_WRITE(isp, DDMA_CONTROL, DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
441 } else if (IS_24XX(isp)) {
445 ISP_WRITE(isp, BIU2400_CSR, BIU2400_DMA_STOP|(3 << 4));
448 val = ISP_READ(isp, BIU2400_CSR);
454 isp_prt(isp, ISP_LOGERR, "DMA Failed to Stop on Reset");
460 ISP_WRITE(isp, BIU2400_CSR, BIU2400_SOFT_RESET|BIU2400_DMA_STOP|(3 << 4));
464 val = ISP_READ(isp, OUTMAILBOX0);
467 val = ISP_READ(isp, BIU2400_CSR);
473 isp_prt(isp, ISP_LOGERR, "Failed to come out of reset");
477 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
486 ISP_WRITE(isp, CDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
487 ISP_WRITE(isp, TDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
488 ISP_WRITE(isp, RDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
496 if (IS_SCSI(isp)) {
497 if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) {
500 } else if (IS_24XX(isp)) {
501 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
505 if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
510 ISP_DUMPREGS(isp, "chip reset timed out");
520 if (IS_SCSI(isp)) {
521 ISP_WRITE(isp, BIU_CONF1, 0);
522 } else if (!IS_24XX(isp)) {
523 ISP_WRITE(isp, BIU2100_CSR, 0);
529 if (IS_24XX(isp)) {
530 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
531 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RELEASE);
532 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RESET);
534 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
536 ISP_WRITE(isp, BIU_SEMA, 0);
542 if (IS_24XX(isp)) {
545 val = ISP_READ(isp, OUTMAILBOX0);
551 isp_prt(isp, ISP_LOGERR, "reset didn't clear");
554 } else if (IS_SCSI(isp)) {
555 uint16_t tmp = isp->isp_mdvec->dv_conf1;
559 if (isp->isp_type == ISP_HA_SCSI_1040A) {
562 ISP_SETBITS(isp, BIU_CONF1, tmp);
564 ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
565 ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
567 if (SDPARAM(isp, 0)->isp_ptisp) {
568 if (SDPARAM(isp, 0)->isp_ultramode) {
569 while (ISP_READ(isp, RISC_MTR) != 0x1313) {
570 ISP_WRITE(isp, RISC_MTR, 0x1313);
571 ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
574 ISP_WRITE(isp, RISC_MTR, 0x1212);
579 ISP_WRITE(isp, RISC_EMB, DUAL_BANK);
581 ISP_WRITE(isp, RISC_MTR, 0x1212);
583 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
585 ISP_WRITE(isp, RISC_MTR2100, 0x1212);
586 if (IS_2200(isp) || IS_23XX(isp)) {
587 ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE);
589 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
596 if (IS_24XX(isp)) {
597 isp->isp_rqstinrp = BIU2400_REQINP;
598 isp->isp_rqstoutrp = BIU2400_REQOUTP;
599 isp->isp_respinrp = BIU2400_RSPINP;
600 isp->isp_respoutrp = BIU2400_RSPOUTP;
601 } else if (IS_23XX(isp)) {
602 isp->isp_rqstinrp = BIU_REQINP;
603 isp->isp_rqstoutrp = BIU_REQOUTP;
604 isp->isp_respinrp = BIU_RSPINP;
605 isp->isp_respoutrp = BIU_RSPOUTP;
607 isp->isp_rqstinrp = INMAILBOX4;
608 isp->isp_rqstoutrp = OUTMAILBOX4;
609 isp->isp_respinrp = OUTMAILBOX5;
610 isp->isp_respoutrp = INMAILBOX5;
612 ISP_WRITE(isp, isp->isp_rqstinrp, 0);
613 ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
614 ISP_WRITE(isp, isp->isp_respinrp, 0);
615 ISP_WRITE(isp, isp->isp_respoutrp, 0);
616 if (IS_24XX(isp)) {
617 if (!IS_26XX(isp)) {
618 ISP_WRITE(isp, BIU2400_PRI_REQINP, 0);
619 ISP_WRITE(isp, BIU2400_PRI_REQOUTP, 0);
621 ISP_WRITE(isp, BIU2400_ATIO_RSPINP, 0);
622 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, 0);
625 if (!IS_24XX(isp) && isp->isp_bustype == ISP_BT_PCI) {
627 ISP_WRITE(isp, HCCR, PCI_HCCR_CMD_BIOS);
636 if (IS_2312(isp) && isp->isp_revision < 2) {
640 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
643 isp_prt(isp, ISP_LOGERR, "MBOX_BUSY never cleared on reset");
660 isp_mboxcmd(isp, &mbs);
662 isp_prt(isp, ISP_LOGERR, "NOP command failed (%x)", mbs.param[0]);
669 if (IS_SCSI(isp) || IS_24XX(isp)) {
680 int nmbox = ISP_NMBOX(isp);
681 if (IS_SCSI(isp))
687 isp_mboxcmd(isp, &mbs);
693 isp_prt(isp, ISP_LOGERR, "Register Test Failed at Register %d: should have 0x%04x but got 0x%04x", i, patterns[i], mbs.param[i]);
708 if ((isp->isp_mdvec->dv_ispfw == NULL) || (isp->isp_confopts & ISP_CFG_NORELOAD)) {
717 if (ISP_MBOXDMASETUP(isp) != 0) {
718 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
723 if (IS_24XX(isp)) {
725 } else if (IS_23XX(isp)) {
731 isp->isp_loaded_fw = 0;
732 if (dodnld && IS_24XX(isp)) {
733 const uint32_t *ptr = isp->isp_mdvec->dv_ispfw;
743 isp_prt(isp, ISP_LOGDEBUG0, "load 0x%x words of code at load address 0x%x", ptr[3], ptr[2]);
752 nw = min(wl, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) / 4);
753 cp = isp->isp_rquest;
755 ISP_IOXPUT_32(isp, ptr[wi + i], &cp[i]);
756 MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
759 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
760 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
763 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
764 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
766 isp_prt(isp, ISP_LOGDEBUG0, "LOAD RISC RAM %u words at load address 0x%x", nw, la);
767 isp_mboxcmd(isp, &mbs);
769 isp_prt(isp, ISP_LOGERR, "F/W download failed");
782 isp->isp_loaded_fw = 1;
783 } else if (dodnld && IS_23XX(isp)) {
784 const uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
794 isp_prt(isp, ISP_LOGDEBUG0, "load 0x%x words of code at load address 0x%x", ptr[3], la);
803 nw = min(wl, min((1 << 15), ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) / 2));
804 cp = isp->isp_rquest;
806 ISP_IOXPUT_16(isp, ptr[wi + i], &cp[i]);
807 MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
812 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
813 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
815 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
816 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
817 isp_prt(isp, ISP_LOGDEBUG1, "LOAD RISC RAM 2100 %u words at load address 0x%x\n", nw, la);
821 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
822 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
824 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
825 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
827 isp_prt(isp, ISP_LOGDEBUG1, "LOAD RISC RAM %u words at load address 0x%x\n", nw, la);
829 isp_mboxcmd(isp, &mbs);
831 isp_prt(isp, ISP_LOGERR, "F/W download failed");
839 if (!IS_2322(isp)) {
859 isp->isp_loaded_fw = 1;
861 const uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
865 isp_prt(isp, ISP_LOGDEBUG1,
871 isp_mboxcmd(isp, &mbs);
873 isp_prt(isp, ISP_LOGERR,
878 } else if (IS_26XX(isp)) {
879 isp_prt(isp, ISP_LOGDEBUG1, "loading firmware from flash");
883 isp_mboxcmd(isp, &mbs);
885 isp_prt(isp, ISP_LOGERR, "Flash F/W load failed");
889 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
895 if (isp->isp_loaded_fw) {
897 if (IS_24XX(isp)) {
903 isp_mboxcmd(isp, &mbs);
905 isp_prt(isp, ISP_LOGERR, dcrc);
917 if (IS_26XX(isp)) {
920 } else if (IS_24XX(isp)) {
923 if (isp->isp_loaded_fw) {
928 } else if (IS_2322(isp)) {
930 if (isp->isp_loaded_fw) {
938 isp_mboxcmd(isp, &mbs);
939 if (IS_2322(isp) || IS_24XX(isp)) {
945 if (IS_SCSI(isp)) {
949 if (isp->isp_clock) {
951 mbs.param[1] = isp->isp_clock;
952 isp_mboxcmd(isp, &mbs);
962 isp_mboxcmd(isp, &mbs);
972 if (ISP_SBUS_SUPPORTED && isp->isp_bustype == ISP_BT_SBUS) {
975 isp->isp_fwrev[0] = 7;
976 isp->isp_fwrev[1] = 55;
978 isp->isp_fwrev[0] = 1;
979 isp->isp_fwrev[1] = 37;
981 isp->isp_fwrev[2] = 0;
984 isp->isp_fwrev[0] = mbs.param[1];
985 isp->isp_fwrev[1] = mbs.param[2];
986 isp->isp_fwrev[2] = mbs.param[3];
989 if (IS_FC(isp)) {
997 if ((ISP_FW_OLDER_THAN(isp, 1, 17, 1))) {
999 isp->isp_fwattr = ISP_FW_ATTR_SCCLUN;
1001 isp->isp_fwattr = 0;
1004 isp->isp_fwattr = mbs.param[6];
1006 if (IS_24XX(isp)) {
1007 isp->isp_fwattr |= ((uint64_t) mbs.param[15]) << 16;
1008 if (isp->isp_fwattr & ISP2400_FW_ATTR_EXTNDED) {
1009 isp->isp_fwattr |=
1015 isp->isp_fwattr = 0;
1018 isp_prt(isp, ISP_LOGCONFIG, "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
1019 btype, isp->isp_revision, dodnld? "loaded" : "resident", isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
1021 fwt = isp->isp_fwattr;
1022 if (IS_24XX(isp)) {
1023 buf = FCPARAM(isp, 0)->isp_scanscratch;
1110 isp_prt(isp, ISP_LOGCONFIG, "%s", buf);
1111 } else if (IS_FC(isp)) {
1112 buf = FCPARAM(isp, 0)->isp_scanscratch;
1154 isp_prt(isp, ISP_LOGCONFIG, "%s", buf);
1157 if (IS_24XX(isp)) {
1159 isp_mboxcmd(isp, &mbs);
1163 isp->isp_maxcmds = mbs.param[3];
1166 isp_mboxcmd(isp, &mbs);
1170 isp->isp_maxcmds = mbs.param[2];
1172 isp_prt(isp, ISP_LOGCONFIG, "%d max I/O command limit set", isp->isp_maxcmds);
1179 if (IS_FC(isp) && isp->isp_nchan > 1) {
1180 if (!ISP_CAP_MULTI_ID(isp)) {
1181 isp_prt(isp, ISP_LOGWARN, "non-MULTIID f/w loaded, "
1182 "only can enable 1 of %d channels", isp->isp_nchan);
1183 isp->isp_nchan = 1;
1184 } else if (!ISP_CAP_VP0(isp)) {
1185 isp_prt(isp, ISP_LOGWARN, "We can not use MULTIID "
1187 isp->isp_nchan = 1;
1194 if (ISP_MBOXDMASETUP(isp) != 0) {
1195 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
1202 if (ISP_IRQSETUP(isp) != 0) {
1203 isp_prt(isp, ISP_LOGERR, "Cannot setup IRQ");
1206 ISP_ENABLE_INTS(isp);
1208 if (IS_FC(isp)) {
1209 for (i = 0; i < isp->isp_nchan; i++)
1210 isp_change_fw_state(isp, i, FW_CONFIG_WAIT);
1213 isp->isp_state = ISP_RESETSTATE;
1232 if (IS_SCSI(isp)) {
1234 if (IS_ULTRA2(isp) || IS_ULTRA3(isp)) {
1235 isp->isp_maxluns = 32;
1237 isp->isp_maxluns = 8;
1240 isp->isp_maxluns = 8;
1243 if (ISP_CAP_SCCFW(isp)) {
1244 isp->isp_maxluns = 0; /* No limit -- 2/8 bytes */
1246 isp->isp_maxluns = 16;
1256 if (IS_SCSI(isp)) {
1257 isp_setdfltsdparm(isp);
1259 for (i = 0; i < isp->isp_nchan; i++) {
1260 isp_setdfltfcparm(isp, i);
1270 isp_stop(ispsoftc_t *isp)
1274 isp->isp_state = ISP_NILSTATE;
1284 isp_mboxcmd(isp, &mbs);
1292 isp_shutdown(ispsoftc_t *isp)
1295 if (isp->isp_state >= ISP_RESETSTATE)
1296 isp_stop(isp);
1297 ISP_DISABLE_INTS(isp);
1298 if (IS_FC(isp)) {
1299 if (IS_24XX(isp)) {
1300 ISP_WRITE(isp, BIU2400_ICR, 0);
1301 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
1303 ISP_WRITE(isp, BIU_ICR, 0);
1304 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
1305 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
1306 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
1307 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
1308 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
1309 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
1312 ISP_WRITE(isp, BIU_ICR, 0);
1313 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
1323 isp_init(ispsoftc_t *isp)
1325 if (IS_FC(isp)) {
1326 if (IS_24XX(isp)) {
1327 isp_fibre_init_2400(isp);
1329 isp_fibre_init(isp);
1332 isp_scsi_init(isp);
1337 isp_scsi_init(ispsoftc_t *isp)
1342 isp->isp_state = ISP_INITSTATE;
1344 sdp_chan0 = SDPARAM(isp, 0);
1346 if (IS_DUALBUS(isp)) {
1347 sdp_chan1 = SDPARAM(isp, 1);
1356 ISP_WRITE(isp, RISC_MTR, 0x1313);
1368 isp_mboxcmd(isp, &mbs);
1379 isp_mboxcmd(isp, &mbs);
1394 isp_mboxcmd(isp, &mbs);
1396 isp_prt(isp, ISP_LOGERR,
1413 isp_mboxcmd(isp, &mbs);
1415 isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
1426 isp_mboxcmd(isp, &mbs);
1432 isp_scsi_channel_init(isp, 0);
1433 if (IS_DUALBUS(isp))
1434 isp_scsi_channel_init(isp, 1);
1440 if (IS_ULTRA2(isp) || IS_1240(isp)) {
1442 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1443 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1444 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1446 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1447 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1448 isp_mboxcmd(isp, &mbs);
1452 isp->isp_residx = isp->isp_resodx = mbs.param[5];
1455 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1456 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1457 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1459 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1460 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1461 isp_mboxcmd(isp, &mbs);
1465 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1468 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1469 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1470 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1472 isp_mboxcmd(isp, &mbs);
1476 isp->isp_residx = isp->isp_resodx = mbs.param[5];
1479 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1480 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1481 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1483 isp_mboxcmd(isp, &mbs);
1487 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1501 if (IS_ULTRA2(isp))
1504 if (IS_ULTRA3(isp))
1507 if (IS_ULTRA3(isp))
1512 isp_mboxcmd(isp, &mbs);
1514 isp_prt(isp, ISP_LOGINFO,
1519 isp->isp_state = ISP_RUNSTATE;
1523 isp_scsi_channel_init(ispsoftc_t *isp, int chan)
1529 sdp = SDPARAM(isp, chan);
1536 isp_mboxcmd(isp, &mbs);
1540 isp_prt(isp, ISP_LOGINFO, "Chan %d Initiator ID is %d",
1563 if (isp->isp_loaded_fw) {
1587 isp_prt(isp, ISP_LOGDEBUG0, "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x",
1589 isp_mboxcmd(isp, &mbs);
1596 isp_mboxcmd(isp, &mbs);
1614 for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
1619 isp_mboxcmd(isp, &mbs);
1638 isp_fibre_init(ispsoftc_t *isp)
1648 fcp = FCPARAM(isp, 0);
1652 isp->isp_state = ISP_INITSTATE;
1667 if (IS_2100(isp) && isp->isp_revision < 5) {
1676 if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1699 if ((fcp->role & ISP_ROLE_INITIATOR) || IS_2100(isp) || IS_2200(isp)) {
1705 icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
1707 isp_prt(isp, ISP_LOGERR, "bad frame length (%d) from NVRAM- using %d", DEFAULT_FRAMESIZE(isp), ICB_DFLT_FRMLEN);
1712 isp_prt(isp, ISP_LOGERR, "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
1715 icbp->icb_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
1717 isp_prt(isp, ISP_LOGERR, "bad execution throttle of %d- using %d", DEFAULT_EXEC_THROTTLE(isp), ICB_DFLT_THROTTLE);
1723 ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
1733 if (ownloopid || ISP_FW_NEWER_THAN(isp, 2, 2, 5)) {
1743 if (IS_2100(isp)) {
1749 } else if (IS_2200(isp) || IS_23XX(isp)) {
1754 if (ISP_CAP_FCTAPE(isp)) {
1755 if (isp->isp_confopts & ISP_CFG_NOFCTAPE)
1758 if (isp->isp_confopts & ISP_CFG_FCTAPE)
1764 FCPARAM(isp, 0)->fctape_enabled = 1;
1766 FCPARAM(isp, 0)->fctape_enabled = 0;
1770 FCPARAM(isp, 0)->fctape_enabled = 0;
1776 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
1807 if (IS_2200(isp)) {
1831 if (isp->isp_confopts & ISP_CFG_1GB) {
1834 } else if (isp->isp_confopts & ISP_CFG_2GB) {
1856 if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
1861 if (ISP_FW_NEWER_THAN(isp, 3, 16, 0)) {
1864 if (ISP_FW_NEWER_THAN(isp, 3, 25, 0)) {
1870 isp_mboxcmd(isp, &mbs);
1889 isp_prt(isp, ISP_LOGDEBUG1,
1898 isp_prt(isp, ISP_LOGDEBUG1,
1903 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
1906 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1908 isp_prt(isp, ISP_LOGERR, "bad request queue length");
1910 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1912 isp_prt(isp, ISP_LOGERR, "bad result queue length");
1914 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1915 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1916 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1917 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1918 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1919 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1920 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1921 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1923 if (FC_SCRATCH_ACQUIRE(isp, 0)) {
1924 isp_prt(isp, ISP_LOGERR, sacq);
1927 isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x",
1930 isp_put_icb(isp, icbp, (isp_icb_t *)fcp->isp_scratch);
1931 if (isp->isp_dblev & ISP_LOGDEBUG1) {
1932 isp_print_bytes(isp, "isp_fibre_init",
1945 isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %p (%08x%08x)",
1948 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp), 0);
1949 isp_mboxcmd(isp, &mbs);
1950 FC_SCRATCH_RELEASE(isp, 0);
1953 isp->isp_reqidx = 0;
1954 isp->isp_reqodx = 0;
1955 isp->isp_residx = 0;
1956 isp->isp_resodx = 0;
1961 isp->isp_state = ISP_RUNSTATE;
1965 isp_fibre_init_2400(ispsoftc_t *isp)
1976 for (chan = 0; chan < isp->isp_nchan; chan++) {
1977 fcp = FCPARAM(isp, chan);
1982 if (chan == isp->isp_nchan) {
1983 isp_prt(isp, ISP_LOG_WARN1, "all %d channels with role 'none'", chan);
1987 isp->isp_state = ISP_INITSTATE;
1992 fcp = FCPARAM(isp, 0);
1999 isp_mboxcmd(isp, &mbs);
2008 if (isp->isp_nchan > 1 && ISP_CAP_VP0(isp)) {
2023 icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
2025 isp_prt(isp, ISP_LOGERR, "bad frame length (%d) from NVRAM- using %d", DEFAULT_FRAMESIZE(isp), ICB_DFLT_FRMLEN);
2029 icbp->icb_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
2030 if (icbp->icb_execthrottle < 1 && !IS_26XX(isp)) {
2031 isp_prt(isp, ISP_LOGERR, "bad execution throttle of %d- using %d", DEFAULT_EXEC_THROTTLE(isp), ICB_DFLT_THROTTLE);
2039 icbp->icb_xchgcnt = isp->isp_maxcmds;
2045 ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
2055 if (isp->isp_confopts & ISP_CFG_NOFCTAPE) {
2058 if (isp->isp_confopts & ISP_CFG_FCTAPE) {
2062 for (chan = 0; chan < isp->isp_nchan; chan++) {
2064 FCPARAM(isp, chan)->fctape_enabled = 1;
2066 FCPARAM(isp, chan)->fctape_enabled = 0;
2069 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
2106 isp_prt(isp, ISP_LOGWARN, "bad value %x in fwopt2 timer field", icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK);
2111 if (IS_26XX(isp)) {
2120 if (isp->isp_confopts & ISP_CFG_1GB) {
2123 } else if (isp->isp_confopts & ISP_CFG_2GB) {
2126 } else if (isp->isp_confopts & ISP_CFG_4GB) {
2129 } else if (isp->isp_confopts & ISP_CFG_8GB) {
2132 } else if (isp->isp_confopts & ISP_CFG_16GB) {
2135 } else if (isp->isp_confopts & ISP_CFG_32GB) {
2147 if (isp->isp_type <= ISP_HA_FC_2500)
2151 if (isp->isp_type <= ISP_HA_FC_2400)
2169 isp_prt(isp, ISP_LOGDEBUG1, "Setting ICB Node 0x%08x%08x Port 0x%08x%08x", ((uint32_t) (fcp->isp_wwnn >> 32)), ((uint32_t) (fcp->isp_wwnn)),
2174 isp_prt(isp, ISP_LOGDEBUG1, "Setting ICB Node to be same as Port 0x%08x%08x", ((uint32_t) (fcp->isp_wwpn >> 32)), ((uint32_t) (fcp->isp_wwpn)));
2176 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
2181 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
2183 isp_prt(isp, ISP_LOGERR, "bad request queue length %d", icbp->icb_rqstqlen);
2186 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
2188 isp_prt(isp, ISP_LOGERR, "bad result queue length %d",
2192 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
2193 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
2194 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
2195 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
2197 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
2198 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
2199 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
2200 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
2204 icbp->icb_atioqlen = RESULT_QUEUE_LEN(isp);
2206 isp_prt(isp, ISP_LOGERR, "bad ATIO queue length %d", icbp->icb_atioqlen);
2209 icbp->icb_atioqaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_atioq_dma);
2210 icbp->icb_atioqaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_atioq_dma);
2211 icbp->icb_atioqaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_atioq_dma);
2212 icbp->icb_atioqaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_atioq_dma);
2213 isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init_2400: atioq %04x%04x%04x%04x", DMA_WD3(isp->isp_atioq_dma), DMA_WD2(isp->isp_atioq_dma),
2214 DMA_WD1(isp->isp_atioq_dma), DMA_WD0(isp->isp_atioq_dma));
2217 if (ISP_CAP_MSIX(isp) && isp->isp_nirq >= 2) {
2219 if (IS_26XX(isp) && isp->isp_nirq >= 3)
2223 isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init_2400: fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x", icbp->icb_fwoptions1, icbp->icb_fwoptions2, icbp->icb_fwoptions3);
2225 isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init_2400: rqst %04x%04x%04x%04x rsp %04x%04x%04x%04x", DMA_WD3(isp->isp_rquest_dma), DMA_WD2(isp->isp_rquest_dma),
2226 DMA_WD1(isp->isp_rquest_dma), DMA_WD0(isp->isp_rquest_dma), DMA_WD3(isp->isp_result_dma), DMA_WD2(isp->isp_result_dma),
2227 DMA_WD1(isp->isp_result_dma), DMA_WD0(isp->isp_result_dma));
2229 if (FC_SCRATCH_ACQUIRE(isp, 0)) {
2230 isp_prt(isp, ISP_LOGERR, sacq);
2234 isp_put_icb_2400(isp, icbp, fcp->isp_scratch);
2235 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2236 isp_print_bytes(isp, "isp_fibre_init_2400",
2243 if (isp->isp_nchan > 1) {
2250 if (ISP_CAP_VP0(isp)) {
2252 vpinfo.vp_count = isp->isp_nchan;
2255 vpinfo.vp_count = isp->isp_nchan - 1;
2261 isp_put_icb_2400_vpinfo(isp, &vpinfo, vdst);
2263 for (; chan < isp->isp_nchan; chan++) {
2267 fcp2 = FCPARAM(isp, chan);
2277 if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
2285 if (ISP_CAP_VP0(isp))
2290 isp_put_vp_port_info(isp, &pi, pdst);
2293 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2294 isp_print_bytes(isp, "isp_fibre_init_2400",
2304 if (isp->isp_nchan > 1) {
2314 isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %04x%04x%04x%04x", DMA_WD3(fcp->isp_scdma), DMA_WD2(fcp->isp_scdma), DMA_WD1(fcp->isp_scdma), DMA_WD0(fcp->isp_scdma));
2315 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp), 0);
2316 isp_mboxcmd(isp, &mbs);
2317 FC_SCRATCH_RELEASE(isp, 0);
2322 isp->isp_reqidx = 0;
2323 isp->isp_reqodx = 0;
2324 isp->isp_residx = 0;
2325 isp->isp_resodx = 0;
2326 isp->isp_atioodx = 0;
2331 isp->isp_state = ISP_RUNSTATE;
2335 isp_fc_enable_vp(ispsoftc_t *isp, int chan)
2337 fcparam *fcp = FCPARAM(isp, chan);
2357 if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
2365 vp.vp_mod_hdl = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2367 isp_prt(isp, ISP_LOGERR,
2373 reqp = isp_getrqentry(isp);
2375 isp_prt(isp, ISP_LOGERR,
2377 isp_destroy_handle(isp, vp.vp_mod_hdl);
2380 isp_put_vp_modify(isp, &vp, (vp_modify_t *)reqp);
2381 if (isp->isp_dblev & ISP_LOGDEBUG1)
2382 isp_print_bytes(isp, "IOCB VP_MODIFY", QENTRY_LEN, reqp);
2383 ISP_SYNC_REQUEST(isp);
2384 if (msleep(resp, &isp->isp_lock, 0, "VP_MODIFY", 5*hz) == EWOULDBLOCK) {
2385 isp_prt(isp, ISP_LOGERR,
2387 isp_destroy_handle(isp, vp.vp_mod_hdl);
2390 if (isp->isp_dblev & ISP_LOGDEBUG1)
2391 isp_print_bytes(isp, "IOCB VP_MODIFY response", QENTRY_LEN, resp);
2392 isp_get_vp_modify(isp, (vp_modify_t *)resp, &vp);
2395 isp_prt(isp, ISP_LOGERR,
2404 isp_fc_disable_vp(ispsoftc_t *isp, int chan)
2414 if (ISP_CAP_VP0(isp)) {
2426 vp.vp_ctrl_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2428 isp_prt(isp, ISP_LOGERR,
2434 reqp = isp_getrqentry(isp);
2436 isp_prt(isp, ISP_LOGERR,
2438 isp_destroy_handle(isp, vp.vp_ctrl_handle);
2441 isp_put_vp_ctrl_info(isp, &vp, (vp_ctrl_info_t *)reqp);
2442 if (isp->isp_dblev & ISP_LOGDEBUG1)
2443 isp_print_bytes(isp, "IOCB VP_CTRL", QENTRY_LEN, reqp);
2444 ISP_SYNC_REQUEST(isp);
2445 if (msleep(resp, &isp->isp_lock, 0, "VP_CTRL", 5*hz) == EWOULDBLOCK) {
2446 isp_prt(isp, ISP_LOGERR,
2448 isp_destroy_handle(isp, vp.vp_ctrl_handle);
2451 if (isp->isp_dblev & ISP_LOGDEBUG1)
2452 isp_print_bytes(isp, "IOCB VP_CTRL response", QENTRY_LEN, resp);
2453 isp_get_vp_ctrl_info(isp, (vp_ctrl_info_t *)resp, &vp);
2456 isp_prt(isp, ISP_LOGERR,
2466 isp_fc_change_role(ispsoftc_t *isp, int chan, int new_role)
2468 fcparam *fcp = FCPARAM(isp, chan);
2471 if (chan >= isp->isp_nchan) {
2472 isp_prt(isp, ISP_LOGWARN, "%s: bad channel %d", __func__, chan);
2477 for (was = 0, i = 0; i < isp->isp_nchan; i++) {
2478 if (FCPARAM(isp, i)->role != ISP_ROLE_NONE)
2483 return (isp_reinit(isp, 0));
2486 res = isp_fc_disable_vp(isp, chan);
2487 isp_clear_portdb(isp, chan);
2491 res = isp_fc_enable_vp(isp, chan);
2496 isp_clear_portdb(ispsoftc_t *isp, int chan)
2498 fcparam *fcp = FCPARAM(isp, chan);
2509 isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
2524 isp_mark_portdb(ispsoftc_t *isp, int chan)
2526 fcparam *fcp = FCPARAM(isp, chan);
2546 isp_plogx(ispsoftc_t *isp, int chan, uint16_t handle, uint32_t portid, int flags)
2556 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d PLOGX %s PortID 0x%06x nphdl 0x%x",
2559 if (!IS_24XX(isp)) {
2562 return (isp_port_login(isp, handle, portid));
2564 return (isp_port_logout(isp, handle, portid));
2581 pl.plogx_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2583 isp_prt(isp, ISP_LOGERR,
2589 reqp = isp_getrqentry(isp);
2591 isp_prt(isp, ISP_LOGERR,
2593 isp_destroy_handle(isp, pl.plogx_handle);
2596 isp_put_plogx(isp, &pl, (isp_plogx_t *)reqp);
2597 if (isp->isp_dblev & ISP_LOGDEBUG1)
2598 isp_print_bytes(isp, "IOCB LOGX", QENTRY_LEN, reqp);
2599 FCPARAM(isp, chan)->isp_login_hdl = handle;
2600 ISP_SYNC_REQUEST(isp);
2601 if (msleep(resp, &isp->isp_lock, 0, "PLOGX", 3 * ICB_LOGIN_TOV * hz)
2603 isp_prt(isp, ISP_LOGERR,
2605 isp_destroy_handle(isp, pl.plogx_handle);
2608 FCPARAM(isp, chan)->isp_login_hdl = NIL_HANDLE;
2609 if (isp->isp_dblev & ISP_LOGDEBUG1)
2610 isp_print_bytes(isp, "IOCB LOGX response", QENTRY_LEN, resp);
2611 isp_get_plogx(isp, (isp_plogx_t *)resp, &pl);
2616 isp_prt(isp, ISP_LOGWARN,
2689 isp_prt(isp, lev, "Chan %d PLOGX PortID 0x%06x to N-Port handle 0x%x: %s",
2696 isp_port_login(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2701 if (ISP_CAP_2KLOGIN(isp)) {
2711 isp_mboxcmd(isp, &mbs);
2715 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: portid 0x%06x already logged in as 0x%x", portid, mbs.param[1]);
2719 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: handle 0x%x in use for port id 0x%02xXXXX", handle, mbs.param[1] & 0xff);
2726 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: error 0x%x in PLOGI to port 0x%06x", mbs.param[1], portid);
2730 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: all IDs used for fabric login");
2734 isp_prt(isp, ISP_LOG_SANCFG, "isp_port_login: error 0x%x on port login of 0x%06x@0x%0x", mbs.param[0], portid, handle);
2745 isp_port_logout(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2750 if (ISP_CAP_2KLOGIN(isp)) {
2756 isp_mboxcmd(isp, &mbs);
2761 isp_getpdb(ispsoftc_t *isp, int chan, uint16_t id, isp_pdb_t *pdb)
2771 if (IS_24XX(isp)) {
2775 } else if (ISP_CAP_2KLOGIN(isp)) {
2780 mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
2781 mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
2782 mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
2783 mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
2784 MEMORYBARRIER(isp, SYNC_IFORDEV, 0, sizeof(un), chan);
2786 isp_mboxcmd(isp, &mbs);
2790 MEMORYBARRIER(isp, SYNC_IFORCPU, 0, sizeof(un), chan);
2791 if (IS_24XX(isp)) {
2792 isp_get_pdb_24xx(isp, isp->isp_iocb, &un.bill);
2799 isp_prt(isp, ISP_LOGDEBUG0,
2809 isp_get_pdb_21xx(isp, isp->isp_iocb, &un.fred);
2816 isp_prt(isp, ISP_LOGDEBUG1,
2823 isp_gethandles(ispsoftc_t *isp, int chan, uint16_t *handles, int *num, int loop)
2825 fcparam *fcp = FCPARAM(isp, chan);
2835 if (IS_24XX(isp)) {
2849 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2850 isp_prt(isp, ISP_LOGERR, sacq);
2853 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, ISP_FC_SCRLEN, chan);
2854 isp_mboxcmd(isp, &mbs);
2856 FC_SCRATCH_RELEASE(isp, chan);
2859 MEMORYBARRIER(isp, SYNC_SFORCPU, 0, ISP_FC_SCRLEN, chan);
2864 if (IS_24XX(isp)) {
2865 isp_get_pnhle_24xx(isp, &elp4[i], &el4);
2869 } else if (IS_23XX(isp)) {
2870 isp_get_pnhle_23xx(isp, &elp3[i], &el3);
2875 isp_get_pnhle_21xx(isp, &elp1[i], &el1);
2885 FC_SCRATCH_RELEASE(isp, chan);
2890 isp_dump_chip_portdb(ispsoftc_t *isp, int chan)
2895 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d chip port dump", chan);
2896 if (ISP_CAP_2KLOGIN(isp)) {
2902 if (isp_getpdb(isp, chan, nphdl, &pdb)) {
2905 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d Handle 0x%04x "
2914 isp_get_wwn(ispsoftc_t *isp, int chan, int nphdl, int nodename)
2921 if (ISP_CAP_2KLOGIN(isp)) {
2934 isp_mboxcmd(isp, &mbs);
2938 if (IS_24XX(isp)) {
2967 isp_fclink_test(ispsoftc_t *isp, int chan, int usdelay)
2976 fcp = FCPARAM(isp, chan);
2983 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test", chan);
2990 isp_change_fw_state(isp, chan, isp_fw_state(isp, chan));
2999 ISP_SLEEP(isp, 1000);
3002 isp_prt(isp, ISP_LOG_SANCFG,
3013 isp_mboxcmd(isp, &mbs);
3018 if (IS_2100(isp)) {
3023 if (ISP_FW_NEWER_THAN(isp, 1, 15, 37))
3055 nphdl = IS_24XX(isp) ? NPH_FL_ID : FL_ID;
3056 r = isp_getpdb(isp, chan, nphdl, &pdb);
3058 if (IS_2100(isp)) {
3061 isp_prt(isp, ISP_LOGWARN,
3068 if (IS_24XX(isp)) {
3071 r = isp_register_fc4_type(isp, chan);
3076 r = isp_register_fc4_features_24xx(isp, chan);
3081 r = isp_register_port_name_24xx(isp, chan);
3086 isp_register_node_name_24xx(isp, chan);
3091 r = isp_register_fc4_type(isp, chan);
3095 isp_send_change_request(isp, chan);
3102 if (IS_23XX(isp) || IS_24XX(isp)) {
3106 isp_mboxcmd(isp, &mbs);
3127 isp_prt(isp, ISP_LOG_SANCFG,
3132 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG,
3135 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG,
3139 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test done", chan);
3155 isp_pdb_sync(ispsoftc_t *isp, int chan)
3157 fcparam *fcp = FCPARAM(isp, chan);
3166 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync", chan);
3180 isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
3182 (void) isp_plogx(isp, chan, lp->handle,
3195 isp_async(isp, ISPASYNC_DEV_ARRIVED, chan, lp);
3199 isp_async(isp, ISPASYNC_DEV_CHANGED, chan, lp);
3205 isp_async(isp, ISPASYNC_DEV_STAYED, chan, lp);
3210 isp_prt(isp, ISP_LOGWARN,
3213 isp_dump_portdb(isp, chan);
3218 isp_prt(isp, ISP_LOG_SANCFG,
3224 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync done", chan);
3229 isp_pdb_add_update(ispsoftc_t *isp, int chan, isp_pdb_t *pdb)
3238 if (isp_find_pdb_by_wwpn(isp, chan, wwpn, &lp)) {
3240 isp_prt(isp, ISP_LOGERR,
3243 FC_PORTDB_TGT(isp, chan, lp), lp->state);
3244 isp_dump_portdb(isp, chan);
3258 isp_prt(isp, ISP_LOG_SANCFG,
3270 isp_prt(isp, ISP_LOG_SANCFG,
3277 if (!isp_find_pdb_empty(isp, chan, &lp)) {
3278 isp_prt(isp, ISP_LOGERR, "Chan %d out of portdb entries", chan);
3291 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Port 0x%06x@0x%04x is new",
3301 isp_fix_portids(ispsoftc_t *isp, int chan)
3303 fcparam *fcp = FCPARAM(isp, chan);
3317 r = isp_getpdb(isp, chan, lp->handle, &pdb);
3321 isp_prt(isp, ISP_LOGDEBUG1,
3331 isp_prt(isp, ISP_LOG_SANCFG,
3341 isp_scan_loop(ispsoftc_t *isp, int chan)
3343 fcparam *fcp = FCPARAM(isp, chan);
3354 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan", chan);
3357 if (!IS_24XX(isp)) {
3358 isp_fix_portids(isp, chan);
3362 isp_prt(isp, ISP_LOG_SANCFG,
3370 r = isp_gethandles(isp, chan, handles, &lim, 1);
3372 isp_prt(isp, ISP_LOG_SANCFG,
3374 isp_prt(isp, ISP_LOG_SANCFG,
3379 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Got %d handles",
3385 isp_mark_portdb(isp, chan);
3392 if (ISP_CAP_2KLOGIN(isp)) {
3404 if (IS_2100(isp) || IS_2200(isp)) {
3405 uint64_t node_wwn = isp_get_wwn(isp, chan, handle, 1);
3408 isp_prt(isp, ISP_LOG_SANCFG,
3420 r = isp_getpdb(isp, chan, handle, &pdb);
3424 isp_prt(isp, ISP_LOGDEBUG1,
3430 isp_pdb_add_update(isp, chan, &pdb);
3435 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan done", chan);
3440 isp_ct_sns(ispsoftc_t *isp, int chan, uint32_t cmd_bcnt, uint32_t rsp_bcnt)
3442 fcparam *fcp = FCPARAM(isp, chan);
3445 if (isp->isp_dblev & ISP_LOGDEBUG1)
3446 isp_print_bytes(isp, "CT SNS request", cmd_bcnt, fcp->isp_scratch);
3447 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, cmd_bcnt, chan);
3455 isp_mboxcmd(isp, &mbs);
3464 MEMORYBARRIER(isp, SYNC_SFORCPU, 0, rsp_bcnt, chan);
3465 if (isp->isp_dblev & ISP_LOGDEBUG1)
3466 isp_print_bytes(isp, "CT response", rsp_bcnt, fcp->isp_scratch);
3471 isp_ct_passthru(ispsoftc_t *isp, int chan, uint32_t cmd_bcnt, uint32_t rsp_bcnt)
3473 fcparam *fcp = FCPARAM(isp, chan);
3478 if (isp->isp_dblev & ISP_LOGDEBUG1)
3479 isp_print_bytes(isp, "CT request", cmd_bcnt, fcp->isp_scratch);
3489 pt.ctp_vpidx = ISP_GET_VPIDX(isp, chan);
3503 pt.ctp_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
3505 isp_prt(isp, ISP_LOGERR,
3511 reqp = isp_getrqentry(isp);
3513 isp_prt(isp, ISP_LOGERR,
3515 isp_destroy_handle(isp, pt.ctp_handle);
3518 isp_put_ct_pt(isp, &pt, (isp_ct_pt_t *)reqp);
3519 if (isp->isp_dblev & ISP_LOGDEBUG1)
3520 isp_print_bytes(isp, "CT IOCB request", QENTRY_LEN, reqp);
3521 ISP_SYNC_REQUEST(isp);
3522 if (msleep(resp, &isp->isp_lock, 0, "CTP", pt.ctp_time*hz) == EWOULDBLOCK) {
3523 isp_prt(isp, ISP_LOGERR,
3525 isp_destroy_handle(isp, pt.ctp_handle);
3528 if (isp->isp_dblev & ISP_LOGDEBUG1)
3529 isp_print_bytes(isp, "CT IOCB response", QENTRY_LEN, resp);
3531 isp_get_ct_pt(isp, (isp_ct_pt_t *)resp, &pt);
3533 isp_prt(isp, ISP_LOGWARN,
3539 if (isp->isp_dblev & ISP_LOGDEBUG1)
3540 isp_print_bytes(isp, "CT response", rsp_bcnt, fcp->isp_scratch);
3560 isp_gid_pt(ispsoftc_t *isp, int chan)
3562 fcparam *fcp = FCPARAM(isp, chan);
3567 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GID_PT", chan);
3568 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3569 isp_prt(isp, ISP_LOGERR, sacq);
3573 if (IS_24XX(isp)) {
3581 isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3587 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t), GIDLEN)) {
3588 FC_SCRATCH_RELEASE(isp, chan);
3606 isp_put_gid_pt_request(isp, &rq, (sns_gid_pt_req_t *)scp);
3608 if (isp_ct_sns(isp, chan, sizeof(rq), NGENT)) {
3609 FC_SCRATCH_RELEASE(isp, chan);
3614 isp_get_gid_xx_response(isp, (sns_gid_xx_rsp_t *)scp,
3616 FC_SCRATCH_RELEASE(isp, chan);
3621 isp_gff_id(ispsoftc_t *isp, int chan, uint32_t portid)
3623 fcparam *fcp = FCPARAM(isp, chan);
3633 if (!IS_24XX(isp)) /* Old chips can't request GFF_ID. */
3636 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFF_ID", chan);
3637 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3638 isp_prt(isp, ISP_LOGERR, sacq);
3649 isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3651 ISP_IOZPUT_32(isp, portid, rp);
3653 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
3655 FC_SCRATCH_RELEASE(isp, chan);
3659 isp_get_gff_id_response(isp, (sns_gff_id_rsp_t *)scp, &rsp);
3671 if (((ISP_SWAP32(isp, rsp.snscb_fc4_features[FC4_SCSI / 8]) >>
3675 FC_SCRATCH_RELEASE(isp, chan);
3676 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFF_ID result is %d", chan, res);
3681 isp_gft_id(ispsoftc_t *isp, int chan, uint32_t portid)
3683 fcparam *fcp = FCPARAM(isp, chan);
3694 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFT_ID", chan);
3695 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3696 isp_prt(isp, ISP_LOGERR, sacq);
3700 if (IS_24XX(isp)) {
3708 isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3710 ISP_IOZPUT_32(isp, portid, rp);
3712 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
3714 FC_SCRATCH_RELEASE(isp, chan);
3729 isp_put_gxx_id_request(isp, &rq, (sns_gxx_id_req_t *)scp);
3731 if (isp_ct_sns(isp, chan, sizeof(rq), SNS_GFT_ID_RESP_SIZE)) {
3732 FC_SCRATCH_RELEASE(isp, chan);
3737 isp_get_gft_id_response(isp, (sns_gft_id_rsp_t *)scp, &rsp);
3749 FC_SCRATCH_RELEASE(isp, chan);
3750 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFT_ID result is %d", chan, res);
3755 isp_scan_fabric(ispsoftc_t *isp, int chan)
3757 fcparam *fcp = FCPARAM(isp, chan);
3770 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan", chan);
3774 isp_prt(isp, ISP_LOG_SANCFG,
3781 FC_SCRATCH_RELEASE(isp, chan);
3782 isp_prt(isp, ISP_LOG_SANCFG,
3790 nphdl = IS_24XX(isp) ? NPH_FL_ID : FL_ID;
3791 r = isp_getpdb(isp, chan, nphdl, &pdb);
3793 isp_dump_chip_portdb(isp, chan);
3798 isp_prt(isp, ISP_LOG_SANCFG,
3804 r = isp_gid_pt(isp, chan);
3828 isp_prt(isp, level, "Chan %d Fabric Nameserver rejected GID_PT"
3842 isp_prt(isp, ISP_LOGWARN,
3846 isp_prt(isp, ISP_LOG_SANCFG,
3872 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d removing duplicate PortID 0x%06x entry from list", chan, portid);
3890 isp_mark_portdb(isp, chan);
3895 isp_prt(isp, ISP_LOG_SANCFG,
3898 isp_prt(isp, ISP_LOG_SANCFG,
3904 isp_prt(isp, ISP_LOG_SANCFG,
3910 if (isp_find_pdb_by_portid(isp, chan, portid, &lp)) {
3912 isp_prt(isp, ISP_LOGERR,
3915 FC_PORTDB_TGT(isp, chan, lp), lp->state);
3916 isp_dump_portdb(isp, chan);
3938 r = isp_getpdb(isp, chan, lp->handle, &pdb);
3943 isp_prt(isp, ISP_LOG_SANCFG,
3949 isp_pdb_add_update(isp, chan, &pdb);
3955 isp_prt(isp, ISP_LOG_SANCFG,
3960 r = isp_gff_id(isp, chan, portid);
3962 isp_prt(isp, ISP_LOG_SANCFG,
3967 r = isp_gft_id(isp, chan, portid);
3969 isp_prt(isp, ISP_LOG_SANCFG,
3974 if (isp_login_device(isp, chan, portid, &pdb,
3975 &FCPARAM(isp, 0)->isp_lasthdl)) {
3981 isp_pdb_add_update(isp, chan, &pdb);
3987 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan done", chan);
3995 isp_login_device(ispsoftc_t *isp, int chan, uint32_t portid, isp_pdb_t *p, uint16_t *ohp)
4000 if (ISP_CAP_2KLOGIN(isp)) {
4006 handle = isp_next_handle(isp, ohp);
4008 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
4012 r = isp_getpdb(isp, chan, handle, p);
4016 handle = isp_next_handle(isp, ohp);
4021 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
4027 r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
4036 if (isp_plogx(isp, chan, r >> 16, portid, PLOGX_FLG_CMD_LOGO | PLOGX_FLG_IMPLICIT | PLOGX_FLG_FREE_NPHDL)) {
4037 isp_prt(isp, ISP_LOGERR, "baw... logout of %x failed", r >> 16);
4039 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
4041 r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
4047 handle = isp_next_handle(isp, ohp);
4056 isp_prt(isp, ISP_LOGWARN, "Chan %d PLOGI 0x%06x failed", chan, portid);
4065 r = isp_getpdb(isp, chan, handle, p);
4067 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x disappeared", chan, portid, handle);
4072 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x changed (0x%06x@0x%0x)",
4080 isp_send_change_request(ispsoftc_t *isp, int chan)
4087 isp_mboxcmd(isp, &mbs);
4091 isp_prt(isp, ISP_LOGWARN, "Chan %d Send Change Request: 0x%x",
4098 isp_register_fc4_type(ispsoftc_t *isp, int chan)
4100 fcparam *fcp = FCPARAM(isp, chan);
4107 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4108 isp_prt(isp, ISP_LOGERR, sacq);
4112 if (IS_24XX(isp)) {
4124 isp_put_rft_id(isp, &rp, (rft_id_t *)scp);
4126 if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
4127 FC_SCRATCH_RELEASE(isp, chan);
4143 isp_put_sns_request(isp, reqp, (sns_screq_t *)scp);
4145 if (isp_ct_sns(isp, chan, SNS_RFT_ID_REQ_SIZE, sizeof(ct_hdr_t))) {
4146 FC_SCRATCH_RELEASE(isp, chan);
4151 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4152 FC_SCRATCH_RELEASE(isp, chan);
4154 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "Chan %d Register FC4 Type rejected", chan);
4157 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Register FC4 Type accepted", chan);
4159 isp_prt(isp, ISP_LOGWARN, "Chan %d Register FC4 Type: 0x%x", chan, ct->ct_cmd_resp);
4166 isp_register_fc4_features_24xx(ispsoftc_t *isp, int chan)
4168 fcparam *fcp = FCPARAM(isp, chan);
4173 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4174 isp_prt(isp, ISP_LOGERR, sacq);
4197 isp_put_rff_id(isp, &rp, (rff_id_t *)scp);
4198 if (isp->isp_dblev & ISP_LOGDEBUG1)
4199 isp_print_bytes(isp, "CT request", sizeof(rft_id_t), scp);
4201 if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
4202 FC_SCRATCH_RELEASE(isp, chan);
4206 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4207 FC_SCRATCH_RELEASE(isp, chan);
4209 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4213 isp_prt(isp, ISP_LOG_SANCFG,
4216 isp_prt(isp, ISP_LOGWARN,
4224 isp_register_port_name_24xx(ispsoftc_t *isp, int chan)
4226 fcparam *fcp = FCPARAM(isp, chan);
4232 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4233 isp_prt(isp, ISP_LOGERR, sacq);
4256 ":%s", device_get_nameunit(isp->isp_dev));
4263 isp_put_rspn_id(isp, &rp, (rspn_id_t *)scp);
4265 if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
4266 FC_SCRATCH_RELEASE(isp, chan);
4270 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4271 FC_SCRATCH_RELEASE(isp, chan);
4273 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4277 isp_prt(isp, ISP_LOG_SANCFG,
4280 isp_prt(isp, ISP_LOGWARN,
4288 isp_register_node_name_24xx(ispsoftc_t *isp, int chan)
4290 fcparam *fcp = FCPARAM(isp, chan);
4296 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4297 isp_prt(isp, ISP_LOGERR, sacq);
4319 isp_put_rsnn_nn(isp, &rp, (rsnn_nn_t *)scp);
4321 if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
4322 FC_SCRATCH_RELEASE(isp, chan);
4326 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4327 FC_SCRATCH_RELEASE(isp, chan);
4329 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4333 isp_prt(isp, ISP_LOG_SANCFG,
4336 isp_prt(isp, ISP_LOGWARN,
4344 isp_next_handle(ispsoftc_t *isp, uint16_t *ohp)
4351 if (ISP_CAP_2KLOGIN(isp)) {
4367 isp_prt(isp, ISP_LOGERR, "Out of port handles!");
4373 for (chan = 0; chan < isp->isp_nchan; chan++) {
4374 fcp = FCPARAM(isp, chan);
4394 ispsoftc_t *isp;
4404 isp = XS_ISP(xs);
4413 if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
4414 isp_prt(isp, ISP_LOGERR, "unsupported cdb length (%d, CDB[0]=0x%x)", XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
4424 if (IS_FC(isp)) {
4425 fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
4428 isp_prt(isp, ISP_LOG_WARN1,
4435 if (isp->isp_state != ISP_RUNSTATE) {
4436 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
4441 isp_prt(isp, ISP_LOGDEBUG2, "XS_TGT(xs)=%d", target);
4449 isp_prt(isp, ISP_LOGDEBUG1,
4455 isp_prt(isp, ISP_LOGDEBUG1,
4461 isp_prt(isp, ISP_LOGDEBUG1,
4468 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
4469 if (isp->isp_state != ISP_RUNSTATE) {
4470 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
4476 isp_spi_update(isp, XS_CHANNEL(xs));
4483 qep = isp_getrqentry(isp);
4485 isp_prt(isp, ISP_LOG_WARN1, "Request Queue Overflow");
4498 if (ISP_TST_SENDMARKER(isp, XS_CHANNEL(xs))) {
4499 if (IS_24XX(isp)) {
4505 isp_put_marker_24xx(isp, m, qep);
4512 isp_put_marker(isp, m, qep);
4514 ISP_SYNC_REQUEST(isp);
4515 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 0);
4528 if (IS_24XX(isp)) {
4530 } else if (IS_FC(isp)) {
4543 if (IS_24XX(isp)) {
4560 } else if (IS_FC(isp)) {
4577 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
4588 if (IS_SCSI(isp)) {
4590 isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4599 } else if (IS_24XX(isp)) {
4603 isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4611 t7->req_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(xs));
4613 if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
4614 if (FCP_NEXT_CRN(isp, &t7->req_crn, xs)) {
4615 isp_prt(isp, ISP_LOG_WARN1,
4628 isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4632 if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
4633 if (FCP_NEXT_CRN(isp, &t2->req_crn, xs)) {
4634 isp_prt(isp, ISP_LOG_WARN1,
4641 if (ISP_CAP_2KLOGIN(isp)) {
4647 } else if (ISP_CAP_SCCFW(isp)) {
4663 reqp->req_handle = isp_allocate_handle(isp, xs, ISP_HANDLE_INITIATOR);
4665 isp_prt(isp, ISP_LOG_WARN1, "out of xflist pointers");
4676 dmaresult = ISP_DMASETUP(isp, xs, reqp);
4678 isp_destroy_handle(isp, reqp->req_handle);
4685 isp_xs_prt(isp, xs, ISP_LOGDEBUG0, "START cmd cdb[0]=0x%x datalen %ld", XS_CDBP(xs)[0], (long) XS_XFRLEN(xs));
4690 * isp control
4695 isp_control(ispsoftc_t *isp, ispctl_t ctl, ...)
4708 if (IS_24XX(isp)) {
4709 isp_prt(isp, ISP_LOGERR, "BUS RESET NOT IMPLEMENTED");
4711 } else if (IS_FC(isp)) {
4718 mbs.param[1] = SDPARAM(isp, chan)->isp_bus_reset_delay;
4725 ISP_SET_SENDMARKER(isp, chan, 1);
4726 isp_mboxcmd(isp, &mbs);
4730 isp_prt(isp, ISP_LOGINFO, "driver initiated bus reset of bus %d", chan);
4738 if (IS_24XX(isp)) {
4742 fcparam *fcp = FCPARAM(isp, chan);
4746 isp_prt(isp, ISP_LOGWARN, "Chan %d trying to reset bad target %d", chan, tgt);
4752 isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
4766 tmf->tmf_vpidx = ISP_GET_VPIDX(isp, chan);
4767 isp_put_24xx_tmf(isp, tmf, isp->isp_iocb);
4768 if (isp->isp_dblev & ISP_LOGDEBUG1)
4769 isp_print_bytes(isp, "TMF IOCB request", QENTRY_LEN, isp->isp_iocb);
4770 MEMORYBARRIER(isp, SYNC_IFORDEV, 0, QENTRY_LEN, chan);
4773 isp_prt(isp, ISP_LOGALL, "Chan %d Reset N-Port Handle 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
4777 mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
4778 mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
4779 mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
4780 mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
4781 isp_mboxcmd(isp, &mbs);
4785 MEMORYBARRIER(isp, SYNC_IFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
4786 if (isp->isp_dblev & ISP_LOGDEBUG1)
4787 isp_print_bytes(isp, "TMF IOCB response", QENTRY_LEN, &((isp24xx_statusreq_t *)isp->isp_iocb)[1]);
4789 isp_get_24xx_response(isp, &((isp24xx_statusreq_t *)isp->isp_iocb)[1], sp);
4793 isp_prt(isp, ISP_LOGWARN, "Chan %d reset of target %d returned 0x%x", chan, tgt, sp->req_completion_status);
4795 } else if (IS_FC(isp)) {
4796 if (ISP_CAP_2KLOGIN(isp)) {
4807 isp_mboxcmd(isp, &mbs);
4811 isp_prt(isp, ISP_LOGINFO, "Target %d on Bus %d Reset Succeeded", tgt, chan);
4812 ISP_SET_SENDMARKER(isp, chan, 1);
4823 handle = isp_find_handle(isp, xs);
4825 isp_prt(isp, ISP_LOGWARN, "cannot find handle for command to abort");
4828 if (IS_24XX(isp)) {
4833 fcp = FCPARAM(isp, chan);
4835 isp_prt(isp, ISP_LOGWARN, "Chan %d trying to abort bad target %d", chan, tgt);
4841 isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
4844 isp_prt(isp, ISP_LOGALL, "Chan %d Abort Cmd for N-Port 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
4852 ab->abrt_vpidx = ISP_GET_VPIDX(isp, chan);
4853 isp_put_24xx_abrt(isp, ab, isp->isp_iocb);
4854 if (isp->isp_dblev & ISP_LOGDEBUG1)
4855 isp_print_bytes(isp, "AB IOCB quest", QENTRY_LEN, isp->isp_iocb);
4856 MEMORYBARRIER(isp, SYNC_IFORDEV, 0, 2 * QENTRY_LEN, chan);
4861 mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
4862 mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
4863 mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
4864 mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
4866 isp_mboxcmd(isp, &mbs);
4870 MEMORYBARRIER(isp, SYNC_IFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
4871 if (isp->isp_dblev & ISP_LOGDEBUG1)
4872 isp_print_bytes(isp, "AB IOCB response", QENTRY_LEN, &((isp24xx_abrt_t *)isp->isp_iocb)[1]);
4873 isp_get_24xx_abrt(isp, &((isp24xx_abrt_t *)isp->isp_iocb)[1], ab);
4877 isp_prt(isp, ISP_LOGWARN, "Chan %d handle %d abort returned 0x%x", chan, tgt, ab->abrt_nphdl);
4879 } else if (IS_FC(isp)) {
4880 if (ISP_CAP_SCCFW(isp)) {
4881 if (ISP_CAP_2KLOGIN(isp)) {
4896 isp_mboxcmd(isp, &mbs);
4907 isp_spi_update(isp, chan);
4912 if (IS_FC(isp)) {
4921 return (isp_fclink_test(isp, chan, usdelay));
4927 if (IS_FC(isp)) {
4931 return (isp_scan_fabric(isp, chan));
4937 if (IS_FC(isp)) {
4941 return (isp_scan_loop(isp, chan));
4947 if (IS_FC(isp)) {
4951 return (isp_pdb_sync(isp, chan));
4957 if (IS_FC(isp) && !IS_24XX(isp)) {
4959 if (ISP_CAP_2KLOGIN(isp)) {
4962 isp_mboxcmd(isp, &mbs);
4970 if (IS_FC(isp)) {
4977 return (isp_getpdb(isp, chan, tgt, pdb));
4994 *wwnn = isp_get_wwn(isp, chan, tgt, 1);
5000 *wwnp = isp_get_wwn(isp, chan, tgt, 0);
5012 isp_mboxcmd(isp, mbr);
5025 return (isp_plogx(isp, p->channel, p->handle, p->portid, p->flags));
5028 isp_next_handle(isp, &p->handle);
5029 r = isp_plogx(isp, p->channel, p->handle, p->portid, p->flags);
5039 if (IS_FC(isp)) {
5046 r = isp_fc_change_role(isp, chan, role);
5051 isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
5067 isp_intr_atioq(ispsoftc_t *isp)
5074 iptr = ISP_READ(isp, BIU2400_ATIO_RSPINP);
5075 optr = isp->isp_atioodx;
5078 MEMORYBARRIER(isp, SYNC_ATIOQ, oop, QENTRY_LEN, -1);
5079 addr = ISP_QUEUE_ENTRY(isp->isp_atioq, oop);
5080 isp_get_hdr(isp, addr, (isphdr_t *)qe);
5085 (void) isp_target_notify(isp, addr, &oop);
5088 isp_print_qentry(isp, "?ATIOQ entry?", oop, addr);
5091 optr = ISP_NXT_QENTRY(oop, RESULT_QUEUE_LEN(isp));
5093 if (isp->isp_atioodx != optr) {
5094 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, optr);
5095 isp->isp_atioodx = optr;
5101 isp_intr_async(ispsoftc_t *isp, uint16_t event)
5104 if (IS_FC(isp))
5105 isp_parse_async_fc(isp, event);
5107 isp_parse_async(isp, event);
5111 isp_intr_mbox(ispsoftc_t *isp, uint16_t mbox0)
5115 if (!isp->isp_mboxbsy) {
5116 isp_prt(isp, ISP_LOGWARN, "mailbox 0x%x with no waiters", mbox0);
5119 obits = isp->isp_obits;
5120 isp->isp_mboxtmp[0] = mbox0;
5121 for (i = 1; i < ISP_NMBOX(isp); i++) {
5124 isp->isp_mboxtmp[i] = ISP_READ(isp, MBOX_OFF(i));
5126 MBOX_NOTIFY_COMPLETE(isp);
5130 isp_intr_respq(ispsoftc_t *isp)
5145 if (isp->isp_state != ISP_RUNSTATE) {
5146 isp_prt(isp, ISP_LOGINFO, "respq interrupt when not ready");
5150 iptr = ISP_READ(isp, isp->isp_respinrp);
5152 if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) {
5155 iptr = ISP_READ(isp, isp->isp_respinrp);
5158 isp->isp_residx = iptr;
5160 optr = isp->isp_resodx;
5163 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, cptr);
5164 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
5169 MEMORYBARRIER(isp, SYNC_RESULT, cptr, QENTRY_LEN, -1);
5170 if (isp->isp_dblev & ISP_LOGDEBUG1)
5171 isp_print_qentry(isp, "Response Queue Entry", cptr, hp);
5172 isp_get_hdr(isp, hp, &sp->req_header);
5181 if (IS_24XX(isp) && etype == RQSTYPE_RESPONSE) {
5182 isp_get_24xx_response(isp, (isp24xx_statusreq_t *)hp, sp2);
5192 isp_get_response(isp, (ispstatusreq_t *) hp, sp);
5200 isp_get_rio1(isp, (isp_rio1_t *) hp, rio);
5202 isp_fastpost_complete(isp, rio->req_handles[i]);
5207 isp_prt(isp, ISP_LOGERR, "dropping RIO2 response");
5212 isp_get_cont_response(isp, (ispstatus_cont_t *)hp, scp);
5220 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
5225 isp_prt(isp, ISP_LOG_WARN1, "Ignored Continuation Response");
5229 } else if (isp_handle_other_response(isp, etype, hp, &cptr)) {
5233 sptr = ISP_NXT_QENTRY(sptr, RESULT_QUEUE_LEN(isp));
5234 hp = (isphdr_t *)ISP_QUEUE_ENTRY(isp->isp_result, sptr);
5237 optr = ISP_NXT_QENTRY(cptr, RESULT_QUEUE_LEN(isp));
5241 isp_prt(isp, ISP_LOGERR, notresp, etype, cptr, optr);
5249 isp_print_qentry(isp, "unexpected continuation segment",
5254 isp_prt(isp, ISP_LOG_WARN1, "internal queues full");
5260 isp_print_qentry(isp, "bad header flag",
5265 isp_print_qentry(isp, "bad request packet",
5270 isp_print_qentry(isp, "invalid entry count",
5275 isp_print_qentry(isp, "invalid IOCB ordering",
5281 xs = isp_find_xs(isp, sp->req_handle);
5289 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (type 0x%x)", sp->req_handle, etype);
5291 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (status 0x%x)", sp->req_handle, ts);
5297 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%jx bus was reset",
5300 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
5303 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%jx buddaboom",
5310 if (IS_24XX(isp) && (scsi_status & (RQCS_RV|RQCS_SV)) != 0) {
5313 } else if (IS_FC(isp) && (scsi_status & RQCS_RV) != 0) {
5317 if (IS_FC(isp) && (scsi_status & RQCS_SV) != 0) {
5324 if (IS_24XX(isp)) {
5334 } else if (IS_SCSI(isp) && (req_state_flags & RQSF_GOT_SENSE)) {
5367 isp_xs_prt(isp, xs, ISP_LOGWARN,
5373 if (IS_24XX(isp))
5374 isp_parse_status_24xx(isp, sp2, xs, &resid);
5376 isp_parse_status(isp, sp, xs, &resid);
5380 if (IS_SCSI(isp)) {
5389 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
5407 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
5412 isp_prt(isp, ISP_LOGDEBUG2, "asked for %lu got raw resid %lu settled for %lu",
5416 ISP_DMAFREE(isp, xs, sp->req_handle);
5417 isp_destroy_handle(isp, sp->req_handle);
5431 if (optr != isp->isp_resodx) {
5432 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5433 isp->isp_resodx = optr;
5441 isp_parse_async(ispsoftc_t *isp, uint16_t mbox)
5451 if (IS_DUALBUS(isp)) {
5452 chan = ISP_READ(isp, OUTMAILBOX6);
5455 isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5459 ISP_SET_SENDMARKER(isp, chan, 1);
5461 isp_target_async(isp, chan, mbox);
5463 isp_async(isp, ISPASYNC_BUS_RESET, chan);
5466 isp->isp_state = ISP_CRASHED;
5471 if (isp->isp_mboxbsy) {
5472 isp->isp_obits = 1;
5473 isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5474 MBOX_NOTIFY_COMPLETE(isp);
5480 isp_async(isp, ISPASYNC_FW_CRASH);
5484 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5488 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5497 mbox = ISP_READ(isp, isp->isp_rqstoutrp);
5501 isp_prt(isp, ISP_LOGWARN, "timeout initiated SCSI bus reset of chan %d", chan);
5502 ISP_SET_SENDMARKER(isp, chan, 1);
5504 isp_target_async(isp, chan, mbox);
5509 isp_prt(isp, ISP_LOGINFO, "device reset on chan %d", chan);
5510 ISP_SET_SENDMARKER(isp, chan, 1);
5512 isp_target_async(isp, chan, mbox);
5517 isp_prt(isp, ISP_LOGWARN, "extended message underrun");
5521 isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
5525 isp_prt(isp, ISP_LOGERR, "stalled SCSI Bus after DATA Overrun");
5530 isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
5534 mbox = ISP_READ(isp, OUTMAILBOX2);
5537 isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
5538 SDPARAM(isp, chan)->isp_diffmode = 0;
5539 SDPARAM(isp, chan)->isp_ultramode = 0;
5540 SDPARAM(isp, chan)->isp_lvdmode = 1;
5543 isp_prt(isp, ISP_LOGINFO,
5545 SDPARAM(isp, chan)->isp_diffmode = 1;
5546 SDPARAM(isp, chan)->isp_ultramode = 0;
5547 SDPARAM(isp, chan)->isp_lvdmode = 0;
5550 isp_prt(isp, ISP_LOGINFO,
5552 SDPARAM(isp, chan)->isp_diffmode = 0;
5553 SDPARAM(isp, chan)->isp_ultramode = 1;
5554 SDPARAM(isp, chan)->isp_lvdmode = 0;
5557 isp_prt(isp, ISP_LOGWARN,
5565 ISP_SET_SENDMARKER(isp, chan, 1);
5570 if (!IS_ULTRA3(isp)) {
5571 isp_prt(isp, ISP_LOGERR, "unexpected fast posting completion");
5575 h1 = (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1);
5579 h1 = (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1);
5580 h2 = (ISP_READ(isp, OUTMAILBOX7) << 16) | ISP_READ(isp, OUTMAILBOX6);
5588 isp_prt(isp, ISP_LOGERR, "unexpected 16 bit RIO handle");
5591 isp_prt(isp, ISP_LOGWARN, "%s: unhandled async code 0x%x", __func__, mbox);
5596 isp_prt(isp, ISP_LOGDEBUG3, "fast post/rio completion of 0x%08x", h1);
5597 isp_fastpost_complete(isp, h1);
5599 isp_prt(isp, ISP_LOGDEBUG3, "fast post/rio completion of 0x%08x", h2);
5600 isp_fastpost_complete(isp, h2);
5606 isp_parse_async_fc(ispsoftc_t *isp, uint16_t mbox)
5611 if (IS_DUALBUS(isp)) {
5612 chan = ISP_READ(isp, OUTMAILBOX6);
5616 isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5620 isp->isp_state = ISP_CRASHED;
5621 FCPARAM(isp, chan)->isp_loopstate = LOOP_NIL;
5622 isp_change_fw_state(isp, chan, FW_CONFIG_WAIT);
5627 if (isp->isp_mboxbsy) {
5628 isp->isp_obits = 1;
5629 isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5630 MBOX_NOTIFY_COMPLETE(isp);
5636 isp_async(isp, ISPASYNC_FW_CRASH);
5640 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5644 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5649 if (IS_24XX(isp)) {
5650 isp_prt(isp, ISP_LOGERR, "ATIO Queue Transfer Error");
5654 isp_prt(isp, ISP_LOGERR, "%s: unexpected ASYNC_QWAKEUP code", __func__);
5658 isp_fastpost_complete(isp, (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1));
5662 isp_intr_respq(isp);
5667 isp_target_async(isp, (ISP_READ(isp, OUTMAILBOX2) << 16) |
5668 ISP_READ(isp, OUTMAILBOX1), mbox);
5670 isp_prt(isp, ISP_LOGWARN, "unexpected ASYNC CTIO done");
5681 for (chan = 0; chan < isp->isp_nchan; chan++) {
5682 fcp = FCPARAM(isp, chan);
5689 ISP_SET_SENDMARKER(isp, chan, 1);
5690 isp_async(isp, ISPASYNC_LIP, chan);
5692 isp_target_async(isp, chan, mbox);
5703 for (i = j = 0; i < isp->isp_maxcmds; i++) {
5707 hdp = &isp->isp_xflist[i];
5716 isp_prt(isp, ISP_LOG_WARN1,
5724 isp_prt(isp, ISP_LOGERR, lipd, chan, j);
5735 for (chan = 0; chan < isp->isp_nchan; chan++) {
5736 fcp = FCPARAM(isp, chan);
5742 ISP_SET_SENDMARKER(isp, chan, 1);
5743 isp_async(isp, ISPASYNC_LOOP_UP, chan);
5745 isp_target_async(isp, chan, mbox);
5755 for (chan = 0; chan < isp->isp_nchan; chan++) {
5756 fcp = FCPARAM(isp, chan);
5759 ISP_SET_SENDMARKER(isp, chan, 1);
5762 isp_async(isp, ISPASYNC_LOOP_DOWN, chan);
5764 isp_target_async(isp, chan, mbox);
5774 for (chan = 0; chan < isp->isp_nchan; chan++) {
5775 fcp = FCPARAM(isp, chan);
5778 ISP_SET_SENDMARKER(isp, chan, 1);
5781 isp_async(isp, ISPASYNC_LOOP_RESET, chan);
5783 isp_target_async(isp, chan, mbox);
5792 if (IS_23XX(isp) || IS_24XX(isp)) {
5793 nphdl = ISP_READ(isp, OUTMAILBOX1);
5794 nlstate = ISP_READ(isp, OUTMAILBOX2);
5798 if (IS_24XX(isp))
5799 reason = ISP_READ(isp, OUTMAILBOX3) >> 8;
5802 if (ISP_CAP_MULTI_ID(isp)) {
5803 chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
5806 echan = isp->isp_nchan - 1;
5807 } else if (chan >= isp->isp_nchan) {
5816 fcp = FCPARAM(isp, chan);
5827 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
5836 portid = ((ISP_READ(isp, OUTMAILBOX1) & 0xff) << 16) |
5837 ISP_READ(isp, OUTMAILBOX2);
5838 if (ISP_CAP_MULTI_ID(isp)) {
5839 chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
5840 if (chan >= isp->isp_nchan)
5845 fcp = FCPARAM(isp, chan);
5852 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
5857 isp_prt(isp, ISP_LOGWARN, "Error logging disabled (reason 0x%x)",
5858 ISP_READ(isp, OUTMAILBOX1));
5864 if (!IS_2200(isp) && !IS_2100(isp)) {
5865 isp_prt(isp, ISP_LOGWARN, "bad card for ASYNC_CONNMODE event");
5869 mbox = ISP_READ(isp, OUTMAILBOX1);
5872 isp_prt(isp, ISP_LOGINFO,
5876 isp_prt(isp, ISP_LOGINFO,
5880 isp_prt(isp, ISP_LOGWARN,
5884 isp->isp_state = ISP_CRASHED;
5885 isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
5886 isp_async(isp, ISPASYNC_FW_CRASH);
5889 isp_prt(isp, ISP_LOGWARN,
5893 isp_prt(isp, ISP_LOGWARN,
5897 ISP_SET_SENDMARKER(isp, chan, 1);
5898 FCPARAM(isp, chan)->isp_loopstate = LOOP_HAVE_LINK;
5899 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan, ISPASYNC_CHANGE_OTHER);
5902 isp_prt(isp, ISP_LOGWARN, "P2P init error (reason 0x%x)",
5903 ISP_READ(isp, OUTMAILBOX1));
5906 if (IS_24XX(isp)) {
5907 isp_prt(isp, ISP_LOGWARN, "Receive Error");
5909 isp_prt(isp, ISP_LOGWARN, "unexpected ASYNC_RCV_ERR");
5913 if (IS_24XX(isp)) {
5914 isp_prt(isp, ISP_LOGTDEBUG0, "LS_RJT sent");
5917 isp_prt(isp, ISP_LOGTDEBUG0, "QFULL sent");
5921 isp_prt(isp, ISP_LOGDEBUG0, "FW restart complete");
5924 isp_prt(isp, ISP_LOGERR, "Temperature alert (subcode 0x%x)",
5925 ISP_READ(isp, OUTMAILBOX1));
5928 isp_prt(isp, ISP_LOGDEBUG0, "Transceiver insertion (0x%x)",
5929 ISP_READ(isp, OUTMAILBOX1));
5932 isp_prt(isp, ISP_LOGDEBUG0, "Transceiver removal");
5935 isp_prt(isp, ISP_LOGDEBUG0, "Autoload FW init complete");
5938 isp_prt(isp, ISP_LOGERR, "Autoload FW init failure");
5941 isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
5953 isp_handle_other_response(ispsoftc_t *isp, int type, isphdr_t *hp, uint32_t *optrp)
5962 isp_prt(isp, ISP_LOG_WARN1, "Marker Response");
5965 isp_get_ridacq(isp, (isp_ridacq_t *)hp, &rid);
5969 for (chan = 0; chan < isp->isp_nchan; chan++) {
5970 fcparam *fcp = FCPARAM(isp, chan);
5977 isp_async(isp, ISPASYNC_CHANGE_NOTIFY,
5981 isp_async(isp, ISPASYNC_LOOP_DOWN,
5986 fcparam *fcp = FCPARAM(isp, rid.ridacq_vp_index);
5992 isp_async(isp, ISPASYNC_CHANGE_NOTIFY,
5996 isp_async(isp, ISPASYNC_LOOP_DOWN,
6005 ISP_IOXGET_32(isp, (uint32_t *)(hp + 1), hdl);
6006 ptr = isp_find_xs(isp, hdl);
6008 isp_destroy_handle(isp, hdl);
6025 return (isp_target_notify(isp, (ispstatusreq_t *) hp, optrp));
6035 isp_parse_status(ispsoftc_t *isp, ispstatusreq_t *sp, XS_T *xs, uint32_t *rp)
6046 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Selection Timeout @ %s:%d", __func__, __LINE__);
6053 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Incomplete, state 0x%x", sp->req_state_flags);
6057 isp_xs_prt(isp, xs, ISP_LOGERR, "DMA Error");
6111 isp_xs_prt(isp, xs, ISP_LOGERR, "Transport Error: %s", buf);
6118 isp_xs_prt(isp, xs, ISP_LOGWARN, "Bus Reset destroyed command");
6119 for (chan = 0; chan < isp->isp_nchan; chan++) {
6120 FCPARAM(isp, chan)->sendmarker = 1;
6129 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
6130 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
6137 isp_xs_prt(isp, xs, ISP_LOGWARN, "Command timed out");
6148 isp_xs_prt(isp, xs, ISP_LOGERR, "data overrun (%ld)", (long) XS_GET_RESID(xs));
6155 isp_xs_prt(isp, xs, ISP_LOGERR, "command overrun");
6159 isp_xs_prt(isp, xs, ISP_LOGERR, "status overrun");
6163 isp_xs_prt(isp, xs, ISP_LOGERR, "msg not COMMAND COMPLETE after status");
6167 isp_xs_prt(isp, xs, ISP_LOGERR, "No MESSAGE OUT phase after selection");
6171 isp_xs_prt(isp, xs, ISP_LOGERR, "EXTENDED IDENTIFY failed");
6175 isp_xs_prt(isp, xs, ISP_LOGERR, "INITIATOR DETECTED ERROR rejected");
6179 isp_xs_prt(isp, xs, ISP_LOGERR, "ABORT OPERATION rejected");
6183 isp_xs_prt(isp, xs, ISP_LOGERR, "MESSAGE REJECT rejected");
6187 isp_xs_prt(isp, xs, ISP_LOGERR, "NOP rejected");
6191 isp_xs_prt(isp, xs, ISP_LOGERR, "MESSAGE PARITY ERROR rejected");
6195 isp_xs_prt(isp, xs, ISP_LOGWARN, "BUS DEVICE RESET rejected");
6199 isp_xs_prt(isp, xs, ISP_LOGERR, "IDENTIFY rejected");
6203 isp_xs_prt(isp, xs, ISP_LOGERR, "Unexpected Bus Free");
6208 if (IS_FC(isp)) {
6211 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
6226 isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued transaction with disconnect not set");
6230 isp_xs_prt(isp, xs, ISP_LOGERR,
6236 isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued cmd when queueing disabled");
6240 isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
6244 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "internal queues full status 0x%x", *XS_STSP(xs));
6265 isp_xs_prt(isp, xs, ISP_LOGERR, "SCSI phase skipped");
6269 isp_xs_prt(isp, xs, ISP_LOGERR, "Auto Request Sense Failed");
6276 isp_xs_prt(isp, xs, ISP_LOGERR, "Wide Negotiation Failed");
6277 if (IS_SCSI(isp)) {
6278 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
6289 isp_xs_prt(isp, xs, ISP_LOGERR, "SDTR Message Failed");
6290 if (IS_SCSI(isp)) {
6291 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
6300 isp_xs_prt(isp, xs, ISP_LOGERR, "Bad LVD condition");
6311 fcparam *fcp = FCPARAM(isp, 0);
6323 isp_prt(isp, ISP_LOGINFO, "port %s for target %d", reason, XS_TGT(xs));
6338 isp_prt(isp, ISP_LOGWARN, "port changed for target %d", XS_TGT(xs));
6346 isp_prt(isp, ISP_LOGWARN, "port busy for target %d", XS_TGT(xs));
6354 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x", sp->req_completion_status);
6363 isp_parse_status_24xx(ispsoftc_t *isp, isp24xx_statusreq_t *sp, XS_T *xs, uint32_t *rp)
6376 isp_xs_prt(isp, xs, ISP_LOGERR, "DMA error");
6380 isp_xs_prt(isp, xs, ISP_LOGERR, "Transport Error");
6384 isp_xs_prt(isp, xs, ISP_LOGWARN, "reset destroyed command");
6385 FCPARAM(isp, chan)->sendmarker = 1;
6392 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
6393 FCPARAM(isp, chan)->sendmarker = 1;
6400 isp_xs_prt(isp, xs, ISP_LOGWARN, "Command Timed Out");
6408 isp_xs_prt(isp, xs, ISP_LOGERR, "Data Overrun");
6415 isp_prt(isp, ISP_LOGERR, "Chan %d data reassembly error for target %d", chan, XS_TGT(xs));
6423 isp_prt(isp, ISP_LOGERR, "Chan %d target %d sent ABTS", chan, XS_TGT(xs));
6438 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
6445 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Data Underrun (%d) for command 0x%x", sp->req_resid, XS_CDBP(xs)[0] & 0xff);
6459 fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
6471 isp_prt(isp, ISP_LOGINFO, "Chan %d port %s for target %d",
6487 isp_prt(isp, ISP_LOGWARN, "port changed for target %d chan %d", XS_TGT(xs), chan);
6495 isp_prt(isp, ISP_LOGWARN, "f/w resource unavailable for target %d chan %d", XS_TGT(xs), chan);
6503 isp_prt(isp, ISP_LOGWARN, "command for target %d overlapped task management for chan %d", XS_TGT(xs), chan);
6511 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x on chan %d", sp->req_completion_status, chan);
6520 isp_fastpost_complete(ispsoftc_t *isp, uint32_t fph)
6527 xs = isp_find_xs(isp, fph);
6529 isp_prt(isp, ISP_LOGWARN,
6533 isp_destroy_handle(isp, fph);
6543 ISP_DMAFREE(isp, xs, fph);
7022 isp_mboxcmd(ispsoftc_t *isp, mbreg_t *mbp)
7029 if (IS_FC(isp)) {
7032 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
7041 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
7052 isp_prt(isp, ISP_LOGDEBUG3, "Mailbox Command '%s'", cname);
7069 isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
7076 if (MBOX_ACQUIRE(isp)) {
7081 for (box = 0; box < ISP_NMBOX(isp); box++) {
7083 isp_prt(isp, ISP_LOGDEBUG3, "IN mbox %d = 0x%04x", box,
7085 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
7087 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
7090 isp->isp_lastmbxcmd = opcode;
7095 isp->isp_obits = obits;
7096 isp->isp_mboxbsy = 1;
7101 if (IS_24XX(isp)) {
7102 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
7104 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
7110 MBOX_WAIT_COMPLETE(isp, mbp);
7116 isp->isp_mboxbsy = 0;
7117 MBOX_RELEASE(isp);
7124 for (box = 0; box < ISP_NMBOX(isp); box++) {
7126 mbp->param[box] = isp->isp_mboxtmp[box];
7127 isp_prt(isp, ISP_LOGDEBUG3, "OUT mbox %d = 0x%04x", box,
7132 isp->isp_mboxbsy = 0;
7133 MBOX_RELEASE(isp);
7199 isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s%s)",
7205 isp_fw_state(ispsoftc_t *isp, int chan)
7207 if (IS_FC(isp)) {
7211 isp_mboxcmd(isp, &mbs);
7220 isp_spi_update(ispsoftc_t *isp, int chan)
7226 if (IS_FC(isp)) {
7232 sdp = SDPARAM(isp, chan);
7242 isp_prt(isp, ISP_LOGDEBUG0, "skipping target %d bus %d update", tgt, chan);
7298 isp_prt(isp, ISP_LOGDEBUG0, "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
7305 isp_mboxcmd(isp, &mbs);
7321 isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, chan, tgt);
7335 isp_setdfltsdparm(ispsoftc_t *isp)
7340 sdp = SDPARAM(isp, 0);
7341 if (IS_DUALBUS(isp))
7352 sdp->isp_initiator_id = DEFAULT_IID(isp, 0);
7353 if (isp->isp_type >= ISP_HA_SCSI_1040) {
7359 sdp->isp_max_queue_depth = MAXISPREQUEST(isp);
7393 if (IS_ULTRA3(isp)) {
7396 } else if (IS_ULTRA2(isp)) {
7399 } else if (IS_1240(isp)) {
7402 } else if ((isp->isp_bustype == ISP_BT_SBUS &&
7403 isp->isp_type < ISP_HA_SCSI_1020A) ||
7404 (isp->isp_bustype == ISP_BT_PCI &&
7405 isp->isp_type < ISP_HA_SCSI_1040) ||
7406 (isp->isp_clock && isp->isp_clock < 60) ||
7426 sdp1->isp_initiator_id = DEFAULT_IID(isp, 1);
7435 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7438 if (isp_read_nvram(isp, 0) == 0) {
7439 if (IS_DUALBUS(isp)) {
7440 if (isp_read_nvram(isp, 1) == 0) {
7446 isp_mboxcmd(isp, &mbs);
7471 isp_setdfltfcparm(ispsoftc_t *isp, int chan)
7473 fcparam *fcp = FCPARAM(isp, chan);
7478 fcp->role = DEFAULT_ROLE(isp, chan);
7482 fcp->isp_loopid = DEFAULT_LOOPID(isp, chan);
7483 fcp->isp_wwnn_nvram = DEFAULT_NODEWWN(isp, chan);
7484 fcp->isp_wwpn_nvram = DEFAULT_PORTWWN(isp, chan);
7491 if (IS_24XX(isp)) {
7494 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
7503 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
7519 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7525 j = isp_read_nvram(isp, chan);
7531 isp->isp_confopts |= ISP_CFG_NONVRAM;
7535 fcp->isp_wwnn = ACTIVE_NODEWWN(isp, chan);
7536 fcp->isp_wwpn = ACTIVE_PORTWWN(isp, chan);
7537 isp_prt(isp, ISP_LOGCONFIG, "Chan %d 0x%08x%08x/0x%08x%08x Role %s",
7550 isp_reinit(ispsoftc_t *isp, int do_load_defaults)
7554 if (isp->isp_state > ISP_RESETSTATE)
7555 isp_stop(isp);
7556 if (isp->isp_state != ISP_RESETSTATE)
7557 isp_reset(isp, do_load_defaults);
7558 if (isp->isp_state != ISP_RESETSTATE) {
7560 isp_prt(isp, ISP_LOGERR, "%s: cannot reset card", __func__);
7564 isp_init(isp);
7565 if (isp->isp_state > ISP_RESETSTATE &&
7566 isp->isp_state != ISP_RUNSTATE) {
7568 isp_prt(isp, ISP_LOGERR, "%s: cannot init card", __func__);
7569 ISP_DISABLE_INTS(isp);
7570 if (IS_FC(isp)) {
7574 if (!IS_24XX(isp)) {
7575 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
7576 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
7577 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
7578 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
7579 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
7585 isp_clear_commands(isp);
7586 if (IS_FC(isp)) {
7587 for (i = 0; i < isp->isp_nchan; i++)
7588 isp_clear_portdb(isp, i);
7597 isp_read_nvram(ispsoftc_t *isp, int bus)
7608 if (IS_24XX(isp)) {
7609 return (isp_read_nvram_2400(isp, nvram_data));
7610 } else if (IS_FC(isp)) {
7613 } else if (IS_ULTRA2(isp)) {
7622 isp_rdnvram_word(isp, i, &nvram_words[i]);
7627 if (isp->isp_bustype != ISP_BT_SBUS) {
7628 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
7629 isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x", nvram_data[0], nvram_data[1], nvram_data[2]);
7639 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7645 isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
7651 if (IS_ULTRA3(isp)) {
7652 isp_parse_nvram_12160(isp, bus, nvram_data);
7653 } else if (IS_1080(isp)) {
7654 isp_parse_nvram_1080(isp, bus, nvram_data);
7655 } else if (IS_1280(isp) || IS_1240(isp)) {
7656 isp_parse_nvram_1080(isp, bus, nvram_data);
7657 } else if (IS_SCSI(isp)) {
7658 isp_parse_nvram_1020(isp, nvram_data);
7660 isp_parse_nvram_2100(isp, nvram_data);
7670 isp_read_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
7675 if (isp->isp_port) {
7683 isp_rd_2400_nvram(isp, addr++, dptr++);
7687 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header (%x %x %x)",
7695 ISP_IOXGET_32(isp, &dptr[lwrds], tmp);
7699 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7703 isp_parse_nvram_2400(isp, nvram_data);
7709 isp_rdnvram_word(ispsoftc_t *isp, int wo, uint16_t *rp)
7714 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7716 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7719 if (IS_FC(isp)) {
7721 if (IS_2312(isp) && isp->isp_port) {
7726 } else if (IS_ULTRA2(isp)) {
7745 ISP_WRITE(isp, BIU_NVRAM, bit);
7747 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7748 ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
7750 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7751 ISP_WRITE(isp, BIU_NVRAM, bit);
7753 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7762 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7764 rv = ISP_READ(isp, BIU_NVRAM);
7769 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7771 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7773 ISP_WRITE(isp, BIU_NVRAM, 0);
7775 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7776 ISP_SWIZZLE_NVRAM_WORD(isp, rp);
7780 isp_rd_2400_nvram(ispsoftc_t *isp, uint32_t addr, uint32_t *rp)
7786 if (IS_26XX(isp)) {
7788 } else if (IS_25XX(isp)) {
7791 ISP_WRITE(isp, BIU2400_FLASH_ADDR, base | addr);
7794 tmp = ISP_READ(isp, BIU2400_FLASH_ADDR);
7800 *rp = ISP_READ(isp, BIU2400_FLASH_DATA);
7801 ISP_SWIZZLE_NVRAM_LONG(isp, rp);
7808 isp_parse_nvram_1020(ispsoftc_t *isp, uint8_t *nvram_data)
7810 sdparam *sdp = SDPARAM(isp, 0);
7817 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7832 if (isp->isp_type >= ISP_HA_SCSI_1040) {
7879 if (isp->isp_type < ISP_HA_SCSI_1040) {
7920 isp_parse_nvram_1080(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7922 sdparam *sdp = SDPARAM(isp, bus);
7928 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7995 isp_parse_nvram_12160(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7997 sdparam *sdp = SDPARAM(isp, bus);
8003 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
8070 isp_parse_nvram_2100(ispsoftc_t *isp, uint8_t *nvram_data)
8072 fcparam *fcp = FCPARAM(isp, 0);
8088 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x",
8095 if (IS_2200(isp) || IS_23XX(isp)) {
8098 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x",
8113 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
8114 DEFAULT_FRAMESIZE(isp) =
8119 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
8122 if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
8123 DEFAULT_EXEC_THROTTLE(isp) =
8127 isp_prt(isp, ISP_LOGDEBUG0,
8135 isp_prt(isp, ISP_LOGDEBUG0,
8143 isp_prt(isp, ISP_LOGDEBUG0, "xfwoptions 0x%x zfw options 0x%x",
8148 isp_parse_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
8150 fcparam *fcp = FCPARAM(isp, 0);
8153 isp_prt(isp, ISP_LOGDEBUG0,
8161 isp_prt(isp, ISP_LOGDEBUG0,
8187 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
8188 DEFAULT_FRAMESIZE(isp) =
8191 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
8194 if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
8195 DEFAULT_EXEC_THROTTLE(isp) =