Lines Matching +full:chan +full:- +full:name
1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
4 * Copyright (c) 2009-2020 Alexander Motin <mav@FreeBSD.org>
5 * Copyright (c) 1997-2009 by Matthew Jacob
34 * code for the Qlogic ISP SCSI and FC-SCSI adapters.
72 static const char lipd[] = "Chan %d LIP destroyed %d active commands";
147 isp_change_fw_state(ispsoftc_t *isp, int chan, int state)
149 fcparam *fcp = FCPARAM(isp, chan);
151 if (fcp->isp_fwstate == state)
154 "Chan %d Firmware state <%s->%s>", chan,
155 isp_fc_fw_statename(fcp->isp_fwstate), isp_fc_fw_statename(state));
156 fcp->isp_fwstate = state;
166 fcp->flash_data_addr = ISP28XX_BASE_ADDR;
167 fcp->flt_region_flt = ISP28XX_FLT_ADDR;
169 fcp->flash_data_addr = ISP27XX_BASE_ADDR;
170 fcp->flt_region_flt = ISP27XX_FLT_ADDR;
172 fcp->flash_data_addr = ISP25XX_BASE_ADDR;
173 fcp->flt_region_flt = ISP25XX_FLT_ADDR;
175 fcp->flash_data_addr = ISP24XX_BASE_ADDR;
176 fcp->flt_region_flt = ISP24XX_FLT_ADDR;
178 fcp->flt_length = 0;
184 fcp->flt_region_nvram = 0x300000;
186 fcp->flash_data_addr = 0x7fe7c000;
187 fcp->flt_region_nvram = 0;
189 fcp->flt_region_nvram = 0x48000;
191 fcp->flash_data_addr = 0x7ffe0000;
192 fcp->flt_region_nvram = 0;
194 fcp->flt_region_nvram += ISP2400_NVRAM_PORT_ADDR(isp->isp_port);
217 isp->isp_state = ISP_NILSTATE;
228 switch (isp->isp_type) {
295 * Post-RISC Reset stuff.
317 isp->isp_reqidx = isp->isp_reqodx = 0;
318 isp->isp_resodx = 0;
319 isp->isp_atioodx = 0;
420 snprintf(fcp->fw_version_ispfw, sizeof(fcp->fw_version_ispfw),
422 snprintf(fcp->fw_version_flash, sizeof(fcp->fw_version_flash),
424 snprintf(fcp->fw_version_run, sizeof(fcp->fw_version_run),
429 if (!(isp->isp_confopts & ISP_CFG_NORELOAD)) {
431 snprintf(fwname, sizeof(fwname), "isp_%04x", isp->isp_did);
432 isp->isp_osinfo.ispfw = firmware_get(fwname);
433 if (isp->isp_osinfo.ispfw != NULL) {
434 isp->isp_mdvec->dv_ispfw = isp->isp_osinfo.ispfw->data;
435 const uint32_t *ispfwptr = isp->isp_mdvec->dv_ispfw;
437 fcp->fw_ispfwrev[i] = ispfwptr[4 + i];
440 snprintf(fcp->fw_version_ispfw,
441 sizeof(fcp->fw_version_ispfw),
442 "%u.%u.%u", fcp->fw_ispfwrev[0],
443 fcp->fw_ispfwrev[1], fcp->fw_ispfwrev[2]);
446 fcp->fw_ispfwrev[0], fcp->fw_ispfwrev[1],
447 fcp->fw_ispfwrev[2], fcp->fw_ispfwrev[3]);
475 if (isp->isp_osinfo.ispfw != NULL)
481 if (isp->isp_osinfo.ispfw != NULL)
487 const uint32_t *ptr = isp->isp_mdvec->dv_ispfw;
505 cp = isp->isp_rquest;
515 wl -= nw;
525 if (isp->isp_osinfo.ispfw != NULL)
526 firmware_put(isp->isp_osinfo.ispfw, FIRMWARE_UNLOAD);
572 fcp->fw_ability_mask = (mbs.param[3] << 16) | mbs.param[2];
574 fcp->fw_ability_mask);
576 fcp->max_supported_speed = mbs.param[2] & (0x1 | 0x2);
578 fcp->max_supported_speed == 0 ? "16Gbit/s" :
579 fcp->max_supported_speed == 1 ? "32Gbit/s" :
580 fcp->max_supported_speed == 2 ? "64Gbit/s" : "unknown");
597 isp->isp_fwrev[0] = mbs.param[1];
598 isp->isp_fwrev[1] = mbs.param[2];
599 isp->isp_fwrev[2] = mbs.param[3];
600 isp->isp_fwattr = mbs.param[6];
601 isp->isp_fwattr_h = mbs.param[15];
602 if (isp->isp_fwattr & ISP_FW_ATTR_EXTNDED) {
603 isp->isp_fwattr_ext[0] = mbs.param[16];
604 isp->isp_fwattr_ext[1] = mbs.param[17];
608 btype, isp->isp_revision, dodnld ? "loaded" : "resident",
609 isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
610 snprintf(fcp->fw_version_run, sizeof(fcp->fw_version_run),
611 "%u.%u.%u", isp->isp_fwrev[0], isp->isp_fwrev[1],
612 isp->isp_fwrev[2]);
614 snprintf(fcp->fw_version_flash, sizeof(fcp->fw_version_flash),
615 "%s", fcp->fw_version_run);
617 fwt = isp->isp_fwattr;
618 buf = FCPARAM(isp, 0)->isp_scanscratch;
622 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s Class2", buf);
626 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s IP", buf);
630 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MultiID", buf);
634 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SB2", buf);
638 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s T10CRC", buf);
642 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VI", buf);
646 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MQ", buf);
650 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MSIX", buf);
654 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s FCOE", buf);
658 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VP0_Decoupling", buf);
662 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (Experimental)", buf);
666 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s HotFW", buf);
670 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf),
675 fwt = isp->isp_fwattr_h;
676 buf = FCPARAM(isp, 0)->isp_scanscratch;
680 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ExtVP", buf);
684 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VN2VN", buf);
688 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s EXMOFF", buf);
692 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s NPMOFF", buf);
696 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s DIFCHOP", buf);
700 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SRIOV", buf);
704 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s NVMe", buf);
708 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s NVMe(updated)", buf);
712 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s NVMe(first burst)", buf);
715 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf),
720 fwt = isp->isp_fwattr_ext[0];
721 buf = FCPARAM(isp, 0)->isp_scanscratch;
725 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ASICTMP", buf);
729 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ATIOMQ", buf);
733 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s EDIF", buf);
737 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SCM", buf);
741 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s NVMe-2", buf);
744 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf),
749 fwt = isp->isp_fwattr_ext[1];
750 buf = FCPARAM(isp, 0)->isp_scanscratch;
753 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf),
767 isp->isp_maxcmds = MIN(mbs.param[3], ISP_HANDLE_MAX - ISP_HANDLE_RESERVE);
768 isp_prt(isp, ISP_LOGCONFIG, "%d max I/O command limit set", isp->isp_maxcmds);
771 * If we don't have Multi-ID f/w loaded, we need to restrict channels to one.
772 * Only make this check for non-SCSI cards (I'm not sure firmware attributes
775 if (isp->isp_nchan > 1) {
777 isp_prt(isp, ISP_LOGWARN, "non-MULTIID f/w loaded, "
778 "only can enable 1 of %d channels", isp->isp_nchan);
779 isp->isp_nchan = 1;
783 isp->isp_nchan = 1;
804 for (i = 0; i < isp->isp_nchan; i++)
807 isp->isp_state = ISP_RESETSTATE;
815 for (i = 0; i < isp->isp_nchan; i++)
828 isp->isp_state = ISP_NILSTATE;
849 if (isp->isp_state >= ISP_RESETSTATE)
867 int chan;
873 for (chan = 0; chan < isp->isp_nchan; chan++) {
874 fcp = FCPARAM(isp, chan);
875 if (fcp->role != ISP_ROLE_NONE) {
879 if (chan == isp->isp_nchan) {
880 isp_prt(isp, ISP_LOG_WARN1, "all %d channels with role 'none'", chan);
884 isp->isp_state = ISP_INITSTATE;
902 icbp->icb_fwoptions1 = fcp->isp_fwoptions;
903 icbp->icb_fwoptions2 = fcp->isp_xfwoptions;
904 icbp->icb_fwoptions3 = fcp->isp_zfwoptions;
905 if (isp->isp_nchan > 1 && ISP_CAP_VP0(isp)) {
906 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_INI_DISABLE;
907 icbp->icb_fwoptions1 |= ICB2400_OPT1_TGT_ENABLE;
909 if (fcp->role & ISP_ROLE_TARGET)
910 icbp->icb_fwoptions1 |= ICB2400_OPT1_TGT_ENABLE;
912 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_TGT_ENABLE;
913 if (fcp->role & ISP_ROLE_INITIATOR)
914 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_INI_DISABLE;
916 icbp->icb_fwoptions1 |= ICB2400_OPT1_INI_DISABLE;
919 icbp->icb_version = ICB_VERSION1;
920 icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
921 if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN || icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
922 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
924 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN_28XX;
927 "bad frame length (%d) from NVRAM - using %d",
928 DEFAULT_FRAMESIZE(isp), icbp->icb_maxfrmlen);
932 icbp->icb_execthrottle = 0xffff;
938 if (icbp->icb_fwoptions1 & ICB2400_OPT1_TGT_ENABLE) {
939 if ((icbp->icb_fwoptions1 & ICB2400_OPT1_INI_DISABLE) == 0)
940 icbp->icb_xchgcnt = MIN(isp->isp_maxcmds / 2, ATPDPSIZE);
942 icbp->icb_xchgcnt = isp->isp_maxcmds;
946 ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
947 icbp->icb_hardaddr = fcp->isp_loopid;
948 if (icbp->icb_hardaddr >= LOCAL_LOOP_LIM) {
949 icbp->icb_hardaddr = 0;
954 icbp->icb_fwoptions1 |= ICB2400_OPT1_HARD_ADDRESS;
956 if (isp->isp_confopts & ISP_CFG_NOFCTAPE) {
957 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_FCTAPE;
959 if (isp->isp_confopts & ISP_CFG_FCTAPE) {
960 icbp->icb_fwoptions2 |= ICB2400_OPT2_FCTAPE;
963 for (chan = 0; chan < isp->isp_nchan; chan++) {
964 if (icbp->icb_fwoptions2 & ICB2400_OPT2_FCTAPE)
965 FCPARAM(isp, chan)->fctape_enabled = 1;
967 FCPARAM(isp, chan)->fctape_enabled = 0;
970 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
972 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
973 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_ONLY;
976 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
977 icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_ONLY;
982 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
983 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
987 switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TOPO_MASK) {
993 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
994 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
999 switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK) {
1002 icbp->icb_idelaytimer = 0;
1007 isp_prt(isp, ISP_LOGWARN, "bad value %x in fwopt2 timer field", icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK);
1008 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TIMER_MASK;
1014 icbp->icb_fwoptions2 |= ICB2400_OPT2_ENA_IHR;
1015 icbp->icb_fwoptions2 |= ICB2400_OPT2_ENA_IHA;
1018 if ((icbp->icb_fwoptions3 & ICB2400_OPT3_RSPSZ_MASK) == 0) {
1019 icbp->icb_fwoptions3 |= ICB2400_OPT3_RSPSZ_24;
1021 if (isp->isp_confopts & ISP_CFG_1GB) {
1022 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
1023 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_1GB;
1024 } else if (isp->isp_confopts & ISP_CFG_2GB) {
1025 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
1026 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_2GB;
1027 } else if (isp->isp_confopts & ISP_CFG_4GB) {
1028 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
1029 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_4GB;
1030 } else if (isp->isp_confopts & ISP_CFG_8GB) {
1031 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
1032 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_8GB;
1033 } else if (isp->isp_confopts & ISP_CFG_16GB) {
1034 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
1035 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_16GB;
1036 } else if (isp->isp_confopts & ISP_CFG_32GB) {
1037 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
1038 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_32GB;
1039 } else if (isp->isp_confopts & ISP_CFG_64GB) {
1040 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
1041 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_64GB;
1043 switch (icbp->icb_fwoptions3 & ICB2400_OPT3_RATE_MASK) {
1052 if (isp->isp_type <= ISP_HA_FC_2500)
1056 if (isp->isp_type <= ISP_HA_FC_2400)
1060 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
1061 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_AUTO;
1066 icbp->icb_fwoptions3 |= ICB2400_OPT3_SOFTID;
1068 icbp->icb_logintime = ICB_LOGIN_TOV;
1070 if (fcp->isp_wwnn && fcp->isp_wwpn) {
1071 icbp->icb_fwoptions1 |= ICB2400_OPT1_BOTH_WWNS;
1072 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
1073 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwnn);
1074 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)),
1075 ((uint32_t) (fcp->isp_wwpn >> 32)), ((uint32_t) (fcp->isp_wwpn)));
1076 } else if (fcp->isp_wwpn) {
1077 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_BOTH_WWNS;
1078 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
1079 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)));
1084 icbp->icb_rspnsin = isp->isp_resodx;
1085 icbp->icb_rqstout = isp->isp_reqidx;
1086 icbp->icb_retry_count = fcp->isp_retry_count;
1088 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1089 if (icbp->icb_rqstqlen < 8) {
1090 isp_prt(isp, ISP_LOGERR, "bad request queue length %d", icbp->icb_rqstqlen);
1093 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1094 if (icbp->icb_rsltqlen < 8) {
1096 icbp->icb_rsltqlen);
1099 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1100 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1101 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1102 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1104 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1105 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1106 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1107 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1111 icbp->icb_atio_in = isp->isp_atioodx;
1112 icbp->icb_atioqlen = ATIO_QUEUE_LEN(isp);
1113 if (icbp->icb_atioqlen < 8) {
1114 isp_prt(isp, ISP_LOGERR, "bad ATIO queue length %d", icbp->icb_atioqlen);
1117 icbp->icb_atioqaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_atioq_dma);
1118 icbp->icb_atioqaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_atioq_dma);
1119 icbp->icb_atioqaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_atioq_dma);
1120 icbp->icb_atioqaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_atioq_dma);
1121 isp_prt(isp, ISP_LOGDEBUG0, "isp_init: atioq %04x%04x%04x%04x", DMA_WD3(isp->isp_atioq_dma), DMA_WD2(isp->isp_atioq_dma),
1122 DMA_WD1(isp->isp_atioq_dma), DMA_WD0(isp->isp_atioq_dma));
1125 if (ISP_CAP_MSIX(isp) && isp->isp_nirq >= 2) {
1126 icbp->icb_msixresp = 1;
1127 if (IS_26XX(isp) && isp->isp_nirq >= 3)
1128 icbp->icb_msixatio = 2;
1131 isp_prt(isp, ISP_LOGDEBUG0, "isp_init: fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x", icbp->icb_fwoptions1, icbp->icb_fwoptions2, icbp->icb_fwoptions3);
1133 isp_prt(isp, ISP_LOGDEBUG0, "isp_init: rqst %04x%04x%04x%04x rsp %04x%04x%04x%04x", DMA_WD3(isp->isp_rquest_dma), DMA_WD2(isp->isp_rquest_dma),
1134 DMA_WD1(isp->isp_rquest_dma), DMA_WD0(isp->isp_rquest_dma), DMA_WD3(isp->isp_result_dma), DMA_WD2(isp->isp_result_dma),
1135 DMA_WD1(isp->isp_result_dma), DMA_WD0(isp->isp_result_dma));
1141 ISP_MEMZERO(fcp->isp_scratch, ISP_FC_SCRLEN);
1142 isp_put_icb_2400(isp, icbp, fcp->isp_scratch);
1143 if (isp->isp_dblev & ISP_LOGDEBUG1) {
1145 sizeof (*icbp), fcp->isp_scratch);
1151 if (isp->isp_nchan > 1) {
1160 vpinfo.vp_count = isp->isp_nchan;
1161 chan = 0;
1163 vpinfo.vp_count = isp->isp_nchan - 1;
1164 chan = 1;
1166 off = fcp->isp_scratch;
1171 for (; chan < isp->isp_nchan; chan++) {
1175 fcp2 = FCPARAM(isp, chan);
1176 if (fcp2->role != ISP_ROLE_NONE) {
1179 if (fcp2->role & ISP_ROLE_INITIATOR)
1181 if ((fcp2->role & ISP_ROLE_TARGET) == 0)
1183 if (fcp2->isp_loopid < LOCAL_LOOP_LIM) {
1184 pi.vp_port_loopid = fcp2->isp_loopid;
1185 if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
1190 MAKE_NODE_NAME_FROM_WWN(pi.vp_port_portname, fcp2->isp_wwpn);
1191 MAKE_NODE_NAME_FROM_WWN(pi.vp_port_nodename, fcp2->isp_wwnn);
1192 off = fcp->isp_scratch;
1194 off += ICB2400_VPINFO_PORT_OFF(chan);
1196 off += ICB2400_VPINFO_PORT_OFF(chan - 1);
1201 if (isp->isp_dblev & ISP_LOGDEBUG1) {
1203 amt - ICB2400_VPINFO_OFF,
1204 (char *)fcp->isp_scratch + ICB2400_VPINFO_OFF);
1212 if (isp->isp_nchan > 1) {
1218 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1219 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1220 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1221 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1222 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));
1234 isp->isp_state = ISP_RUNSTATE;
1238 isp_fc_enable_vp(ispsoftc_t *isp, int chan)
1240 fcparam *fcp = FCPARAM(isp, chan);
1249 vp.vp_mod_idx0 = chan;
1253 if (fcp->role & ISP_ROLE_INITIATOR)
1255 if ((fcp->role & ISP_ROLE_TARGET) == 0)
1257 if (fcp->isp_loopid < LOCAL_LOOP_LIM) {
1258 vp.vp_mod_ports[0].loopid = fcp->isp_loopid;
1259 if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
1262 MAKE_NODE_NAME_FROM_WWN(vp.vp_mod_ports[0].wwpn, fcp->isp_wwpn);
1263 MAKE_NODE_NAME_FROM_WWN(vp.vp_mod_ports[0].wwnn, fcp->isp_wwnn);
1267 isp_prt(isp, ISP_LOGERR, "%s: VP_MODIFY of chan %d error %d",
1268 __func__, chan, retval);
1274 "%s: VP_MODIFY of Chan %d failed with flags %x status %d",
1275 __func__, chan, vp.vp_mod_hdr.rqs_flags, vp.vp_mod_status);
1282 isp_fc_disable_vp(ispsoftc_t *isp, int chan)
1295 chan--; /* VP0 can not be controlled in this case. */
1299 vp.vp_ctrl_idmap[chan / 16] |= (1 << chan % 16);
1303 isp_prt(isp, ISP_LOGERR, "%s: VP_CTRL of chan %d error %d",
1304 __func__, chan, retval);
1310 "%s: VP_CTRL of Chan %d failed with flags %x status %d %d",
1311 __func__, chan, vp.vp_ctrl_hdr.rqs_flags,
1319 isp_fc_change_role(ispsoftc_t *isp, int chan, int new_role)
1321 fcparam *fcp = FCPARAM(isp, chan);
1324 if (chan >= isp->isp_nchan) {
1325 isp_prt(isp, ISP_LOGWARN, "%s: bad channel %d", __func__, chan);
1328 if (fcp->role == new_role)
1330 for (was = 0, i = 0; i < isp->isp_nchan; i++) {
1331 if (FCPARAM(isp, i)->role != ISP_ROLE_NONE)
1334 if (was == 0 || (was == 1 && fcp->role != ISP_ROLE_NONE)) {
1335 fcp->role = new_role;
1338 if (fcp->role != ISP_ROLE_NONE) {
1339 res = isp_fc_disable_vp(isp, chan);
1340 isp_clear_portdb(isp, chan);
1342 fcp->role = new_role;
1343 if (fcp->role != ISP_ROLE_NONE)
1344 res = isp_fc_enable_vp(isp, chan);
1349 isp_clear_portdb(ispsoftc_t *isp, int chan)
1351 fcparam *fcp = FCPARAM(isp, chan);
1356 lp = &fcp->portdb[i];
1357 switch (lp->state) {
1361 lp->state = FC_PORTDB_STATE_NIL;
1362 isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
1366 lp->state = FC_PORTDB_STATE_NIL;
1371 panic("Don't know how to clear state %d\n", lp->state);
1377 isp_mark_portdb(ispsoftc_t *isp, int chan)
1379 fcparam *fcp = FCPARAM(isp, chan);
1384 lp = &fcp->portdb[i];
1385 if (lp->state == FC_PORTDB_STATE_NIL)
1387 if (lp->portid >= DOMAIN_CONTROLLER_BASE &&
1388 lp->portid <= DOMAIN_CONTROLLER_END)
1390 fcp->portdb[i].probational = 1;
1399 isp_plogx(ispsoftc_t *isp, int chan, uint16_t handle, uint32_t portid, int flags)
1407 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d PLOGX %s PortID 0x%06x nphdl 0x%x",
1408 chan, (flags & PLOGX_FLG_CMD_MASK) == PLOGX_FLG_CMD_PLOGI ?
1415 pl.plogx_vphdl = chan;
1422 isp_prt(isp, ISP_LOGERR, "%s: PLOGX of chan %d error %d",
1423 __func__, chan, retval);
1432 pl.plogx_status, chan);
1433 return (-1);
1439 retval = -1;
1481 ISP_SNPRINTF(buf, sizeof (buf), "already logged in with N-Port handle 0x%x", parm1);
1503 isp_prt(isp, lev, "Chan %d PLOGX PortID 0x%06x to N-Port handle 0x%x: %s",
1504 chan, portid, handle, msg);
1510 isp_getpdb(ispsoftc_t *isp, int chan, uint16_t id, isp_pdb_t *pdb)
1521 mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
1522 mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
1523 mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
1524 mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
1525 mbs.param[9] = chan;
1526 MEMORYBARRIER(isp, SYNC_IFORDEV, 0, sizeof(un), chan);
1532 MEMORYBARRIER(isp, SYNC_IFORCPU, 0, sizeof(un), chan);
1533 isp_get_pdb_24xx(isp, isp->isp_iocb, &un.bill);
1534 pdb->handle = un.bill.pdb_handle;
1535 pdb->prli_word0 = un.bill.pdb_prli_svc0;
1536 pdb->prli_word3 = un.bill.pdb_prli_svc3;
1537 pdb->portid = BITS2WORD_24XX(un.bill.pdb_portid_bits);
1538 ISP_MEMCPY(pdb->portname, un.bill.pdb_portname, 8);
1539 ISP_MEMCPY(pdb->nodename, un.bill.pdb_nodename, 8);
1541 "Chan %d handle 0x%x Port 0x%06x flags 0x%x curstate %x laststate %x",
1542 chan, id, pdb->portid, un.bill.pdb_flags,
1561 isp_gethandles(ispsoftc_t *isp, int chan, uint16_t *handles, int *num, int loop)
1563 fcparam *fcp = FCPARAM(isp, chan);
1570 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1571 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1572 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1573 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1575 mbs.param[9] = chan;
1576 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
1578 return (-1);
1580 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, ISP_FC_SCRLEN, chan);
1583 FC_SCRATCH_RELEASE(isp, chan);
1586 MEMORYBARRIER(isp, SYNC_SFORCPU, 0, ISP_FC_SCRLEN, chan);
1587 elp4 = fcp->isp_scratch;
1591 if (loop && (p >> 8) != (fcp->isp_portid >> 8))
1596 FC_SCRATCH_RELEASE(isp, chan);
1601 isp_dump_chip_portdb(ispsoftc_t *isp, int chan)
1606 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d chip port dump", chan);
1608 if (isp_getpdb(isp, chan, nphdl, &pdb)) {
1611 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d Handle 0x%04x "
1613 chan, nphdl, pdb.portid, pdb.portname[0], pdb.portname[1],
1620 isp_get_wwn(ispsoftc_t *isp, int chan, int nphdl, int nodename)
1630 mbs.param[9] = chan;
1651 isp_fclink_test(ispsoftc_t *isp, int chan, int usdelay)
1659 fcp = FCPARAM(isp, chan);
1661 if (fcp->isp_loopstate < LOOP_HAVE_LINK)
1662 return (-1);
1663 if (fcp->isp_loopstate >= LOOP_LTEST_DONE)
1666 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test", chan);
1673 isp_change_fw_state(isp, chan, isp_fw_state(isp, chan));
1674 if (fcp->isp_fwstate == FW_READY) {
1677 if (fcp->isp_loopstate < LOOP_HAVE_LINK)
1684 if (fcp->isp_fwstate != FW_READY) {
1686 "Chan %d Firmware is not ready (%s)",
1687 chan, isp_fc_fw_statename(fcp->isp_fwstate));
1688 return (-1);
1695 mbs.param[9] = chan;
1698 return (-1);
1704 fcp->isp_topo = topo;
1705 fcp->isp_portid = mbs.param[2] | (mbs.param[3] << 16);
1707 if (!TOPO_IS_FABRIC(fcp->isp_topo)) {
1708 fcp->isp_loopid = mbs.param[1] & 0xff;
1709 } else if (fcp->isp_topo != TOPO_F_PORT) {
1710 uint8_t alpa = fcp->isp_portid;
1717 fcp->isp_loopid = i;
1721 fcp->isp_loopstate = LOOP_HAVE_ADDR;
1723 fcp->isp_loopstate = LOOP_TESTING_LINK;
1725 if (fcp->isp_topo == TOPO_F_PORT || fcp->isp_topo == TOPO_FL_PORT) {
1726 r = isp_getpdb(isp, chan, NPH_FL_ID, &pdb);
1730 fcp->isp_topo = TOPO_PTP_STUB;
1734 fcp->isp_fabric_params = mbs.param[7];
1735 fcp->isp_sns_hdl = NPH_SNS_ID;
1736 r = isp_register_fc4_type(isp, chan);
1737 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
1741 r = isp_register_fc4_features_24xx(isp, chan);
1742 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
1746 r = isp_register_port_name_24xx(isp, chan);
1747 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
1751 isp_register_node_name_24xx(isp, chan);
1752 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
1758 fcp->isp_gbspeed = 1;
1765 fcp->isp_gbspeed = 10;
1767 fcp->isp_gbspeed = 64;
1769 fcp->isp_gbspeed = 32;
1771 fcp->isp_gbspeed = 16;
1773 fcp->isp_gbspeed = 8;
1775 fcp->isp_gbspeed = 4;
1777 fcp->isp_gbspeed = 2;
1779 fcp->isp_gbspeed = 1;
1782 if (fcp->isp_loopstate < LOOP_TESTING_LINK) {
1785 "Chan %d FC link test aborted", chan);
1788 fcp->isp_loopstate = LOOP_LTEST_DONE;
1790 "Chan %d WWPN %016jx WWNN %016jx",
1791 chan, (uintmax_t)fcp->isp_wwpn, (uintmax_t)fcp->isp_wwnn);
1793 "Chan %d %dGb %s PortID 0x%06x LoopID 0x%02x",
1794 chan, fcp->isp_gbspeed, isp_fc_toponame(fcp), fcp->isp_portid,
1795 fcp->isp_loopid);
1796 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test done", chan);
1812 isp_pdb_sync(ispsoftc_t *isp, int chan)
1814 fcparam *fcp = FCPARAM(isp, chan);
1818 if (fcp->isp_loopstate < LOOP_FSCAN_DONE)
1819 return (-1);
1820 if (fcp->isp_loopstate >= LOOP_READY)
1823 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync", chan);
1825 fcp->isp_loopstate = LOOP_SYNCING_PDB;
1828 lp = &fcp->portdb[dbidx];
1830 if (lp->state == FC_PORTDB_STATE_NIL)
1832 if (lp->probational && lp->state != FC_PORTDB_STATE_ZOMBIE)
1833 lp->state = FC_PORTDB_STATE_DEAD;
1834 switch (lp->state) {
1836 lp->state = FC_PORTDB_STATE_NIL;
1837 isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
1838 if ((lp->portid & 0xffff00) != 0) {
1839 (void) isp_plogx(isp, chan, lp->handle,
1840 lp->portid,
1851 lp->state = FC_PORTDB_STATE_VALID;
1852 isp_async(isp, ISPASYNC_DEV_ARRIVED, chan, lp);
1855 lp->state = FC_PORTDB_STATE_VALID;
1856 isp_async(isp, ISPASYNC_DEV_CHANGED, chan, lp);
1857 lp->portid = lp->new_portid;
1858 lp->prli_word0 = lp->new_prli_word0;
1859 lp->prli_word3 = lp->new_prli_word3;
1862 isp_async(isp, ISPASYNC_DEV_STAYED, chan, lp);
1869 lp->state, dbidx);
1870 isp_dump_portdb(isp, chan);
1874 if (fcp->isp_loopstate < LOOP_SYNCING_PDB) {
1876 "Chan %d FC PDB sync aborted", chan);
1880 fcp->isp_loopstate = LOOP_READY;
1881 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync done", chan);
1886 isp_pdb_add_update(ispsoftc_t *isp, int chan, isp_pdb_t *pdb)
1891 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb->nodename);
1892 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb->portname);
1895 if (isp_find_pdb_by_wwpn(isp, chan, wwpn, &lp)) {
1896 if (!lp->probational) {
1898 "Chan %d Port 0x%06x@0x%04x [%d] is not probational (0x%x)",
1899 chan, lp->portid, lp->handle,
1900 FC_PORTDB_TGT(isp, chan, lp), lp->state);
1901 isp_dump_portdb(isp, chan);
1904 lp->probational = 0;
1905 lp->node_wwn = wwnn;
1908 if (lp->portid == pdb->portid &&
1909 lp->handle == pdb->handle &&
1910 lp->prli_word3 == pdb->prli_word3 &&
1911 ((pdb->prli_word0 & PRLI_WD0_EST_IMAGE_PAIR) ==
1912 (lp->prli_word0 & PRLI_WD0_EST_IMAGE_PAIR))) {
1913 if (lp->state != FC_PORTDB_STATE_NEW)
1914 lp->state = FC_PORTDB_STATE_VALID;
1916 "Chan %d Port 0x%06x@0x%04x is valid",
1917 chan, pdb->portid, pdb->handle);
1922 lp->state = FC_PORTDB_STATE_CHANGED;
1923 lp->handle = pdb->handle;
1924 lp->new_portid = pdb->portid;
1925 lp->new_prli_word0 = pdb->prli_word0;
1926 lp->new_prli_word3 = pdb->prli_word3;
1928 "Chan %d Port 0x%06x@0x%04x is changed",
1929 chan, pdb->portid, pdb->handle);
1934 if (!isp_find_pdb_empty(isp, chan, &lp)) {
1935 isp_prt(isp, ISP_LOGERR, "Chan %d out of portdb entries", chan);
1940 lp->probational = 0;
1941 lp->state = FC_PORTDB_STATE_NEW;
1942 lp->portid = lp->new_portid = pdb->portid;
1943 lp->prli_word0 = lp->new_prli_word0 = pdb->prli_word0;
1944 lp->prli_word3 = lp->new_prli_word3 = pdb->prli_word3;
1945 lp->handle = pdb->handle;
1946 lp->port_wwn = wwpn;
1947 lp->node_wwn = wwnn;
1948 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Port 0x%06x@0x%04x is new",
1949 chan, pdb->portid, pdb->handle);
1956 isp_scan_loop(ispsoftc_t *isp, int chan)
1958 fcparam *fcp = FCPARAM(isp, chan);
1964 if (fcp->isp_loopstate < LOOP_LTEST_DONE)
1965 return (-1);
1966 if (fcp->isp_loopstate >= LOOP_LSCAN_DONE)
1969 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan", chan);
1970 fcp->isp_loopstate = LOOP_SCANNING_LOOP;
1971 if (TOPO_IS_FABRIC(fcp->isp_topo)) {
1973 "Chan %d FC loop scan done (no loop)", chan);
1974 fcp->isp_loopstate = LOOP_LSCAN_DONE;
1978 handles = (uint16_t *)fcp->isp_scanscratch;
1980 r = isp_gethandles(isp, chan, handles, &lim, 1);
1983 "Chan %d Getting list of handles failed with %x", chan, r);
1985 "Chan %d FC loop scan done (bad)", chan);
1986 return (-1);
1989 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Got %d handles",
1990 chan, lim);
1995 isp_mark_portdb(isp, chan);
2008 r = isp_getpdb(isp, chan, handle, &pdb);
2009 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
2012 "Chan %d FC loop scan aborted", chan);
2017 "Chan %d FC Scan Loop handle %d returned %x",
2018 chan, handle, r);
2022 isp_pdb_add_update(isp, chan, &pdb);
2024 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
2026 fcp->isp_loopstate = LOOP_LSCAN_DONE;
2027 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan done", chan);
2032 isp_ct_passthru(ispsoftc_t *isp, int chan, uint32_t cmd_bcnt, uint32_t rsp_bcnt)
2034 fcparam *fcp = FCPARAM(isp, chan);
2038 if (isp->isp_dblev & ISP_LOGDEBUG1)
2039 isp_print_bytes(isp, "CT request", cmd_bcnt, fcp->isp_scratch);
2047 pt.ctp_nphdl = fcp->isp_sns_hdl;
2049 pt.ctp_vpidx = ISP_GET_VPIDX(isp, chan);
2054 pt.ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma);
2055 pt.ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma);
2057 pt.ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma);
2058 pt.ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma);
2063 isp_prt(isp, ISP_LOGERR, "%s: CTP of chan %d error %d",
2064 __func__, chan, retval);
2070 "Chan %d CT pass-through returned 0x%x",
2071 chan, pt.ctp_status);
2072 return (-1);
2075 if (isp->isp_dblev & ISP_LOGDEBUG1)
2076 isp_print_bytes(isp, "CT response", rsp_bcnt, fcp->isp_scratch);
2087 * We use CT Pass-through IOCB.
2090 #define NGENT ((GIDLEN - 16) >> 2)
2093 isp_gid_pt(ispsoftc_t *isp, int chan)
2095 fcparam *fcp = FCPARAM(isp, chan);
2097 uint8_t *scp = fcp->isp_scratch;
2099 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GID_PT", chan);
2100 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2102 return (-1);
2105 /* Build the CT command and execute via pass-through. */
2111 ct.ct_bcnt_resid = (GIDLEN - 16) >> 2;
2118 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t), GIDLEN)) {
2119 FC_SCRATCH_RELEASE(isp, chan);
2120 return (-1);
2124 (sns_gid_xx_rsp_t *)fcp->isp_scanscratch, NGENT);
2125 FC_SCRATCH_RELEASE(isp, chan);
2130 isp_gff_id(ispsoftc_t *isp, int chan, uint32_t portid)
2132 fcparam *fcp = FCPARAM(isp, chan);
2135 uint8_t *scp = fcp->isp_scratch;
2137 int i, res = -1;
2139 if (!fcp->isp_use_gff_id) /* User may block GFF_ID use. */
2142 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFF_ID", chan);
2143 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2148 /* Build the CT command and execute via pass-through. */
2154 ct.ct_bcnt_resid = (SNS_GFF_ID_RESP_SIZE - sizeof(ct)) / 4;
2159 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
2161 FC_SCRATCH_RELEASE(isp, chan);
2181 FC_SCRATCH_RELEASE(isp, chan);
2182 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFF_ID result is %d", chan, res);
2187 isp_gft_id(ispsoftc_t *isp, int chan, uint32_t portid)
2189 fcparam *fcp = FCPARAM(isp, chan);
2192 uint8_t *scp = fcp->isp_scratch;
2194 int i, res = -1;
2196 if (!fcp->isp_use_gft_id) /* User may block GFT_ID use. */
2199 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFT_ID", chan);
2200 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2205 /* Build the CT command and execute via pass-through. */
2211 ct.ct_bcnt_resid = (SNS_GFT_ID_RESP_SIZE - sizeof(ct)) / 4;
2216 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
2218 FC_SCRATCH_RELEASE(isp, chan);
2234 FC_SCRATCH_RELEASE(isp, chan);
2235 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFT_ID result is %d", chan, res);
2240 isp_scan_fabric(ispsoftc_t *isp, int chan)
2242 fcparam *fcp = FCPARAM(isp, chan);
2249 if (fcp->isp_loopstate < LOOP_LSCAN_DONE)
2250 return (-1);
2251 if (fcp->isp_loopstate >= LOOP_FSCAN_DONE)
2254 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan", chan);
2255 fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
2256 if (!TOPO_IS_FABRIC(fcp->isp_topo)) {
2257 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2259 "Chan %d FC fabric scan done (no fabric)", chan);
2263 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC) {
2265 FC_SCRATCH_RELEASE(isp, chan);
2267 "Chan %d FC fabric scan aborted", chan);
2274 r = isp_getpdb(isp, chan, NPH_FL_ID, &pdb);
2276 isp_dump_chip_portdb(isp, chan);
2279 fcp->isp_loopstate = LOOP_LTEST_DONE;
2282 "Chan %d FC fabric scan done (bad)", chan);
2283 return (-1);
2287 r = isp_gid_pt(isp, chan);
2288 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
2291 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2292 return (-1);
2294 fcp->isp_loopstate = LOOP_LTEST_DONE; /* try again */
2295 return (-1);
2298 rs = (sns_gid_xx_rsp_t *) fcp->isp_scanscratch;
2299 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
2301 if (rs->snscb_cthdr.ct_cmd_resp != LS_ACC) {
2303 /* FC-4 Type and Port Type not registered are not errors. */
2304 if (rs->snscb_cthdr.ct_reason == 9 &&
2305 (rs->snscb_cthdr.ct_explanation == 0x07 ||
2306 rs->snscb_cthdr.ct_explanation == 0x0a)) {
2311 isp_prt(isp, level, "Chan %d Fabric Nameserver rejected GID_PT"
2312 " (Reason=0x%x Expl=0x%x)", chan,
2313 rs->snscb_cthdr.ct_reason,
2314 rs->snscb_cthdr.ct_explanation);
2315 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2316 return (-1);
2320 for (portidx = 0; portidx < NGENT-1; portidx++) {
2321 if (rs->snscb_ports[portidx].control & 0x80)
2324 if ((rs->snscb_ports[portidx].control & 0x80) == 0) {
2330 "Chan %d Got %d ports back from name server", chan, portlim);
2337 ((rs->snscb_ports[portidx].portid[0]) << 16) |
2338 ((rs->snscb_ports[portidx].portid[1]) << 8) |
2339 ((rs->snscb_ports[portidx].portid[2]));
2343 ((rs->snscb_ports[npidx].portid[0]) << 16) |
2344 ((rs->snscb_ports[npidx].portid[1]) << 8) |
2345 ((rs->snscb_ports[npidx].portid[2]));
2352 rs->snscb_ports[npidx].portid[0] = 0;
2353 rs->snscb_ports[npidx].portid[1] = 0;
2354 rs->snscb_ports[npidx].portid[2] = 0;
2355 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d removing duplicate PortID 0x%06x entry from list", chan, portid);
2361 * that the Fabric Name server knows about.
2364 * for probational entries- if we find one, then an old entry is
2373 isp_mark_portdb(isp, chan);
2375 portid = ((rs->snscb_ports[portidx].portid[0]) << 16) |
2376 ((rs->snscb_ports[portidx].portid[1]) << 8) |
2377 ((rs->snscb_ports[portidx].portid[2]));
2379 "Chan %d Checking fabric port 0x%06x", chan, portid);
2382 "Chan %d Port at idx %d is zero",
2383 chan, portidx);
2386 if (portid == fcp->isp_portid) {
2388 "Chan %d Port 0x%06x is our", chan, portid);
2393 if (isp_find_pdb_by_portid(isp, chan, portid, &lp)) {
2394 if (!lp->probational) {
2396 "Chan %d Port 0x%06x@0x%04x [%d] is not probational (0x%x)",
2397 chan, lp->portid, lp->handle,
2398 FC_PORTDB_TGT(isp, chan, lp), lp->state);
2399 isp_dump_portdb(isp, chan);
2403 if (lp->state == FC_PORTDB_STATE_ZOMBIE)
2421 r = isp_getpdb(isp, chan, lp->handle, &pdb);
2422 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
2425 lp->state = FC_PORTDB_STATE_DEAD;
2427 "Chan %d Port 0x%06x handle 0x%x is dead (%d)",
2428 chan, portid, lp->handle, r);
2432 isp_pdb_add_update(isp, chan, &pdb);
2437 if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
2439 "Chan %d Port 0x%06x is not logged in", chan, portid);
2443 r = isp_gff_id(isp, chan, portid);
2446 "Chan %d Port 0x%06x is not an FCP target", chan, portid);
2450 r = isp_gft_id(isp, chan, portid);
2453 "Chan %d Port 0x%06x is not FCP", chan, portid);
2457 if (isp_login_device(isp, chan, portid, &pdb,
2458 &FCPARAM(isp, 0)->isp_lasthdl)) {
2459 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
2464 isp_pdb_add_update(isp, chan, &pdb);
2467 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
2469 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2470 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan done", chan);
2478 isp_login_device(ispsoftc_t *isp, int chan, uint32_t portid, isp_pdb_t *p, uint16_t *ohp)
2485 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
2486 return (-1);
2489 r = isp_getpdb(isp, chan, handle, p);
2491 if (p->portid != portid) {
2498 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
2499 return (-1);
2504 r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
2513 if (isp_plogx(isp, chan, r >> 16, portid, PLOGX_FLG_CMD_LOGO | PLOGX_FLG_IMPLICIT | PLOGX_FLG_FREE_NPHDL)) {
2516 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
2517 return (-1);
2518 r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
2533 isp_prt(isp, ISP_LOGWARN, "Chan %d PLOGI 0x%06x failed", chan, portid);
2534 return (-1);
2542 r = isp_getpdb(isp, chan, handle, p);
2544 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x disappeared", chan, portid, handle);
2545 return (-1);
2548 if (p->handle != handle || p->portid != portid) {
2549 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x changed (0x%06x@0x%0x)",
2550 chan, portid, handle, p->portid, p->handle);
2551 return (-1);
2557 isp_register_fc4_type(ispsoftc_t *isp, int chan)
2559 fcparam *fcp = FCPARAM(isp, chan);
2562 uint8_t *scp = fcp->isp_scratch;
2564 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2566 return (-1);
2569 /* Build the CT command and execute via pass-through. */
2571 ct->ct_revision = CT_REVISION;
2572 ct->ct_fcs_type = CT_FC_TYPE_FC;
2573 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
2574 ct->ct_cmd_resp = SNS_RFT_ID;
2575 ct->ct_bcnt_resid = (sizeof (rft_id_t) - sizeof (ct_hdr_t)) >> 2;
2576 rp.rftid_portid[0] = fcp->isp_portid >> 16;
2577 rp.rftid_portid[1] = fcp->isp_portid >> 8;
2578 rp.rftid_portid[2] = fcp->isp_portid;
2582 if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
2583 FC_SCRATCH_RELEASE(isp, chan);
2584 return (-1);
2588 FC_SCRATCH_RELEASE(isp, chan);
2589 if (ct->ct_cmd_resp == LS_RJT) {
2590 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "Chan %d Register FC4 Type rejected", chan);
2591 return (-1);
2592 } else if (ct->ct_cmd_resp == LS_ACC) {
2593 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Register FC4 Type accepted", chan);
2595 isp_prt(isp, ISP_LOGWARN, "Chan %d Register FC4 Type: 0x%x", chan, ct->ct_cmd_resp);
2596 return (-1);
2602 isp_register_fc4_features_24xx(ispsoftc_t *isp, int chan)
2604 fcparam *fcp = FCPARAM(isp, chan);
2607 uint8_t *scp = fcp->isp_scratch;
2609 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2611 return (-1);
2619 ct->ct_revision = CT_REVISION;
2620 ct->ct_fcs_type = CT_FC_TYPE_FC;
2621 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
2622 ct->ct_cmd_resp = SNS_RFF_ID;
2623 ct->ct_bcnt_resid = (sizeof (rff_id_t) - sizeof (ct_hdr_t)) >> 2;
2624 rp.rffid_portid[0] = fcp->isp_portid >> 16;
2625 rp.rffid_portid[1] = fcp->isp_portid >> 8;
2626 rp.rffid_portid[2] = fcp->isp_portid;
2628 if (fcp->role & ISP_ROLE_TARGET)
2630 if (fcp->role & ISP_ROLE_INITIATOR)
2634 if (isp->isp_dblev & ISP_LOGDEBUG1)
2637 if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
2638 FC_SCRATCH_RELEASE(isp, chan);
2639 return (-1);
2643 FC_SCRATCH_RELEASE(isp, chan);
2644 if (ct->ct_cmd_resp == LS_RJT) {
2646 "Chan %d Register FC4 Features rejected", chan);
2647 return (-1);
2648 } else if (ct->ct_cmd_resp == LS_ACC) {
2650 "Chan %d Register FC4 Features accepted", chan);
2653 "Chan %d Register FC4 Features: 0x%x", chan, ct->ct_cmd_resp);
2654 return (-1);
2660 isp_register_port_name_24xx(ispsoftc_t *isp, int chan)
2662 fcparam *fcp = FCPARAM(isp, chan);
2665 uint8_t *scp = fcp->isp_scratch;
2668 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2670 return (-1);
2678 ct->ct_revision = CT_REVISION;
2679 ct->ct_fcs_type = CT_FC_TYPE_FC;
2680 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
2681 ct->ct_cmd_resp = SNS_RSPN_ID;
2682 rp.rspnid_portid[0] = fcp->isp_portid >> 16;
2683 rp.rspnid_portid[1] = fcp->isp_portid >> 8;
2684 rp.rspnid_portid[2] = fcp->isp_portid;
2692 ":%s", device_get_nameunit(isp->isp_dev));
2693 if (chan != 0) {
2695 "/%d", chan);
2698 ct->ct_bcnt_resid = (len - sizeof(ct_hdr_t)) >> 2;
2701 if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
2702 FC_SCRATCH_RELEASE(isp, chan);
2703 return (-1);
2707 FC_SCRATCH_RELEASE(isp, chan);
2708 if (ct->ct_cmd_resp == LS_RJT) {
2710 "Chan %d Register Symbolic Port Name rejected", chan);
2711 return (-1);
2712 } else if (ct->ct_cmd_resp == LS_ACC) {
2714 "Chan %d Register Symbolic Port Name accepted", chan);
2717 "Chan %d Register Symbolic Port Name: 0x%x", chan, ct->ct_cmd_resp);
2718 return (-1);
2724 isp_register_node_name_24xx(ispsoftc_t *isp, int chan)
2726 fcparam *fcp = FCPARAM(isp, chan);
2729 uint8_t *scp = fcp->isp_scratch;
2732 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2734 return (-1);
2742 ct->ct_revision = CT_REVISION;
2743 ct->ct_fcs_type = CT_FC_TYPE_FC;
2744 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
2745 ct->ct_cmd_resp = SNS_RSNN_NN;
2746 MAKE_NODE_NAME_FROM_WWN(rp.rsnnnn_nodename, fcp->isp_wwnn);
2754 ct->ct_bcnt_resid = (len - sizeof(ct_hdr_t)) >> 2;
2757 if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
2758 FC_SCRATCH_RELEASE(isp, chan);
2759 return (-1);
2763 FC_SCRATCH_RELEASE(isp, chan);
2764 if (ct->ct_cmd_resp == LS_RJT) {
2766 "Chan %d Register Symbolic Node Name rejected", chan);
2767 return (-1);
2768 } else if (ct->ct_cmd_resp == LS_ACC) {
2770 "Chan %d Register Symbolic Node Name accepted", chan);
2773 "Chan %d Register Symbolic Node Name: 0x%x", chan, ct->ct_cmd_resp);
2774 return (-1);
2783 int i, chan, wrap;
2794 if (handle > NPH_RESERVED - 1) {
2802 for (chan = 0; chan < isp->isp_nchan; chan++) {
2803 fcp = FCPARAM(isp, chan);
2804 if (fcp->role == ISP_ROLE_NONE)
2807 if (fcp->portdb[i].state != FC_PORTDB_STATE_NIL &&
2808 fcp->portdb[i].handle == handle)
2854 if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
2862 if (isp->isp_state != ISP_RUNSTATE) {
2869 lp = &fcp->portdb[target];
2871 lp->is_target == 0) {
2875 if (fcp->isp_loopstate != LOOP_READY) {
2881 if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
2887 if (lp->state != FC_PORTDB_STATE_VALID) {
2890 XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs), lp->state);
2913 m->mrk_header.rqs_entry_count = 1;
2914 m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
2915 m->mrk_modifier = SYNC_ALL;
2916 m->mrk_vphdl = XS_CHANNEL(xs);
2927 if (cdblen > sizeof (reqp->req_cdb)) {
2933 reqp->req_header.rqs_entry_type = RQSTYPE_T7RQS;
2934 reqp->req_header.rqs_entry_count = 1;
2935 reqp->req_nphdl = lp->handle;
2936 reqp->req_time = XS_TIME(xs);
2937 be64enc(reqp->req_lun, CAM_EXTLUN_BYTE_SWIZZLE(XS_LUN(xs)));
2939 reqp->req_alen_datadir = FCP_CMND_DATA_READ;
2941 reqp->req_alen_datadir = FCP_CMND_DATA_WRITE;
2943 reqp->req_task_attribute = XS_TAG_TYPE(xs);
2945 reqp->req_task_attribute = FCP_CMND_TASK_ATTR_SIMPLE;
2946 reqp->req_task_attribute |= (XS_PRIORITY(xs) << FCP_CMND_PRIO_SHIFT) &
2948 if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
2949 if (FCP_NEXT_CRN(isp, &reqp->req_crn, xs)) {
2957 ISP_MEMCPY(reqp->req_cdb, XS_CDBP(xs), cdblen);
2958 reqp->req_dl = XS_XFRLEN(xs);
2959 reqp->req_tidlo = lp->portid;
2960 reqp->req_tidhi = lp->portid >> 16;
2961 reqp->req_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(xs));
2964 reqp->req_handle = isp_allocate_handle(isp, xs, ISP_HANDLE_INITIATOR);
2965 if (reqp->req_handle == 0) {
2979 isp_destroy_handle(isp, reqp->req_handle);
3002 int chan, tgt;
3021 chan = va_arg(ap, int);
3024 fcp = FCPARAM(isp, chan);
3027 isp_prt(isp, ISP_LOGWARN, "Chan %d trying to reset bad target %d", chan, tgt);
3030 lp = &fcp->portdb[tgt];
3031 if (lp->is_target == 0 || lp->state != FC_PORTDB_STATE_VALID) {
3032 isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
3038 tmf->tmf_header.rqs_entry_type = RQSTYPE_TSK_MGMT;
3039 tmf->tmf_header.rqs_entry_count = 1;
3040 tmf->tmf_nphdl = lp->handle;
3041 tmf->tmf_delay = 2;
3042 tmf->tmf_timeout = 4;
3043 tmf->tmf_flags = ISP24XX_TMF_TARGET_RESET;
3044 tmf->tmf_tidlo = lp->portid;
3045 tmf->tmf_tidhi = lp->portid >> 16;
3046 tmf->tmf_vpidx = ISP_GET_VPIDX(isp, chan);
3047 fcp->sendmarker = 1;
3048 isp_prt(isp, ISP_LOGALL, "Chan %d Reset N-Port Handle 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
3051 if (isp_exec_entry_mbox(isp, tmf, sp, 2 * tmf->tmf_timeout))
3054 if (sp->req_completion_status == 0)
3056 isp_prt(isp, ISP_LOGWARN, "Chan %d reset of target %d returned 0x%x", chan, tgt, sp->req_completion_status);
3068 chan = XS_CHANNEL(xs);
3076 fcp = FCPARAM(isp, chan);
3078 isp_prt(isp, ISP_LOGWARN, "Chan %d trying to abort bad target %d", chan, tgt);
3081 lp = &fcp->portdb[tgt];
3082 if (lp->is_target == 0 || lp->state != FC_PORTDB_STATE_VALID) {
3083 isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
3086 isp_prt(isp, ISP_LOGALL, "Chan %d Abort Cmd for N-Port 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
3088 ab->abrt_header.rqs_entry_type = RQSTYPE_ABORT_IO;
3089 ab->abrt_header.rqs_entry_count = 1;
3090 ab->abrt_handle = lp->handle;
3091 ab->abrt_cmd_handle = handle;
3092 ab->abrt_tidlo = lp->portid;
3093 ab->abrt_tidhi = lp->portid >> 16;
3094 ab->abrt_vpidx = ISP_GET_VPIDX(isp, chan);
3099 if (ab->abrt_nphdl == ISP24XX_ABRT_OKAY)
3101 isp_prt(isp, ISP_LOGWARN, "Chan %d handle %d abort returned 0x%x", chan, tgt, ab->abrt_nphdl);
3109 chan = va_arg(ap, int);
3114 return (isp_fclink_test(isp, chan, usdelay));
3119 chan = va_arg(ap, int);
3121 return (isp_scan_fabric(isp, chan));
3126 chan = va_arg(ap, int);
3128 return (isp_scan_loop(isp, chan));
3133 chan = va_arg(ap, int);
3135 return (isp_pdb_sync(isp, chan));
3144 chan = va_arg(ap, int);
3148 return (isp_getpdb(isp, chan, tgt, pdb));
3154 chan = va_arg(ap, int);
3163 *wwnn = isp_get_wwn(isp, chan, tgt, 1);
3169 *wwnp = isp_get_wwn(isp, chan, tgt, 0);
3193 if ((p->flags & PLOGX_FLG_CMD_MASK) != PLOGX_FLG_CMD_PLOGI || (p->handle != NIL_HANDLE)) {
3194 return (isp_plogx(isp, p->channel, p->handle, p->portid, p->flags));
3197 isp_next_handle(isp, &p->handle);
3198 r = isp_plogx(isp, p->channel, p->handle, p->portid, p->flags);
3200 p->handle = r >> 16;
3212 chan = va_arg(ap, int);
3215 return (isp_fc_change_role(isp, chan, role));
3222 return (-1);
3240 optr = isp->isp_atioodx;
3243 MEMORYBARRIER(isp, SYNC_ATIOQ, oop, QENTRY_LEN, -1);
3244 addr = ISP_QUEUE_ENTRY(isp->isp_atioq, oop);
3245 switch (((isphdr_t *)addr)->rqs_entry_type) {
3260 if (isp->isp_atioodx != optr) {
3262 isp->isp_atioodx = optr;
3272 if (!isp->isp_mboxbsy) {
3276 obits = isp->isp_obits;
3277 isp->isp_mboxtmp[0] = mbox0;
3281 isp->isp_mboxtmp[i] = ISP_READ(isp, MBOX_OFF(i));
3283 isp->isp_mboxbsy = 0;
3304 if (isp->isp_state != ISP_RUNSTATE) {
3310 optr = isp->isp_resodx;
3316 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, cptr);
3322 MEMORYBARRIER(isp, SYNC_RESULT, cptr, QENTRY_LEN, -1);
3323 if (isp->isp_dblev & ISP_LOGDEBUG1)
3325 isp_get_hdr(isp, hp, &sp->req_header);
3331 if (sp->req_header.rqs_flags & RQSFLAG_BADTYPE) {
3335 if (sp->req_header.rqs_flags & RQSFLAG_BADPARAM) {
3339 if (sp->req_header.rqs_flags & RQSFLAG_BADCOUNT) {
3343 if (sp->req_header.rqs_flags & RQSFLAG_BADORDER) {
3348 etype = sp->req_header.rqs_entry_type;
3372 slen = min(cont, sizeof(scp->req_sense_data));
3373 XS_SENSE_APPEND(cont_xs, scp->req_sense_data, slen);
3374 cont -= slen;
3397 hp = (isphdr_t *)ISP_QUEUE_ENTRY(isp->isp_result, sptr);
3408 /* We don't know what was this -- log and skip. */
3414 xs = isp_find_xs(isp, sp->req_handle);
3420 if (sp->req_completion_status != RQCS_ABORTED &&
3421 sp->req_completion_status != RQCS_RESET_OCCURRED)
3423 sp->req_handle, sp->req_completion_status);
3428 resp = snsp = sp->req_rsp_sense;
3430 scsi_status = sp->req_scsi_status;
3432 rlen = sp->req_response_len;
3436 totslen = sp->req_sense_len;
3437 slen = MIN(totslen, sizeof(sp->req_rsp_sense) - rlen);
3441 XS_SET_RESID(xs, sp->req_fcp_residual);
3479 cont = totslen - slen;
3488 isp_destroy_handle(isp, sp->req_handle);
3501 if (optr != isp->isp_resodx) {
3503 isp->isp_resodx = optr;
3512 uint16_t chan;
3518 isp->isp_state = ISP_CRASHED;
3519 for (chan = 0; chan < isp->isp_nchan; chan++) {
3520 FCPARAM(isp, chan)->isp_loopstate = LOOP_NIL;
3521 isp_change_fw_state(isp, chan, FW_CONFIG_WAIT);
3527 if (isp->isp_mboxbsy) {
3528 isp->isp_obits = 1;
3529 isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
3530 isp->isp_mboxbsy = 0;
3559 for (chan = 0; chan < isp->isp_nchan; chan++) {
3560 fcp = FCPARAM(isp, chan);
3561 int topo = fcp->isp_topo;
3563 if (fcp->role == ISP_ROLE_NONE)
3565 if (fcp->isp_loopstate > LOOP_HAVE_LINK)
3566 fcp->isp_loopstate = LOOP_HAVE_LINK;
3567 ISP_SET_SENDMARKER(isp, chan, 1);
3568 isp_async(isp, ISPASYNC_LIP, chan);
3570 isp_target_async(isp, chan, mbox);
3585 hdp = &isp->isp_xflist[i];
3586 if (ISP_H2HT(hdp->handle) != ISP_HANDLE_INITIATOR) {
3589 xs = hdp->cmd;
3590 if (XS_CHANNEL(xs) != chan) {
3602 isp_prt(isp, ISP_LOGERR, lipd, chan, j);
3613 for (chan = 0; chan < isp->isp_nchan; chan++) {
3614 fcp = FCPARAM(isp, chan);
3615 if (fcp->role == ISP_ROLE_NONE)
3617 fcp->isp_linkstate = 1;
3618 if (fcp->isp_loopstate < LOOP_HAVE_LINK)
3619 fcp->isp_loopstate = LOOP_HAVE_LINK;
3620 ISP_SET_SENDMARKER(isp, chan, 1);
3621 isp_async(isp, ISPASYNC_LOOP_UP, chan);
3623 isp_target_async(isp, chan, mbox);
3633 for (chan = 0; chan < isp->isp_nchan; chan++) {
3634 fcp = FCPARAM(isp, chan);
3635 if (fcp->role == ISP_ROLE_NONE)
3637 ISP_SET_SENDMARKER(isp, chan, 1);
3638 fcp->isp_linkstate = 0;
3639 fcp->isp_loopstate = LOOP_NIL;
3640 isp_async(isp, ISPASYNC_LOOP_DOWN, chan);
3642 isp_target_async(isp, chan, mbox);
3652 for (chan = 0; chan < isp->isp_nchan; chan++) {
3653 fcp = FCPARAM(isp, chan);
3654 if (fcp->role == ISP_ROLE_NONE)
3656 ISP_SET_SENDMARKER(isp, chan, 1);
3657 if (fcp->isp_loopstate > LOOP_HAVE_LINK)
3658 fcp->isp_loopstate = LOOP_HAVE_LINK;
3659 isp_async(isp, ISPASYNC_LOOP_RESET, chan);
3661 isp_target_async(isp, chan, mbox);
3674 chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
3675 if (chan == 0xff || nphdl == NIL_HANDLE) {
3676 chan = 0;
3677 echan = isp->isp_nchan - 1;
3678 } else if (chan >= isp->isp_nchan) {
3681 echan = chan;
3684 chan = echan = 0;
3686 for (; chan <= echan; chan++) {
3687 fcp = FCPARAM(isp, chan);
3688 if (fcp->role == ISP_ROLE_NONE)
3690 if (fcp->isp_loopstate > LOOP_LTEST_DONE) {
3692 nphdl == fcp->isp_login_hdl &&
3695 fcp->isp_loopstate = LOOP_LTEST_DONE;
3696 } else if (fcp->isp_loopstate < LOOP_HAVE_LINK)
3697 fcp->isp_loopstate = LOOP_HAVE_LINK;
3698 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
3710 chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
3711 if (chan >= isp->isp_nchan)
3714 chan = 0;
3716 fcp = FCPARAM(isp, chan);
3717 if (fcp->role == ISP_ROLE_NONE)
3719 if (fcp->isp_loopstate > LOOP_LTEST_DONE)
3720 fcp->isp_loopstate = LOOP_LTEST_DONE;
3721 else if (fcp->isp_loopstate < LOOP_HAVE_LINK)
3722 fcp->isp_loopstate = LOOP_HAVE_LINK;
3723 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
3749 isp_prt(isp, ISP_LOGDEBUG0, "Inter-driver communication complete");
3752 isp_prt(isp, ISP_LOGDEBUG0, "Inter-driver communication notification");
3755 isp_prt(isp, ISP_LOGDEBUG0, "Inter-driver communication time extended");
3788 switch (hp->rqs_entry_type) {
3820 int chan, c;
3827 for (chan = 0; chan < isp->isp_nchan; chan++) {
3828 fcp = FCPARAM(isp, chan);
3829 if (fcp->role == ISP_ROLE_NONE)
3831 c = (chan == 0) ? 127 : (chan - 1);
3833 chan == 0) {
3834 fcp->isp_loopstate = LOOP_HAVE_LINK;
3836 chan, ISPASYNC_CHANGE_OTHER);
3838 fcp->isp_loopstate = LOOP_NIL;
3840 chan);
3847 fcp->isp_topo = (rid.ridacq_map[0] >> 9) & 0x7;
3848 fcp->isp_portid = portid;
3849 fcp->isp_loopstate = LOOP_HAVE_ADDR;
3853 fcp->isp_loopstate = LOOP_NIL;
3864 int chan = XS_CHANNEL(xs);
3866 switch (sp->req_completion_status) {
3884 FCPARAM(isp, chan)->sendmarker = 1;
3891 FCPARAM(isp, chan)->sendmarker = 1;
3903 XS_SET_RESID(xs, sp->req_resid);
3910 isp_prt(isp, ISP_LOGERR, "Chan %d data reassembly error for target %d", chan, XS_TGT(xs));
3916 isp_prt(isp, ISP_LOGERR, "Chan %d target %d sent ABTS", chan, XS_TGT(xs));
3922 ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
3925 * if we got a non-zero status.
3927 sv_marked = (sp->req_scsi_status & (RQCS_SV|RQCS_RV)) != 0;
3929 (sp->req_resid > XS_XFRLEN(xs))) {
3930 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
3935 XS_SET_RESID(xs, sp->req_resid);
3936 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Data Underrun (%d) for command 0x%x", sp->req_resid, XS_CDBP(xs)[0] & 0xff);
3946 uint8_t sts = sp->req_completion_status & 0xff;
3951 * It was there (maybe)- treat as a selection timeout.
3959 isp_prt(isp, ISP_LOGINFO, "Chan %d port %s for target %d",
3960 chan, reason, XS_TGT(xs));
3965 lp = &fcp->portdb[XS_TGT(xs)];
3966 if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
3975 isp_prt(isp, ISP_LOGWARN, "port changed for target %d chan %d", XS_TGT(xs), chan);
3983 isp_prt(isp, ISP_LOGWARN, "f/w resource unavailable for target %d chan %d", XS_TGT(xs), chan);
3991 isp_prt(isp, ISP_LOGWARN, "command for target %d overlapped task management for chan %d", XS_TGT(xs), chan);
3999 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x on chan %d", sp->req_completion_status, chan);
4130 ISP_FC_OPMAP_HALF(0x03, 0xcf, 0x00, 0x07), /* 0x75: GET PORT/NODE NAME LIST */
4152 "NO-OP", /* 00h */
4251 "GET FC-AL POSITION MAP",
4258 "GET PORT NAME",
4269 "GET PORT/NODE NAME LIST",
4288 opcode = mbp->param[0];
4290 mbp->param[0] = MBOX_INVALID_COMMAND;
4306 ibits |= mbp->ibits;
4307 obits |= mbp->obits;
4312 ibits &= mbp->ibitm;
4313 obits &= mbp->obitm;
4317 mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
4325 mbp->param[box]);
4326 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
4328 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
4331 isp->isp_obits = obits;
4332 isp->isp_mboxbsy = 1;
4342 to = (mbp->timeout == 0) ? MBCMD_DEFAULT_TIMEOUT : mbp->timeout;
4344 if (!isp->isp_mboxbsy)
4347 if (!isp->isp_mboxbsy)
4355 if (isp->isp_mboxbsy) {
4356 isp->isp_mboxbsy = 0;
4358 opcode, to, mbp->func, mbp->lineno);
4359 mbp->param[0] = MBOX_TIMEOUT;
4368 mbp->param[box] = isp->isp_mboxtmp[box];
4370 mbp->param[box]);
4375 if (mbp->logval == 0 || mbp->param[0] == MBOX_COMMAND_COMPLETE)
4378 if ((mbp->param[0] & 0xbfe0) == 0 &&
4379 (mbp->logval & MBLOGMASK(mbp->param[0])) == 0)
4384 switch (mbp->param[0]) {
4397 mbp->param[1]);
4434 ISP_SNPRINTF(mname, sizeof(mname), "error 0x%x", mbp->param[0]);
4445 isp_fw_state(ispsoftc_t *isp, int chan)
4457 isp_setdfltfcparm(ispsoftc_t *isp, int chan)
4459 fcparam *fcp = FCPARAM(isp, chan);
4464 fcp->role = DEFAULT_ROLE(isp, chan);
4465 fcp->isp_retry_delay = ICB_DFLT_RDELAY;
4466 fcp->isp_retry_count = ICB_DFLT_RCOUNT;
4467 fcp->isp_loopid = DEFAULT_LOOPID(isp, chan);
4468 fcp->isp_wwnn_nvram = DEFAULT_NODEWWN(isp, chan);
4469 fcp->isp_wwpn_nvram = DEFAULT_PORTWWN(isp, chan);
4470 fcp->isp_fwoptions = 0;
4471 fcp->isp_xfwoptions = 0;
4472 fcp->isp_zfwoptions = 0;
4473 fcp->isp_lasthdl = NIL_HANDLE;
4474 fcp->isp_login_hdl = NIL_HANDLE;
4476 fcp->isp_fwoptions |= ICB2400_OPT1_FAIRNESS;
4477 fcp->isp_fwoptions |= ICB2400_OPT1_HARD_ADDRESS;
4478 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
4479 fcp->isp_fwoptions |= ICB2400_OPT1_FULL_DUPLEX;
4480 fcp->isp_fwoptions |= ICB2400_OPT1_BOTH_WWNS;
4481 fcp->isp_xfwoptions |= ICB2400_OPT2_LOOP_2_PTP;
4482 fcp->isp_zfwoptions |= ICB2400_OPT3_RATE_AUTO;
4488 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
4500 isp->isp_confopts |= ISP_CFG_NONVRAM;
4504 fcp->isp_wwnn = ACTIVE_NODEWWN(isp, chan);
4505 fcp->isp_wwpn = ACTIVE_PORTWWN(isp, chan);
4506 isp_prt(isp, ISP_LOGCONFIG, "Chan %d 0x%08x%08x/0x%08x%08x Role %s",
4507 chan, (uint32_t) (fcp->isp_wwnn >> 32), (uint32_t) (fcp->isp_wwnn),
4508 (uint32_t) (fcp->isp_wwpn >> 32), (uint32_t) (fcp->isp_wwpn),
4509 isp_class3_roles[fcp->role]);
4513 * Re-initialize the ISP and complete all orphaned commands
4523 if (isp->isp_state > ISP_RESETSTATE)
4525 if (isp->isp_state != ISP_RESETSTATE)
4527 if (isp->isp_state != ISP_RESETSTATE) {
4534 if (isp->isp_state > ISP_RESETSTATE &&
4535 isp->isp_state != ISP_RUNSTATE) {
4543 for (i = 0; i < isp->isp_nchan; i++)
4556 return (fcp->flash_data_addr + faddr);
4601 uint32_t base = fcp->flash_data_addr;
4626 addr = fcp->flt_region_flt;
4640 retval = -1;
4655 fcp->flt_length = le16toh((uint16_t) (ISP2XXX_FLT_LENGTH(flthdr_data)));
4658 if ((fcp->flt_length == 0) ||
4659 (fcp->flt_length > (FLT_HEADER_SIZE + FLT_REGIONS_SIZE))) {
4662 fcp->flt_length, fcp->flt_length);
4666 ver, fcp->flt_length, fcp->flt_length, csum);
4674 int len = fcp->flt_length - FLT_HEADER_SIZE;
4677 fcp->flt_region_entries = len / FLT_REGION_SIZE;
4679 addr = fcp->flt_region_flt + (FLT_HEADER_SIZE >> 2);
4682 fcp->flt_region_entries);
4695 struct flt_region region[fcp->flt_region_entries];
4697 for (count = 0; count < fcp->flt_region_entries; count++) {
4718 fcp->flt_region_fw = region[count].start;
4721 fcp->flt_region_boot = region[count].start;
4724 fcp->flt_region_vpd_nvram = region[count].start;
4725 if (isp->isp_port == 0)
4726 fcp->flt_region_vpd = region[count].start;
4729 if (isp->isp_port == 1)
4730 fcp->flt_region_vpd = region[count].start;
4735 if (isp->isp_port == 2)
4736 fcp->flt_region_vpd = region[count].start;
4741 if (isp->isp_port == 3)
4742 fcp->flt_region_vpd = region[count].start;
4745 if (isp->isp_port == 0)
4746 fcp->flt_region_nvram = region[count].start;
4749 if (isp->isp_port == 1)
4750 fcp->flt_region_nvram = region[count].start;
4755 if (isp->isp_port == 2)
4756 fcp->flt_region_nvram = region[count].start;
4761 if (isp->isp_port == 3)
4762 fcp->flt_region_nvram = region[count].start;
4765 fcp->flt_region_fdt = region[count].start;
4768 fcp->flt_region_flt = region[count].start;
4771 if (isp->isp_port == 0)
4772 fcp->flt_region_npiv_conf = region[count].start;
4775 if (isp->isp_port == 1)
4776 fcp->flt_region_npiv_conf = region[count].start;
4779 fcp->flt_region_gold_fw = region[count].start;
4782 if (isp->isp_port == 0)
4783 fcp->flt_region_fcp_prio = region[count].start;
4786 if (isp->isp_port == 1)
4787 fcp->flt_region_fcp_prio = region[count].start;
4791 fcp->flt_region_img_status_pri = region[count].start;
4795 fcp->flt_region_img_status_sec = region[count].start;
4799 fcp->flt_region_fw_sec = region[count].start;
4803 fcp->flt_region_boot_sec = region[count].start;
4807 fcp->flt_region_aux_img_status_pri = region[count].start;
4811 fcp->flt_region_aux_img_status_sec = region[count].start;
4815 if (isp->isp_port == 0)
4816 fcp->flt_region_nvram_sec = region[count].start;
4820 if (isp->isp_port == 1)
4821 fcp->flt_region_nvram_sec = region[count].start;
4825 if (isp->isp_port == 2)
4826 fcp->flt_region_nvram_sec = region[count].start;
4830 if (isp->isp_port == 3)
4831 fcp->flt_region_nvram_sec = region[count].start;
4836 fcp->flt_region_vpd_nvram_sec = region[count].start;
4837 if (isp->isp_port == 0)
4838 fcp->flt_region_vpd_sec = region[count].start;
4844 if (isp->isp_port == 1)
4845 fcp->flt_region_vpd_sec = region[count].start;
4850 if (isp->isp_port == 2)
4851 fcp->flt_region_vpd_sec = region[count].start;
4856 if (isp->isp_port == 3)
4857 fcp->flt_region_vpd_sec = region[count].start;
4864 fcp->flt_region_boot, fcp->flt_region_fw, fcp->flt_region_vpd_nvram,
4865 fcp->flt_region_vpd, fcp->flt_region_nvram, fcp->flt_region_fdt,
4866 fcp->flt_region_flt, fcp->flt_region_npiv_conf,
4867 fcp->flt_region_fcp_prio);
4873 isp_print_image(ispsoftc_t *isp, char *name, struct isp_image_status *image_status)
4877 name, "status",
4878 image_status->image_status_mask,
4879 le16toh(image_status->generation),
4880 image_status->ver_major,
4881 image_status->ver_minor,
4882 image_status->bitmap,
4883 le32toh(image_status->checksum),
4884 le32toh(image_status->signature));
4890 unsigned long signature = le32toh(image_status->signature);
4898 unsigned long signature = le32toh(image_status->signature);
4911 for ( ; n--; p++)
4920 return (aux->bitmap & bitmask ?
4927 active_regions->aux.board_config =
4930 active_regions->aux.vpd_nvram =
4933 active_regions->aux.npiv_config_0_1 =
4936 active_regions->aux.npiv_config_2_3 =
4939 active_regions->aux.nvme_params =
4950 le16toh(pri_image_status->generation) -
4951 le16toh(sec_image_status->generation);
4966 if (!fcp->flt_region_aux_img_status_pri) {
4973 fcp->flt_region_aux_img_status_pri,
4999 if (!fcp->flt_region_aux_img_status_sec) {
5006 fcp->flt_region_aux_img_status_sec,
5050 active_regions->aux.board_config,
5051 active_regions->aux.vpd_nvram,
5052 active_regions->aux.npiv_config_0_1,
5053 active_regions->aux.npiv_config_2_3,
5054 active_regions->aux.nvme_params);
5065 if (!fcp->flt_region_img_status_pri) {
5072 fcp->flt_region_img_status_pri, sizeof(pri_image_status) >> 2) !=
5100 if (!fcp->flt_region_img_status_sec) {
5107 fcp->flt_region_img_status_sec, sizeof(sec_image_status) >> 2) !=
5135 active_regions->global = ISP27XX_PRIMARY_IMAGE;
5138 if (!active_regions->global ||
5141 active_regions->global = ISP27XX_SECONDARY_IMAGE;
5146 active_regions->global == ISP27XX_DEFAULT_IMAGE ?
5148 active_regions->global == ISP27XX_PRIMARY_IMAGE ?
5150 active_regions->global == ISP27XX_SECONDARY_IMAGE ?
5152 active_regions->global);
5168 MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
5171 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
5172 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
5175 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
5176 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
5205 dcode = isp->isp_rquest;
5208 snprintf(fcp->fw_version_flash, sizeof(fcp->fw_version_flash),
5218 fcp->fw_flashrev[i] = be32toh(dcode[4 + i]);
5219 snprintf(fcp->fw_version_flash, sizeof(fcp->fw_version_flash),
5220 "%u.%u.%u", fcp->fw_flashrev[0], fcp->fw_flashrev[1],
5221 fcp->fw_flashrev[2]);
5224 fcp->fw_flashrev[0], fcp->fw_flashrev[1],
5225 fcp->fw_flashrev[2], fcp->fw_flashrev[3]);
5228 if (isp->isp_osinfo.ispfw != NULL) {
5231 if (ISP_FW_NEWER_THANX(fcp->fw_ispfwrev, fcp->fw_flashrev)) {
5235 if (isp->isp_confopts & ISP_CFG_FWLOAD_FORCE) {
5252 dcode = isp->isp_rquest;
5266 "Loading fragment %u: 0x%x <- 0x%x (0x%lx dwords)",
5283 risc_size -= dlen;
5311 rval = isp_load_risc_flash(isp, srisc_addr, fcp->flt_region_fw_sec);
5317 rval = isp_load_risc_flash(isp, srisc_addr, fcp->flt_region_fw);
5333 addr = fcp->flt_region_nvram;
5337 addr = fcp->flt_region_nvram_sec;
5352 retval = -1;
5363 retval = -1;
5392 fcp->isp_wwpn_nvram = wwn;
5400 if (wwn == 0 && (fcp->isp_wwpn_nvram >> 60) == 2) {
5401 wwn = fcp->isp_wwpn_nvram;
5404 fcp->isp_wwnn_nvram = wwn;
5406 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
5410 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
5411 fcp->isp_loopid = ISP2400_NVRAM_HARDLOOPID(nvram_data);
5413 fcp->isp_fwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data);
5414 fcp->isp_xfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data);
5415 fcp->isp_zfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data);