Lines Matching defs:isp
1 /* $NetBSD: isp.c,v 1.135 2021/12/12 13:05:14 andvar Exp $ */
4 * code for the Qlogic ISP SCSI adapters.
46 __KERNEL_RCSID(0, "$NetBSD: isp.c,v 1.135 2021/12/12 13:05:14 andvar Exp $");
52 #include <dev/isp/isp_freebsd.h>
69 isp_prt(isp, ISP_LOGSANCFG, \
160 isp_reset(ispsoftc_t *isp, int do_load_defaults)
168 isp->isp_state = ISP_NILSTATE;
169 if (isp->isp_dead) {
170 isp_shutdown(isp);
171 ISP_DISABLE_INTS(isp);
185 ISP_DISABLE_INTS(isp);
192 if (IS_24XX(isp)) {
193 isp->isp_maxcmds = 4096;
194 } else if (IS_2322(isp)) {
195 isp->isp_maxcmds = 2048;
196 } else if (IS_23XX(isp) || IS_2200(isp)) {
197 isp->isp_maxcmds = 1024;
199 isp->isp_maxcmds = 512;
208 if (ISP_MBOXDMASETUP(isp) != 0) {
209 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
217 if (IS_24XX(isp)) {
218 isp->isp_rqstinrp = BIU2400_REQINP;
219 isp->isp_rqstoutrp = BIU2400_REQOUTP;
220 isp->isp_respinrp = BIU2400_RSPINP;
221 isp->isp_respoutrp = BIU2400_RSPOUTP;
222 } else if (IS_23XX(isp)) {
223 isp->isp_rqstinrp = BIU_REQINP;
224 isp->isp_rqstoutrp = BIU_REQOUTP;
225 isp->isp_respinrp = BIU_RSPINP;
226 isp->isp_respoutrp = BIU_RSPOUTP;
228 isp->isp_rqstinrp = INMAILBOX4;
229 isp->isp_rqstoutrp = OUTMAILBOX4;
230 isp->isp_respinrp = OUTMAILBOX5;
231 isp->isp_respoutrp = INMAILBOX5;
238 if (IS_24XX(isp)) {
239 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_HOST_INT);
240 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
241 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
243 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
246 if (IS_FC(isp)) {
247 switch (isp->isp_type) {
273 if (!IS_24XX(isp)) {
278 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
279 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
280 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
281 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
282 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
284 } else if (IS_1240(isp)) {
288 isp->isp_clock = 60;
289 sdp = SDPARAM(isp, 0);
291 sdp = SDPARAM(isp, 1);
296 } else if (IS_ULTRA3(isp)) {
297 sdparam *sdp = isp->isp_param;
299 isp->isp_clock = 100;
301 if (IS_10160(isp))
303 else if (IS_12160(isp))
309 if (IS_DUALBUS(isp)) {
313 } else if (IS_ULTRA2(isp)) {
316 sdparam *sdp = SDPARAM(isp, 0);
318 isp->isp_clock = 100;
320 if (IS_1280(isp))
322 else if (IS_1080(isp))
327 l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK;
331 isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD");
335 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential");
339 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended");
342 isp_prt(isp, ISP_LOGERR,
347 if (IS_DUALBUS(isp)) {
348 sdp = SDPARAM(isp, 1);
349 l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT);
354 isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD");
358 isp_prt(isp, ISP_LOGCONFIG,
363 isp_prt(isp, ISP_LOGCONFIG,
367 isp_prt(isp, ISP_LOGERR,
373 sdparam *sdp = SDPARAM(isp, 0);
374 i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
377 isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i);
381 isp->isp_type = ISP_HA_SCSI_1020;
382 isp->isp_clock = 40;
391 isp->isp_type = ISP_HA_SCSI_1020A;
392 isp->isp_clock = 40;
396 isp->isp_type = ISP_HA_SCSI_1040;
397 isp->isp_clock = 60;
401 isp->isp_type = ISP_HA_SCSI_1040A;
402 isp->isp_clock = 60;
406 isp->isp_type = ISP_HA_SCSI_1040B;
407 isp->isp_clock = 60;
411 isp->isp_type = ISP_HA_SCSI_1040C;
412 isp->isp_clock = 60;
419 if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
420 isp_prt(isp, ISP_LOGCONFIG, "Differential Mode");
425 i = ISP_READ(isp, RISC_PSR);
426 if (isp->isp_bustype == ISP_BT_SBUS) {
432 isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable");
438 isp->isp_clock = 60;
450 if (isp->isp_mdvec->dv_clock) {
451 if (isp->isp_mdvec->dv_clock < isp->isp_clock) {
452 isp->isp_clock = isp->isp_mdvec->dv_clock;
461 isp->isp_intcnt = isp->isp_intbogus = 0;
466 ISP_RESET0(isp);
473 if (IS_SCSI(isp)) {
474 ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
483 ISP_WRITE(isp, CDMA_CONTROL, DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
484 ISP_WRITE(isp, DDMA_CONTROL, DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
487 } else if (IS_24XX(isp)) {
491 ISP_WRITE(isp, BIU2400_CSR, BIU2400_DMA_STOP|(3 << 4));
494 val = ISP_READ(isp, BIU2400_CSR);
500 ISP_RESET0(isp);
501 isp_prt(isp, ISP_LOGERR, "DMA Failed to Stop on Reset");
507 ISP_WRITE(isp, BIU2400_CSR, BIU2400_SOFT_RESET|BIU2400_DMA_STOP|(3 << 4));
511 val = ISP_READ(isp, OUTMAILBOX0);
514 val = ISP_READ(isp, BIU2400_CSR);
520 ISP_RESET0(isp);
521 isp_prt(isp, ISP_LOGERR, "Failed to come out of reset");
525 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
534 ISP_WRITE(isp, CDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
535 ISP_WRITE(isp, TDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
536 ISP_WRITE(isp, RDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
540 * Wait for ISP to be ready to go...
544 if (IS_SCSI(isp)) {
545 if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) {
548 } else if (IS_24XX(isp)) {
549 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
553 if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
558 ISP_DUMPREGS(isp, "chip reset timed out");
559 ISP_RESET0(isp);
569 if (IS_SCSI(isp)) {
570 ISP_WRITE(isp, BIU_CONF1, 0);
571 } else if (!IS_24XX(isp)) {
572 ISP_WRITE(isp, BIU2100_CSR, 0);
578 if (IS_24XX(isp)) {
579 isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
580 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RELEASE);
581 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RESET);
583 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
585 ISP_WRITE(isp, BIU_SEMA, 0);
591 if (IS_24XX(isp)) {
594 val = ISP_READ(isp, OUTMAILBOX0);
600 ISP_RESET0(isp);
601 isp_prt(isp, ISP_LOGERR, "reset didn't clear");
604 } else if (IS_SCSI(isp)) {
605 uint16_t tmp = isp->isp_mdvec->dv_conf1;
609 if (isp->isp_type == ISP_HA_SCSI_1040A) {
612 ISP_SETBITS(isp, BIU_CONF1, tmp);
614 ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
615 ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
617 if (SDPARAM(isp, 0)->isp_ptisp) {
618 if (SDPARAM(isp, 0)->isp_ultramode) {
619 while (ISP_READ(isp, RISC_MTR) != 0x1313) {
620 ISP_WRITE(isp, RISC_MTR, 0x1313);
621 ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
624 ISP_WRITE(isp, RISC_MTR, 0x1212);
629 ISP_WRITE(isp, RISC_EMB, DUAL_BANK);
631 ISP_WRITE(isp, RISC_MTR, 0x1212);
633 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
635 ISP_WRITE(isp, RISC_MTR2100, 0x1212);
636 if (IS_2200(isp) || IS_23XX(isp)) {
637 ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE);
639 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
642 ISP_WRITE(isp, isp->isp_rqstinrp, 0);
643 ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
644 ISP_WRITE(isp, isp->isp_respinrp, 0);
645 ISP_WRITE(isp, isp->isp_respoutrp, 0);
646 if (IS_24XX(isp)) {
647 ISP_WRITE(isp, BIU2400_PRI_REQINP, 0);
648 ISP_WRITE(isp, BIU2400_PRI_REQOUTP, 0);
649 ISP_WRITE(isp, BIU2400_ATIO_RSPINP, 0);
650 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, 0);
656 ISP_RESET1(isp);
664 if (IS_2312(isp) && isp->isp_revision < 2) {
668 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
671 ISP_RESET0(isp);
672 isp_prt(isp, ISP_LOGERR,
692 isp_mboxcmd(isp, &mbs);
694 isp_prt(isp, ISP_LOGERR, "NOP command failed (%x)", mbs.param[0]);
695 ISP_RESET0(isp);
703 if (IS_SCSI(isp) || IS_24XX(isp)) {
714 isp_mboxcmd(isp, &mbs);
716 ISP_RESET0(isp);
722 ISP_RESET0(isp);
723 isp_prt(isp, ISP_LOGERR, "Register Test Failed (0x%x 0x%x 0x%x 0x%x 0x%x)", mbs.param[1], mbs.param[2], mbs.param[3], mbs.param[4], mbs.param[5]);
738 if ((isp->isp_mdvec->dv_ispfw == NULL) || (isp->isp_confopts & ISP_CFG_NORELOAD)) {
742 if (IS_24XX(isp)) {
744 } else if (IS_23XX(isp)) {
750 if (dodnld && IS_24XX(isp)) {
751 const uint32_t *ptr = isp->isp_mdvec->dv_ispfw;
761 isp_prt(isp, ISP_LOGDEBUG0, "load 0x%x words of code at load address 0x%x", ptr[3], ptr[2]);
771 nw = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) >> 2;
775 cp = isp->isp_rquest;
777 ISP_IOXPUT_32(isp, ptr[wi++], &cp[i]);
780 MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
785 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
786 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
788 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
789 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
793 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
794 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
797 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
798 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
802 isp_mboxcmd(isp, &mbs);
804 isp_prt(isp, ISP_LOGERR, "F/W Risc Ram Load Failed");
805 ISP_RESET0(isp);
816 isp->isp_loaded_fw = 1;
817 } else if (dodnld && IS_23XX(isp)) {
818 const uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
828 isp_prt(isp, ISP_LOGDEBUG0, "load 0x%x words of code at load address 0x%x", ptr[3], la);
837 nw = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) >> 1;
844 cp = isp->isp_rquest;
846 ISP_IOXPUT_16(isp, ptr[wi++], &cp[i]);
849 MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
854 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
855 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
857 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
858 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
862 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
863 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
865 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
866 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
870 isp_mboxcmd(isp, &mbs);
872 isp_prt(isp, ISP_LOGERR, "F/W Risc Ram Load Failed");
873 ISP_RESET0(isp);
879 if (!IS_2322(isp)) {
899 isp->isp_loaded_fw = 1;
905 ucd.cp = isp->isp_mdvec->dv_ispfw;
906 isp->isp_mbxworkp = &ucd.np[1];
907 isp->isp_mbxwrk0 = ucd.np[3] - 1;
908 isp->isp_mbxwrk1 = code_org + 1;
914 isp_mboxcmd(isp, &mbs);
916 isp_prt(isp, ISP_LOGERR, "F/W download failed at word %d", isp->isp_mbxwrk1 - code_org);
917 ISP_RESET0(isp);
921 isp->isp_loaded_fw = 0;
922 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
928 if (isp->isp_loaded_fw) {
931 if (IS_24XX(isp)) {
937 isp_mboxcmd(isp, &mbs);
939 isp_prt(isp, ISP_LOGERR, dcrc);
940 ISP_RESET0(isp);
954 if (IS_24XX(isp)) {
957 if (isp->isp_loaded_fw) {
962 if (IS_25XX(isp)) {
965 } else if (IS_2322(isp)) {
967 if (isp->isp_loaded_fw) {
975 isp_mboxcmd(isp, &mbs);
976 if (IS_2322(isp) || IS_24XX(isp)) {
978 ISP_RESET0(isp);
987 if (IS_24XX(isp)) {
993 isp_prt(isp, ISP_LOGERR, "f/w didn't *really* start");
994 ISP_RESET0(isp);
999 if (IS_SCSI(isp)) {
1003 if (isp->isp_clock) {
1005 mbs.param[1] = isp->isp_clock;
1007 isp_mboxcmd(isp, &mbs);
1018 isp_mboxcmd(isp, &mbs);
1020 ISP_RESET0(isp);
1029 if (ISP_SBUS_SUPPORTED && isp->isp_bustype == ISP_BT_SBUS) {
1032 isp->isp_fwrev[0] = 7;
1033 isp->isp_fwrev[1] = 55;
1035 isp->isp_fwrev[0] = 1;
1036 isp->isp_fwrev[1] = 37;
1038 isp->isp_fwrev[2] = 0;
1041 isp->isp_fwrev[0] = mbs.param[1];
1042 isp->isp_fwrev[1] = mbs.param[2];
1043 isp->isp_fwrev[2] = mbs.param[3];
1046 isp_prt(isp, ISP_LOGCONFIG, "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
1047 btype, isp->isp_revision, dodnld? "loaded" : "resident", isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
1049 if (IS_FC(isp)) {
1057 if ((ISP_FW_OLDER_THAN(isp, 1, 17, 1))) {
1059 isp->isp_fwattr = ISP_FW_ATTR_SCCLUN;
1061 isp->isp_fwattr = 0;
1064 isp->isp_fwattr = mbs.param[6];
1065 isp_prt(isp, ISP_LOGDEBUG0, "Firmware Attributes = 0x%x", mbs.param[6]);
1069 isp->isp_fwattr = ISP_FW_ATTR_TMODE;
1071 isp->isp_fwattr = 0;
1075 if (!IS_24XX(isp)) {
1077 isp_mboxcmd(isp, &mbs);
1079 ISP_RESET0(isp);
1082 if (isp->isp_maxcmds >= mbs.param[2]) {
1083 isp->isp_maxcmds = mbs.param[2];
1086 isp_prt(isp, ISP_LOGCONFIG, "%d max I/O command limit set", isp->isp_maxcmds);
1093 if (IS_FC(isp) && ISP_CAP_MULTI_ID(isp) == 0 && isp->isp_nchan > 1) {
1094 isp_prt(isp, ISP_LOGWARN, "non-MULTIID f/w loaded, only can enable 1 of %d channels", isp->isp_nchan);
1095 isp->isp_nchan = 1;
1098 for (i = 0; i < isp->isp_nchan; i++) {
1099 isp_fw_state(isp, i);
1101 if (isp->isp_dead) {
1102 isp_shutdown(isp);
1103 ISP_DISABLE_INTS(isp);
1107 isp->isp_state = ISP_RESETSTATE;
1126 if (IS_SCSI(isp)) {
1128 if (IS_ULTRA2(isp) || IS_ULTRA3(isp)) {
1129 isp->isp_maxluns = 32;
1131 isp->isp_maxluns = 8;
1134 isp->isp_maxluns = 8;
1137 if (ISP_CAP_SCCFW(isp)) {
1138 isp->isp_maxluns = 16384;
1140 isp->isp_maxluns = 16;
1150 if (IS_SCSI(isp)) {
1151 isp_setdfltsdparm(isp);
1153 for (i = 0; i < isp->isp_nchan; i++) {
1154 isp_setdfltfcparm(isp, i);
1167 isp_init(ispsoftc_t *isp)
1169 if (IS_FC(isp)) {
1170 if (IS_24XX(isp)) {
1171 isp_fibre_init_2400(isp);
1173 isp_fibre_init(isp);
1176 isp_scsi_init(isp);
1178 GET_NANOTIME(&isp->isp_init_time);
1182 isp_scsi_init(ispsoftc_t *isp)
1187 sdp_chan0 = SDPARAM(isp, 0);
1189 if (IS_DUALBUS(isp)) {
1190 sdp_chan1 = SDPARAM(isp, 1);
1199 ISP_WRITE(isp, RISC_MTR, 0x1313);
1211 isp_mboxcmd(isp, &mbs);
1222 isp_mboxcmd(isp, &mbs);
1237 isp_mboxcmd(isp, &mbs);
1239 isp_prt(isp, ISP_LOGERR,
1256 isp_mboxcmd(isp, &mbs);
1258 isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
1269 isp_mboxcmd(isp, &mbs);
1275 isp_scsi_channel_init(isp, 0);
1276 if (IS_DUALBUS(isp))
1277 isp_scsi_channel_init(isp, 1);
1283 if (IS_ULTRA2(isp) || IS_1240(isp)) {
1285 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1286 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1287 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1289 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1290 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1291 isp_mboxcmd(isp, &mbs);
1295 isp->isp_residx = mbs.param[5];
1298 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1299 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1300 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1302 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1303 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1304 isp_mboxcmd(isp, &mbs);
1308 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1311 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1312 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1313 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1315 isp_mboxcmd(isp, &mbs);
1319 isp->isp_residx = mbs.param[5];
1322 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1323 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1324 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1326 isp_mboxcmd(isp, &mbs);
1330 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1344 if (IS_ULTRA2(isp))
1347 if (IS_ULTRA3(isp))
1350 if (IS_ULTRA3(isp))
1355 isp_mboxcmd(isp, &mbs);
1357 isp_prt(isp, ISP_LOGINFO,
1362 isp->isp_state = ISP_INITSTATE;
1366 isp_scsi_channel_init(ispsoftc_t *isp, int chan)
1372 sdp = SDPARAM(isp, chan);
1379 isp_mboxcmd(isp, &mbs);
1383 isp_prt(isp, ISP_LOGINFO, "Chan %d Initiator ID is %d",
1406 if (isp->isp_loaded_fw) {
1430 isp_prt(isp, ISP_LOGDEBUG0, "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x",
1432 isp_mboxcmd(isp, &mbs);
1439 isp_mboxcmd(isp, &mbs);
1452 * It turns out that sometimes the ISP just ignores our
1457 for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
1462 isp_mboxcmd(isp, &mbs);
1481 isp_fibre_init(ispsoftc_t *isp)
1491 fcp = FCPARAM(isp, 0);
1493 isp->isp_state = ISP_INITSTATE;
1511 if (IS_2100(isp) && isp->isp_revision < 5) {
1520 if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1544 icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
1546 isp_prt(isp, ISP_LOGERR, "bad frame length (%d) from NVRAM- using %d", DEFAULT_FRAMESIZE(isp), ICB_DFLT_FRMLEN);
1551 isp_prt(isp, ISP_LOGERR, "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
1554 icbp->icb_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
1556 isp_prt(isp, ISP_LOGERR, "bad execution throttle of %d- using %d", DEFAULT_EXEC_THROTTLE(isp), ICB_DFLT_THROTTLE);
1562 ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
1572 if (ownloopid || ISP_FW_NEWER_THAN(isp, 2, 2, 5)) {
1582 if (IS_2100(isp)) {
1588 } else if (IS_2200(isp) || IS_23XX(isp)) {
1593 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
1607 if (IS_2200(isp)) {
1630 if (isp->isp_confopts & ISP_CFG_ONEGB) {
1632 } else if (isp->isp_confopts & ISP_CFG_TWOGB) {
1647 if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
1652 if (ISP_FW_NEWER_THAN(isp, 3, 16, 0)) {
1658 isp_mboxcmd(isp, &mbs);
1670 isp_prt(isp, ISP_LOGDEBUG1,
1679 isp_prt(isp, ISP_LOGDEBUG1,
1684 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
1687 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1689 isp_prt(isp, ISP_LOGERR, "bad request queue length");
1691 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1693 isp_prt(isp, ISP_LOGERR, "bad result queue length");
1695 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1696 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1697 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1698 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1699 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1700 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1701 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1702 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1704 if (FC_SCRATCH_ACQUIRE(isp, 0)) {
1705 isp_prt(isp, ISP_LOGERR, sacq);
1708 isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x",
1711 isp_put_icb(isp, icbp, (isp_icb_t *)fcp->isp_scratch);
1722 isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %p (%08x%08x)",
1725 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp), 0);
1726 isp_mboxcmd(isp, &mbs);
1727 FC_SCRATCH_RELEASE(isp, 0);
1729 isp_print_bytes(isp, "isp_fibre_init", sizeof (*icbp), icbp);
1732 isp->isp_reqidx = 0;
1733 isp->isp_reqodx = 0;
1734 isp->isp_residx = 0;
1739 isp->isp_state = ISP_INITSTATE;
1743 isp_fibre_init_2400(ispsoftc_t *isp)
1753 for (chan = 0; chan < isp->isp_nchan; chan++) {
1754 fcp = FCPARAM(isp, chan);
1759 if (chan == isp->isp_nchan) {
1760 isp_prt(isp, ISP_LOGDEBUG0, "all %d channels with role 'none'", chan);
1761 isp->isp_state = ISP_INITSTATE;
1768 fcp = FCPARAM(isp, 0);
1775 isp_mboxcmd(isp, &mbs);
1795 icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
1797 isp_prt(isp, ISP_LOGERR, "bad frame length (%d) from NVRAM- using %d", DEFAULT_FRAMESIZE(isp), ICB_DFLT_FRMLEN);
1801 icbp->icb_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
1803 isp_prt(isp, ISP_LOGERR, "bad execution throttle of %d- using %d", DEFAULT_EXEC_THROTTLE(isp), ICB_DFLT_THROTTLE);
1813 isp_mboxcmd(isp, &mbs);
1832 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
1867 isp_prt(isp, ISP_LOGWARN, "bad value %x in fwopt2 timer field", icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK);
1879 if (isp->isp_confopts & ISP_CFG_ONEGB) {
1881 } else if (isp->isp_confopts & ISP_CFG_TWOGB) {
1883 } else if (isp->isp_confopts & ISP_CFG_FOURGB) {
1889 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
1898 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)),
1903 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)));
1905 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
1910 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1912 isp_prt(isp, ISP_LOGERR, "bad request queue length %d", icbp->icb_rqstqlen);
1915 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1917 isp_prt(isp, ISP_LOGERR, "bad result queue length %d",
1921 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1922 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1923 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1924 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1926 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1927 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1928 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1929 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1933 icbp->icb_atioqlen = RESULT_QUEUE_LEN(isp);
1935 isp_prt(isp, ISP_LOGERR, "bad ATIO queue length %d", icbp->icb_atioqlen);
1938 icbp->icb_atioqaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_atioq_dma);
1939 icbp->icb_atioqaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_atioq_dma);
1940 icbp->icb_atioqaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_atioq_dma);
1941 icbp->icb_atioqaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_atioq_dma);
1942 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),
1943 DMA_WD1(isp->isp_atioq_dma), DMA_WD0(isp->isp_atioq_dma));
1946 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);
1948 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),
1949 DMA_WD1(isp->isp_rquest_dma), DMA_WD0(isp->isp_rquest_dma), DMA_WD3(isp->isp_result_dma), DMA_WD2(isp->isp_result_dma),
1950 DMA_WD1(isp->isp_result_dma), DMA_WD0(isp->isp_result_dma));
1952 if (isp->isp_dblev & ISP_LOGDEBUG1) {
1953 isp_print_bytes(isp, "isp_fibre_init_2400", sizeof (*icbp), icbp);
1956 if (FC_SCRATCH_ACQUIRE(isp, 0)) {
1957 isp_prt(isp, ISP_LOGERR, sacq);
1961 isp_put_icb_2400(isp, icbp, fcp->isp_scratch);
1966 if (isp->isp_nchan > 1) {
1972 vpinfo.vp_count = isp->isp_nchan - 1;
1977 isp_put_icb_2400_vpinfo(isp, &vpinfo, vdst);
1979 for (chan = 1; chan < isp->isp_nchan; chan++) {
1983 fcp2 = FCPARAM(isp, chan);
1998 isp_put_vp_port_info(isp, &pi, pdst);
2007 if (isp->isp_nchan > 1) {
2016 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));
2017 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp), 0);
2018 isp_mboxcmd(isp, &mbs);
2019 FC_SCRATCH_RELEASE(isp, 0);
2024 isp->isp_reqidx = 0;
2025 isp->isp_reqodx = 0;
2026 isp->isp_residx = 0;
2031 isp->isp_state = ISP_INITSTATE;
2035 isp_mark_portdb(ispsoftc_t *isp, int chan, int disposition)
2037 fcparam *fcp = FCPARAM(isp, chan);
2040 if (chan < 0 || chan >= isp->isp_nchan) {
2041 isp_prt(isp, ISP_LOGWARN, "isp_mark_portdb: bad channel %d", chan);
2047 isp_prt(isp, ISP_LOGTINFO, "isp_mark_portdb: Chan %d zeroing handle 0x" "%04x port 0x%06x", chan,
2080 isp_plogx(ispsoftc_t *isp, int chan, uint16_t handle, uint32_t portid, int flags, int gs)
2092 if (!IS_24XX(isp)) {
2095 return (isp_port_login(isp, handle, portid));
2097 return (isp_port_logout(isp, handle, portid));
2114 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2115 isp_print_bytes(isp, "IOCB LOGX", QENTRY_LEN, plp);
2119 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2120 isp_prt(isp, ISP_LOGERR, sacq);
2124 fcp = FCPARAM(isp, chan);
2126 isp_put_plogx(isp, plp, (isp_plogx_t *) scp);
2134 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, QENTRY_LEN, chan);
2135 isp_mboxcmd(isp, &mbs);
2140 MEMORYBARRIER(isp, SYNC_SFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
2142 isp_get_plogx(isp, (isp_plogx_t *) scp, plp);
2143 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2144 isp_print_bytes(isp, "IOCB LOGX response", QENTRY_LEN, plp);
2151 isp_prt(isp, ISP_LOGWARN,
2222 isp_prt(isp, ISP_LOGERR, "Chan %d PLOGX PortID 0x%06x to N-Port handle 0x%x: %s", chan, portid, handle, msg);
2226 FC_SCRATCH_RELEASE(isp, chan);
2232 isp_port_login(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2237 if (ISP_CAP_2KLOGIN(isp)) {
2247 isp_mboxcmd(isp, &mbs);
2251 isp_prt(isp, ISP_LOGDEBUG0,
2257 isp_prt(isp, ISP_LOGDEBUG0,
2266 isp_prt(isp, ISP_LOGINFO,
2272 isp_prt(isp, ISP_LOGINFO,
2277 isp_prt(isp, ISP_LOGINFO,
2285 isp_port_logout(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2290 if (ISP_CAP_2KLOGIN(isp)) {
2296 isp_mboxcmd(isp, &mbs);
2301 isp_getpdb(ispsoftc_t *isp, int chan, uint16_t id, isp_pdb_t *pdb, int dolock)
2303 fcparam *fcp = FCPARAM(isp, chan);
2311 if (IS_24XX(isp)) {
2315 } else if (ISP_CAP_2KLOGIN(isp)) {
2325 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2326 isp_prt(isp, ISP_LOGERR, sacq);
2330 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (un), chan);
2331 isp_mboxcmd(isp, &mbs);
2334 FC_SCRATCH_RELEASE(isp, chan);
2338 if (IS_24XX(isp)) {
2339 isp_get_pdb_24xx(isp, fcp->isp_scratch, &un.bill);
2345 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
2353 FC_SCRATCH_RELEASE(isp, chan);
2358 isp_get_pdb_21xx(isp, fcp->isp_scratch, &un.fred);
2366 FC_SCRATCH_RELEASE(isp, chan);
2372 isp_dump_chip_portdb(ispsoftc_t *isp, int chan, int dolock)
2377 if (ISP_CAP_2KLOGIN(isp)) {
2383 if (isp_getpdb(isp, chan, loopid, &pdb, dolock)) {
2386 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGINFO, "Chan %d Loopid 0x%04x "
2395 isp_get_wwn(ispsoftc_t *isp, int chan, int loopid, int nodename)
2398 fcparam *fcp = FCPARAM(isp, chan);
2406 if (ISP_CAP_2KLOGIN(isp)) {
2412 if (ISP_CAP_MULTI_ID(isp)) {
2422 isp_mboxcmd(isp, &mbs);
2426 if (IS_24XX(isp)) {
2455 isp_fclink_test(ispsoftc_t *isp, int chan, int usdelay)
2465 fcp = FCPARAM(isp, chan);
2467 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Chan %d FC Link Test Entry", chan);
2468 ISP_MARK_PORTDB(isp, chan, 1);
2481 isp_fw_state(isp, chan);
2483 isp_prt(isp, ISP_LOGCONFIG|ISP_LOGSANCFG, "Chan %d Firmware State <%s->%s>", chan, isp_fc_fw_statename((int)lwfs), isp_fc_fw_statename((int)fcp->isp_fwstate));
2497 isp_prt(isp, ISP_LOGDEBUG1, "usec%d: 0x%lx->0x%lx enano 0x%x%08x", count, (long) GET_NANOSEC(&hra), (long) GET_NANOSEC(&hrb), (uint32_t)(enano >> 32), (uint32_t)(enano));
2512 ISP_SLEEP(isp, 4000000);
2517 ISP_SLEEP(isp, wrk);
2534 isp_prt(isp, ISP_LOGSANCFG, "%s: chan %d not at FW_READY state", __func__, chan);
2542 if (ISP_CAP_MULTI_ID(isp)) {
2547 isp_mboxcmd(isp, &mbs);
2552 if (ISP_CAP_2KLOGIN(isp)) {
2558 if (IS_2100(isp)) {
2569 if (IS_2100(isp)) {
2574 if (ISP_FW_NEWER_THAN(isp, 1, 15, 37)) {
2594 isp_prt(isp, ISP_LOGWARN, "Zero AL_PA for Loop Topology?");
2603 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Chan %d deriving loopid %d from AL_PA map (AL_PA 0x%x) and ignoring returned value %d (AL_PA 0x%x)", chan, i, alpa_map[i], fcp->isp_loopid, alpa);
2610 if (IS_24XX(isp)) { /* XXX SHOULDN'T THIS BE FOR 2K F/W? XXX */
2616 r = isp_getpdb(isp, chan, loopid, &pdb, 1);
2618 isp_prt(isp, ISP_LOGWARN, "fabric topology but cannot get info about fabric controller (0x%x)", r);
2625 if (IS_2100(isp)) {
2648 if (IS_24XX(isp)) {
2650 if (ISP_FW_NEWER_THAN(isp, 4, 0, 27)) {
2653 isp_prt(isp, ISP_LOGCONFIG, "fabric supports NP-IV");
2658 r = isp_plogx(isp, chan, fcp->isp_sns_hdl, SNS_PORT_ID, PLOGX_FLG_CMD_PLOGI | PLOGX_FLG_COND_PLOGI | PLOGX_FLG_SKIP_PRLI, 0);
2660 isp_prt(isp, ISP_LOGWARN, "%s: Chan %d cannot log into SNS", __func__, chan);
2666 r = isp_register_fc4_type_24xx(isp, chan);
2669 r = isp_register_fc4_type(isp, chan);
2672 isp_prt(isp, ISP_LOGWARN|ISP_LOGSANCFG, "%s: register fc4 type failed", __func__);
2681 if (IS_23XX(isp) || IS_24XX(isp)) {
2685 isp_mboxcmd(isp, &mbs);
2688 isp_prt(isp, ISP_LOGINFO, "Chan %d 8Gb link speed", chan);
2691 isp_prt(isp, ISP_LOGINFO, "Chan %d 4Gb link speed", chan);
2694 isp_prt(isp, ISP_LOGINFO, "Chan %d 2Gb link speed", chan);
2697 isp_prt(isp, ISP_LOGINFO, "Chan %d 1Gb link speed", chan);
2706 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGCONFIG, topology, chan, (uint32_t) (fcp->isp_wwpn >> 32), (uint32_t) fcp->isp_wwpn, fcp->isp_portid, fcp->isp_loopid, isp_fc_toponame(fcp));
2707 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Chan %d FC Link Test Complete", chan);
2732 isp_pdb_sync(ispsoftc_t *isp, int chan)
2734 fcparam *fcp = FCPARAM(isp, chan);
2748 isp_prt(isp, ISP_LOGWARN, "isp_pdb_sync: bad loopstate %d",
2757 if (isp_scan_loop(isp, chan) != 0) {
2758 isp_prt(isp, ISP_LOGWARN,
2767 if (isp_scan_fabric(isp, chan) != 0) {
2768 isp_prt(isp, ISP_LOGWARN,
2775 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
2789 isp_prt(isp,
2803 isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
2805 (void) isp_plogx(isp, chan, lp->handle,
2828 isp_async(isp, ISPASYNC_DEV_ARRIVED, chan, lp);
2839 isp_async(isp, ISPASYNC_DEV_CHANGED, chan, lp);
2853 isp_async(isp, ISPASYNC_DEV_STAYED, chan, lp);
2864 isp_prt(isp, ISP_LOGWARN,
2867 isp_dump_portdb(isp, chan);
2885 isp_scan_loop(ispsoftc_t *isp, int chan)
2888 fcparam *fcp = FCPARAM(isp, chan);
2916 if (IS_24XX(isp) && isp->isp_nchan > 1) {
2917 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
2928 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
2936 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
2951 if (ISP_CAP_2KLOGIN(isp)) {
2960 if (IS_2100(isp) || IS_2200(isp)) {
2961 uint64_t node_wwn = isp_get_wwn(isp, chan, handle, 1);
2963 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
2975 r = isp_getpdb(isp, chan, handle, &pdb, 1);
2977 isp_prt(isp, ISP_LOGDEBUG1,
2981 ISP_MARK_PORTDB(isp, chan, 1);
2982 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
2990 ISP_MARK_PORTDB(isp, chan, 1);
2991 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3002 if (IS_2100(isp) && pdb.handle != handle) {
3003 isp_prt(isp, ISP_LOGWARN,
3005 ISP_MARK_PORTDB(isp, chan, 1);
3006 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3032 isp_get_wwn(isp, chan, handle, 1);
3034 isp_get_wwn(isp, chan, handle, 0);
3036 isp_prt(isp, ISP_LOGINFO, "DODGED!");
3040 isp_prt(isp, ISP_LOGWARN,
3043 isp_dump_portdb(isp, chan);
3072 isp_prt(isp, ISP_LOGERR,
3075 isp_dump_portdb(isp, chan);
3076 ISP_MARK_PORTDB(isp, chan, 1);
3077 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3098 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3114 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3143 isp_prt(isp, ISP_LOGERR,
3157 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3162 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3196 isp_gid_ft_sns(ispsoftc_t *isp, int chan)
3202 fcparam *fcp = FCPARAM(isp, chan);
3206 isp_prt(isp, ISP_LOGDEBUG0,
3220 isp_put_gid_ft_request(isp, rq, fcp->isp_scratch);
3221 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GID_FT_REQ_SIZE, chan);
3230 isp_mboxcmd(isp, &mbs);
3242 isp_gid_ft_ct_passthru(ispsoftc_t *isp, int chan)
3245 fcparam *fcp = FCPARAM(isp, chan);
3256 isp_prt(isp, ISP_LOGDEBUG0,
3259 if (!IS_24XX(isp)) {
3273 pt->ctp_vpidx = ISP_GET_VPIDX(isp, chan);
3284 if (isp->isp_dblev & ISP_LOGDEBUG1) {
3285 isp_print_bytes(isp, "ct IOCB", QENTRY_LEN, pt);
3287 isp_put_ct_pt(isp, pt, (isp_ct_pt_t *) &scp[CTXOFF]);
3302 isp_put_ct_hdr(isp, ct, (ct_hdr_t *) &scp[XTXOFF]);
3304 ISP_IOZPUT_32(isp, FC4_SCSI, rp);
3305 if (isp->isp_dblev & ISP_LOGDEBUG1) {
3306 isp_print_bytes(isp, "CT HDR + payload after put",
3316 MEMORYBARRIER(isp, SYNC_SFORDEV, XTXOFF, 2 * QENTRY_LEN, chan);
3317 isp_mboxcmd(isp, &mbs);
3321 MEMORYBARRIER(isp, SYNC_SFORCPU, ZTXOFF, QENTRY_LEN, chan);
3323 isp_get_ct_pt(isp, (isp_ct_pt_t *) &scp[ZTXOFF], pt);
3324 if (isp->isp_dblev & ISP_LOGDEBUG1) {
3325 isp_print_bytes(isp, "IOCB response", QENTRY_LEN, pt);
3329 isp_prt(isp, ISP_LOGWARN,
3330 "Chan %d ISP GID FT CT Passthrough returned 0x%x",
3334 MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN + 16, chan);
3335 if (isp->isp_dblev & ISP_LOGDEBUG1) {
3336 isp_print_bytes(isp, "CT response", GIDLEN+16, &scp[IGPOFF]);
3342 isp_scan_fabric(ispsoftc_t *isp, int chan)
3344 fcparam *fcp = FCPARAM(isp, chan);
3351 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3362 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3368 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3369 isp_prt(isp, ISP_LOGERR, sacq);
3370 ISP_MARK_PORTDB(isp, chan, 1);
3374 FC_SCRATCH_RELEASE(isp, chan);
3375 ISP_MARK_PORTDB(isp, chan, 1);
3382 if (IS_24XX(isp)) { /* XXX SHOULDN'T THIS BE TRUE FOR 2K F/W? XXX */
3387 r = isp_getpdb(isp, chan, loopid, &pdb, 0);
3389 isp_dump_chip_portdb(isp, chan, 0);
3393 FC_SCRATCH_RELEASE(isp, chan);
3394 ISP_MARK_PORTDB(isp, chan, 1);
3398 if (IS_24XX(isp)) {
3399 r = isp_gid_ft_ct_passthru(isp, chan);
3401 r = isp_gid_ft_sns(isp, chan);
3405 FC_SCRATCH_RELEASE(isp, chan);
3406 ISP_MARK_PORTDB(isp, chan, 1);
3412 FC_SCRATCH_RELEASE(isp, chan);
3416 FC_SCRATCH_RELEASE(isp, chan);
3420 MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN, chan);
3423 isp_get_gid_ft_response(isp, rs0, rs1, NGENT);
3425 FC_SCRATCH_RELEASE(isp, chan);
3426 ISP_MARK_PORTDB(isp, chan, 1);
3437 isp_prt(isp, level, "Chan %d Fabric Nameserver rejected GID_FT"
3441 FC_SCRATCH_RELEASE(isp, chan);
3455 oldhandle = FCPARAM(isp, 0)->isp_lasthdl;
3473 isp_prt(isp, ISP_LOGWARN,
3477 isp_prt(isp, ISP_LOGSANCFG,
3502 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3534 isp_prt(isp, ISP_LOGSANCFG,
3548 if (ISP_CAP_MULTI_ID(isp)) {
3550 isp_prt(isp, ISP_LOGSANCFG,
3556 isp_prt(isp, ISP_LOGSANCFG,
3562 isp_prt(isp, ISP_LOGSANCFG,
3608 r = isp_getpdb(isp, chan, lp->handle, &pdb, 0);
3610 FC_SCRATCH_RELEASE(isp, chan);
3611 ISP_MARK_PORTDB(isp, chan, 1);
3617 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3636 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3653 if (isp_login_device(isp, chan, portid, &pdb,
3659 FC_SCRATCH_RELEASE(isp, chan);
3660 ISP_MARK_PORTDB(isp, chan, 1);
3667 FC_SCRATCH_RELEASE(isp, chan);
3668 ISP_MARK_PORTDB(isp, chan, 1);
3671 FCPARAM(isp, 0)->isp_lasthdl = oldhandle;
3676 isp_prt(isp, ISP_LOGWARN, "changed WWN"
3705 isp_prt(isp, ISP_LOGSANCFG,
3710 isp_prt(isp, ISP_LOGSANCFG,
3752 isp_prt(isp, ISP_LOGWARN, "Chan %d PortID 0x%06x "
3762 isp_prt(isp, ISP_LOGERR,
3780 if (isp_login_device(isp, chan, portid, &pdb, &oldhandle)) {
3782 FC_SCRATCH_RELEASE(isp, chan);
3783 ISP_MARK_PORTDB(isp, chan, 1);
3789 FC_SCRATCH_RELEASE(isp, chan);
3790 ISP_MARK_PORTDB(isp, chan, 1);
3793 FCPARAM(isp, 0)->isp_lasthdl = oldhandle;
3826 isp_prt(isp, ISP_LOGSANCFG,
3833 isp_prt(isp, ISP_LOGWARN,
3856 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3861 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3868 FC_SCRATCH_RELEASE(isp, chan);
3870 ISP_MARK_PORTDB(isp, chan, 1);
3874 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3883 isp_login_device(ispsoftc_t *isp, int chan, uint32_t portid, isp_pdb_t *p, uint16_t *ohp)
3888 if (ISP_CAP_2KLOGIN(isp)) {
3894 handle = isp_nxt_handle(isp, chan, *ohp);
3901 r = isp_getpdb(isp, chan, handle, p, 0);
3903 (void) isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_LOGO | PLOGX_FLG_IMPLICIT | PLOGX_FLG_FREE_NPHDL, 1);
3907 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC) {
3913 r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI, 1);
3914 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC) {
3926 if (isp_plogx(isp, chan, r >> 16, portid, PLOGX_FLG_CMD_LOGO | PLOGX_FLG_IMPLICIT | PLOGX_FLG_FREE_NPHDL, 1)) {
3927 isp_prt(isp, ISP_LOGERR, "baw... logout of %x failed", r >> 16);
3929 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC) {
3932 r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI, 1);
3933 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC) {
3947 handle = isp_nxt_handle(isp, chan, handle);
3958 isp_prt(isp, ISP_LOGWARN, "Chan %d PLOGI 0x%06x failed", chan, portid);
3967 r = isp_getpdb(isp, chan, handle, p, 0);
3968 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC) {
3972 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x disappeared", chan, portid, handle);
3977 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x changed (0x%06x@0x%0x)",
3985 isp_register_fc4_type(ispsoftc_t *isp, int chan)
3987 fcparam *fcp = FCPARAM(isp, chan);
4003 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4004 isp_prt(isp, ISP_LOGERR, sacq);
4007 isp_put_sns_request(isp, reqp, (sns_screq_t *) fcp->isp_scratch);
4014 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_RFT_ID_REQ_SIZE, chan);
4015 isp_mboxcmd(isp, &mbs);
4016 FC_SCRATCH_RELEASE(isp, chan);
4025 isp_register_fc4_type_24xx(ispsoftc_t *isp, int chan)
4028 fcparam *fcp = FCPARAM(isp, chan);
4039 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4040 isp_prt(isp, ISP_LOGERR, sacq);
4054 pt->ctp_vpidx = ISP_GET_VPIDX(isp, chan);
4065 isp_put_ct_pt(isp, pt, (isp_ct_pt_t *) &scp[CTXOFF]);
4066 if (isp->isp_dblev & ISP_LOGDEBUG1) {
4067 isp_print_bytes(isp, "IOCB CT Request", QENTRY_LEN, pt);
4087 isp_put_rft_id(isp, rp, (rft_id_t *) &scp[XTXOFF]);
4088 if (isp->isp_dblev & ISP_LOGDEBUG1) {
4089 isp_print_bytes(isp, "CT Header", QENTRY_LEN, &scp[XTXOFF]);
4100 MEMORYBARRIER(isp, SYNC_SFORDEV, XTXOFF, 2 * QENTRY_LEN, chan);
4101 isp_mboxcmd(isp, &mbs);
4103 FC_SCRATCH_RELEASE(isp, chan);
4106 MEMORYBARRIER(isp, SYNC_SFORCPU, ZTXOFF, QENTRY_LEN, chan);
4108 isp_get_ct_pt(isp, (isp_ct_pt_t *) &scp[ZTXOFF], pt);
4109 if (isp->isp_dblev & ISP_LOGDEBUG1) {
4110 isp_print_bytes(isp, "IOCB response", QENTRY_LEN, pt);
4113 FC_SCRATCH_RELEASE(isp, chan);
4114 isp_prt(isp, ISP_LOGWARN,
4120 isp_get_ct_hdr(isp, (ct_hdr_t *) &scp[IGPOFF], ct);
4121 FC_SCRATCH_RELEASE(isp, chan);
4124 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
4128 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
4132 isp_prt(isp, ISP_LOGWARN,
4140 isp_nxt_handle(ispsoftc_t *isp, int chan, uint16_t handle)
4144 if (FCPARAM(isp, chan)->isp_topo == TOPO_F_PORT) {
4157 if (ISP_CAP_2KLOGIN(isp)) {
4167 if (handle == FCPARAM(isp, chan)->isp_loopid) {
4168 return (isp_nxt_handle(isp, chan, handle));
4171 if (FCPARAM(isp, chan)->portdb[i].state ==
4175 if (FCPARAM(isp, chan)->portdb[i].handle == handle) {
4176 return (isp_nxt_handle(isp, chan, handle));
4189 ispsoftc_t *isp;
4198 isp = XS_ISP(xs);
4204 if (isp->isp_state != ISP_RUNSTATE) {
4205 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
4217 if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
4218 isp_prt(isp, ISP_LOGERR, "unsupported cdb length (%d, CDB[0]=0x%x)", XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
4228 if (IS_FC(isp)) {
4229 fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
4249 isp_prt(isp, ISP_LOGDEBUG2, "XS_TGT(xs)=%d- hdlidx value %d", XS_TGT(xs), hdlidx);
4264 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
4270 isp_spi_update(isp, XS_CHANNEL(xs));
4276 qep = isp_getrqentry(isp);
4278 isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow");
4285 * Now see if we need to synchronize the ISP with respect to anything.
4291 if (ISP_TST_SENDMARKER(isp, XS_CHANNEL(xs))) {
4292 if (IS_24XX(isp)) {
4297 isp_put_marker_24xx(isp, m, qep);
4304 isp_put_marker(isp, m, qep);
4306 ISP_SYNC_REQUEST(isp);
4307 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 0);
4312 if (IS_24XX(isp)) {
4314 } else if (IS_FC(isp)) {
4324 if (IS_24XX(isp)) {
4343 } else if (IS_FC(isp)) {
4367 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
4380 if (IS_SCSI(isp)) {
4386 } else if (IS_24XX(isp)) {
4390 lp = &FCPARAM(isp, XS_CHANNEL(xs))->portdb[hdlidx];
4394 t7->req_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(xs));
4403 } else if (ISP_CAP_2KLOGIN(isp)) {
4409 } else if (ISP_CAP_SCCFW(isp)) {
4428 if (IS_24XX(isp) && *tptr > 0x1999) {
4432 if (isp_allocate_xs(isp, xs, &handle)) {
4433 isp_prt(isp, ISP_LOGDEBUG0, "out of xflist pointers");
4446 dmaresult = ISP_DMASETUP(isp, xs, reqp);
4448 isp_destroy_handle(isp, handle);
4455 isp_xs_prt(isp, xs, ISP_LOGDEBUG0, "START cmd cdb[0]=0x%x datalen %ld", XS_CDBP(xs)[0], (long) XS_XFRLEN(xs));
4456 isp->isp_nactive++;
4461 * isp control
4466 isp_control(ispsoftc_t *isp, ispctl_t ctl, ...)
4479 if (IS_24XX(isp)) {
4480 isp_prt(isp, ISP_LOGWARN, "RESET BUS NOT IMPLEMENTED");
4482 } else if (IS_FC(isp)) {
4489 mbs.param[1] = SDPARAM(isp, chan)->isp_bus_reset_delay;
4496 ISP_SET_SENDMARKER(isp, chan, 1);
4497 isp_mboxcmd(isp, &mbs);
4501 isp_prt(isp, ISP_LOGINFO,
4510 if (IS_24XX(isp)) {
4514 fcparam *fcp = FCPARAM(isp, chan);
4520 isp_prt(isp, ISP_LOGWARN,
4527 isp_prt(isp, ISP_LOGWARN,
4544 tmf->tmf_vpidx = ISP_GET_VPIDX(isp, chan);
4545 isp_prt(isp, ISP_LOGALL, "Chan %d Reset N-Port Handle 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
4553 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4554 isp_prt(isp, ISP_LOGERR, sacq);
4557 isp_put_24xx_tmf(isp, tmf, fcp->isp_scratch);
4558 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, QENTRY_LEN, chan);
4560 isp_mboxcmd(isp, &mbs);
4562 FC_SCRATCH_RELEASE(isp, chan);
4565 MEMORYBARRIER(isp, SYNC_SFORCPU, QENTRY_LEN,
4568 isp_get_24xx_response(isp,
4570 FC_SCRATCH_RELEASE(isp, chan);
4574 isp_prt(isp, ISP_LOGWARN,
4578 } else if (IS_FC(isp)) {
4579 if (ISP_CAP_2KLOGIN(isp)) {
4590 isp_mboxcmd(isp, &mbs);
4594 isp_prt(isp, ISP_LOGINFO,
4596 ISP_SET_SENDMARKER(isp, chan, 1);
4607 handle = isp_find_handle(isp, xs);
4609 isp_prt(isp, ISP_LOGWARN,
4613 if (IS_24XX(isp)) {
4619 fcp = FCPARAM(isp, chan);
4622 isp_prt(isp, ISP_LOGWARN,
4629 isp_prt(isp, ISP_LOGWARN,
4634 isp_prt(isp, ISP_LOGALL,
4644 ab->abrt_vpidx = ISP_GET_VPIDX(isp, chan);
4654 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4655 isp_prt(isp, ISP_LOGERR, sacq);
4658 isp_put_24xx_abrt(isp, ab, fcp->isp_scratch);
4662 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, 2 * QENTRY_LEN, chan);
4663 isp_mboxcmd(isp, &mbs);
4665 FC_SCRATCH_RELEASE(isp, chan);
4668 MEMORYBARRIER(isp, SYNC_SFORCPU, QENTRY_LEN,
4670 isp_get_24xx_abrt(isp, ab2, ab);
4671 FC_SCRATCH_RELEASE(isp, chan);
4675 isp_prt(isp, ISP_LOGWARN,
4679 } else if (IS_FC(isp)) {
4680 if (ISP_CAP_SCCFW(isp)) {
4681 if (ISP_CAP_2KLOGIN(isp)) {
4695 isp_mboxcmd(isp, &mbs);
4706 isp_spi_update(isp, chan);
4711 if (IS_FC(isp)) {
4720 return (isp_fclink_test(isp, chan, usdelay));
4726 if (IS_FC(isp)) {
4730 return (isp_scan_fabric(isp, chan));
4736 if (IS_FC(isp)) {
4740 return (isp_scan_loop(isp, chan));
4746 if (IS_FC(isp)) {
4750 return (isp_pdb_sync(isp, chan));
4756 if (IS_FC(isp) && !IS_24XX(isp)) {
4758 if (ISP_CAP_2KLOGIN(isp)) {
4761 isp_mboxcmd(isp, &mbs);
4769 if (IS_FC(isp)) {
4776 return (isp_getpdb(isp, chan, tgt, pdb, 1));
4793 *wwnn = isp_get_wwn(isp, chan, tgt, 1);
4799 *wwnp = isp_get_wwn(isp, chan, tgt, 0);
4811 isp_mboxcmd(isp, mbr);
4824 return (isp_plogx(isp, p->channel, p->handle, p->portid, p->flags, 0));
4827 p->handle = isp_nxt_handle(isp, p->channel, p->handle);
4828 r = isp_plogx(isp, p->channel, p->handle, p->portid, p->flags, 0);
4838 isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
4861 isp_intr(ispsoftc_t *isp, uint32_t isr, uint16_t sema, uint16_t mbox)
4868 optr = isp->isp_residx;
4876 isp->isp_intmboxc++;
4877 if (isp->isp_mboxbsy) {
4878 int obits = isp->isp_obits;
4879 isp->isp_mboxtmp[0] = mbox;
4880 for (i = 1; i < MAX_MAILBOX(isp); i++) {
4884 isp->isp_mboxtmp[i] = ISP_READ(isp, MBOX_OFF(i));
4886 if (isp->isp_mbxwrk0) {
4887 if (isp_mbox_continue(isp) == 0) {
4891 MBOX_NOTIFY_COMPLETE(isp);
4893 isp_prt(isp, ISP_LOGWARN, "mailbox cmd (0x%x) with no waiters", mbox);
4896 i = IS_FC(isp)? isp_parse_async_fc(isp, mbox) : isp_parse_async(isp, mbox);
4901 if ((IS_FC(isp) && mbox != ASYNC_RIOZIO_STALL) || isp->isp_state != ISP_RUNSTATE) {
4909 if (isp->isp_state != ISP_RUNSTATE) {
4913 if (isp->isp_mboxbsy && isp->isp_lastmbxcmd == MBOX_ABOUT_FIRMWARE) {
4916 isp_prt(isp, ISP_LOGINFO, "interrupt (ISR=%x SEMA=%x) when not ready", isr, sema);
4920 ISP_WRITE(isp, isp->isp_respoutrp, ISP_READ(isp, isp->isp_respinrp));
4921 if (IS_24XX(isp)) {
4922 ISP_DISABLE_INTS(isp);
4931 if (IS_24XX(isp)) {
4932 iptr = ISP_READ(isp, BIU2400_ATIO_RSPINP);
4933 optr = ISP_READ(isp, BIU2400_ATIO_RSPOUTP);
4942 MEMORYBARRIER(isp, SYNC_ATIOQ, oop, QENTRY_LEN, -1);
4943 addr = ISP_QUEUE_ENTRY(isp->isp_atioq, oop);
4944 isp_get_hdr(isp, addr, (isphdr_t *)qe);
4949 (void) isp_target_notify(isp, addr, &oop);
4952 isp_print_qentry(isp, "?ATIOQ entry?", oop, addr);
4955 optr = ISP_NXT_QENTRY(oop, RESULT_QUEUE_LEN(isp));
4956 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, optr);
4958 optr = isp->isp_residx;
4967 if (IS_23XX(isp) || IS_24XX(isp)) {
4968 optr = ISP_READ(isp, isp->isp_respoutrp);
4972 if (isp->isp_residx != optr) {
4973 isp_prt(isp, ISP_LOGINFO, "isp_intr: hard optr=%x, soft optr %x", optr, isp->isp_residx);
4974 isp->isp_residx = optr;
4977 optr = isp->isp_residx;
4986 if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) {
4989 iptr = ISP_READ(isp, isp->isp_respinrp);
4990 junk = ISP_READ(isp, isp->isp_respinrp);
4994 isp_prt(isp, ISP_LOGWARN, "Response Queue Out Pointer Unstable (%x, %x)", iptr, junk);
4998 iptr = ISP_READ(isp, isp->isp_respinrp);
5000 isp->isp_resodx = iptr;
5012 if (IS_24XX(isp)) {
5014 } else if (IS_23XX(isp)) {
5016 iptr = ISP_READ(isp, isp->isp_respinrp);
5017 junk = ISP_READ(isp, BIU_R2HSTSLO);
5019 junk = ISP_READ(isp, BIU_ISR);
5022 if (IS_23XX(isp) || IS_24XX(isp)) {
5025 sema = ISP_READ(isp, BIU_SEMA);
5026 mbox = ISP_READ(isp, OUTMAILBOX0);
5031 isp->isp_intbogus++;
5032 isp_prt(isp, ISP_LOGDEBUG1, "bogus intr- isr %x (%x) iptr %x optr %x", isr, junk, iptr, optr);
5035 isp->isp_resodx = iptr;
5048 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
5050 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
5059 MEMORYBARRIER(isp, SYNC_RESULT, oop, QENTRY_LEN, -1);
5060 isp_get_hdr(isp, hp, &sp->req_header);
5063 if (IS_24XX(isp) && etype == RQSTYPE_RESPONSE) {
5065 isp_get_24xx_response(isp, (isp24xx_statusreq_t *)hp, sp2);
5066 if (isp->isp_dblev & ISP_LOGDEBUG1) {
5067 isp_print_bytes(isp, "Response Queue Entry", QENTRY_LEN, sp2);
5074 isp_get_response(isp, (ispstatusreq_t *) hp, sp);
5075 if (isp->isp_dblev & ISP_LOGDEBUG1) {
5076 isp_print_bytes(isp, "Response Queue Entry", QENTRY_LEN, sp);
5085 isp_get_rio1(isp, (isp_rio1_t *) hp, rio);
5086 if (isp->isp_dblev & ISP_LOGDEBUG1) {
5087 isp_print_bytes(isp, "Response Queue Entry", QENTRY_LEN, rio);
5090 isp_fastpost_complete(isp, rio->req_handles[i]);
5092 if (isp->isp_fpcchiwater < rio->req_header.rqs_seqno) {
5093 isp->isp_fpcchiwater = rio->req_header.rqs_seqno;
5098 isp_prt(isp, ISP_LOGERR, "dropping RIO2 response\n");
5109 r = isp_handle_other_response(isp, etype, hp, &tsto);
5119 RESULT_QUEUE_LEN(isp));
5122 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5139 isp_prt(isp, ISP_LOGERR, notresp,
5141 isp_print_bytes(isp,
5156 isp_print_bytes(isp, "unexpected continuation segment", QENTRY_LEN, sp);
5157 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5161 isp_prt(isp, ISP_LOGDEBUG0, "internal queues full");
5167 isp_print_bytes(isp, "bad header flag", QENTRY_LEN, sp);
5171 isp_print_bytes(isp, "bad request packet", QENTRY_LEN, sp);
5175 isp_print_bytes(isp, "invalid entry count", QENTRY_LEN, sp);
5179 isp_print_bytes(isp, "invalid IOCB ordering", QENTRY_LEN, sp);
5180 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5185 if (!ISP_VALID_HANDLE(isp, sp->req_handle)) {
5186 isp_prt(isp, ISP_LOGERR, "bad request handle 0x%x (iocb type 0x%x)", sp->req_handle, etype);
5188 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5191 xs = isp_find_xs(isp, sp->req_handle);
5199 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (type 0x%x)", sp->req_handle, etype);
5201 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (status 0x%x)", sp->req_handle, ts);
5204 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5209 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
5219 if (IS_24XX(isp) && (scsi_status & (RQCS_RV|RQCS_SV)) != 0) {
5222 } else if (IS_FC(isp) && (scsi_status & RQCS_RV) != 0) {
5226 if (IS_FC(isp) && (scsi_status & RQCS_SV) != 0) {
5233 if (IS_24XX(isp)) {
5241 } else if (IS_SCSI(isp) && (req_state_flags & RQSF_GOT_SENSE)) {
5268 isp_xs_prt(isp, xs, ISP_LOGWARN, "FCP RESPONSE, LENGTH %u: %s CDB0=0x%02x", rlen, ptr, XS_CDBP(xs)[0] & 0xff);
5273 if (IS_24XX(isp)) {
5274 isp_parse_status_24xx(isp, (isp24xx_statusreq_t *)sp, xs, &resid);
5276 isp_parse_status(isp, (void *)sp, xs, &resid);
5281 if (IS_SCSI(isp)) {
5290 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
5305 } else if ((req_status_flags & RQSF_GOT_STATUS) && (scsi_status & 0xff) == SCSI_CHECK && IS_FC(isp)) {
5306 isp_prt(isp, ISP_LOGWARN, "CHECK CONDITION w/o sense data for CDB=0x%x", XS_CDBP(xs)[0] & 0xff);
5307 isp_print_bytes(isp, "CC with no Sense", QENTRY_LEN, qe);
5309 isp_prt(isp, ISP_LOGDEBUG2, "asked for %ld got raw resid %ld settled for %ld", (long) XS_XFRLEN(xs), resid, (long) XS_GET_RESID(xs));
5316 if (!IS_24XX(isp) && (sp->req_header.rqs_flags & RQSFLAG_FULL)) {
5328 isp_print_bytes(isp, "Unhandled Response Type", QENTRY_LEN, qe);
5340 ISP_DMAFREE(isp, xs, sp->req_handle);
5342 isp_destroy_handle(isp, sp->req_handle);
5344 if (((isp->isp_dblev & (ISP_LOGDEBUG1|ISP_LOGDEBUG2|ISP_LOGDEBUG3))) ||
5345 ((isp->isp_dblev & (ISP_LOGDEBUG0|ISP_LOG_CWARN) && ((!XS_NOERR(xs)) || (*XS_STSP(xs) != SCSI_GOOD))))) {
5346 isp_prt_endcmd(isp, xs);
5348 if (isp->isp_nactive > 0) {
5349 isp->isp_nactive--;
5361 * ISP's notion of what we've seen so far.
5364 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5368 isp->isp_reqodx = ISP_READ(isp, isp->isp_rqstoutrp);
5369 if (isp->isp_rscchiwater < ndone) {
5370 isp->isp_rscchiwater = ndone;
5376 if (IS_24XX(isp)) {
5377 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
5379 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
5380 ISP_WRITE(isp, BIU_SEMA, 0);
5383 isp->isp_residx = optr;
5387 isp->isp_rsltccmplt++;
5398 isp_prt_endcmd(ispsoftc_t *isp, XS_T *xs)
5409 isp_xs_prt(isp, xs, ISP_LOGALL, "FIN dl%d resid %ld CDB=%s KEY/ASC/ASCQ=0x%02x/0x%02x/0x%02x",
5412 isp_xs_prt(isp, xs, ISP_LOGALL, "FIN dl%d resid %ld CDB=%s STS 0x%x XS_ERR=0x%x", XS_XFRLEN(xs), (long) XS_GET_RESID(xs), cdbstr, *XS_STSP(xs), XS_ERR(xs));
5422 isp_parse_async(ispsoftc_t *isp, uint16_t mbox)
5433 if (IS_DUALBUS(isp)) {
5434 chan = ISP_READ(isp, OUTMAILBOX6);
5437 isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5441 ISP_SET_SENDMARKER(isp, chan, 1);
5443 if (isp_target_async(isp, chan, mbox)) {
5447 isp_async(isp, ISPASYNC_BUS_RESET, chan);
5450 isp->isp_dead = 1;
5451 isp->isp_state = ISP_CRASHED;
5456 if (isp->isp_mboxbsy) {
5457 isp->isp_obits = 1;
5458 isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5459 MBOX_NOTIFY_COMPLETE(isp);
5465 isp_async(isp, ISPASYNC_FW_CRASH);
5470 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5474 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5483 mbox = ISP_READ(isp, isp->isp_rqstoutrp);
5487 isp_prt(isp, ISP_LOGWARN, "timeout initiated SCSI bus reset of chan %d", chan);
5488 ISP_SET_SENDMARKER(isp, chan, 1);
5490 if (isp_target_async(isp, chan, mbox)) {
5497 isp_prt(isp, ISP_LOGINFO, "device reset on chan %d", chan);
5498 ISP_SET_SENDMARKER(isp, chan, 1);
5500 if (isp_target_async(isp, chan, mbox)) {
5507 isp_prt(isp, ISP_LOGWARN, "extended message underrun");
5511 isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
5515 isp_prt(isp, ISP_LOGERR, "stalled SCSI Bus after DATA Overrun");
5520 isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
5524 mbox = ISP_READ(isp, OUTMAILBOX2);
5527 isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
5528 SDPARAM(isp, chan)->isp_diffmode = 0;
5529 SDPARAM(isp, chan)->isp_ultramode = 0;
5530 SDPARAM(isp, chan)->isp_lvdmode = 1;
5533 isp_prt(isp, ISP_LOGINFO,
5535 SDPARAM(isp, chan)->isp_diffmode = 1;
5536 SDPARAM(isp, chan)->isp_ultramode = 0;
5537 SDPARAM(isp, chan)->isp_lvdmode = 0;
5540 isp_prt(isp, ISP_LOGINFO,
5542 SDPARAM(isp, chan)->isp_diffmode = 0;
5543 SDPARAM(isp, chan)->isp_ultramode = 1;
5544 SDPARAM(isp, chan)->isp_lvdmode = 0;
5547 isp_prt(isp, ISP_LOGWARN,
5555 ISP_SET_SENDMARKER(isp, chan, 1);
5560 if (!IS_ULTRA3(isp)) {
5561 isp_prt(isp, ISP_LOGERR, "unexpected fast posting completion");
5565 h1 = (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1);
5569 h1 = (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1);
5570 h2 = (ISP_READ(isp, OUTMAILBOX7) << 16) | ISP_READ(isp, OUTMAILBOX6);
5578 isp_prt(isp, ISP_LOGERR, "unexpected 16 bit RIO handle");
5581 isp_prt(isp, ISP_LOGWARN, "%s: unhandled async code 0x%x", __func__, mbox);
5586 isp_prt(isp, ISP_LOGDEBUG3, "fast post/rio completion of 0x%08x", h1);
5587 isp_fastpost_complete(isp, h1);
5589 isp_prt(isp, ISP_LOGDEBUG3, "fast post/rio completion of 0x%08x", h2);
5590 isp_fastpost_complete(isp, h2);
5591 if (isp->isp_fpcchiwater < 2) {
5592 isp->isp_fpcchiwater = 2;
5595 if (isp->isp_fpcchiwater < 1) {
5596 isp->isp_fpcchiwater = 1;
5600 isp->isp_intoasync++;
5605 #define GET_24XX_BUS(isp, chan, msg) \
5606 if (IS_24XX(isp)) { \
5607 chan = ISP_READ(isp, OUTMAILBOX3) & 0xff; \
5608 if (chan >= isp->isp_nchan) { \
5609 isp_prt(isp, ISP_LOGERR, "bogus channel %u for %s at line %d", chan, msg, __LINE__); \
5616 isp_parse_async_fc(ispsoftc_t *isp, uint16_t mbox)
5621 if (IS_DUALBUS(isp)) {
5622 chan = ISP_READ(isp, OUTMAILBOX6);
5626 isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5630 isp->isp_dead = 1;
5631 isp->isp_state = ISP_CRASHED;
5632 FCPARAM(isp, chan)->isp_loopstate = LOOP_NIL;
5633 FCPARAM(isp, chan)->isp_fwstate = FW_CONFIG_WAIT;
5638 if (isp->isp_mboxbsy) {
5639 isp->isp_obits = 1;
5640 isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5641 MBOX_NOTIFY_COMPLETE(isp);
5647 isp_async(isp, ISPASYNC_FW_CRASH);
5652 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5656 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5661 if (IS_24XX(isp)) {
5662 isp_prt(isp, ISP_LOGERR, "ATIO Queue Transfer Error");
5666 isp_prt(isp, ISP_LOGERR, "%s: unexpected ASYNC_QWAKEUP code", __func__);
5670 isp_fastpost_complete(isp, (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1));
5671 if (isp->isp_fpcchiwater < 1) {
5672 isp->isp_fpcchiwater = 1;
5681 if (isp_target_async(isp, (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1), mbox)) {
5684 isp->isp_fphccmplt++;
5687 isp_prt(isp, ISP_LOGWARN, "unexpected ASYNC CTIO done");
5698 for (chan = 0; chan < isp->isp_nchan; chan++) {
5699 fcparam *fcp = FCPARAM(isp, chan);
5708 ISP_SET_SENDMARKER(isp, chan, 1);
5709 ISP_MARK_PORTDB(isp, chan, 1);
5710 isp_async(isp, ISPASYNC_LIP, chan);
5712 if (isp_target_async(isp, chan, mbox)) {
5725 for (i = j = 0; i < isp->isp_maxcmds; i++) {
5729 hdp = &isp->isp_xflist[i];
5741 isp_prt(isp, ISP_LOGERR, lipd, chan, j);
5752 for (chan = 0; chan < isp->isp_nchan; chan++) {
5753 fcparam *fcp = FCPARAM(isp, chan);
5759 ISP_SET_SENDMARKER(isp, chan, 1);
5763 ISP_MARK_PORTDB(isp, chan, 1);
5764 isp_async(isp, ISPASYNC_LOOP_UP, chan);
5766 if (isp_target_async(isp, chan, mbox)) {
5778 for (chan = 0; chan < isp->isp_nchan; chan++) {
5779 fcparam *fcp = FCPARAM(isp, chan);
5785 ISP_SET_SENDMARKER(isp, chan, 1);
5788 ISP_MARK_PORTDB(isp, chan, 1);
5789 isp_async(isp, ISPASYNC_LOOP_DOWN, chan);
5791 if (isp_target_async(isp, chan, mbox)) {
5803 for (chan = 0; chan < isp->isp_nchan; chan++) {
5804 fcparam *fcp = FCPARAM(isp, chan);
5810 ISP_SET_SENDMARKER(isp, chan, 1);
5813 ISP_MARK_PORTDB(isp, chan, 1);
5814 isp_async(isp, ISPASYNC_LOOP_RESET, chan);
5816 if (isp_target_async(isp, chan, mbox)) {
5831 if (IS_24XX(isp)) {
5832 nphdl = ISP_READ(isp, OUTMAILBOX1);
5833 nlstate = ISP_READ(isp, OUTMAILBOX2);
5834 reason = ISP_READ(isp, OUTMAILBOX3) >> 8;
5839 for (chan = 0; chan < isp->isp_nchan; chan++) {
5840 fcparam *fcp = FCPARAM(isp, chan);
5845 ISP_SET_SENDMARKER(isp, chan, 1);
5847 ISP_MARK_PORTDB(isp, chan, 1);
5848 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan, ISPASYNC_CHANGE_PDB, nphdl, nlstate, reason);
5856 if (ISP_FW_NEWER_THAN(isp, 4, 0, 25) && ISP_CAP_MULTI_ID(isp)) {
5857 GET_24XX_BUS(isp, chan, "ASYNC_CHANGE_NOTIFY");
5862 hichan = isp->isp_nchan;
5865 fcparam *fcp = FCPARAM(isp, chan);
5876 ISP_MARK_PORTDB(isp, chan, 1);
5877 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan, ISPASYNC_CHANGE_SNS);
5886 if (!IS_2200(isp) && !IS_2100(isp)) {
5887 isp_prt(isp, ISP_LOGWARN, "bad card for ASYNC_CONNMODE event");
5891 mbox = ISP_READ(isp, OUTMAILBOX1);
5892 ISP_MARK_PORTDB(isp, chan, 1);
5895 isp_prt(isp, ISP_LOGINFO,
5899 isp_prt(isp, ISP_LOGINFO,
5903 isp_prt(isp, ISP_LOGWARN,
5907 isp->isp_dead = 1;
5908 isp->isp_state = ISP_CRASHED;
5909 isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
5910 isp_async(isp, ISPASYNC_FW_CRASH);
5913 isp_prt(isp, ISP_LOGWARN,
5917 isp_prt(isp, ISP_LOGWARN,
5921 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan, ISPASYNC_CHANGE_OTHER);
5922 FCPARAM(isp, chan)->sendmarker = 1;
5923 FCPARAM(isp, chan)->isp_fwstate = FW_CONFIG_WAIT;
5924 FCPARAM(isp, chan)->isp_loopstate = LOOP_LIP_RCVD;
5928 if (IS_24XX(isp)) {
5929 isp_prt(isp, ISP_LOGWARN, "Receive Error");
5931 isp_prt(isp, ISP_LOGWARN, "unexpected ASYNC_RCV_ERR");
5935 if (IS_24XX(isp)) {
5936 isp_prt(isp, ISP_LOGTDEBUG0, "LS_RJT sent");
5938 } else if (IS_2200(isp)) {
5939 isp_prt(isp, ISP_LOGTDEBUG0, "QFULL sent");
5944 isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
5948 isp->isp_intoasync++;
5960 isp_handle_other_response(ispsoftc_t *isp, int type, isphdr_t *hp, uint32_t *optrp)
5964 isp_prt(isp, ISP_LOGDEBUG0, "Ignored Continuation Response");
5967 isp_prt(isp, ISP_LOGDEBUG0, "Marker Response");
5982 isp->isp_rsltccmplt++; /* count as a response completion */
5984 if (isp_target_notify(isp, (ispstatusreq_t *) hp, optrp)) {
5990 if (IS_24XX(isp)) {
5992 isp_get_ridacq(isp, (isp_ridacq_t *)hp, &rid);
6001 if (type != isp_get_response_type(isp, hp)) {
6010 isp_prt(isp, ISP_LOGINFO,
6014 isp_prt(isp, ISP_LOGWARN, "Unhandled Response Type 0x%x",
6015 isp_get_response_type(isp, hp));
6021 isp_parse_status(ispsoftc_t *isp, ispstatusreq_t *sp, XS_T *xs, long *rp)
6032 isp_xs_prt(isp, xs, ISP_LOGDEBUG1, "Selection Timeout");
6039 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Incomplete, state 0x%x", sp->req_state_flags);
6043 isp_xs_prt(isp, xs, ISP_LOGERR, "DMA Error");
6097 isp_xs_prt(isp, xs, ISP_LOGERR, "Transport Error: %s", buf);
6104 isp_xs_prt(isp, xs, ISP_LOGWARN, "Bus Reset destroyed command");
6105 for (chan = 0; chan < isp->isp_nchan; chan++) {
6106 FCPARAM(isp, chan)->sendmarker = 1;
6115 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
6116 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
6123 isp_xs_prt(isp, xs, ISP_LOGWARN, "Command timed out");
6134 isp_xs_prt(isp, xs, ISP_LOGERR, "data overrun (%ld)", (long) XS_GET_RESID(xs));
6141 isp_xs_prt(isp, xs, ISP_LOGERR, "command overrun");
6145 isp_xs_prt(isp, xs, ISP_LOGERR, "status overrun");
6149 isp_xs_prt(isp, xs, ISP_LOGERR, "msg not COMMAND COMPLETE after status");
6153 isp_xs_prt(isp, xs, ISP_LOGERR, "No MESSAGE OUT phase after selection");
6157 isp_xs_prt(isp, xs, ISP_LOGERR, "EXTENDED IDENTIFY failed");
6161 isp_xs_prt(isp, xs, ISP_LOGERR, "INITIATOR DETECTED ERROR rejected");
6165 isp_xs_prt(isp, xs, ISP_LOGERR, "ABORT OPERATION rejected");
6169 isp_xs_prt(isp, xs, ISP_LOGERR, "MESSAGE REJECT rejected");
6173 isp_xs_prt(isp, xs, ISP_LOGERR, "NOP rejected");
6177 isp_xs_prt(isp, xs, ISP_LOGERR, "MESSAGE PARITY ERROR rejected");
6181 isp_xs_prt(isp, xs, ISP_LOGWARN, "BUS DEVICE RESET rejected");
6185 isp_xs_prt(isp, xs, ISP_LOGERR, "IDENTIFY rejected");
6189 isp_xs_prt(isp, xs, ISP_LOGERR, "Unexpected Bus Free");
6194 if (IS_FC(isp)) {
6197 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
6212 isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued transaction with disconnect not set");
6216 isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued transaction to target routine %d", XS_LUN(xs));
6220 isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued cmd when queueing disabled");
6224 isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
6228 isp_xs_prt(isp, xs, ISP_LOGDEBUG0, "internal queues full status 0x%x", *XS_STSP(xs));
6252 isp_xs_prt(isp, xs, ISP_LOGERR, "SCSI phase skipped");
6256 isp_xs_prt(isp, xs, ISP_LOGERR, "Auto Request Sense Failed");
6263 isp_xs_prt(isp, xs, ISP_LOGERR, "Wide Negotiation Failed");
6264 if (IS_SCSI(isp)) {
6265 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
6276 isp_xs_prt(isp, xs, ISP_LOGERR, "SDTR Message Failed");
6277 if (IS_SCSI(isp)) {
6278 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
6287 isp_xs_prt(isp, xs, ISP_LOGERR, "Bad LVD condition");
6308 isp_prt(isp, ISP_LOGINFO, "port %s for target %d",
6316 if (FCPARAM(isp, 0)->isp_topo == TOPO_NL_PORT ||
6317 FCPARAM(isp, 0)->isp_topo == TOPO_FL_PORT) {
6320 if (ISP_CAP_2KLOGIN(isp)) {
6323 isp_mboxcmd_qnw(isp, &mbs, 1);
6331 isp_prt(isp, ISP_LOGWARN,
6339 isp_prt(isp, ISP_LOGWARN,
6347 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x",
6357 isp_parse_status_24xx(ispsoftc_t *isp, isp24xx_statusreq_t *sp, XS_T *xs, long *rp)
6370 isp_xs_prt(isp, xs, ISP_LOGERR, "DMA error");
6374 isp_xs_prt(isp, xs, ISP_LOGERR, "Transport Error");
6378 isp_xs_prt(isp, xs, ISP_LOGWARN, "reset destroyed command");
6379 FCPARAM(isp, chan)->sendmarker = 1;
6386 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
6387 FCPARAM(isp, chan)->sendmarker = 1;
6394 isp_xs_prt(isp, xs, ISP_LOGWARN, "Command Timed Out");
6402 isp_xs_prt(isp, xs, ISP_LOGERR, "Data Overrun");
6409 isp_prt(isp, ISP_LOGERR,
6419 isp_prt(isp, ISP_LOGERR, "Chan %d target %d sent ABTS",
6435 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
6442 isp_xs_prt(isp, xs, ISP_LOGDEBUG0, "Data Underrun (%d) for command 0x%x", sp->req_resid, XS_CDBP(xs)[0] & 0xff);
6466 isp_prt(isp, ISP_LOGINFO, "Chan %d port %s for target %d",
6478 isp_prt(isp, ISP_LOGWARN,
6487 isp_prt(isp, ISP_LOGWARN,
6497 isp_prt(isp, ISP_LOGWARN,
6507 isp_prt(isp, ISP_LOGERR,
6518 isp_fastpost_complete(ispsoftc_t *isp, uint32_t fph)
6525 xs = isp_find_xs(isp, fph);
6527 isp_prt(isp, ISP_LOGWARN,
6531 isp_destroy_handle(isp, fph);
6541 ISP_DMAFREE(isp, xs, fph);
6543 if (isp->isp_nactive) {
6544 isp->isp_nactive--;
6546 isp->isp_fphccmplt++;
6551 isp_mbox_continue(ispsoftc_t *isp)
6557 switch (isp->isp_lastmbxcmd) {
6566 if (isp->isp_mboxtmp[0] != MBOX_COMMAND_COMPLETE) {
6567 isp->isp_mbxwrk0 = 0;
6574 if (IS_24XX(isp)) {
6575 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
6577 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
6578 ISP_WRITE(isp, BIU_SEMA, 0);
6585 ptr = isp->isp_mbxworkp;
6586 switch (isp->isp_lastmbxcmd) {
6588 mbs.param[1] = isp->isp_mbxwrk1++;
6592 *ptr++ = isp->isp_mboxtmp[2];
6593 mbs.param[1] = isp->isp_mbxwrk1++;
6596 offset = isp->isp_mbxwrk1;
6597 offset |= isp->isp_mbxwrk8 << 16;
6602 isp->isp_mbxwrk1 = ++offset;
6603 isp->isp_mbxwrk8 = offset >> 16;
6606 offset = isp->isp_mbxwrk1;
6607 offset |= isp->isp_mbxwrk8 << 16;
6609 *ptr++ = isp->isp_mboxtmp[2];
6612 isp->isp_mbxwrk1 = ++offset;
6613 isp->isp_mbxwrk8 = offset >> 16;
6616 isp->isp_mbxworkp = ptr;
6617 isp->isp_mbxwrk0--;
6618 mbs.param[0] = isp->isp_lastmbxcmd;
6620 isp_mboxcmd_qnw(isp, &mbs, 0);
7090 isp_mboxcmd_qnw(ispsoftc_t *isp, mbreg_t *mbp, int nodelay)
7095 if (IS_FC(isp)) {
7101 ibits = HIWRD(mcp[opcode]) & NMBOX_BMASK(isp);
7102 obits = LOWRD(mcp[opcode]) & NMBOX_BMASK(isp);
7105 for (box = 0; box < MAX_MAILBOX(isp); box++) {
7107 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
7110 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
7114 isp->isp_lastmbxcmd = opcode;
7115 isp->isp_obits = obits;
7116 isp->isp_mboxbsy = 1;
7118 if (IS_24XX(isp)) {
7119 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
7121 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
7134 isp_mboxcmd(ispsoftc_t *isp, mbreg_t *mbp)
7141 if (IS_FC(isp)) {
7151 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
7155 ibits = HIWRD(mcp[opcode]) & NMBOX_BMASK(isp);
7156 obits = LOWRD(mcp[opcode]) & NMBOX_BMASK(isp);
7166 isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
7173 if (MBOX_ACQUIRE(isp)) {
7178 for (box = 0; box < MAX_MAILBOX(isp); box++) {
7180 isp_prt(isp, ISP_LOGDEBUG3, "IN mbox %d = 0x%04x", box,
7182 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
7184 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
7187 isp->isp_lastmbxcmd = opcode;
7192 isp->isp_obits = obits;
7193 isp->isp_mboxbsy = 1;
7198 if (IS_24XX(isp)) {
7199 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
7201 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
7207 MBOX_WAIT_COMPLETE(isp, mbp);
7213 isp->isp_mboxbsy = 0;
7214 MBOX_RELEASE(isp);
7221 for (box = 0; box < MAX_MAILBOX(isp); box++) {
7223 mbp->param[box] = isp->isp_mboxtmp[box];
7224 isp_prt(isp, ISP_LOGDEBUG3, "OUT mbox %d = 0x%04x", box,
7229 isp->isp_mboxbsy = 0;
7230 MBOX_RELEASE(isp);
7235 cname = (IS_FC(isp))? fc_mbcmd_names[opcode] : scsi_mbcmd_names[opcode];
7300 isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s)",
7306 isp_fw_state(ispsoftc_t *isp, int chan)
7308 if (IS_FC(isp)) {
7310 fcparam *fcp = FCPARAM(isp, chan);
7313 isp_mboxcmd(isp, &mbs);
7321 isp_spi_update(ispsoftc_t *isp, int chan)
7327 if (IS_FC(isp)) {
7333 sdp = SDPARAM(isp, chan);
7343 isp_prt(isp, ISP_LOGDEBUG0, "skipping target %d bus %d update", tgt, chan);
7399 isp_prt(isp, ISP_LOGDEBUG0, "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
7406 isp_mboxcmd(isp, &mbs);
7422 isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, chan, tgt);
7436 isp_setdfltsdparm(ispsoftc_t *isp)
7441 sdp = SDPARAM(isp, 0);
7442 sdp->role = GET_DEFAULT_ROLE(isp, 0);
7443 if (IS_DUALBUS(isp)) {
7445 sdp1->role = GET_DEFAULT_ROLE(isp, 1);
7456 sdp->isp_initiator_id = DEFAULT_IID(isp, 0);
7457 if (isp->isp_type >= ISP_HA_SCSI_1040) {
7463 sdp->isp_max_queue_depth = MAXISPREQUEST(isp);
7497 if (IS_ULTRA3(isp)) {
7500 } else if (IS_ULTRA2(isp)) {
7503 } else if (IS_1240(isp)) {
7506 } else if ((isp->isp_bustype == ISP_BT_SBUS &&
7507 isp->isp_type < ISP_HA_SCSI_1020A) ||
7508 (isp->isp_bustype == ISP_BT_PCI &&
7509 isp->isp_type < ISP_HA_SCSI_1040) ||
7510 (isp->isp_clock && isp->isp_clock < 60) ||
7530 sdp1->isp_initiator_id = DEFAULT_IID(isp, 1);
7539 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7542 if (isp_read_nvram(isp, 0) == 0) {
7543 if (IS_DUALBUS(isp)) {
7544 if (isp_read_nvram(isp, 1) == 0) {
7550 isp_mboxcmd(isp, &mbs);
7575 isp_setdfltfcparm(ispsoftc_t *isp, int chan)
7577 fcparam *fcp = FCPARAM(isp, chan);
7582 fcp->role = GET_DEFAULT_ROLE(isp, chan);
7586 fcp->isp_loopid = DEFAULT_LOOPID(isp, chan);
7587 fcp->isp_wwnn_nvram = DEFAULT_NODEWWN(isp, chan);
7588 fcp->isp_wwpn_nvram = DEFAULT_PORTWWN(isp, chan);
7592 if (IS_24XX(isp)) {
7595 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX) {
7603 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX) {
7618 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7624 j = isp_read_nvram(isp, chan);
7630 isp->isp_confopts |= ISP_CFG_NONVRAM;
7634 fcp->isp_wwnn = ACTIVE_NODEWWN(isp, chan);
7635 fcp->isp_wwpn = ACTIVE_PORTWWN(isp, chan);
7636 isp_prt(isp, ISP_LOGCONFIG, "Chan %d 0x%08x%08x/0x%08x%08x Role %s",
7643 * Re-initialize the ISP and complete all orphaned commands
7649 isp_reinit(ispsoftc_t *isp, int do_load_defaults)
7653 isp_reset(isp, do_load_defaults);
7655 if (isp->isp_state != ISP_RESETSTATE) {
7656 isp_prt(isp, ISP_LOGERR, "%s: cannot reset card", __func__);
7657 ISP_DISABLE_INTS(isp);
7661 isp_init(isp);
7663 if (isp->isp_state == ISP_INITSTATE) {
7664 isp->isp_state = ISP_RUNSTATE;
7667 if (isp->isp_state != ISP_RUNSTATE) {
7669 isp_prt(isp, ISP_LOGWARN, "%s: not at runstate", __func__);
7671 ISP_DISABLE_INTS(isp);
7672 if (IS_FC(isp)) {
7676 if (!IS_24XX(isp)) {
7677 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
7678 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
7679 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
7680 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
7681 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
7688 isp->isp_nactive = 0;
7690 isp_clear_commands(isp);
7691 if (IS_FC(isp)) {
7692 for (i = 0; i < isp->isp_nchan; i++) {
7693 ISP_MARK_PORTDB(isp, i, -1);
7702 isp_read_nvram(ispsoftc_t *isp, int bus)
7713 if (IS_24XX(isp)) {
7714 return (isp_read_nvram_2400(isp, nvram_data));
7715 } else if (IS_FC(isp)) {
7718 } else if (IS_ULTRA2(isp)) {
7727 isp_rdnvram_word(isp, i, &nvram_words[i]);
7732 if (isp->isp_bustype != ISP_BT_SBUS) {
7733 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
7734 isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x", nvram_data[0], nvram_data[1], nvram_data[2]);
7744 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7750 isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
7756 if (IS_ULTRA3(isp)) {
7757 isp_parse_nvram_12160(isp, bus, nvram_data);
7758 } else if (IS_1080(isp)) {
7759 isp_parse_nvram_1080(isp, bus, nvram_data);
7760 } else if (IS_1280(isp) || IS_1240(isp)) {
7761 isp_parse_nvram_1080(isp, bus, nvram_data);
7762 } else if (IS_SCSI(isp)) {
7763 isp_parse_nvram_1020(isp, nvram_data);
7765 isp_parse_nvram_2100(isp, nvram_data);
7775 isp_read_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
7780 if (isp->isp_port) {
7788 isp_rd_2400_nvram(isp, addr++, dptr++);
7792 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header (%x %x %x)",
7800 ISP_IOXGET_32(isp, &dptr[lwrds], tmp);
7804 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7808 isp_parse_nvram_2400(isp, nvram_data);
7814 isp_rdnvram_word(ispsoftc_t *isp, int wo, uint16_t *rp)
7819 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7821 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7824 if (IS_FC(isp)) {
7826 if (IS_2312(isp) && isp->isp_port) {
7831 } else if (IS_ULTRA2(isp)) {
7850 ISP_WRITE(isp, BIU_NVRAM, bit);
7852 (void)ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7853 ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
7855 (void)ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7856 ISP_WRITE(isp, BIU_NVRAM, bit);
7858 (void)ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7867 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7869 rv = ISP_READ(isp, BIU_NVRAM);
7874 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7876 (void)ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7878 ISP_WRITE(isp, BIU_NVRAM, 0);
7880 (void)ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7881 ISP_SWIZZLE_NVRAM_WORD(isp, rp);
7885 isp_rd_2400_nvram(ispsoftc_t *isp, uint32_t addr, uint32_t *rp)
7891 if (IS_25XX(isp)) {
7894 ISP_WRITE(isp, BIU2400_FLASH_ADDR, base | addr);
7897 tmp = ISP_READ(isp, BIU2400_FLASH_ADDR);
7903 *rp = ISP_READ(isp, BIU2400_FLASH_DATA);
7904 ISP_SWIZZLE_NVRAM_LONG(isp, rp);
7911 isp_parse_nvram_1020(ispsoftc_t *isp, uint8_t *nvram_data)
7913 sdparam *sdp = SDPARAM(isp, 0);
7920 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7936 if (isp->isp_type >= ISP_HA_SCSI_1040) {
7983 if (isp->isp_type < ISP_HA_SCSI_1040) {
8024 isp_parse_nvram_1080(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
8026 sdparam *sdp = SDPARAM(isp, bus);
8032 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
8100 isp_parse_nvram_12160(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
8102 sdparam *sdp = SDPARAM(isp, bus);
8108 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
8176 isp_parse_nvram_2100(ispsoftc_t *isp, uint8_t *nvram_data)
8178 fcparam *fcp = FCPARAM(isp, 0);
8194 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x",
8201 if (IS_2200(isp) || IS_23XX(isp)) {
8204 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x",
8219 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
8220 DEFAULT_FRAMESIZE(isp) =
8225 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
8228 if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
8229 DEFAULT_EXEC_THROTTLE(isp) =
8233 isp_prt(isp, ISP_LOGDEBUG0,
8241 isp_prt(isp, ISP_LOGDEBUG0,
8249 isp_prt(isp, ISP_LOGDEBUG0, "xfwoptions 0x%x zfw options 0x%x",
8254 isp_parse_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
8256 fcparam *fcp = FCPARAM(isp, 0);
8259 isp_prt(isp, ISP_LOGDEBUG0,
8267 isp_prt(isp, ISP_LOGDEBUG0,
8293 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
8294 DEFAULT_FRAMESIZE(isp) =
8297 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
8300 if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
8301 DEFAULT_EXEC_THROTTLE(isp) =
Indexes created Thu Sep 25 14:09:45 GMT 2025