Lines Matching refs:isp
34 #include <dev/isp/isp_freebsd.h>
40 #include <dev/isp/isp_ioctl.h>
45 MODULE_VERSION(isp, 1);
46 MODULE_DEPEND(isp, cam, 1, 1, 1);
54 static void isp_loop_changed(ispsoftc_t *isp, int chan);
70 .d_name = "isp",
76 ispsoftc_t *isp = (ispsoftc_t *)arg1;
80 value = FCPARAM(isp, chan)->role;
89 ISP_LOCK(isp);
90 old = FCPARAM(isp, chan)->role;
97 ISP_UNLOCK(isp);
102 error = isp_control(isp, ISPCTL_CHANGE_ROLE, chan, value);
103 ISP_UNLOCK(isp);
108 isp_attach_chan(ispsoftc_t *isp, struct cam_devq *devq, int chan)
110 fcparam *fcp = FCPARAM(isp, chan);
111 struct isp_fc *fc = ISP_FC_PC(isp, chan);
112 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(isp->isp_osinfo.dev);
113 struct sysctl_oid *tree = device_get_sysctl_tree(isp->isp_osinfo.dev);
121 sim = cam_sim_alloc(isp_action, isp_poll, "isp", isp,
122 device_get_unit(isp->isp_dev), &isp->isp_lock,
123 isp->isp_maxcmds, isp->isp_maxcmds, devq);
127 if (xpt_bus_register(sim, isp->isp_dev, chan) != CAM_SUCCESS) {
137 ISP_LOCK(isp);
140 fc->isp = isp;
145 callout_init_mtx(&fc->gdt, &isp->isp_lock, 0);
158 isp_loop_changed(isp, chan);
159 ISP_UNLOCK(isp);
161 "%s_%d", device_get_nameunit(isp->isp_osinfo.dev), chan)) {
193 isp, chan, isp_role_sysctl, "I", "Current role");
228 isp_detach_chan(ispsoftc_t *isp, int chan)
230 struct isp_fc *fc = ISP_FC_PC(isp, chan);
239 mtx_sleep(&fc->num_threads, &isp->isp_lock, PRIBIO, "isp_reap", 0);
243 isp_attach(ispsoftc_t *isp)
245 const char *nu = device_get_nameunit(isp->isp_osinfo.dev);
246 int du = device_get_unit(isp->isp_dev);
252 isp->isp_osinfo.devq = cam_simq_alloc(isp->isp_maxcmds);
253 if (isp->isp_osinfo.devq == NULL) {
257 for (chan = 0; chan < isp->isp_nchan; chan++) {
258 if (isp_attach_chan(isp, isp->isp_osinfo.devq, chan)) {
263 callout_init_mtx(&isp->isp_osinfo.tmo, &isp->isp_lock, 0);
265 callout_reset(&isp->isp_osinfo.tmo, isp_timer_count, isp_timer, isp);
267 isp->isp_osinfo.cdev = make_dev(&isp_cdevsw, du, UID_ROOT, GID_OPERATOR, 0600, "%s", nu);
268 if (isp->isp_osinfo.cdev) {
269 isp->isp_osinfo.cdev->si_drv1 = isp;
274 ISP_LOCK(isp);
275 isp->isp_osinfo.is_exiting = 1;
277 isp_detach_chan(isp, chan);
278 ISP_UNLOCK(isp);
279 cam_simq_free(isp->isp_osinfo.devq);
280 isp->isp_osinfo.devq = NULL;
285 isp_detach(ispsoftc_t *isp)
289 if (isp->isp_osinfo.cdev) {
290 destroy_dev(isp->isp_osinfo.cdev);
291 isp->isp_osinfo.cdev = NULL;
293 ISP_LOCK(isp);
295 isp->isp_osinfo.is_exiting = 1;
296 for (chan = isp->isp_nchan - 1; chan >= 0; chan -= 1)
297 isp_detach_chan(isp, chan);
298 ISP_UNLOCK(isp);
299 callout_drain(&isp->isp_osinfo.tmo);
300 cam_simq_free(isp->isp_osinfo.devq);
305 isp_freeze_loopdown(ispsoftc_t *isp, int chan)
307 struct isp_fc *fc = ISP_FC_PC(isp, chan);
312 isp_prt(isp, ISP_LOGDEBUG0,
318 isp_prt(isp, ISP_LOGDEBUG0,
325 isp_unfreeze_loopdown(ispsoftc_t *isp, int chan)
327 struct isp_fc *fc = ISP_FC_PC(isp, chan);
334 isp_prt(isp, ISP_LOGDEBUG0,
346 isp_rq_check_above(ispsoftc_t *isp)
348 struct isp_fc *fc = ISP_FC_PC(isp, 0);
350 if (isp->isp_rqovf || fc->sim == NULL)
352 if (!isp_rqentry_avail(isp, QENTRY_MAX)) {
354 isp->isp_rqovf = 1;
359 isp_rq_check_below(ispsoftc_t *isp)
361 struct isp_fc *fc = ISP_FC_PC(isp, 0);
363 if (!isp->isp_rqovf || fc->sim == NULL)
365 if (isp_rqentry_avail(isp, QENTRY_MAX)) {
367 isp->isp_rqovf = 0;
374 ispsoftc_t *isp;
377 isp = dev->si_drv1;
382 int olddblev = isp->isp_dblev;
383 isp->isp_dblev = *(int *)addr;
390 if (chan < 0 || chan >= isp->isp_nchan) {
394 *(int *)addr = FCPARAM(isp, chan)->role;
400 if (chan < 0 || chan >= isp->isp_nchan) {
409 ISP_LOCK(isp);
410 *(int *)addr = FCPARAM(isp, chan)->role;
411 retval = isp_control(isp, ISPCTL_CHANGE_ROLE, chan, nr);
412 ISP_UNLOCK(isp);
416 ISP_LOCK(isp);
417 isp_reinit(isp, 0);
418 ISP_UNLOCK(isp);
424 if (chan < 0 || chan >= isp->isp_nchan) {
428 ISP_LOCK(isp);
429 if (isp_fc_runstate(isp, chan, 5 * 1000000) != LOOP_READY) {
434 ISP_UNLOCK(isp);
439 if (chan < 0 || chan >= isp->isp_nchan) {
443 ISP_LOCK(isp);
444 if (isp_control(isp, ISPCTL_SEND_LIP, chan)) {
449 ISP_UNLOCK(isp);
460 lp = &FCPARAM(isp, ifc->chan)->portdb[ifc->loopid];
478 if (chan < 0 || chan >= isp->isp_nchan) {
482 hba->fc_fw_major = ISP_FW_MAJORX(isp->isp_fwrev);
483 hba->fc_fw_minor = ISP_FW_MINORX(isp->isp_fwrev);
484 hba->fc_fw_micro = ISP_FW_MICROX(isp->isp_fwrev);
485 hba->fc_nchannels = isp->isp_nchan;
487 hba->fc_speed = FCPARAM(isp, hba->fc_channel)->isp_gbspeed;
488 hba->fc_topology = FCPARAM(isp, chan)->isp_topo + 1;
489 hba->fc_loopid = FCPARAM(isp, chan)->isp_loopid;
490 hba->nvram_node_wwn = FCPARAM(isp, chan)->isp_wwnn_nvram;
491 hba->nvram_port_wwn = FCPARAM(isp, chan)->isp_wwpn_nvram;
492 hba->active_node_wwn = FCPARAM(isp, chan)->isp_wwnn;
493 hba->active_port_wwn = FCPARAM(isp, chan)->isp_wwpn;
509 if (chan < 0 || chan >= isp->isp_nchan) {
516 ISP_LOCK(isp);
517 fcp = FCPARAM(isp, chan);
527 ISP_UNLOCK(isp);
538 tmf.tmf_vpidx = ISP_GET_VPIDX(isp, chan);
568 ISP_UNLOCK(isp);
572 retval = isp_exec_entry_queue(isp, &tmf, &sp, 5);
574 isp_prt(isp, ISP_LOGERR, "%s: TMF of chan %d error %d",
576 ISP_UNLOCK(isp);
584 ISP_UNLOCK(isp);
601 isp_get_pcmd(ispsoftc_t *isp, union ccb *ccb)
603 ISP_PCMD(ccb) = isp->isp_osinfo.pcmd_free;
607 isp->isp_osinfo.pcmd_free = ((struct isp_pcmd *)ISP_PCMD(ccb))->next;
612 isp_free_pcmd(ispsoftc_t *isp, union ccb *ccb)
618 PISP_PCMD(ccb)->next = isp->isp_osinfo.pcmd_free;
619 isp->isp_osinfo.pcmd_free = ISP_PCMD(ccb);
641 static void isp_complete_ctio(ispsoftc_t *isp, union ccb *);
651 get_lun_statep(ispsoftc_t *isp, int bus, lun_id_t lun)
653 struct isp_fc *fc = ISP_FC_PC(isp, bus);
664 isp_atio_restart(ispsoftc_t *isp, int bus, tstate_t *tptr)
675 isp_prt(isp, ISP_LOGTDEBUG0,
678 isp_handle_platform_atio7(isp, (at7_entry_t *) ntp->data);
679 isp_put_ntpd(isp, bus, ntp);
691 isp_tmcmd_restart(ispsoftc_t *isp)
698 for (bus = 0; bus < isp->isp_nchan; bus++) {
699 fc = ISP_FC_PC(isp, bus);
702 isp_atio_restart(isp, bus, tptr);
711 isp_target_start_ctio(isp, ccb, FROM_TIMER);
714 isp_rq_check_above(isp);
715 isp_rq_check_below(isp);
719 isp_get_atpd(ispsoftc_t *isp, int chan, uint32_t tag, void *ccb)
721 struct isp_fc *fc = ISP_FC_PC(isp, chan);
735 isp_find_atpd(ispsoftc_t *isp, int chan, uint32_t tag)
737 struct isp_fc *fc = ISP_FC_PC(isp, chan);
752 isp_find_atpd_ccb(ispsoftc_t *isp, int chan, uint32_t tag, void *ccb)
754 struct isp_fc *fc = ISP_FC_PC(isp, chan);
765 isp_put_atpd(ispsoftc_t *isp, int chan, atio_private_data_t *atp)
767 struct isp_fc *fc = ISP_FC_PC(isp, chan);
770 isp_put_ecmd(isp, atp->ests);
777 isp_dump_atpd(ispsoftc_t *isp, int chan)
779 struct isp_fc *fc = ISP_FC_PC(isp, chan);
786 isp_prt(isp, ISP_LOGALL, "Chan %d ATP [0x%x] origdlen %u bytes_xfrd %u lun %jx nphdl 0x%04x s_id 0x%06x d_id 0x%06x oxid 0x%04x state %s",
792 isp_get_ntpd(ispsoftc_t *isp, int chan)
794 struct isp_fc *fc = ISP_FC_PC(isp, chan);
804 isp_find_ntpd(ispsoftc_t *isp, int chan, uint32_t tag_id, uint32_t seq_id)
806 struct isp_fc *fc = ISP_FC_PC(isp, chan);
817 isp_put_ntpd(ispsoftc_t *isp, int chan, inot_private_data_t *ntp)
819 struct isp_fc *fc = ISP_FC_PC(isp, chan);
826 create_lun_state(ispsoftc_t *isp, int bus, struct cam_path *path)
828 struct isp_fc *fc = ISP_FC_PC(isp, bus);
841 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, path, "created tstate\n");
846 destroy_lun_state(ispsoftc_t *isp, int bus, tstate_t *tptr)
848 struct isp_fc *fc = ISP_FC_PC(isp, bus);
863 isp_endcmd(isp, ntp->data, NIL_HANDLE, bus, SCSI_STATUS_BUSY, 0);
865 isp_put_ntpd(isp, bus, ntp);
872 isp_enable_lun(ispsoftc_t *isp, union ccb *ccb)
883 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0|ISP_LOGCONFIG, ccb->ccb_h.path,
892 tptr = get_lun_statep(isp, bus, lun);
898 tptr = create_lun_state(isp, bus, ccb->ccb_h.path);
910 isp_disable_lun(ispsoftc_t *isp, union ccb *ccb)
917 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0|ISP_LOGCONFIG, ccb->ccb_h.path,
926 if ((tptr = get_lun_statep(isp, bus, lun)) == NULL) {
932 destroy_lun_state(isp, bus, tptr);
938 isp_target_start_ctio(ispsoftc_t *isp, union ccb *ccb, enum Start_Ctio_How how)
948 isp_prt(isp, ISP_LOGTDEBUG0, "%s: ENTRY[0x%x] how %u xfrlen %u sendstatus %d sense_len %u", __func__, ccb->csio.tag_id, how, ccb->csio.dxfer_len,
951 waitq = &ISP_FC_PC(isp, XS_CHANNEL(ccb))->waitq;
973 ISP_PATH_PRT(isp, ISP_LOGERR, ccb->ccb_h.path, "a data transfer length of zero but no status to send is wrong\n");
980 atp = isp_find_atpd(isp, XS_CHANNEL(ccb), cso->tag_id);
982 isp_prt(isp, ISP_LOGERR, "%s: [0x%x] cannot find private data adjunct in %s", __func__, cso->tag_id, __func__);
983 isp_dump_atpd(isp, XS_CHANNEL(ccb));
993 isp_prt(isp, ISP_LOGERR, "%s: [0x%x] not sending a CTIO for a dead command", __func__, cso->tag_id);
1002 fcp = FCPARAM(isp, XS_CHANNEL(ccb));
1004 isp_prt(isp, ISP_LOGERR, "%s: [0x%x] stopping sending a CTIO because we're no longer in target mode", __func__, cso->tag_id);
1015 isp_prt(isp, ISP_LOGTINFO, "[0x%x] handling only %d CCBs at a time (flags for this ccb: 0x%x)", cso->tag_id, ATPD_CCB_OUTSTANDING, ccb->ccb_h.flags);
1034 isp_prt(isp, ISP_LOGTDEBUG0, "[0x%x] now sending synthesized status orig_dl=%u xfered=%u bit=%u",
1069 isp_prt(isp, ISP_LOGERR,
1096 cto->ct_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(ccb));
1134 atp->ests = isp_get_ecmd(isp);
1158 isp_put_fcp_rsp_iu(isp, &rp, atp->ests);
1161 isp_put_fcp_rsp_iu(isp, &rp, atp->ests);
1163 if (isp->isp_dblev & ISP_LOGTDEBUG1) {
1164 isp_print_bytes(isp, "FCP Response Frame After Swizzling", MIN_FCP_RESPONSE_SIZE + sense_length, atp->ests);
1166 bus_dmamap_sync(isp->isp_osinfo.ecmd_dmat, isp->isp_osinfo.ecmd_map, BUS_DMASYNC_PREWRITE);
1167 addr = isp->isp_osinfo.ecmd_dma;
1168 addr += ((((isp_ecmd_t *)atp->ests) - isp->isp_osinfo.ecmd_base) * XCMD_SIZE);
1169 isp_prt(isp, ISP_LOGTDEBUG0, "%s: ests base %p vaddr %p ecmd_dma %jx addr %jx len %u", __func__, isp->isp_osinfo.ecmd_base, atp->ests,
1170 (uintmax_t) isp->isp_osinfo.ecmd_dma, (uintmax_t)addr, MIN_FCP_RESPONSE_SIZE + sense_length);
1177 isp_prt(isp, ISP_LOGTDEBUG0, "%s: CTIO7[0x%x] seq %u nc %d CDB0=%x sstatus=0x%x flags=0x%x resid=%d slen %u sense: %x %x/%x/%x", __func__,
1181 isp_prt(isp, ISP_LOGDEBUG0, "%s: CTIO7[0x%x] seq %u nc %d CDB0=%x sstatus=0x%x flags=0x%x resid=%d", __func__,
1202 if (ISP_FC_PC(isp, XS_CHANNEL(ccb))->inject_lost_data_frame && xfrlen > ISP_FC_PC(isp, XS_CHANNEL(ccb))->inject_lost_data_frame) {
1203 isp_prt(isp, ISP_LOGWARN, "%s: truncating data frame with xfrlen %d to %d", __func__, xfrlen, xfrlen - (xfrlen >> 2));
1204 ISP_FC_PC(isp, XS_CHANNEL(ccb))->inject_lost_data_frame = 0;
1224 isp_prt(isp, ISP_LOGTDEBUG0, "%s: CTIO7[0x%x] seq %u nc %d CDB0=%x sstatus=0x%x flags=0x%x xfrlen=%u off=%u", __func__,
1228 if (isp_get_pcmd(isp, ccb)) {
1229 ISP_PATH_PRT(isp, ISP_LOGWARN, ccb->ccb_h.path, "out of PCMDs\n");
1233 handle = isp_allocate_handle(isp, ccb, ISP_HANDLE_TARGET);
1235 ISP_PATH_PRT(isp, ISP_LOGWARN, ccb->ccb_h.path, "No XFLIST pointers for %s\n", __func__);
1237 isp_free_pcmd(isp, ccb);
1252 dmaresult = ISP_DMASETUP(isp, cso, cto);
1254 isp_destroy_handle(isp, handle);
1255 isp_free_pcmd(isp, ccb);
1279 ispsoftc_t *isp = tp->isp;
1281 ISP_ASSERT_LOCKED(isp);
1282 if (isp_notify_ack(isp, tp->not)) {
1291 isp_complete_ctio(ispsoftc_t *isp, union ccb *ccb)
1294 isp_rq_check_below(isp);
1300 isp_handle_platform_atio7(ispsoftc_t *isp, at7_entry_t *aep)
1317 if (ISP_CAP_MULTI_ID(isp) && isp->isp_nchan > 1) {
1319 isp_find_chan_by_did(isp, did, &chan);
1321 isp_prt(isp, ISP_LOGWARN,
1324 isp_endcmd(isp, aep, NIL_HANDLE, ISP_NOCHAN,
1335 if (isp_find_pdb_by_portid(isp, chan, sid, &lp) == 0) {
1339 isp_prt(isp, ISP_LOGTINFO, "%s: [RX_ID 0x%x] D_ID 0x%06x found on Chan %d for S_ID 0x%06x wasn't in PDB already",
1341 isp_dump_portdb(isp, chan);
1342 isp_endcmd(isp, aep, NIL_HANDLE, chan, ECMD_TERMINATE, 0);
1350 tptr = get_lun_statep(isp, chan, lun);
1352 tptr = get_lun_statep(isp, chan, CAM_LUN_WILDCARD);
1354 isp_prt(isp, ISP_LOGWARN,
1358 isp_endcmd(isp, aep, nphdl, chan, SCSI_STATUS_BUSY, 0);
1360 isp_endcmd(isp, aep, nphdl, chan, SCSI_STATUS_CHECK_COND | ECMD_SVALID | (0x5 << 12) | (0x25 << 16), 0);
1369 if (isp_atio_restart(isp, chan, tptr))
1376 isp_endcmd(isp, aep, nphdl, chan, SCSI_BUSY, 0);
1385 isp_prt(isp, ISP_LOGTDEBUG0, "[0x%x] out of atios", aep->at_rxid);
1389 oatp = isp_find_atpd(isp, chan, aep->at_rxid);
1391 isp_prt(isp, oatp->state == ATPD_STATE_LAST_CTIO ? ISP_LOGTDEBUG0 :
1400 atp = isp_get_atpd(isp, chan, aep->at_rxid, atiop);
1402 isp_prt(isp, ISP_LOGTDEBUG0, "[0x%x] out of atps", aep->at_rxid);
1403 isp_endcmd(isp, aep, nphdl, chan, SCSI_BUSY, 0);
1409 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, atiop->ccb_h.path, "Take FREE ATIO\n");
1410 atiop->init_id = FC_PORTDB_TGT(isp, chan, lp);
1411 atiop->ccb_h.target_id = ISP_MAX_TARGETS(isp);
1416 isp_prt(isp, ISP_LOGWARN, "additional CDBLEN ignored");
1458 isp_prt(isp, ISP_LOGTDEBUG0, "ATIO7[0x%x] CDB=0x%x lun %jx datalen %u",
1464 ntp = isp_get_ntpd(isp, chan);
1466 isp_endcmd(isp, aep, nphdl, chan, SCSI_STATUS_BUSY, 0);
1481 isp_handle_srr_start(ispsoftc_t *isp, atio_private_data_t *atp)
1493 isp_prt(isp, ISP_LOGWARN, "SRR[0x%x] null ccb", atp->tag);
1509 isp_prt(isp, ISP_LOGWARN, "SRR[0x%x] SRR offset 0x%x but current CCB doesn't transfer data", atp->tag, srr_off);
1513 isp_prt(isp, ISP_LOGWARN, "SRR[0x%x] SRR offset 0x%x not covered by current CCB data range [0x%x..0x%x]", atp->tag, srr_off, ccb_off, ccb_end);
1516 isp_prt(isp, ISP_LOGWARN, "SRR[0x%x] SRR offset 0x%x covered by current CCB data range [0x%x..0x%x]", atp->tag, srr_off, ccb_off, ccb_end);
1519 isp_prt(isp, ISP_LOGTINFO, "SRR[0x%x] Got an FCP RSP SRR- resending status", atp->tag);
1529 isp_prt(isp, ISP_LOGWARN, "Got an FCP DATA IN SRR- dropping");
1533 isp_prt(isp, ISP_LOGWARN, "Got an unknown information (%x) SRR- dropping", inot->in_srr_iu);
1542 if (isp_notify_ack(isp, inot)) {
1543 isp_prt(isp, ISP_LOGWARN, "could not push positive ack for SRR- you lose");
1546 isp_target_start_ctio(isp, ccb, FROM_SRR);
1550 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot);
1553 isp_complete_ctio(isp, ccb);
1556 if (isp_notify_ack(isp, inot)) {
1557 isp_prt(isp, ISP_LOGWARN, "could not push positive ack for SRR- you lose");
1574 isp_complete_ctio(isp, ccb);
1579 isp_handle_platform_srr(ispsoftc_t *isp, isp_notify_t *notify)
1585 atp = isp_find_atpd(isp, notify->nt_channel, tag);
1587 isp_prt(isp, ISP_LOGERR, "%s: cannot find adjunct for %x in SRR Notify",
1589 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot);
1594 isp_prt(isp, ISP_LOGTINFO, "SRR[0x%x] flags 0x%x srr_iu %x reloff 0x%x",
1598 isp_handle_srr_start(isp, atp);
1602 isp_handle_platform_ctio(ispsoftc_t *isp, ct7_entry_t *ct)
1611 ccb = isp_find_xs(isp, handle);
1613 isp_print_bytes(isp, "null ccb in isp_handle_platform_ctio", QENTRY_LEN, ct);
1616 isp_destroy_handle(isp, handle);
1618 isp_free_pcmd(isp, ccb);
1621 atp = isp_find_atpd(isp, bus, ct->ct_rxid);
1628 atp = isp_find_atpd(isp, bus, ccb->csio.tag_id);
1631 isp_prt(isp, ISP_LOGERR, "%s: cannot find adjunct for %x after I/O", __func__, ccb->csio.tag_id);
1642 isp_handle_srr_start(isp, atp);
1656 isp_prt(isp, ok? ISP_LOGTDEBUG0 : ISP_LOGWARN, "%s: CTIO7[%x] seq %u nc %d sts 0x%x flg 0x%x sns %d resid %d %s", __func__, ct->ct_rxid, ATPD_GET_SEQNO(ct),
1680 isp_prt(isp, ISP_LOGTDEBUG0, "%s CTIO[0x%x] done (ok=%d nc=%d nowsendstatus=%d ccb ss=%d)",
1684 isp_target_start_ctio(isp, ccb, FROM_CTIO_DONE);
1694 isp_put_atpd(isp, bus, atp);
1701 isp_complete_ctio(isp, ccb);
1705 isp_handle_platform_target_notify_ack(ispsoftc_t *isp, isp_notify_t *mp, uint32_t rsp)
1709 if (isp->isp_state != ISP_RUNSTATE) {
1710 isp_prt(isp, ISP_LOGTINFO, "Notify Code 0x%x (qevalid=%d) acked- h/w not ready (dropping)", mp->nt_ncode, mp->nt_lreserved != NULL);
1724 if (isp_find_pdb_by_portid(isp, mp->nt_channel, sid, &lp)) {
1749 return (isp_send_entry(isp, cto));
1756 return (isp_acknak_abts(isp, mp->nt_lreserved, (rsp == 0) ? 0 : EINVAL));
1762 isp_prt(isp, ISP_LOGTINFO, "Notify Code 0x%x (qevalid=%d) being acked", mp->nt_ncode, mp->nt_lreserved != NULL);
1766 return (isp_notify_ack(isp, mp->nt_lreserved));
1779 isp_handle_platform_target_tmf(ispsoftc_t *isp, isp_notify_t *notify)
1788 isp_prt(isp, ISP_LOGTDEBUG0, "%s: code 0x%x sid 0x%x tagval 0x%016llx chan %d lun %jx", __func__, notify->nt_ncode,
1794 atp = isp_find_atpd(isp, notify->nt_channel,
1801 tptr = get_lun_statep(isp, notify->nt_channel, lun);
1803 tptr = get_lun_statep(isp, notify->nt_channel, CAM_LUN_WILDCARD);
1805 isp_prt(isp, ISP_LOGWARN, "%s: no state pointer found for chan %d lun %#jx", __func__, notify->nt_channel, (uintmax_t)lun);
1811 isp_prt(isp, ISP_LOGWARN, "%s: out of immediate notify structures for chan %d lun %#jx", __func__, notify->nt_channel, (uintmax_t)lun);
1815 inot->ccb_h.target_id = ISP_MAX_TARGETS(isp);
1817 if (isp_find_pdb_by_portid(isp, notify->nt_channel, notify->nt_sid, &lp) == 0 &&
1818 isp_find_pdb_by_handle(isp, notify->nt_channel, notify->nt_nphdl, &lp) == 0) {
1821 inot->initiator_id = FC_PORTDB_TGT(isp, notify->nt_channel, lp);
1828 isp_target_mark_aborted_early(isp, notify->nt_channel, tptr, inot->tag_id);
1832 isp_target_mark_aborted_early(isp, notify->nt_channel, tptr, TAG_ANY);
1854 isp_prt(isp, ISP_LOGWARN, "%s: unknown TMF code 0x%x for chan %d lun %#jx", __func__, notify->nt_ncode, notify->nt_channel, (uintmax_t)lun);
1858 ntp = isp_get_ntpd(isp, notify->nt_channel);
1860 isp_prt(isp, ISP_LOGWARN, "%s: out of inotify private structures", __func__);
1872 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, inot->ccb_h.path, "Take FREE INOT\n");
1879 if (isp_acknak_abts(isp, notify->nt_lreserved, ENOMEM)) {
1880 isp_prt(isp, ISP_LOGWARN, "you lose- unable to send an ACKNAK");
1883 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, notify->nt_lreserved);
1892 isp_target_mark_aborted_early(ispsoftc_t *isp, int chan, tstate_t *tptr, uint32_t tag_id)
1902 isp_endcmd(isp, ntp->data, NIL_HANDLE, chan,
1904 isp_put_ntpd(isp, chan, ntp);
1913 ispsoftc_t *isp = cam_sim_softc(sim);
1915 ISP_RUN_ISR(isp);
1923 ispsoftc_t *isp;
1926 isp = XS_ISP(xs);
1928 handle = isp_find_handle(isp, xs);
1934 ISP_RUN_ISR(isp);
1936 handle = isp_find_handle(isp, xs);
1947 if (isp_control(isp, ISPCTL_ABORT_CMD, xs) == 0) {
1955 xs = isp_find_xs(isp, handle);
1968 ISP_DMAFREE(isp, xs);
1969 isp_destroy_handle(isp, handle);
1970 isp_prt(isp, ISP_LOGERR, "%s: timeout for handle 0x%x", __func__, handle);
1975 isp_prt(isp, ISP_LOGWARN, "%s: timeout for handle 0x%x, recovered during interrupt", __func__, ohandle);
1977 isp_prt(isp, ISP_LOGWARN, "%s: timeout for handle already free", __func__);
1983 isp_make_here(ispsoftc_t *isp, fcportdb_t *fcp, int chan, int tgt)
1986 struct isp_fc *fc = ISP_FC_PC(isp, chan);
1993 isp_prt(isp, ISP_LOGWARN, "Chan %d unable to alloc CCB for rescan", chan);
1998 isp_prt(isp, ISP_LOGWARN, "unable to create path for rescan");
2006 isp_make_gone(ispsoftc_t *isp, fcportdb_t *fcp, int chan, int tgt)
2009 struct isp_fc *fc = ISP_FC_PC(isp, chan);
2038 ispsoftc_t *isp = fc->isp;
2039 int chan = fc - ISP_FC_PC(isp, 0);
2045 ISP_LOCK(isp);
2046 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GDT timer expired", chan);
2048 lp = &FCPARAM(isp, chan)->portdb[dbidx];
2058 isp_prt(isp, ISP_LOGCONFIG, prom3, chan, dbidx, lp->portid, "Gone Device Timeout");
2061 isp_make_gone(isp, lp, chan, dbidx);
2080 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Stopping Gone Device Timer @ %lu", chan, (unsigned long) time_uptime);
2083 ISP_UNLOCK(isp);
2096 isp_loop_changed(ispsoftc_t *isp, int chan)
2098 fcparam *fcp = FCPARAM(isp, chan);
2099 struct isp_fc *fc = ISP_FC_PC(isp, chan);
2103 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0, "Chan %d Loop changed", chan);
2105 isp_freeze_loopdown(isp, chan);
2111 isp_loop_up(ispsoftc_t *isp, int chan)
2113 struct isp_fc *fc = ISP_FC_PC(isp, chan);
2115 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0, "Chan %d Loop is up", chan);
2118 isp_unfreeze_loopdown(isp, chan);
2122 isp_loop_dead(ispsoftc_t *isp, int chan)
2124 fcparam *fcp = FCPARAM(isp, chan);
2125 struct isp_fc *fc = ISP_FC_PC(isp, chan);
2131 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0, "Chan %d Loop is dead", chan);
2142 for (i = 0; i < ISP_HANDLE_NUM(isp); i++) {
2145 if (ISP_H2HT(isp->isp_xflist[i].handle) != ISP_HANDLE_INITIATOR) {
2148 if ((xs = isp->isp_xflist[i].cmd) == NULL) {
2154 isp_prt(isp, ISP_LOGWARN, "command handle 0x%x for %d.%d.%jx orphaned by loop down timeout",
2155 isp->isp_xflist[i].handle, chan, XS_TGT(xs),
2163 if (isp_control(isp, ISPCTL_ABORT_CMD, xs) == 0) {
2167 ISP_DMAFREE(isp, xs);
2168 isp_destroy_handle(isp, isp->isp_xflist[i].handle);
2169 isp_prt(isp, ISP_LOGWARN, "command handle 0x%x for %d.%d.%jx could not be aborted and was destroyed",
2170 isp->isp_xflist[i].handle, chan, XS_TGT(xs),
2176 isp_prt(isp, ISP_LOGCONFIG, prom3, chan, dbidx, lp->portid, "Loop Down Timeout");
2179 isp_make_gone(isp, lp, chan, dbidx);
2193 isp_unfreeze_loopdown(isp, chan);
2201 ispsoftc_t *isp = fc->isp;
2202 int chan = fc - ISP_FC_PC(isp, 0);
2206 ISP_LOCK(isp);
2207 while (isp->isp_osinfo.is_exiting == 0) {
2208 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0,
2210 lb = isp_fc_runstate(isp, chan, 250000);
2211 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0,
2253 isp_loop_up(isp, chan);
2255 isp_loop_dead(isp, chan);
2258 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0,
2260 msleep(fc, &isp->isp_lock, PRIBIO, "ispf", slp * hz);
2264 ISP_UNLOCK(isp);
2270 isp_abort_atpd(ispsoftc_t *isp, int chan, atio_private_data_t *atp)
2285 return (isp_send_entry(isp, cto));
2289 isp_abort_atio(ispsoftc_t *isp, union ccb *ccb)
2296 tptr = get_lun_statep(isp, XS_CHANNEL(accb), XS_LUN(accb));
2303 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, sccb->path,
2313 atp = isp_find_atpd_ccb(isp, XS_CHANNEL(accb), accb->atio.tag_id, accb);
2315 if (isp_abort_atpd(isp, XS_CHANNEL(accb), atp)) {
2319 isp_put_atpd(isp, XS_CHANNEL(accb), atp);
2326 isp_abort_inot(ispsoftc_t *isp, union ccb *ccb)
2333 tptr = get_lun_statep(isp, XS_CHANNEL(accb), XS_LUN(accb));
2340 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, sccb->path,
2350 ntp = isp_find_ntpd(isp, XS_CHANNEL(accb), accb->cin1.tag_id, accb->cin1.seq_id);
2353 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK,
2356 isp_put_ntpd(isp, XS_CHANNEL(accb), ntp);
2369 ispsoftc_t *isp;
2376 isp = (ispsoftc_t *)cam_sim_softc(sim);
2377 ISP_ASSERT_LOCKED(isp);
2379 isp_prt(isp, ISP_LOGDEBUG2, "isp_action code %x", ccb->ccb_h.func_code);
2395 if (ccb->ccb_h.target_id >= ISP_MAX_TARGETS(isp)) {
2405 if (isp_get_pcmd(isp, ccb)) {
2406 isp_prt(isp, ISP_LOGWARN, "out of PCMDs");
2414 isp_rq_check_above(isp);
2426 isp_prt(isp, ISP_LOGDEBUG0, "%d.%jx retry later",
2431 isp_free_pcmd(isp, ccb);
2435 isp_free_pcmd(isp, ccb);
2445 isp_prt(isp, ISP_LOGERR, "What's this? 0x%x at %d in file %s", error, __LINE__, __FILE__);
2447 isp_free_pcmd(isp, ccb);
2455 isp_enable_lun(isp, ccb);
2457 isp_disable_lun(isp, ccb);
2463 tstate_t *tptr = get_lun_statep(isp, XS_CHANNEL(ccb), ccb->ccb_h.target_lun);
2471 ISP_PATH_PRT(isp, ISP_LOGWARN, ccb->ccb_h.path,
2482 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, ccb->ccb_h.path,
2487 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, ccb->ccb_h.path,
2505 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, ccb->ccb_h.path, "%s: [0x%x] NOTIFY ACKNOWLEDGE for 0x%x seen\n", __func__, ccb->cna2.tag_id, ccb->cna2.seq_id);
2506 ntp = isp_find_ntpd(isp, XS_CHANNEL(ccb), ccb->cna2.tag_id, ccb->cna2.seq_id);
2508 ISP_PATH_PRT(isp, ISP_LOGWARN, ccb->ccb_h.path, "%s: [0x%x] XPT_NOTIFY_ACKNOWLEDGE of 0x%x cannot find ntp private data\n", __func__,
2523 (atp = isp_find_atpd(isp, XS_CHANNEL(ccb), ccb->cna2.seq_id)) != NULL) {
2525 isp_abort_atpd(isp, XS_CHANNEL(ccb), atp) == 0)
2526 isp_put_atpd(isp, XS_CHANNEL(ccb), atp);
2531 if (isp_handle_platform_target_notify_ack(isp, &ntp->nt, rsp)) {
2538 isp_put_ntpd(isp, XS_CHANNEL(ccb), ntp);
2540 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, ccb->ccb_h.path, "%s: [0x%x] calling xpt_done for tag 0x%x\n", __func__, ccb->cna2.tag_id, ccb->cna2.seq_id);
2545 isp_target_start_ctio(isp, ccb, FROM_CAM);
2546 isp_rq_check_above(isp);
2553 error = isp_control(isp, ISPCTL_RESET_DEV, bus, tgt);
2562 isp_fcp_reset_crn(isp, bus, tgt, /*tgt_set*/ 1);
2574 isp_abort_atio(isp, ccb);
2577 isp_abort_inot(isp, ccb);
2581 error = isp_control(isp, ISPCTL_ABORT_CMD, accb);
2618 fcp = FCPARAM(isp, bus);
2646 error = isp_control(isp, ISPCTL_RESET_BUS, bus);
2655 xpt_async(AC_BUS_RESET, ISP_FC_PC(isp, bus)->path, 0);
2668 fcparam *fcp = FCPARAM(isp, bus);
2671 fcp->isp_wwnn = ISP_FC_PC(isp, bus)->def_wwnn = kp->xport_specific.fc.wwnn;
2672 fcp->isp_wwpn = ISP_FC_PC(isp, bus)->def_wwpn = kp->xport_specific.fc.wwpn;
2673 isp_prt(isp, ISP_LOGALL, "Setting Channel %d wwns to 0x%jx 0x%jx", bus, fcp->isp_wwnn, fcp->isp_wwpn);
2707 ISP_PATH_PRT(isp, ISP_LOGCONFIG, ccb->ccb_h.path, "changing role on from %d to %d\n", fcp->role, newrole);
2708 if (isp_control(isp, ISPCTL_CHANGE_ROLE,
2723 fcparam *fcp = FCPARAM(isp, bus);
2757 cpi->max_target = ISP_MAX_TARGETS(isp) - 1;
2762 fcp = FCPARAM(isp, bus);
2776 if (IS_25XX(isp))
2807 ispsoftc_t *isp = XS_ISP(sccb);
2833 isp_free_pcmd(isp, (union ccb *) sccb);
2835 isp_rq_check_below(isp);
2840 isp_async(ispsoftc_t *isp, ispasync_t cmd, ...)
2862 lipp = ISP_READ(isp, OUTMAILBOX1);
2863 fcp = FCPARAM(isp, bus);
2865 isp_prt(isp, ISP_LOGINFO, "Chan %d LOOP Reset, LIP primitive %x", bus, lipp);
2878 isp_fcp_reset_crn(isp, bus, /*tgt*/0, /*tgt_set*/ 0);
2879 isp_loop_changed(isp, bus);
2896 isp_loop_changed(isp, bus);
2897 isp_prt(isp, ISP_LOGINFO, "Chan %d %s", bus, msg);
2904 fc = ISP_FC_PC(isp, bus);
2905 tgt = FC_PORTDB_TGT(isp, bus, lp);
2907 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->portid, lp->handle, buf, "arrived");
2908 if ((FCPARAM(isp, bus)->role & ISP_ROLE_INITIATOR) &&
2911 isp_fcp_reset_crn(isp, bus, tgt, /*tgt_set*/ 1);
2912 isp_make_here(isp, lp, bus, tgt);
2914 if ((FCPARAM(isp, bus)->role & ISP_ROLE_TARGET) &&
2936 fc = ISP_FC_PC(isp, bus);
2937 tgt = FC_PORTDB_TGT(isp, bus, lp);
2940 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->new_portid, lp->handle, buf, "changed");
2942 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->portid, lp->handle, buf, "stayed");
2945 ((FCPARAM(isp, bus)->role & ISP_ROLE_INITIATOR) &&
2950 isp_fcp_reset_crn(isp, bus, tgt, /*tgt_set*/ 1);
2953 isp_make_here(isp, lp, bus, tgt);
2955 isp_make_gone(isp, lp, bus, tgt);
2957 isp_fcp_reset_crn(isp, bus, tgt, /*tgt_set*/ 1);
2963 ((FCPARAM(isp, bus)->role & ISP_ROLE_TARGET) &&
2977 isp_fcp_reset_crn(isp, bus, tgt, /*tgt_set*/ 1);
2986 fc = ISP_FC_PC(isp, bus);
2987 tgt = FC_PORTDB_TGT(isp, bus, lp);
2996 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->portid, lp->handle, buf, "gone zombie");
2998 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0, "Chan %d Starting Gone Device Timer with %u seconds time now %lu", bus, lp->gone_timer, (unsigned long)time_uptime);
3003 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->portid, lp->handle, buf, "gone");
3028 isp_prt(isp, ISP_LOGINFO,
3055 if (!isp_find_pdb_by_handle(isp, bus, nphdl, &lp))
3057 tgt = FC_PORTDB_TGT(isp, bus, lp);
3060 isp_fcp_reset_crn(isp, bus, tgt, tgt_set);
3067 isp_prt(isp, ISP_LOGINFO, "Chan %d %s (PortID 0x%06x)",
3071 isp_prt(isp, ISP_LOGINFO, "Chan %d %s", bus, msg);
3073 isp_loop_changed(isp, bus);
3095 isp_handle_platform_target_tmf(isp, notify);
3106 isp_handle_platform_srr(isp, notify);
3109 isp_prt(isp, ISP_LOGALL, "target notify code 0x%x", notify->nt_ncode);
3110 isp_handle_platform_target_notify_ack(isp, notify, 0);
3121 if (isp_notify_ack(isp, inot)) {
3124 tp->isp = isp;
3127 callout_init_mtx(&tp->timer, &isp->isp_lock, 0);
3131 isp_prt(isp, ISP_LOGERR, "you lose- cannot allocate a notify refire");
3145 isp_handle_platform_atio7(isp, (at7_entry_t *)hp);
3148 isp_handle_platform_ctio(isp, (ct7_entry_t *)hp);
3151 isp_prt(isp, ISP_LOGWARN, "%s: unhandled target action 0x%x",
3161 mbox1 = ISP_READ(isp, OUTMAILBOX1);
3162 isp_prt(isp, ISP_LOGERR, "Internal Firmware Error @ RISC Address 0x%x", mbox1);
3164 isp_reinit(isp, 1);
3165 isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
3170 isp_prt(isp, ISP_LOGERR, "unknown isp_async event %d", cmd);
3176 isp_default_wwn(ispsoftc_t * isp, int chan, int isactive, int iswwnn)
3179 struct isp_fc *fc = ISP_FC_PC(isp, chan);
3188 seed = iswwnn ? FCPARAM(isp, chan)->isp_wwnn_nvram :
3189 FCPARAM(isp, chan)->isp_wwpn_nvram;
3196 seed = iswwnn ? ISP_FC_PC(isp, 0)->def_wwnn :
3197 ISP_FC_PC(isp, 0)->def_wwpn;
3199 seed = iswwnn ? FCPARAM(isp, 0)->isp_wwnn_nvram :
3200 FCPARAM(isp, 0)->isp_wwpn_nvram;
3206 seed = 0x400000007F000000ull + device_get_unit(isp->isp_dev);
3226 isp_prt(ispsoftc_t *isp, int level, const char *fmt, ...)
3232 if (level != ISP_LOGALL && (level & isp->isp_dblev) == 0) {
3235 snprintf(lbuf, sizeof (lbuf), "%s: ", device_get_nameunit(isp->isp_dev));
3244 isp_xs_prt(ispsoftc_t *isp, XS_T *xs, int level, const char *fmt, ...)
3247 if (level != ISP_LOGALL && (level & isp->isp_dblev) == 0) {
3271 isp_fc_scratch_acquire(ispsoftc_t *isp, int chan)
3273 struct isp_fc *fc = ISP_FC_PC(isp, chan);
3284 ispsoftc_t *isp = arg;
3286 ISP_LOCK(isp);
3287 ISP_RUN_ISR(isp);
3288 ISP_UNLOCK(isp);
3294 ispsoftc_t *isp = arg;
3296 ISP_LOCK(isp);
3297 isp_intr_respq(isp);
3298 ISP_UNLOCK(isp);
3301 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
3307 ispsoftc_t *isp = arg;
3309 ISP_LOCK(isp);
3311 isp_intr_atioq(isp);
3313 ISP_UNLOCK(isp);
3316 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
3320 ispsoftc_t *isp;
3330 ispsoftc_t *isp= mp->isp;
3343 bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, op);
3345 mp->error = ISP_SEND_CMD(isp, mp->qe, dm_segs, nseg);
3347 isp_dmafree(isp, csio);
3351 isp_dmasetup(ispsoftc_t *isp, struct ccb_scsiio *csio, void *qe)
3357 mp.isp = isp;
3361 error = bus_dmamap_load_ccb(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap,
3366 error = ISP_SEND_CMD(isp, qe, NULL, 0);
3391 isp_dmafree(ispsoftc_t *isp, struct ccb_scsiio *csio)
3403 bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, op);
3404 bus_dmamap_unload(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap);
3413 isp_fcp_reset_crn(ispsoftc_t *isp, int chan, uint32_t tgt, int tgt_set)
3415 struct isp_fc *fc = ISP_FC_PC(isp, chan);
3420 isp_prt(isp, ISP_LOGDEBUG0,
3423 isp_prt(isp, ISP_LOGDEBUG0,
3435 isp_fcp_next_crn(ispsoftc_t *isp, uint8_t *crnp, XS_T *cmd)
3446 fc = ISP_FC_PC(isp, chan);
3482 ispsoftc_t *isp = arg;
3484 isp_tmcmd_restart(isp);
3486 callout_reset(&isp->isp_osinfo.tmo, isp_timer_count, isp_timer, isp);
3491 isp_get_ecmd(ispsoftc_t *isp)
3493 isp_ecmd_t *ecmd = isp->isp_osinfo.ecmd_free;
3495 isp->isp_osinfo.ecmd_free = ecmd->next;
3501 isp_put_ecmd(ispsoftc_t *isp, isp_ecmd_t *ecmd)
3503 ecmd->next = isp->isp_osinfo.ecmd_free;
3504 isp->isp_osinfo.ecmd_free = ecmd;