Lines Matching defs:isp
54 #include <dev/isp/isp_freebsd.h>
127 isp_change_fw_state(ispsoftc_t *isp, int chan, int state)
129 fcparam *fcp = FCPARAM(isp, chan);
133 isp_prt(isp, ISP_LOGCONFIG|ISP_LOG_SANCFG,
148 isp_reset(ispsoftc_t *isp, int do_load_defaults)
158 isp->isp_state = ISP_NILSTATE;
159 ISP_DISABLE_INTS(isp);
165 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_HOST_INT);
166 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
167 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
169 switch (isp->isp_type) {
189 ISP_WRITE(isp, BIU2400_CSR, BIU2400_DMA_STOP|(3 << 4));
192 val = ISP_READ(isp, BIU2400_CSR);
198 isp_prt(isp, ISP_LOGERR, "DMA Failed to Stop on Reset");
203 ISP_WRITE(isp, BIU2400_CSR, BIU2400_SOFT_RESET|BIU2400_DMA_STOP|(3 << 4));
207 val = ISP_READ(isp, OUTMAILBOX0);
215 isp_prt(isp, ISP_LOGERR, "The ROM code is busy after 50ms.");
218 isp_prt(isp, ISP_LOGERR, "Board configuration error.");
221 isp_prt(isp, ISP_LOGERR, "Unknown RISC Status Code 0x%x.", val);
228 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
229 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RELEASE);
230 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RESET);
237 val = ISP_READ(isp, OUTMAILBOX0);
245 isp_prt(isp, ISP_LOGERR, "The ROM code is busy after 50ms.");
248 isp_prt(isp, ISP_LOGERR, "Board configuration error.");
251 isp_prt(isp, ISP_LOGERR, "Unknown RISC Status Code 0x%x.", val);
255 isp->isp_reqidx = isp->isp_reqodx = 0;
256 isp->isp_resodx = 0;
257 isp->isp_atioodx = 0;
258 ISP_WRITE(isp, BIU2400_REQINP, 0);
259 ISP_WRITE(isp, BIU2400_REQOUTP, 0);
260 ISP_WRITE(isp, BIU2400_RSPINP, 0);
261 ISP_WRITE(isp, BIU2400_RSPOUTP, 0);
262 if (!IS_26XX(isp)) {
263 ISP_WRITE(isp, BIU2400_PRI_REQINP, 0);
264 ISP_WRITE(isp, BIU2400_PRI_REQOUTP, 0);
266 ISP_WRITE(isp, BIU2400_ATIO_RSPINP, 0);
267 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, 0);
280 isp_mboxcmd(isp, &mbs);
282 isp_prt(isp, ISP_LOGERR, "NOP command failed (%x)", mbs.param[0]);
300 int nmbox = ISP_NMBOX(isp);
305 isp_mboxcmd(isp, &mbs);
311 isp_prt(isp, ISP_LOGERR, "Register Test Failed at Register %d: should have 0x%04x but got 0x%04x", i, patterns[i], mbs.param[i]);
326 if ((isp->isp_mdvec->dv_ispfw == NULL) || (isp->isp_confopts & ISP_CFG_NORELOAD)) {
335 if (ISP_MBOXDMASETUP(isp) != 0) {
336 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
344 const uint32_t *ptr = isp->isp_mdvec->dv_ispfw;
352 isp_prt(isp, ISP_LOGDEBUG0, "load 0x%x words of code at load address 0x%x", ptr[3], ptr[2]);
361 nw = min(wl, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) / 4);
362 cp = isp->isp_rquest;
364 ISP_IOXPUT_32(isp, ptr[wi + i], &cp[i]);
365 MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
368 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
369 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
372 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
373 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
375 isp_prt(isp, ISP_LOGDEBUG0, "LOAD RISC RAM %u words at load address 0x%x", nw, la);
376 isp_mboxcmd(isp, &mbs);
378 isp_prt(isp, ISP_LOGERR, "F/W download failed");
392 } else if (IS_26XX(isp)) {
393 isp_prt(isp, ISP_LOGDEBUG1, "loading firmware from flash");
397 isp_mboxcmd(isp, &mbs);
399 isp_prt(isp, ISP_LOGERR, "Flash F/W load failed");
403 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
413 isp_mboxcmd(isp, &mbs);
415 isp_prt(isp, ISP_LOGERR, dcrc);
429 if (!IS_26XX(isp))
431 isp_mboxcmd(isp, &mbs);
440 isp_mboxcmd(isp, &mbs);
445 isp->isp_fwrev[0] = mbs.param[1];
446 isp->isp_fwrev[1] = mbs.param[2];
447 isp->isp_fwrev[2] = mbs.param[3];
448 isp->isp_fwattr = mbs.param[6];
449 isp->isp_fwattr |= ((uint64_t) mbs.param[15]) << 16;
450 if (isp->isp_fwattr & ISP2400_FW_ATTR_EXTNDED) {
451 isp->isp_fwattr |=
456 isp_prt(isp, ISP_LOGCONFIG, "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
457 btype, isp->isp_revision, dodnld? "loaded" : "resident", isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
459 fwt = isp->isp_fwattr;
460 buf = FCPARAM(isp, 0)->isp_scanscratch;
547 isp_prt(isp, ISP_LOGCONFIG, "%s", buf);
555 isp_mboxcmd(isp, &mbs);
558 isp->isp_maxcmds = MIN(mbs.param[3], ISP_HANDLE_MAX - ISP_HANDLE_RESERVE);
559 isp_prt(isp, ISP_LOGCONFIG, "%d max I/O command limit set", isp->isp_maxcmds);
566 if (isp->isp_nchan > 1) {
567 if (!ISP_CAP_MULTI_ID(isp)) {
568 isp_prt(isp, ISP_LOGWARN, "non-MULTIID f/w loaded, "
569 "only can enable 1 of %d channels", isp->isp_nchan);
570 isp->isp_nchan = 1;
571 } else if (!ISP_CAP_VP0(isp)) {
572 isp_prt(isp, ISP_LOGWARN, "We can not use MULTIID "
574 isp->isp_nchan = 1;
581 if (ISP_MBOXDMASETUP(isp) != 0) {
582 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
589 if (ISP_IRQSETUP(isp) != 0) {
590 isp_prt(isp, ISP_LOGERR, "Cannot setup IRQ");
593 ISP_ENABLE_INTS(isp);
595 for (i = 0; i < isp->isp_nchan; i++)
596 isp_change_fw_state(isp, i, FW_CONFIG_WAIT);
598 isp->isp_state = ISP_RESETSTATE;
606 for (i = 0; i < isp->isp_nchan; i++)
607 isp_setdfltfcparm(isp, i);
615 isp_stop(ispsoftc_t *isp)
619 isp->isp_state = ISP_NILSTATE;
629 isp_mboxcmd(isp, &mbs);
637 isp_shutdown(ispsoftc_t *isp)
640 if (isp->isp_state >= ISP_RESETSTATE)
641 isp_stop(isp);
642 ISP_DISABLE_INTS(isp);
643 ISP_WRITE(isp, BIU2400_ICR, 0);
644 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
653 isp_init(ispsoftc_t *isp)
664 for (chan = 0; chan < isp->isp_nchan; chan++) {
665 fcp = FCPARAM(isp, chan);
670 if (chan == isp->isp_nchan) {
671 isp_prt(isp, ISP_LOG_WARN1, "all %d channels with role 'none'", chan);
675 isp->isp_state = ISP_INITSTATE;
680 fcp = FCPARAM(isp, 0);
687 isp_mboxcmd(isp, &mbs);
696 if (isp->isp_nchan > 1 && ISP_CAP_VP0(isp)) {
711 icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
713 isp_prt(isp, ISP_LOGERR, "bad frame length (%d) from NVRAM- using %d", DEFAULT_FRAMESIZE(isp), ICB_DFLT_FRMLEN);
717 if (!IS_26XX(isp))
726 icbp->icb_xchgcnt = MIN(isp->isp_maxcmds / 2, ATPDPSIZE);
728 icbp->icb_xchgcnt = isp->isp_maxcmds;
732 ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
742 if (isp->isp_confopts & ISP_CFG_NOFCTAPE) {
745 if (isp->isp_confopts & ISP_CFG_FCTAPE) {
749 for (chan = 0; chan < isp->isp_nchan; chan++) {
751 FCPARAM(isp, chan)->fctape_enabled = 1;
753 FCPARAM(isp, chan)->fctape_enabled = 0;
756 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
793 isp_prt(isp, ISP_LOGWARN, "bad value %x in fwopt2 timer field", icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK);
798 if (IS_26XX(isp)) {
807 if (isp->isp_confopts & ISP_CFG_1GB) {
810 } else if (isp->isp_confopts & ISP_CFG_2GB) {
813 } else if (isp->isp_confopts & ISP_CFG_4GB) {
816 } else if (isp->isp_confopts & ISP_CFG_8GB) {
819 } else if (isp->isp_confopts & ISP_CFG_16GB) {
822 } else if (isp->isp_confopts & ISP_CFG_32GB) {
834 if (isp->isp_type <= ISP_HA_FC_2500)
838 if (isp->isp_type <= ISP_HA_FC_2400)
856 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)),
861 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)));
863 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
866 icbp->icb_rspnsin = isp->isp_resodx;
867 icbp->icb_rqstout = isp->isp_reqidx;
870 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
872 isp_prt(isp, ISP_LOGERR, "bad request queue length %d", icbp->icb_rqstqlen);
875 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
877 isp_prt(isp, ISP_LOGERR, "bad result queue length %d",
881 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
882 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
883 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
884 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
886 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
887 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
888 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
889 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
893 icbp->icb_atio_in = isp->isp_atioodx;
894 icbp->icb_atioqlen = ATIO_QUEUE_LEN(isp);
896 isp_prt(isp, ISP_LOGERR, "bad ATIO queue length %d", icbp->icb_atioqlen);
899 icbp->icb_atioqaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_atioq_dma);
900 icbp->icb_atioqaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_atioq_dma);
901 icbp->icb_atioqaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_atioq_dma);
902 icbp->icb_atioqaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_atioq_dma);
903 isp_prt(isp, ISP_LOGDEBUG0, "isp_init: atioq %04x%04x%04x%04x", DMA_WD3(isp->isp_atioq_dma), DMA_WD2(isp->isp_atioq_dma),
904 DMA_WD1(isp->isp_atioq_dma), DMA_WD0(isp->isp_atioq_dma));
907 if (ISP_CAP_MSIX(isp) && isp->isp_nirq >= 2) {
909 if (IS_26XX(isp) && isp->isp_nirq >= 3)
913 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);
915 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),
916 DMA_WD1(isp->isp_rquest_dma), DMA_WD0(isp->isp_rquest_dma), DMA_WD3(isp->isp_result_dma), DMA_WD2(isp->isp_result_dma),
917 DMA_WD1(isp->isp_result_dma), DMA_WD0(isp->isp_result_dma));
919 if (FC_SCRATCH_ACQUIRE(isp, 0)) {
920 isp_prt(isp, ISP_LOGERR, sacq);
924 isp_put_icb_2400(isp, icbp, fcp->isp_scratch);
925 if (isp->isp_dblev & ISP_LOGDEBUG1) {
926 isp_print_bytes(isp, "isp_init",
933 if (isp->isp_nchan > 1) {
940 if (ISP_CAP_VP0(isp)) {
942 vpinfo.vp_count = isp->isp_nchan;
945 vpinfo.vp_count = isp->isp_nchan - 1;
951 isp_put_icb_2400_vpinfo(isp, &vpinfo, vdst);
953 for (; chan < isp->isp_nchan; chan++) {
957 fcp2 = FCPARAM(isp, chan);
967 if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
975 if (ISP_CAP_VP0(isp))
980 isp_put_vp_port_info(isp, &pi, pdst);
983 if (isp->isp_dblev & ISP_LOGDEBUG1) {
984 isp_print_bytes(isp, "isp_init",
994 if (isp->isp_nchan > 1) {
1004 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));
1005 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp), 0);
1006 isp_mboxcmd(isp, &mbs);
1007 FC_SCRATCH_RELEASE(isp, 0);
1016 isp->isp_state = ISP_RUNSTATE;
1020 isp_fc_enable_vp(ispsoftc_t *isp, int chan)
1022 fcparam *fcp = FCPARAM(isp, chan);
1041 if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
1047 retval = isp_exec_entry_queue(isp, &vp, &vp, 5);
1049 isp_prt(isp, ISP_LOGERR, "%s: VP_MODIFY of chan %d error %d",
1055 isp_prt(isp, ISP_LOGERR,
1064 isp_fc_disable_vp(ispsoftc_t *isp, int chan)
1073 if (ISP_CAP_VP0(isp)) {
1083 retval = isp_exec_entry_queue(isp, &vp, &vp, 5);
1085 isp_prt(isp, ISP_LOGERR, "%s: VP_CTRL of chan %d error %d",
1091 isp_prt(isp, ISP_LOGERR,
1101 isp_fc_change_role(ispsoftc_t *isp, int chan, int new_role)
1103 fcparam *fcp = FCPARAM(isp, chan);
1106 if (chan >= isp->isp_nchan) {
1107 isp_prt(isp, ISP_LOGWARN, "%s: bad channel %d", __func__, chan);
1112 for (was = 0, i = 0; i < isp->isp_nchan; i++) {
1113 if (FCPARAM(isp, i)->role != ISP_ROLE_NONE)
1118 return (isp_reinit(isp, 0));
1121 res = isp_fc_disable_vp(isp, chan);
1122 isp_clear_portdb(isp, chan);
1126 res = isp_fc_enable_vp(isp, chan);
1131 isp_clear_portdb(ispsoftc_t *isp, int chan)
1133 fcparam *fcp = FCPARAM(isp, chan);
1144 isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
1159 isp_mark_portdb(ispsoftc_t *isp, int chan)
1161 fcparam *fcp = FCPARAM(isp, chan);
1181 isp_plogx(ispsoftc_t *isp, int chan, uint16_t handle, uint32_t portid, int flags)
1189 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d PLOGX %s PortID 0x%06x nphdl 0x%x",
1202 retval = isp_exec_entry_queue(isp, &pl, &pl, 3 * ICB_LOGIN_TOV);
1204 isp_prt(isp, ISP_LOGERR, "%s: PLOGX of chan %d error %d",
1212 isp_prt(isp, ISP_LOGWARN,
1285 isp_prt(isp, lev, "Chan %d PLOGX PortID 0x%06x to N-Port handle 0x%x: %s",
1292 isp_getpdb(ispsoftc_t *isp, int chan, uint16_t id, isp_pdb_t *pdb)
1303 mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
1304 mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
1305 mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
1306 mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
1308 MEMORYBARRIER(isp, SYNC_IFORDEV, 0, sizeof(un), chan);
1310 isp_mboxcmd(isp, &mbs);
1314 MEMORYBARRIER(isp, SYNC_IFORCPU, 0, sizeof(un), chan);
1315 isp_get_pdb_24xx(isp, isp->isp_iocb, &un.bill);
1322 isp_prt(isp, ISP_LOGDEBUG0,
1335 isp_gethandles(ispsoftc_t *isp, int chan, uint16_t *handles, int *num, int loop)
1337 fcparam *fcp = FCPARAM(isp, chan);
1350 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
1351 isp_prt(isp, ISP_LOGERR, sacq);
1354 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, ISP_FC_SCRLEN, chan);
1355 isp_mboxcmd(isp, &mbs);
1357 FC_SCRATCH_RELEASE(isp, chan);
1360 MEMORYBARRIER(isp, SYNC_SFORCPU, 0, ISP_FC_SCRLEN, chan);
1363 isp_get_pnhle_24xx(isp, &elp4[i], &el4);
1370 FC_SCRATCH_RELEASE(isp, chan);
1375 isp_dump_chip_portdb(ispsoftc_t *isp, int chan)
1380 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d chip port dump", chan);
1382 if (isp_getpdb(isp, chan, nphdl, &pdb)) {
1385 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d Handle 0x%04x "
1394 isp_get_wwn(ispsoftc_t *isp, int chan, int nphdl, int nodename)
1405 isp_mboxcmd(isp, &mbs);
1425 isp_fclink_test(ispsoftc_t *isp, int chan, int usdelay)
1433 fcp = FCPARAM(isp, chan);
1440 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test", chan);
1447 isp_change_fw_state(isp, chan, isp_fw_state(isp, chan));
1456 ISP_SLEEP(isp, 1000);
1459 isp_prt(isp, ISP_LOG_SANCFG,
1470 isp_mboxcmd(isp, &mbs);
1500 r = isp_getpdb(isp, chan, NPH_FL_ID, &pdb);
1502 isp_prt(isp, ISP_LOGWARN,
1510 r = isp_register_fc4_type(isp, chan);
1515 r = isp_register_fc4_features_24xx(isp, chan);
1520 r = isp_register_port_name_24xx(isp, chan);
1525 isp_register_node_name_24xx(isp, chan);
1536 isp_mboxcmd(isp, &mbs);
1556 isp_prt(isp, ISP_LOG_SANCFG,
1561 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG,
1564 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG,
1568 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test done", chan);
1584 isp_pdb_sync(ispsoftc_t *isp, int chan)
1586 fcparam *fcp = FCPARAM(isp, chan);
1595 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync", chan);
1609 isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
1611 (void) isp_plogx(isp, chan, lp->handle,
1624 isp_async(isp, ISPASYNC_DEV_ARRIVED, chan, lp);
1628 isp_async(isp, ISPASYNC_DEV_CHANGED, chan, lp);
1634 isp_async(isp, ISPASYNC_DEV_STAYED, chan, lp);
1639 isp_prt(isp, ISP_LOGWARN,
1642 isp_dump_portdb(isp, chan);
1647 isp_prt(isp, ISP_LOG_SANCFG,
1653 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync done", chan);
1658 isp_pdb_add_update(ispsoftc_t *isp, int chan, isp_pdb_t *pdb)
1667 if (isp_find_pdb_by_wwpn(isp, chan, wwpn, &lp)) {
1669 isp_prt(isp, ISP_LOGERR,
1672 FC_PORTDB_TGT(isp, chan, lp), lp->state);
1673 isp_dump_portdb(isp, chan);
1687 isp_prt(isp, ISP_LOG_SANCFG,
1699 isp_prt(isp, ISP_LOG_SANCFG,
1706 if (!isp_find_pdb_empty(isp, chan, &lp)) {
1707 isp_prt(isp, ISP_LOGERR, "Chan %d out of portdb entries", chan);
1720 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Port 0x%06x@0x%04x is new",
1728 isp_scan_loop(ispsoftc_t *isp, int chan)
1730 fcparam *fcp = FCPARAM(isp, chan);
1741 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan", chan);
1744 isp_prt(isp, ISP_LOG_SANCFG,
1752 r = isp_gethandles(isp, chan, handles, &lim, 1);
1754 isp_prt(isp, ISP_LOG_SANCFG,
1756 isp_prt(isp, ISP_LOG_SANCFG,
1761 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Got %d handles",
1767 isp_mark_portdb(isp, chan);
1780 r = isp_getpdb(isp, chan, handle, &pdb);
1783 isp_prt(isp, ISP_LOG_SANCFG,
1788 isp_prt(isp, ISP_LOGDEBUG1,
1794 isp_pdb_add_update(isp, chan, &pdb);
1799 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan done", chan);
1804 isp_ct_passthru(ispsoftc_t *isp, int chan, uint32_t cmd_bcnt, uint32_t rsp_bcnt)
1806 fcparam *fcp = FCPARAM(isp, chan);
1810 if (isp->isp_dblev & ISP_LOGDEBUG1)
1811 isp_print_bytes(isp, "CT request", cmd_bcnt, fcp->isp_scratch);
1821 pt.ctp_vpidx = ISP_GET_VPIDX(isp, chan);
1833 retval = isp_exec_entry_queue(isp, &pt, &pt, 2 * pt.ctp_time);
1835 isp_prt(isp, ISP_LOGERR, "%s: CTP of chan %d error %d",
1841 isp_prt(isp, ISP_LOGWARN,
1847 if (isp->isp_dblev & ISP_LOGDEBUG1)
1848 isp_print_bytes(isp, "CT response", rsp_bcnt, fcp->isp_scratch);
1865 isp_gid_pt(ispsoftc_t *isp, int chan)
1867 fcparam *fcp = FCPARAM(isp, chan);
1871 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GID_PT", chan);
1872 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
1873 isp_prt(isp, ISP_LOGERR, sacq);
1884 isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
1890 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t), GIDLEN)) {
1891 FC_SCRATCH_RELEASE(isp, chan);
1895 isp_get_gid_xx_response(isp, (sns_gid_xx_rsp_t *)scp,
1897 FC_SCRATCH_RELEASE(isp, chan);
1902 isp_gff_id(ispsoftc_t *isp, int chan, uint32_t portid)
1904 fcparam *fcp = FCPARAM(isp, chan);
1914 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFF_ID", chan);
1915 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
1916 isp_prt(isp, ISP_LOGERR, sacq);
1927 isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
1929 ISP_IOZPUT_32(isp, portid, rp);
1931 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
1933 FC_SCRATCH_RELEASE(isp, chan);
1937 isp_get_gff_id_response(isp, (sns_gff_id_rsp_t *)scp, &rsp);
1949 if (((ISP_SWAP32(isp, rsp.snscb_fc4_features[FC4_SCSI / 8]) >>
1953 FC_SCRATCH_RELEASE(isp, chan);
1954 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFF_ID result is %d", chan, res);
1959 isp_gft_id(ispsoftc_t *isp, int chan, uint32_t portid)
1961 fcparam *fcp = FCPARAM(isp, chan);
1971 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFT_ID", chan);
1972 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
1973 isp_prt(isp, ISP_LOGERR, sacq);
1984 isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
1986 ISP_IOZPUT_32(isp, portid, rp);
1988 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
1990 FC_SCRATCH_RELEASE(isp, chan);
1994 isp_get_gft_id_response(isp, (sns_gft_id_rsp_t *)scp, &rsp);
2006 FC_SCRATCH_RELEASE(isp, chan);
2007 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFT_ID result is %d", chan, res);
2012 isp_scan_fabric(ispsoftc_t *isp, int chan)
2014 fcparam *fcp = FCPARAM(isp, chan);
2026 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan", chan);
2030 isp_prt(isp, ISP_LOG_SANCFG,
2037 FC_SCRATCH_RELEASE(isp, chan);
2038 isp_prt(isp, ISP_LOG_SANCFG,
2046 r = isp_getpdb(isp, chan, NPH_FL_ID, &pdb);
2048 isp_dump_chip_portdb(isp, chan);
2053 isp_prt(isp, ISP_LOG_SANCFG,
2059 r = isp_gid_pt(isp, chan);
2083 isp_prt(isp, level, "Chan %d Fabric Nameserver rejected GID_PT"
2097 isp_prt(isp, ISP_LOGWARN,
2101 isp_prt(isp, ISP_LOG_SANCFG,
2127 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d removing duplicate PortID 0x%06x entry from list", chan, portid);
2145 isp_mark_portdb(isp, chan);
2150 isp_prt(isp, ISP_LOG_SANCFG,
2153 isp_prt(isp, ISP_LOG_SANCFG,
2159 isp_prt(isp, ISP_LOG_SANCFG,
2165 if (isp_find_pdb_by_portid(isp, chan, portid, &lp)) {
2167 isp_prt(isp, ISP_LOGERR,
2170 FC_PORTDB_TGT(isp, chan, lp), lp->state);
2171 isp_dump_portdb(isp, chan);
2193 r = isp_getpdb(isp, chan, lp->handle, &pdb);
2198 isp_prt(isp, ISP_LOG_SANCFG,
2204 isp_pdb_add_update(isp, chan, &pdb);
2210 isp_prt(isp, ISP_LOG_SANCFG,
2215 r = isp_gff_id(isp, chan, portid);
2217 isp_prt(isp, ISP_LOG_SANCFG,
2222 r = isp_gft_id(isp, chan, portid);
2224 isp_prt(isp, ISP_LOG_SANCFG,
2229 if (isp_login_device(isp, chan, portid, &pdb,
2230 &FCPARAM(isp, 0)->isp_lasthdl)) {
2236 isp_pdb_add_update(isp, chan, &pdb);
2242 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan done", chan);
2250 isp_login_device(ispsoftc_t *isp, int chan, uint32_t portid, isp_pdb_t *p, uint16_t *ohp)
2255 handle = isp_next_handle(isp, ohp);
2257 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
2261 r = isp_getpdb(isp, chan, handle, p);
2265 handle = isp_next_handle(isp, ohp);
2270 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
2276 r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
2285 if (isp_plogx(isp, chan, r >> 16, portid, PLOGX_FLG_CMD_LOGO | PLOGX_FLG_IMPLICIT | PLOGX_FLG_FREE_NPHDL)) {
2286 isp_prt(isp, ISP_LOGERR, "baw... logout of %x failed", r >> 16);
2288 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
2290 r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
2296 handle = isp_next_handle(isp, ohp);
2305 isp_prt(isp, ISP_LOGWARN, "Chan %d PLOGI 0x%06x failed", chan, portid);
2314 r = isp_getpdb(isp, chan, handle, p);
2316 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x disappeared", chan, portid, handle);
2321 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x changed (0x%06x@0x%0x)",
2329 isp_register_fc4_type(ispsoftc_t *isp, int chan)
2331 fcparam *fcp = FCPARAM(isp, chan);
2336 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2337 isp_prt(isp, ISP_LOGERR, sacq);
2352 isp_put_rft_id(isp, &rp, (rft_id_t *)scp);
2354 if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
2355 FC_SCRATCH_RELEASE(isp, chan);
2359 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
2360 FC_SCRATCH_RELEASE(isp, chan);
2362 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "Chan %d Register FC4 Type rejected", chan);
2365 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Register FC4 Type accepted", chan);
2367 isp_prt(isp, ISP_LOGWARN, "Chan %d Register FC4 Type: 0x%x", chan, ct->ct_cmd_resp);
2374 isp_register_fc4_features_24xx(ispsoftc_t *isp, int chan)
2376 fcparam *fcp = FCPARAM(isp, chan);
2381 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2382 isp_prt(isp, ISP_LOGERR, sacq);
2405 isp_put_rff_id(isp, &rp, (rff_id_t *)scp);
2406 if (isp->isp_dblev & ISP_LOGDEBUG1)
2407 isp_print_bytes(isp, "CT request", sizeof(rft_id_t), scp);
2409 if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
2410 FC_SCRATCH_RELEASE(isp, chan);
2414 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
2415 FC_SCRATCH_RELEASE(isp, chan);
2417 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
2421 isp_prt(isp, ISP_LOG_SANCFG,
2424 isp_prt(isp, ISP_LOGWARN,
2432 isp_register_port_name_24xx(ispsoftc_t *isp, int chan)
2434 fcparam *fcp = FCPARAM(isp, chan);
2440 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2441 isp_prt(isp, ISP_LOGERR, sacq);
2464 ":%s", device_get_nameunit(isp->isp_dev));
2471 isp_put_rspn_id(isp, &rp, (rspn_id_t *)scp);
2473 if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
2474 FC_SCRATCH_RELEASE(isp, chan);
2478 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
2479 FC_SCRATCH_RELEASE(isp, chan);
2481 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
2485 isp_prt(isp, ISP_LOG_SANCFG,
2488 isp_prt(isp, ISP_LOGWARN,
2496 isp_register_node_name_24xx(ispsoftc_t *isp, int chan)
2498 fcparam *fcp = FCPARAM(isp, chan);
2504 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2505 isp_prt(isp, ISP_LOGERR, sacq);
2527 isp_put_rsnn_nn(isp, &rp, (rsnn_nn_t *)scp);
2529 if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
2530 FC_SCRATCH_RELEASE(isp, chan);
2534 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
2535 FC_SCRATCH_RELEASE(isp, chan);
2537 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
2541 isp_prt(isp, ISP_LOG_SANCFG,
2544 isp_prt(isp, ISP_LOGWARN,
2552 isp_next_handle(ispsoftc_t *isp, uint16_t *ohp)
2568 isp_prt(isp, ISP_LOGERR, "Out of port handles!");
2574 for (chan = 0; chan < isp->isp_nchan; chan++) {
2575 fcp = FCPARAM(isp, chan);
2595 ispsoftc_t *isp;
2604 isp = XS_ISP(xs);
2614 isp_prt(isp, ISP_LOGERR, "unsupported cdb length (%d, CDB[0]=0x%x)", XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
2624 fcp = FCPARAM(isp, XS_CHANNEL(xs));
2627 isp_prt(isp, ISP_LOG_WARN1,
2634 if (isp->isp_state != ISP_RUNSTATE) {
2635 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
2640 isp_prt(isp, ISP_LOGDEBUG2, "XS_TGT(xs)=%d", target);
2648 isp_prt(isp, ISP_LOGDEBUG1,
2654 isp_prt(isp, ISP_LOGDEBUG1,
2660 isp_prt(isp, ISP_LOGDEBUG1,
2669 qep = isp_getrqentry(isp);
2671 isp_prt(isp, ISP_LOG_WARN1, "Request Queue Overflow");
2683 if (ISP_TST_SENDMARKER(isp, XS_CHANNEL(xs))) {
2689 isp_put_marker_24xx(isp, m, qep);
2690 ISP_SYNC_REQUEST(isp);
2691 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 0);
2700 isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
2720 if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
2721 if (FCP_NEXT_CRN(isp, &reqp->req_crn, xs)) {
2722 isp_prt(isp, ISP_LOG_WARN1,
2733 reqp->req_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(xs));
2736 reqp->req_handle = isp_allocate_handle(isp, xs, ISP_HANDLE_INITIATOR);
2738 isp_prt(isp, ISP_LOG_WARN1, "out of xflist pointers");
2749 dmaresult = ISP_DMASETUP(isp, xs, reqp);
2751 isp_destroy_handle(isp, reqp->req_handle);
2758 isp_xs_prt(isp, xs, ISP_LOGDEBUG0, "START cmd cdb[0]=0x%x datalen %ld", XS_CDBP(xs)[0], (long) XS_XFRLEN(xs));
2763 * isp control
2768 isp_control(ispsoftc_t *isp, ispctl_t ctl, ...)
2784 isp_prt(isp, ISP_LOGERR, "BUS RESET NOT IMPLEMENTED");
2796 fcp = FCPARAM(isp, chan);
2799 isp_prt(isp, ISP_LOGWARN, "Chan %d trying to reset bad target %d", chan, tgt);
2804 isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
2818 tmf->tmf_vpidx = ISP_GET_VPIDX(isp, chan);
2820 isp_prt(isp, ISP_LOGALL, "Chan %d Reset N-Port Handle 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
2823 if (isp_exec_entry_mbox(isp, tmf, sp, 2 * tmf->tmf_timeout))
2828 isp_prt(isp, ISP_LOGWARN, "Chan %d reset of target %d returned 0x%x", chan, tgt, sp->req_completion_status);
2842 handle = isp_find_handle(isp, xs);
2844 isp_prt(isp, ISP_LOGWARN, "cannot find handle for command to abort");
2848 fcp = FCPARAM(isp, chan);
2850 isp_prt(isp, ISP_LOGWARN, "Chan %d trying to abort bad target %d", chan, tgt);
2855 isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
2858 isp_prt(isp, ISP_LOGALL, "Chan %d Abort Cmd for N-Port 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
2866 ab->abrt_vpidx = ISP_GET_VPIDX(isp, chan);
2868 if (isp_exec_entry_mbox(isp, ab, ab, 5))
2873 isp_prt(isp, ISP_LOGWARN, "Chan %d handle %d abort returned 0x%x", chan, tgt, ab->abrt_nphdl);
2885 return (isp_fclink_test(isp, chan, usdelay));
2892 return (isp_scan_fabric(isp, chan));
2899 return (isp_scan_loop(isp, chan));
2906 return (isp_pdb_sync(isp, chan));
2919 return (isp_getpdb(isp, chan, tgt, pdb));
2934 *wwnn = isp_get_wwn(isp, chan, tgt, 1);
2940 *wwnp = isp_get_wwn(isp, chan, tgt, 0);
2952 isp_mboxcmd(isp, mbr);
2965 return (isp_plogx(isp, p->channel, p->handle, p->portid, p->flags));
2968 isp_next_handle(isp, &p->handle);
2969 r = isp_plogx(isp, p->channel, p->handle, p->portid, p->flags);
2986 return (isp_fc_change_role(isp, chan, role));
2989 isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
3005 isp_intr_atioq(ispsoftc_t *isp)
3010 iptr = ISP_READ(isp, BIU2400_ATIO_RSPINP);
3011 optr = isp->isp_atioodx;
3014 MEMORYBARRIER(isp, SYNC_ATIOQ, oop, QENTRY_LEN, -1);
3015 addr = ISP_QUEUE_ENTRY(isp->isp_atioq, oop);
3021 (void) isp_target_notify(isp, addr, &oop,
3022 ATIO_QUEUE_LEN(isp));
3026 isp_print_qentry(isp, "?ATIOQ entry?", oop, addr);
3029 optr = ISP_NXT_QENTRY(oop, ATIO_QUEUE_LEN(isp));
3031 if (isp->isp_atioodx != optr) {
3032 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, optr);
3033 isp->isp_atioodx = optr;
3039 isp_intr_mbox(ispsoftc_t *isp, uint16_t mbox0)
3043 if (!isp->isp_mboxbsy) {
3044 isp_prt(isp, ISP_LOGWARN, "mailbox 0x%x with no waiters", mbox0);
3047 obits = isp->isp_obits;
3048 isp->isp_mboxtmp[0] = mbox0;
3049 for (i = 1; i < ISP_NMBOX(isp); i++) {
3052 isp->isp_mboxtmp[i] = ISP_READ(isp, MBOX_OFF(i));
3054 isp->isp_mboxbsy = 0;
3058 isp_intr_respq(ispsoftc_t *isp)
3072 if (isp->isp_state != ISP_RUNSTATE) {
3073 isp_prt(isp, ISP_LOGINFO, "respq interrupt when not ready");
3077 iptr = ISP_READ(isp, BIU2400_RSPINP);
3078 optr = isp->isp_resodx;
3081 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, cptr);
3082 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
3087 MEMORYBARRIER(isp, SYNC_RESULT, cptr, QENTRY_LEN, -1);
3088 if (isp->isp_dblev & ISP_LOGDEBUG1)
3089 isp_print_qentry(isp, "Response Queue Entry", cptr, hp);
3090 isp_get_hdr(isp, hp, &sp->req_header);
3097 isp_print_qentry(isp, "invalid entry type", cptr, hp);
3101 isp_print_qentry(isp, "invalid entry parameter", cptr, hp);
3105 isp_print_qentry(isp, "invalid entry count", cptr, hp);
3109 isp_print_qentry(isp, "invalid entry order", cptr, hp);
3121 if (isp_handle_control(isp, hp)) {
3128 isp_get_24xx_response(isp, (isp24xx_statusreq_t *)hp, sp);
3131 isp_prt(isp, ISP_LOG_WARN1, "Marker Response");
3135 isp_get_cont_response(isp, (ispstatus_cont_t *)hp, scp);
3143 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
3148 isp_prt(isp, ISP_LOG_WARN1, "Ignored Continuation Response");
3157 isp_target_notify(isp, hp, &cptr, RESULT_QUEUE_LEN(isp));
3161 sptr = ISP_NXT_QENTRY(sptr, RESULT_QUEUE_LEN(isp));
3162 hp = (isphdr_t *)ISP_QUEUE_ENTRY(isp->isp_result, sptr);
3165 optr = ISP_NXT_QENTRY(cptr, RESULT_QUEUE_LEN(isp));
3169 isp_handle_rpt_id_acq(isp, hp);
3174 isp_prt(isp, ISP_LOGERR, notresp, etype, cptr, optr);
3179 xs = isp_find_xs(isp, sp->req_handle);
3187 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (status 0x%x)",
3233 isp_xs_prt(isp, xs, ISP_LOGWARN,
3240 isp_parse_status_24xx(isp, sp, xs);
3246 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
3252 ISP_DMAFREE(isp, xs);
3253 isp_destroy_handle(isp, sp->req_handle);
3266 if (optr != isp->isp_resodx) {
3267 ISP_WRITE(isp, BIU2400_RSPOUTP, optr);
3268 isp->isp_resodx = optr;
3274 isp_intr_async(ispsoftc_t *isp, uint16_t mbox)
3279 isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
3283 isp->isp_state = ISP_CRASHED;
3284 for (chan = 0; chan < isp->isp_nchan; chan++) {
3285 FCPARAM(isp, chan)->isp_loopstate = LOOP_NIL;
3286 isp_change_fw_state(isp, chan, FW_CONFIG_WAIT);
3292 if (isp->isp_mboxbsy) {
3293 isp->isp_obits = 1;
3294 isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
3295 isp->isp_mboxbsy = 0;
3301 isp_async(isp, ISPASYNC_FW_CRASH);
3305 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
3309 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
3313 isp_prt(isp, ISP_LOGERR, "ATIO Queue Transfer Error");
3324 for (chan = 0; chan < isp->isp_nchan; chan++) {
3325 fcp = FCPARAM(isp, chan);
3332 ISP_SET_SENDMARKER(isp, chan, 1);
3333 isp_async(isp, ISPASYNC_LIP, chan);
3335 isp_target_async(isp, chan, mbox);
3346 for (i = j = 0; i < ISP_HANDLE_NUM(isp); i++) {
3350 hdp = &isp->isp_xflist[i];
3359 isp_prt(isp, ISP_LOG_WARN1,
3367 isp_prt(isp, ISP_LOGERR, lipd, chan, j);
3378 for (chan = 0; chan < isp->isp_nchan; chan++) {
3379 fcp = FCPARAM(isp, chan);
3385 ISP_SET_SENDMARKER(isp, chan, 1);
3386 isp_async(isp, ISPASYNC_LOOP_UP, chan);
3388 isp_target_async(isp, chan, mbox);
3398 for (chan = 0; chan < isp->isp_nchan; chan++) {
3399 fcp = FCPARAM(isp, chan);
3402 ISP_SET_SENDMARKER(isp, chan, 1);
3405 isp_async(isp, ISPASYNC_LOOP_DOWN, chan);
3407 isp_target_async(isp, chan, mbox);
3417 for (chan = 0; chan < isp->isp_nchan; chan++) {
3418 fcp = FCPARAM(isp, chan);
3421 ISP_SET_SENDMARKER(isp, chan, 1);
3424 isp_async(isp, ISPASYNC_LOOP_RESET, chan);
3426 isp_target_async(isp, chan, mbox);
3435 nphdl = ISP_READ(isp, OUTMAILBOX1);
3436 nlstate = ISP_READ(isp, OUTMAILBOX2);
3437 reason = ISP_READ(isp, OUTMAILBOX3) >> 8;
3438 if (ISP_CAP_MULTI_ID(isp)) {
3439 chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
3442 echan = isp->isp_nchan - 1;
3443 } else if (chan >= isp->isp_nchan) {
3452 fcp = FCPARAM(isp, chan);
3463 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
3472 portid = ((ISP_READ(isp, OUTMAILBOX1) & 0xff) << 16) |
3473 ISP_READ(isp, OUTMAILBOX2);
3474 if (ISP_CAP_MULTI_ID(isp)) {
3475 chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
3476 if (chan >= isp->isp_nchan)
3481 fcp = FCPARAM(isp, chan);
3488 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
3493 isp_prt(isp, ISP_LOGWARN, "Error logging disabled (reason 0x%x)",
3494 ISP_READ(isp, OUTMAILBOX1));
3497 isp_prt(isp, ISP_LOGWARN, "P2P init error (reason 0x%x)",
3498 ISP_READ(isp, OUTMAILBOX1));
3501 isp_prt(isp, ISP_LOGWARN, "Receive Error");
3504 isp_prt(isp, ISP_LOGTDEBUG0, "LS_RJT sent");
3507 isp_prt(isp, ISP_LOGDEBUG0, "FW restart complete");
3510 isp_prt(isp, ISP_LOGERR, "Temperature alert (subcode 0x%x)",
3511 ISP_READ(isp, OUTMAILBOX1));
3514 isp_prt(isp, ISP_LOGDEBUG0, "Inter-driver communication complete");
3517 isp_prt(isp, ISP_LOGDEBUG0, "Inter-driver communication notification");
3520 isp_prt(isp, ISP_LOGDEBUG0, "Inter-driver communication time extended");
3523 isp_prt(isp, ISP_LOGDEBUG0, "Transceiver insertion (0x%x)",
3524 ISP_READ(isp, OUTMAILBOX1));
3527 isp_prt(isp, ISP_LOGDEBUG0, "Transceiver removal");
3530 isp_prt(isp, ISP_LOGDEBUG0, "NIC Firmware State Change");
3533 isp_prt(isp, ISP_LOGDEBUG0, "Autoload FW init complete");
3536 isp_prt(isp, ISP_LOGERR, "Autoload FW init failure");
3539 isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
3548 isp_handle_control(ispsoftc_t *isp, isphdr_t *hp)
3566 ISP_IOXGET_32(isp, (uint32_t *)(hp + 1), hdl);
3569 ptr = isp_find_xs(isp, hdl);
3571 isp_destroy_handle(isp, hdl);
3581 isp_handle_rpt_id_acq(ispsoftc_t *isp, isphdr_t *hp)
3588 isp_get_ridacq(isp, (isp_ridacq_t *)hp, &rid);
3592 for (chan = 0; chan < isp->isp_nchan; chan++) {
3593 fcp = FCPARAM(isp, chan);
3600 isp_async(isp, ISPASYNC_CHANGE_NOTIFY,
3604 isp_async(isp, ISPASYNC_LOOP_DOWN,
3609 fcp = FCPARAM(isp, rid.ridacq_vp_index);
3615 isp_async(isp, ISPASYNC_CHANGE_NOTIFY,
3619 isp_async(isp, ISPASYNC_LOOP_DOWN,
3626 isp_parse_status_24xx(ispsoftc_t *isp, isp24xx_statusreq_t *sp, XS_T *xs)
3636 isp_xs_prt(isp, xs, ISP_LOGERR, "DMA error");
3642 isp_xs_prt(isp, xs, ISP_LOGERR, "Transport Error");
3648 isp_xs_prt(isp, xs, ISP_LOGWARN, "reset destroyed command");
3649 FCPARAM(isp, chan)->sendmarker = 1;
3655 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
3656 FCPARAM(isp, chan)->sendmarker = 1;
3662 isp_xs_prt(isp, xs, ISP_LOGWARN, "Command Timed Out");
3669 isp_xs_prt(isp, xs, ISP_LOGERR, "Data Overrun");
3675 isp_prt(isp, ISP_LOGERR, "Chan %d data reassembly error for target %d", chan, XS_TGT(xs));
3681 isp_prt(isp, ISP_LOGERR, "Chan %d target %d sent ABTS", chan, XS_TGT(xs));
3695 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
3701 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Data Underrun (%d) for command 0x%x", sp->req_resid, XS_CDBP(xs)[0] & 0xff);
3712 fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
3724 isp_prt(isp, ISP_LOGINFO, "Chan %d port %s for target %d",
3740 isp_prt(isp, ISP_LOGWARN, "port changed for target %d chan %d", XS_TGT(xs), chan);
3748 isp_prt(isp, ISP_LOGWARN, "f/w resource unavailable for target %d chan %d", XS_TGT(xs), chan);
3756 isp_prt(isp, ISP_LOGWARN, "command for target %d overlapped task management for chan %d", XS_TGT(xs), chan);
3764 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x on chan %d", sp->req_completion_status, chan);
4047 isp_mboxcmd(ispsoftc_t *isp, mbreg_t *mbp)
4056 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
4066 isp_prt(isp, ISP_LOGDEBUG3, "Mailbox Command '%s'", cname);
4083 isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
4087 for (box = 0; box < ISP_NMBOX(isp); box++) {
4089 isp_prt(isp, ISP_LOGDEBUG3, "IN mbox %d = 0x%04x", box,
4091 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
4093 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
4096 isp->isp_obits = obits;
4097 isp->isp_mboxbsy = 1;
4102 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
4109 if (!isp->isp_mboxbsy)
4111 ISP_RUN_ISR(isp);
4112 if (!isp->isp_mboxbsy)
4120 if (isp->isp_mboxbsy) {
4121 isp->isp_mboxbsy = 0;
4122 isp_prt(isp, ISP_LOGWARN, "Mailbox Command (0x%x) Timeout (%uus) (%s:%d)",
4131 for (box = 0; box < ISP_NMBOX(isp); box++) {
4133 mbp->param[box] = isp->isp_mboxtmp[box];
4134 isp_prt(isp, ISP_LOGDEBUG3, "OUT mbox %d = 0x%04x", box,
4204 isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s%s)",
4210 isp_fw_state(ispsoftc_t *isp, int chan)
4215 isp_mboxcmd(isp, &mbs);
4222 isp_setdfltfcparm(ispsoftc_t *isp, int chan)
4224 fcparam *fcp = FCPARAM(isp, chan);
4229 fcp->role = DEFAULT_ROLE(isp, chan);
4232 fcp->isp_loopid = DEFAULT_LOOPID(isp, chan);
4233 fcp->isp_wwnn_nvram = DEFAULT_NODEWWN(isp, chan);
4234 fcp->isp_wwpn_nvram = DEFAULT_PORTWWN(isp, chan);
4243 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
4253 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
4259 j = isp_read_nvram(isp, chan);
4265 isp->isp_confopts |= ISP_CFG_NONVRAM;
4269 fcp->isp_wwnn = ACTIVE_NODEWWN(isp, chan);
4270 fcp->isp_wwpn = ACTIVE_PORTWWN(isp, chan);
4271 isp_prt(isp, ISP_LOGCONFIG, "Chan %d 0x%08x%08x/0x%08x%08x Role %s",
4284 isp_reinit(ispsoftc_t *isp, int do_load_defaults)
4288 if (isp->isp_state > ISP_RESETSTATE)
4289 isp_stop(isp);
4290 if (isp->isp_state != ISP_RESETSTATE)
4291 isp_reset(isp, do_load_defaults);
4292 if (isp->isp_state != ISP_RESETSTATE) {
4294 isp_prt(isp, ISP_LOGERR, "%s: cannot reset card", __func__);
4298 isp_init(isp);
4299 if (isp->isp_state > ISP_RESETSTATE &&
4300 isp->isp_state != ISP_RUNSTATE) {
4302 isp_prt(isp, ISP_LOGERR, "%s: cannot init card", __func__);
4303 ISP_DISABLE_INTS(isp);
4307 isp_clear_commands(isp);
4308 for (i = 0; i < isp->isp_nchan; i++)
4309 isp_clear_portdb(isp, i);
4317 isp_read_nvram(ispsoftc_t *isp, int bus)
4320 return (isp_read_nvram_2400(isp));
4324 isp_read_nvram_2400(ispsoftc_t *isp)
4330 if (isp->isp_port) {
4338 isp_rd_2400_nvram(isp, addr++, dptr++);
4342 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header (%x %x %x)",
4350 ISP_IOXGET_32(isp, &dptr[lwrds], tmp);
4354 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
4358 isp_parse_nvram_2400(isp, nvram_data);
4364 isp_rd_2400_nvram(ispsoftc_t *isp, uint32_t addr, uint32_t *rp)
4370 if (IS_26XX(isp)) {
4372 } else if (IS_25XX(isp)) {
4375 ISP_WRITE(isp, BIU2400_FLASH_ADDR, base | addr);
4378 tmp = ISP_READ(isp, BIU2400_FLASH_ADDR);
4384 *rp = ISP_READ(isp, BIU2400_FLASH_DATA);
4385 ISP_SWIZZLE_NVRAM_LONG(isp, rp);
4392 isp_parse_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
4394 fcparam *fcp = FCPARAM(isp, 0);
4397 isp_prt(isp, ISP_LOGDEBUG0,
4404 isp_prt(isp, ISP_LOGDEBUG0,
4426 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
4427 DEFAULT_FRAMESIZE(isp) =
4430 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {