Lines Matching defs:isp
36 #include <dev/isp/isp_freebsd.h>
42 #include <dev/isp/isp_ioctl.h>
47 MODULE_VERSION(isp, 1);
48 MODULE_DEPEND(isp, cam, 1, 1, 1);
56 static void isp_loop_changed(ispsoftc_t *isp, int chan);
72 .d_name = "isp",
78 ispsoftc_t *isp = (ispsoftc_t *)arg1;
82 value = FCPARAM(isp, chan)->role;
91 ISP_LOCK(isp);
92 old = FCPARAM(isp, chan)->role;
99 ISP_UNLOCK(isp);
104 error = isp_control(isp, ISPCTL_CHANGE_ROLE, chan, value);
105 ISP_UNLOCK(isp);
110 isp_attach_chan(ispsoftc_t *isp, struct cam_devq *devq, int chan)
112 fcparam *fcp = FCPARAM(isp, chan);
113 struct isp_fc *fc = ISP_FC_PC(isp, chan);
114 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(isp->isp_osinfo.dev);
115 struct sysctl_oid *tree = device_get_sysctl_tree(isp->isp_osinfo.dev);
123 sim = cam_sim_alloc(isp_action, isp_poll, "isp", isp,
124 device_get_unit(isp->isp_dev), &isp->isp_lock,
125 isp->isp_maxcmds, isp->isp_maxcmds, devq);
129 if (xpt_bus_register(sim, isp->isp_dev, chan) != CAM_SUCCESS) {
139 ISP_LOCK(isp);
142 fc->isp = isp;
147 callout_init_mtx(&fc->gdt, &isp->isp_lock, 0);
160 isp_loop_changed(isp, chan);
161 ISP_UNLOCK(isp);
163 "%s_%d", device_get_nameunit(isp->isp_osinfo.dev), chan)) {
195 isp, chan, isp_role_sysctl, "I", "Current role");
221 isp_detach_chan(ispsoftc_t *isp, int chan)
223 struct isp_fc *fc = ISP_FC_PC(isp, chan);
232 mtx_sleep(&fc->num_threads, &isp->isp_lock, PRIBIO, "isp_reap", 0);
236 isp_attach(ispsoftc_t *isp)
238 const char *nu = device_get_nameunit(isp->isp_osinfo.dev);
239 int du = device_get_unit(isp->isp_dev);
245 isp->isp_osinfo.devq = cam_simq_alloc(isp->isp_maxcmds);
246 if (isp->isp_osinfo.devq == NULL) {
250 for (chan = 0; chan < isp->isp_nchan; chan++) {
251 if (isp_attach_chan(isp, isp->isp_osinfo.devq, chan)) {
256 callout_init_mtx(&isp->isp_osinfo.tmo, &isp->isp_lock, 0);
258 callout_reset(&isp->isp_osinfo.tmo, isp_timer_count, isp_timer, isp);
260 isp->isp_osinfo.cdev = make_dev(&isp_cdevsw, du, UID_ROOT, GID_OPERATOR, 0600, "%s", nu);
261 if (isp->isp_osinfo.cdev) {
262 isp->isp_osinfo.cdev->si_drv1 = isp;
267 ISP_LOCK(isp);
268 isp->isp_osinfo.is_exiting = 1;
270 isp_detach_chan(isp, chan);
271 ISP_UNLOCK(isp);
272 cam_simq_free(isp->isp_osinfo.devq);
273 isp->isp_osinfo.devq = NULL;
278 isp_detach(ispsoftc_t *isp)
282 if (isp->isp_osinfo.cdev) {
283 destroy_dev(isp->isp_osinfo.cdev);
284 isp->isp_osinfo.cdev = NULL;
286 ISP_LOCK(isp);
288 isp->isp_osinfo.is_exiting = 1;
289 for (chan = isp->isp_nchan - 1; chan >= 0; chan -= 1)
290 isp_detach_chan(isp, chan);
291 ISP_UNLOCK(isp);
292 callout_drain(&isp->isp_osinfo.tmo);
293 cam_simq_free(isp->isp_osinfo.devq);
298 isp_freeze_loopdown(ispsoftc_t *isp, int chan)
300 struct isp_fc *fc = ISP_FC_PC(isp, chan);
305 isp_prt(isp, ISP_LOGDEBUG0,
311 isp_prt(isp, ISP_LOGDEBUG0,
318 isp_unfreeze_loopdown(ispsoftc_t *isp, int chan)
320 struct isp_fc *fc = ISP_FC_PC(isp, chan);
327 isp_prt(isp, ISP_LOGDEBUG0,
339 isp_rq_check_above(ispsoftc_t *isp)
341 struct isp_fc *fc = ISP_FC_PC(isp, 0);
343 if (isp->isp_rqovf || fc->sim == NULL)
345 if (!isp_rqentry_avail(isp, QENTRY_MAX)) {
347 isp->isp_rqovf = 1;
352 isp_rq_check_below(ispsoftc_t *isp)
354 struct isp_fc *fc = ISP_FC_PC(isp, 0);
356 if (!isp->isp_rqovf || fc->sim == NULL)
358 if (isp_rqentry_avail(isp, QENTRY_MAX)) {
360 isp->isp_rqovf = 0;
367 ispsoftc_t *isp;
370 isp = dev->si_drv1;
375 int olddblev = isp->isp_dblev;
376 isp->isp_dblev = *(int *)addr;
383 if (chan < 0 || chan >= isp->isp_nchan) {
387 *(int *)addr = FCPARAM(isp, chan)->role;
393 if (chan < 0 || chan >= isp->isp_nchan) {
402 ISP_LOCK(isp);
403 *(int *)addr = FCPARAM(isp, chan)->role;
404 retval = isp_control(isp, ISPCTL_CHANGE_ROLE, chan, nr);
405 ISP_UNLOCK(isp);
409 ISP_LOCK(isp);
410 isp_reinit(isp, 0);
411 ISP_UNLOCK(isp);
417 if (chan < 0 || chan >= isp->isp_nchan) {
421 ISP_LOCK(isp);
422 if (isp_fc_runstate(isp, chan, 5 * 1000000) != LOOP_READY) {
427 ISP_UNLOCK(isp);
432 if (chan < 0 || chan >= isp->isp_nchan) {
436 ISP_LOCK(isp);
437 if (isp_control(isp, ISPCTL_SEND_LIP, chan)) {
442 ISP_UNLOCK(isp);
453 lp = &FCPARAM(isp, ifc->chan)->portdb[ifc->loopid];
471 if (chan < 0 || chan >= isp->isp_nchan) {
475 hba->fc_fw_major = ISP_FW_MAJORX(isp->isp_fwrev);
476 hba->fc_fw_minor = ISP_FW_MINORX(isp->isp_fwrev);
477 hba->fc_fw_micro = ISP_FW_MICROX(isp->isp_fwrev);
478 hba->fc_nchannels = isp->isp_nchan;
480 hba->fc_speed = FCPARAM(isp, hba->fc_channel)->isp_gbspeed;
481 hba->fc_topology = FCPARAM(isp, chan)->isp_topo + 1;
482 hba->fc_loopid = FCPARAM(isp, chan)->isp_loopid;
483 hba->nvram_node_wwn = FCPARAM(isp, chan)->isp_wwnn_nvram;
484 hba->nvram_port_wwn = FCPARAM(isp, chan)->isp_wwpn_nvram;
485 hba->active_node_wwn = FCPARAM(isp, chan)->isp_wwnn;
486 hba->active_port_wwn = FCPARAM(isp, chan)->isp_wwpn;
502 if (chan < 0 || chan >= isp->isp_nchan) {
509 ISP_LOCK(isp);
510 fcp = FCPARAM(isp, chan);
520 ISP_UNLOCK(isp);
531 tmf.tmf_vpidx = ISP_GET_VPIDX(isp, chan);
561 ISP_UNLOCK(isp);
565 retval = isp_exec_entry_queue(isp, &tmf, &sp, 5);
567 isp_prt(isp, ISP_LOGERR, "%s: TMF of chan %d error %d",
569 ISP_UNLOCK(isp);
577 ISP_UNLOCK(isp);
594 isp_get_pcmd(ispsoftc_t *isp, union ccb *ccb)
596 ISP_PCMD(ccb) = isp->isp_osinfo.pcmd_free;
600 isp->isp_osinfo.pcmd_free = ((struct isp_pcmd *)ISP_PCMD(ccb))->next;
605 isp_free_pcmd(ispsoftc_t *isp, union ccb *ccb)
611 PISP_PCMD(ccb)->next = isp->isp_osinfo.pcmd_free;
612 isp->isp_osinfo.pcmd_free = ISP_PCMD(ccb);
633 static void isp_complete_ctio(ispsoftc_t *isp, union ccb *);
643 get_lun_statep(ispsoftc_t *isp, int bus, lun_id_t lun)
645 struct isp_fc *fc = ISP_FC_PC(isp, bus);
656 isp_atio_restart(ispsoftc_t *isp, int bus, tstate_t *tptr)
667 isp_prt(isp, ISP_LOGTDEBUG0,
670 isp_handle_platform_atio7(isp, (at7_entry_t *) ntp->data);
671 isp_put_ntpd(isp, bus, ntp);
683 isp_tmcmd_restart(ispsoftc_t *isp)
690 for (bus = 0; bus < isp->isp_nchan; bus++) {
691 fc = ISP_FC_PC(isp, bus);
694 isp_atio_restart(isp, bus, tptr);
703 isp_target_start_ctio(isp, ccb, FROM_TIMER);
706 isp_rq_check_above(isp);
707 isp_rq_check_below(isp);
711 isp_get_atpd(ispsoftc_t *isp, int chan, uint32_t tag)
713 struct isp_fc *fc = ISP_FC_PC(isp, chan);
726 isp_find_atpd(ispsoftc_t *isp, int chan, uint32_t tag)
728 struct isp_fc *fc = ISP_FC_PC(isp, chan);
739 isp_put_atpd(ispsoftc_t *isp, int chan, atio_private_data_t *atp)
741 struct isp_fc *fc = ISP_FC_PC(isp, chan);
744 isp_put_ecmd(isp, atp->ests);
751 isp_dump_atpd(ispsoftc_t *isp, int chan)
753 struct isp_fc *fc = ISP_FC_PC(isp, chan);
760 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",
766 isp_get_ntpd(ispsoftc_t *isp, int chan)
768 struct isp_fc *fc = ISP_FC_PC(isp, chan);
778 isp_find_ntpd(ispsoftc_t *isp, int chan, uint32_t tag_id, uint32_t seq_id)
780 struct isp_fc *fc = ISP_FC_PC(isp, chan);
791 isp_put_ntpd(ispsoftc_t *isp, int chan, inot_private_data_t *ntp)
793 struct isp_fc *fc = ISP_FC_PC(isp, chan);
800 create_lun_state(ispsoftc_t *isp, int bus, struct cam_path *path)
802 struct isp_fc *fc = ISP_FC_PC(isp, bus);
815 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, path, "created tstate\n");
820 destroy_lun_state(ispsoftc_t *isp, int bus, tstate_t *tptr)
822 struct isp_fc *fc = ISP_FC_PC(isp, bus);
837 isp_endcmd(isp, ntp->data, NIL_HANDLE, bus, SCSI_STATUS_BUSY, 0);
839 isp_put_ntpd(isp, bus, ntp);
846 isp_enable_lun(ispsoftc_t *isp, union ccb *ccb)
857 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0|ISP_LOGCONFIG, ccb->ccb_h.path,
866 tptr = get_lun_statep(isp, bus, lun);
872 tptr = create_lun_state(isp, bus, ccb->ccb_h.path);
884 isp_disable_lun(ispsoftc_t *isp, union ccb *ccb)
891 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0|ISP_LOGCONFIG, ccb->ccb_h.path,
900 if ((tptr = get_lun_statep(isp, bus, lun)) == NULL) {
906 destroy_lun_state(isp, bus, tptr);
912 isp_target_start_ctio(ispsoftc_t *isp, union ccb *ccb, enum Start_Ctio_How how)
922 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,
925 waitq = &ISP_FC_PC(isp, XS_CHANNEL(ccb))->waitq;
947 ISP_PATH_PRT(isp, ISP_LOGERR, ccb->ccb_h.path, "a data transfer length of zero but no status to send is wrong\n");
954 atp = isp_find_atpd(isp, XS_CHANNEL(ccb), cso->tag_id);
956 isp_prt(isp, ISP_LOGERR, "%s: [0x%x] cannot find private data adjunct in %s", __func__, cso->tag_id, __func__);
957 isp_dump_atpd(isp, XS_CHANNEL(ccb));
967 isp_prt(isp, ISP_LOGERR, "%s: [0x%x] not sending a CTIO for a dead command", __func__, cso->tag_id);
976 fcp = FCPARAM(isp, XS_CHANNEL(ccb));
978 isp_prt(isp, ISP_LOGERR, "%s: [0x%x] stopping sending a CTIO because we're no longer in target mode", __func__, cso->tag_id);
989 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);
1008 isp_prt(isp, ISP_LOGTDEBUG0, "[0x%x] now sending synthesized status orig_dl=%u xfered=%u bit=%u",
1043 isp_prt(isp, ISP_LOGERR,
1070 cto->ct_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(ccb));
1108 atp->ests = isp_get_ecmd(isp);
1132 isp_put_fcp_rsp_iu(isp, &rp, atp->ests);
1135 isp_put_fcp_rsp_iu(isp, &rp, atp->ests);
1137 if (isp->isp_dblev & ISP_LOGTDEBUG1) {
1138 isp_print_bytes(isp, "FCP Response Frame After Swizzling", MIN_FCP_RESPONSE_SIZE + sense_length, atp->ests);
1140 bus_dmamap_sync(isp->isp_osinfo.ecmd_dmat, isp->isp_osinfo.ecmd_map, BUS_DMASYNC_PREWRITE);
1141 addr = isp->isp_osinfo.ecmd_dma;
1142 addr += ((((isp_ecmd_t *)atp->ests) - isp->isp_osinfo.ecmd_base) * XCMD_SIZE);
1143 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,
1144 (uintmax_t) isp->isp_osinfo.ecmd_dma, (uintmax_t)addr, MIN_FCP_RESPONSE_SIZE + sense_length);
1151 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__,
1155 isp_prt(isp, ISP_LOGDEBUG0, "%s: CTIO7[0x%x] seq %u nc %d CDB0=%x sstatus=0x%x flags=0x%x resid=%d", __func__,
1176 if (ISP_FC_PC(isp, XS_CHANNEL(ccb))->inject_lost_data_frame && xfrlen > ISP_FC_PC(isp, XS_CHANNEL(ccb))->inject_lost_data_frame) {
1177 isp_prt(isp, ISP_LOGWARN, "%s: truncating data frame with xfrlen %d to %d", __func__, xfrlen, xfrlen - (xfrlen >> 2));
1178 ISP_FC_PC(isp, XS_CHANNEL(ccb))->inject_lost_data_frame = 0;
1198 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__,
1202 if (isp_get_pcmd(isp, ccb)) {
1203 ISP_PATH_PRT(isp, ISP_LOGWARN, ccb->ccb_h.path, "out of PCMDs\n");
1207 handle = isp_allocate_handle(isp, ccb, ISP_HANDLE_TARGET);
1209 ISP_PATH_PRT(isp, ISP_LOGWARN, ccb->ccb_h.path, "No XFLIST pointers for %s\n", __func__);
1211 isp_free_pcmd(isp, ccb);
1226 dmaresult = ISP_DMASETUP(isp, cso, cto);
1228 isp_destroy_handle(isp, handle);
1229 isp_free_pcmd(isp, ccb);
1253 ispsoftc_t *isp = tp->isp;
1255 ISP_ASSERT_LOCKED(isp);
1256 if (isp_notify_ack(isp, tp->not)) {
1265 isp_complete_ctio(ispsoftc_t *isp, union ccb *ccb)
1268 isp_rq_check_below(isp);
1274 isp_handle_platform_atio7(ispsoftc_t *isp, at7_entry_t *aep)
1291 if (ISP_CAP_MULTI_ID(isp) && isp->isp_nchan > 1) {
1293 isp_find_chan_by_did(isp, did, &chan);
1295 isp_prt(isp, ISP_LOGWARN,
1298 isp_endcmd(isp, aep, NIL_HANDLE, ISP_NOCHAN,
1309 if (isp_find_pdb_by_portid(isp, chan, sid, &lp) == 0) {
1313 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",
1315 isp_dump_portdb(isp, chan);
1316 isp_endcmd(isp, aep, NIL_HANDLE, chan, ECMD_TERMINATE, 0);
1324 tptr = get_lun_statep(isp, chan, lun);
1326 tptr = get_lun_statep(isp, chan, CAM_LUN_WILDCARD);
1328 isp_prt(isp, ISP_LOGWARN,
1332 isp_endcmd(isp, aep, nphdl, chan, SCSI_STATUS_BUSY, 0);
1334 isp_endcmd(isp, aep, nphdl, chan, SCSI_STATUS_CHECK_COND | ECMD_SVALID | (0x5 << 12) | (0x25 << 16), 0);
1343 if (isp_atio_restart(isp, chan, tptr))
1350 isp_endcmd(isp, aep, nphdl, chan, SCSI_BUSY, 0);
1359 isp_prt(isp, ISP_LOGTDEBUG0, "[0x%x] out of atios", aep->at_rxid);
1363 oatp = isp_find_atpd(isp, chan, aep->at_rxid);
1365 isp_prt(isp, oatp->state == ATPD_STATE_LAST_CTIO ? ISP_LOGTDEBUG0 :
1374 atp = isp_get_atpd(isp, chan, aep->at_rxid);
1376 isp_prt(isp, ISP_LOGTDEBUG0, "[0x%x] out of atps", aep->at_rxid);
1377 isp_endcmd(isp, aep, nphdl, chan, SCSI_BUSY, 0);
1383 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, atiop->ccb_h.path, "Take FREE ATIO\n");
1384 atiop->init_id = FC_PORTDB_TGT(isp, chan, lp);
1385 atiop->ccb_h.target_id = ISP_MAX_TARGETS(isp);
1390 isp_prt(isp, ISP_LOGWARN, "additional CDBLEN ignored");
1432 isp_prt(isp, ISP_LOGTDEBUG0, "ATIO7[0x%x] CDB=0x%x lun %jx datalen %u",
1438 ntp = isp_get_ntpd(isp, chan);
1440 isp_endcmd(isp, aep, nphdl, chan, SCSI_STATUS_BUSY, 0);
1455 isp_handle_srr_start(ispsoftc_t *isp, atio_private_data_t *atp)
1467 isp_prt(isp, ISP_LOGWARN, "SRR[0x%x] null ccb", atp->tag);
1483 isp_prt(isp, ISP_LOGWARN, "SRR[0x%x] SRR offset 0x%x but current CCB doesn't transfer data", atp->tag, srr_off);
1487 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);
1490 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);
1493 isp_prt(isp, ISP_LOGTINFO, "SRR[0x%x] Got an FCP RSP SRR- resending status", atp->tag);
1503 isp_prt(isp, ISP_LOGWARN, "Got an FCP DATA IN SRR- dropping");
1507 isp_prt(isp, ISP_LOGWARN, "Got an unknown information (%x) SRR- dropping", inot->in_srr_iu);
1516 if (isp_notify_ack(isp, inot)) {
1517 isp_prt(isp, ISP_LOGWARN, "could not push positive ack for SRR- you lose");
1520 isp_target_start_ctio(isp, ccb, FROM_SRR);
1524 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot);
1527 isp_complete_ctio(isp, ccb);
1530 if (isp_notify_ack(isp, inot)) {
1531 isp_prt(isp, ISP_LOGWARN, "could not push positive ack for SRR- you lose");
1548 isp_complete_ctio(isp, ccb);
1553 isp_handle_platform_srr(ispsoftc_t *isp, isp_notify_t *notify)
1559 atp = isp_find_atpd(isp, notify->nt_channel, tag);
1561 isp_prt(isp, ISP_LOGERR, "%s: cannot find adjunct for %x in SRR Notify",
1563 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot);
1568 isp_prt(isp, ISP_LOGTINFO, "SRR[0x%x] flags 0x%x srr_iu %x reloff 0x%x",
1572 isp_handle_srr_start(isp, atp);
1576 isp_handle_platform_ctio(ispsoftc_t *isp, ct7_entry_t *ct)
1585 ccb = isp_find_xs(isp, handle);
1587 isp_print_bytes(isp, "null ccb in isp_handle_platform_ctio", QENTRY_LEN, ct);
1590 isp_destroy_handle(isp, handle);
1592 isp_free_pcmd(isp, ccb);
1595 atp = isp_find_atpd(isp, bus, ct->ct_rxid);
1602 atp = isp_find_atpd(isp, bus, ccb->csio.tag_id);
1605 isp_prt(isp, ISP_LOGERR, "%s: cannot find adjunct for %x after I/O", __func__, ccb->csio.tag_id);
1616 isp_handle_srr_start(isp, atp);
1630 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),
1654 isp_prt(isp, ISP_LOGTDEBUG0, "%s CTIO[0x%x] done (ok=%d nc=%d nowsendstatus=%d ccb ss=%d)",
1658 isp_target_start_ctio(isp, ccb, FROM_CTIO_DONE);
1668 isp_put_atpd(isp, bus, atp);
1675 isp_complete_ctio(isp, ccb);
1679 isp_handle_platform_target_notify_ack(ispsoftc_t *isp, isp_notify_t *mp, uint32_t rsp)
1683 if (isp->isp_state != ISP_RUNSTATE) {
1684 isp_prt(isp, ISP_LOGTINFO, "Notify Code 0x%x (qevalid=%d) acked- h/w not ready (dropping)", mp->nt_ncode, mp->nt_lreserved != NULL);
1698 if (isp_find_pdb_by_portid(isp, mp->nt_channel, sid, &lp)) {
1723 return (isp_send_entry(isp, cto));
1738 isp_prt(isp, ISP_LOGTDEBUG0, "%s: [%x] terminating after ABTS received", __func__, abts->abts_rxid_task);
1748 if (isp_send_entry(isp, cto)) {
1753 return (isp_acknak_abts(isp, mp->nt_lreserved, 0));
1760 isp_prt(isp, ISP_LOGTINFO, "Notify Code 0x%x (qevalid=%d) being acked", mp->nt_ncode, mp->nt_lreserved != NULL);
1764 return (isp_notify_ack(isp, mp->nt_lreserved));
1777 isp_handle_platform_target_tmf(ispsoftc_t *isp, isp_notify_t *notify)
1786 isp_prt(isp, ISP_LOGTDEBUG0, "%s: code 0x%x sid 0x%x tagval 0x%016llx chan %d lun %jx", __func__, notify->nt_ncode,
1792 atp = isp_find_atpd(isp, notify->nt_channel,
1799 tptr = get_lun_statep(isp, notify->nt_channel, lun);
1801 tptr = get_lun_statep(isp, notify->nt_channel, CAM_LUN_WILDCARD);
1803 isp_prt(isp, ISP_LOGWARN, "%s: no state pointer found for chan %d lun %#jx", __func__, notify->nt_channel, (uintmax_t)lun);
1809 isp_prt(isp, ISP_LOGWARN, "%s: out of immediate notify structures for chan %d lun %#jx", __func__, notify->nt_channel, (uintmax_t)lun);
1813 inot->ccb_h.target_id = ISP_MAX_TARGETS(isp);
1815 if (isp_find_pdb_by_portid(isp, notify->nt_channel, notify->nt_sid, &lp) == 0 &&
1816 isp_find_pdb_by_handle(isp, notify->nt_channel, notify->nt_nphdl, &lp) == 0) {
1819 inot->initiator_id = FC_PORTDB_TGT(isp, notify->nt_channel, lp);
1826 isp_target_mark_aborted_early(isp, notify->nt_channel, tptr, inot->tag_id);
1830 isp_target_mark_aborted_early(isp, notify->nt_channel, tptr, TAG_ANY);
1852 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);
1856 ntp = isp_get_ntpd(isp, notify->nt_channel);
1858 isp_prt(isp, ISP_LOGWARN, "%s: out of inotify private structures", __func__);
1870 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, inot->ccb_h.path, "Take FREE INOT\n");
1877 if (isp_acknak_abts(isp, notify->nt_lreserved, ENOMEM)) {
1878 isp_prt(isp, ISP_LOGWARN, "you lose- unable to send an ACKNAK");
1881 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, notify->nt_lreserved);
1887 isp_target_mark_aborted_early(ispsoftc_t *isp, int chan, tstate_t *tptr, uint32_t tag_id)
1889 struct isp_fc *fc = ISP_FC_PC(isp, chan);
1900 isp_endcmd(isp, ntp->data, NIL_HANDLE, chan,
1902 isp_put_ntpd(isp, chan, ntp);
1923 ispsoftc_t *isp = cam_sim_softc(sim);
1925 ISP_RUN_ISR(isp);
1933 ispsoftc_t *isp;
1936 isp = XS_ISP(xs);
1938 handle = isp_find_handle(isp, xs);
1944 ISP_RUN_ISR(isp);
1946 handle = isp_find_handle(isp, xs);
1957 if (isp_control(isp, ISPCTL_ABORT_CMD, xs) == 0) {
1965 xs = isp_find_xs(isp, handle);
1978 ISP_DMAFREE(isp, xs);
1979 isp_destroy_handle(isp, handle);
1980 isp_prt(isp, ISP_LOGERR, "%s: timeout for handle 0x%x", __func__, handle);
1985 isp_prt(isp, ISP_LOGWARN, "%s: timeout for handle 0x%x, recovered during interrupt", __func__, ohandle);
1987 isp_prt(isp, ISP_LOGWARN, "%s: timeout for handle already free", __func__);
1993 isp_make_here(ispsoftc_t *isp, fcportdb_t *fcp, int chan, int tgt)
1996 struct isp_fc *fc = ISP_FC_PC(isp, chan);
2003 isp_prt(isp, ISP_LOGWARN, "Chan %d unable to alloc CCB for rescan", chan);
2008 isp_prt(isp, ISP_LOGWARN, "unable to create path for rescan");
2016 isp_make_gone(ispsoftc_t *isp, fcportdb_t *fcp, int chan, int tgt)
2019 struct isp_fc *fc = ISP_FC_PC(isp, chan);
2048 ispsoftc_t *isp = fc->isp;
2049 int chan = fc - ISP_FC_PC(isp, 0);
2055 ISP_LOCK(isp);
2056 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GDT timer expired", chan);
2058 lp = &FCPARAM(isp, chan)->portdb[dbidx];
2068 isp_prt(isp, ISP_LOGCONFIG, prom3, chan, dbidx, lp->portid, "Gone Device Timeout");
2071 isp_make_gone(isp, lp, chan, dbidx);
2090 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Stopping Gone Device Timer @ %lu", chan, (unsigned long) time_uptime);
2093 ISP_UNLOCK(isp);
2106 isp_loop_changed(ispsoftc_t *isp, int chan)
2108 fcparam *fcp = FCPARAM(isp, chan);
2109 struct isp_fc *fc = ISP_FC_PC(isp, chan);
2113 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0, "Chan %d Loop changed", chan);
2115 isp_freeze_loopdown(isp, chan);
2121 isp_loop_up(ispsoftc_t *isp, int chan)
2123 struct isp_fc *fc = ISP_FC_PC(isp, chan);
2125 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0, "Chan %d Loop is up", chan);
2128 isp_unfreeze_loopdown(isp, chan);
2132 isp_loop_dead(ispsoftc_t *isp, int chan)
2134 fcparam *fcp = FCPARAM(isp, chan);
2135 struct isp_fc *fc = ISP_FC_PC(isp, chan);
2141 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0, "Chan %d Loop is dead", chan);
2152 for (i = 0; i < ISP_HANDLE_NUM(isp); i++) {
2155 if (ISP_H2HT(isp->isp_xflist[i].handle) != ISP_HANDLE_INITIATOR) {
2158 if ((xs = isp->isp_xflist[i].cmd) == NULL) {
2164 isp_prt(isp, ISP_LOGWARN, "command handle 0x%x for %d.%d.%jx orphaned by loop down timeout",
2165 isp->isp_xflist[i].handle, chan, XS_TGT(xs),
2173 if (isp_control(isp, ISPCTL_ABORT_CMD, xs) == 0) {
2177 ISP_DMAFREE(isp, xs);
2178 isp_destroy_handle(isp, isp->isp_xflist[i].handle);
2179 isp_prt(isp, ISP_LOGWARN, "command handle 0x%x for %d.%d.%jx could not be aborted and was destroyed",
2180 isp->isp_xflist[i].handle, chan, XS_TGT(xs),
2186 isp_prt(isp, ISP_LOGCONFIG, prom3, chan, dbidx, lp->portid, "Loop Down Timeout");
2189 isp_make_gone(isp, lp, chan, dbidx);
2203 isp_unfreeze_loopdown(isp, chan);
2211 ispsoftc_t *isp = fc->isp;
2212 int chan = fc - ISP_FC_PC(isp, 0);
2216 ISP_LOCK(isp);
2217 while (isp->isp_osinfo.is_exiting == 0) {
2218 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0,
2220 lb = isp_fc_runstate(isp, chan, 250000);
2221 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0,
2263 isp_loop_up(isp, chan);
2265 isp_loop_dead(isp, chan);
2268 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0,
2270 msleep(fc, &isp->isp_lock, PRIBIO, "ispf", slp * hz);
2274 ISP_UNLOCK(isp);
2280 isp_abort_atio(ispsoftc_t *isp, union ccb *ccb)
2287 tptr = get_lun_statep(isp, XS_CHANNEL(accb), XS_LUN(accb));
2294 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, sccb->path,
2304 atp = isp_find_atpd(isp, XS_CHANNEL(accb), accb->atio.tag_id);
2321 isp_send_entry(isp, cto);
2323 isp_put_atpd(isp, XS_CHANNEL(accb), atp);
2331 isp_abort_inot(ispsoftc_t *isp, union ccb *ccb)
2338 tptr = get_lun_statep(isp, XS_CHANNEL(accb), XS_LUN(accb));
2345 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, sccb->path,
2355 ntp = isp_find_ntpd(isp, XS_CHANNEL(accb), accb->cin1.tag_id, accb->cin1.seq_id);
2358 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK,
2361 isp_put_ntpd(isp, XS_CHANNEL(accb), ntp);
2374 ispsoftc_t *isp;
2381 isp = (ispsoftc_t *)cam_sim_softc(sim);
2382 ISP_ASSERT_LOCKED(isp);
2384 isp_prt(isp, ISP_LOGDEBUG2, "isp_action code %x", ccb->ccb_h.func_code);
2400 if (ccb->ccb_h.target_id >= ISP_MAX_TARGETS(isp)) {
2410 if (isp_get_pcmd(isp, ccb)) {
2411 isp_prt(isp, ISP_LOGWARN, "out of PCMDs");
2419 isp_rq_check_above(isp);
2431 isp_prt(isp, ISP_LOGDEBUG0, "%d.%jx retry later",
2436 isp_free_pcmd(isp, ccb);
2440 isp_free_pcmd(isp, ccb);
2450 isp_prt(isp, ISP_LOGERR, "What's this? 0x%x at %d in file %s", error, __LINE__, __FILE__);
2452 isp_free_pcmd(isp, ccb);
2460 isp_enable_lun(isp, ccb);
2462 isp_disable_lun(isp, ccb);
2468 tstate_t *tptr = get_lun_statep(isp, XS_CHANNEL(ccb), ccb->ccb_h.target_lun);
2476 ISP_PATH_PRT(isp, ISP_LOGWARN, ccb->ccb_h.path,
2487 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, ccb->ccb_h.path,
2492 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, ccb->ccb_h.path,
2509 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);
2510 ntp = isp_find_ntpd(isp, XS_CHANNEL(ccb), ccb->cna2.tag_id, ccb->cna2.seq_id);
2512 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__,
2518 if (isp_handle_platform_target_notify_ack(isp, &ntp->nt,
2526 isp_put_ntpd(isp, XS_CHANNEL(ccb), ntp);
2528 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);
2533 isp_target_start_ctio(isp, ccb, FROM_CAM);
2534 isp_rq_check_above(isp);
2541 error = isp_control(isp, ISPCTL_RESET_DEV, bus, tgt);
2550 isp_fcp_reset_crn(isp, bus, tgt, /*tgt_set*/ 1);
2562 isp_abort_atio(isp, ccb);
2565 isp_abort_inot(isp, ccb);
2569 error = isp_control(isp, ISPCTL_ABORT_CMD, accb);
2606 fcp = FCPARAM(isp, bus);
2634 error = isp_control(isp, ISPCTL_RESET_BUS, bus);
2643 xpt_async(AC_BUS_RESET, ISP_FC_PC(isp, bus)->path, 0);
2656 fcparam *fcp = FCPARAM(isp, bus);
2659 fcp->isp_wwnn = ISP_FC_PC(isp, bus)->def_wwnn = kp->xport_specific.fc.wwnn;
2660 fcp->isp_wwpn = ISP_FC_PC(isp, bus)->def_wwpn = kp->xport_specific.fc.wwpn;
2661 isp_prt(isp, ISP_LOGALL, "Setting Channel %d wwns to 0x%jx 0x%jx", bus, fcp->isp_wwnn, fcp->isp_wwpn);
2695 ISP_PATH_PRT(isp, ISP_LOGCONFIG, ccb->ccb_h.path, "changing role on from %d to %d\n", fcp->role, newrole);
2696 if (isp_control(isp, ISPCTL_CHANGE_ROLE,
2711 fcparam *fcp = FCPARAM(isp, bus);
2745 cpi->max_target = ISP_MAX_TARGETS(isp) - 1;
2750 fcp = FCPARAM(isp, bus);
2764 if (IS_25XX(isp))
2795 ispsoftc_t *isp = XS_ISP(sccb);
2821 isp_free_pcmd(isp, (union ccb *) sccb);
2823 isp_rq_check_below(isp);
2828 isp_async(ispsoftc_t *isp, ispasync_t cmd, ...)
2850 lipp = ISP_READ(isp, OUTMAILBOX1);
2851 fcp = FCPARAM(isp, bus);
2853 isp_prt(isp, ISP_LOGINFO, "Chan %d LOOP Reset, LIP primitive %x", bus, lipp);
2866 isp_fcp_reset_crn(isp, bus, /*tgt*/0, /*tgt_set*/ 0);
2867 isp_loop_changed(isp, bus);
2884 isp_loop_changed(isp, bus);
2885 isp_prt(isp, ISP_LOGINFO, "Chan %d %s", bus, msg);
2892 fc = ISP_FC_PC(isp, bus);
2893 tgt = FC_PORTDB_TGT(isp, bus, lp);
2895 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->portid, lp->handle, buf, "arrived");
2896 if ((FCPARAM(isp, bus)->role & ISP_ROLE_INITIATOR) &&
2899 isp_fcp_reset_crn(isp, bus, tgt, /*tgt_set*/ 1);
2900 isp_make_here(isp, lp, bus, tgt);
2902 if ((FCPARAM(isp, bus)->role & ISP_ROLE_TARGET) &&
2924 fc = ISP_FC_PC(isp, bus);
2925 tgt = FC_PORTDB_TGT(isp, bus, lp);
2928 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->new_portid, lp->handle, buf, "changed");
2930 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->portid, lp->handle, buf, "stayed");
2933 ((FCPARAM(isp, bus)->role & ISP_ROLE_INITIATOR) &&
2938 isp_fcp_reset_crn(isp, bus, tgt, /*tgt_set*/ 1);
2941 isp_make_here(isp, lp, bus, tgt);
2943 isp_make_gone(isp, lp, bus, tgt);
2945 isp_fcp_reset_crn(isp, bus, tgt, /*tgt_set*/ 1);
2951 ((FCPARAM(isp, bus)->role & ISP_ROLE_TARGET) &&
2965 isp_fcp_reset_crn(isp, bus, tgt, /*tgt_set*/ 1);
2974 fc = ISP_FC_PC(isp, bus);
2975 tgt = FC_PORTDB_TGT(isp, bus, lp);
2984 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->portid, lp->handle, buf, "gone zombie");
2986 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);
2991 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->portid, lp->handle, buf, "gone");
3016 isp_prt(isp, ISP_LOGINFO,
3043 if (!isp_find_pdb_by_handle(isp, bus, nphdl, &lp))
3045 tgt = FC_PORTDB_TGT(isp, bus, lp);
3048 isp_fcp_reset_crn(isp, bus, tgt, tgt_set);
3055 isp_prt(isp, ISP_LOGINFO, "Chan %d %s (PortID 0x%06x)",
3059 isp_prt(isp, ISP_LOGINFO, "Chan %d %s", bus, msg);
3061 isp_loop_changed(isp, bus);
3083 isp_handle_platform_target_tmf(isp, notify);
3094 isp_handle_platform_srr(isp, notify);
3097 isp_prt(isp, ISP_LOGALL, "target notify code 0x%x", notify->nt_ncode);
3098 isp_handle_platform_target_notify_ack(isp, notify, 0);
3109 if (isp_notify_ack(isp, inot)) {
3112 tp->isp = isp;
3115 callout_init_mtx(&tp->timer, &isp->isp_lock, 0);
3119 isp_prt(isp, ISP_LOGERR, "you lose- cannot allocate a notify refire");
3133 isp_handle_platform_atio7(isp, (at7_entry_t *)hp);
3136 isp_handle_platform_ctio(isp, (ct7_entry_t *)hp);
3139 isp_prt(isp, ISP_LOGWARN, "%s: unhandled target action 0x%x",
3149 mbox1 = ISP_READ(isp, OUTMAILBOX1);
3150 isp_prt(isp, ISP_LOGERR, "Internal Firmware Error @ RISC Address 0x%x", mbox1);
3152 isp_reinit(isp, 1);
3153 isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
3158 isp_prt(isp, ISP_LOGERR, "unknown isp_async event %d", cmd);
3164 isp_default_wwn(ispsoftc_t * isp, int chan, int isactive, int iswwnn)
3167 struct isp_fc *fc = ISP_FC_PC(isp, chan);
3176 seed = iswwnn ? FCPARAM(isp, chan)->isp_wwnn_nvram :
3177 FCPARAM(isp, chan)->isp_wwpn_nvram;
3184 seed = iswwnn ? ISP_FC_PC(isp, 0)->def_wwnn :
3185 ISP_FC_PC(isp, 0)->def_wwpn;
3187 seed = iswwnn ? FCPARAM(isp, 0)->isp_wwnn_nvram :
3188 FCPARAM(isp, 0)->isp_wwpn_nvram;
3194 seed = 0x400000007F000000ull + device_get_unit(isp->isp_dev);
3214 isp_prt(ispsoftc_t *isp, int level, const char *fmt, ...)
3220 if (level != ISP_LOGALL && (level & isp->isp_dblev) == 0) {
3223 snprintf(lbuf, sizeof (lbuf), "%s: ", device_get_nameunit(isp->isp_dev));
3232 isp_xs_prt(ispsoftc_t *isp, XS_T *xs, int level, const char *fmt, ...)
3235 if (level != ISP_LOGALL && (level & isp->isp_dblev) == 0) {
3259 isp_fc_scratch_acquire(ispsoftc_t *isp, int chan)
3261 struct isp_fc *fc = ISP_FC_PC(isp, chan);
3272 ispsoftc_t *isp = arg;
3274 ISP_LOCK(isp);
3275 ISP_RUN_ISR(isp);
3276 ISP_UNLOCK(isp);
3282 ispsoftc_t *isp = arg;
3284 ISP_LOCK(isp);
3285 isp_intr_respq(isp);
3286 ISP_UNLOCK(isp);
3289 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
3295 ispsoftc_t *isp = arg;
3297 ISP_LOCK(isp);
3299 isp_intr_atioq(isp);
3301 ISP_UNLOCK(isp);
3304 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
3308 ispsoftc_t *isp;
3318 ispsoftc_t *isp= mp->isp;
3331 bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, op);
3333 mp->error = ISP_SEND_CMD(isp, mp->qe, dm_segs, nseg);
3335 isp_dmafree(isp, csio);
3339 isp_dmasetup(ispsoftc_t *isp, struct ccb_scsiio *csio, void *qe)
3345 mp.isp = isp;
3349 error = bus_dmamap_load_ccb(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap,
3354 error = ISP_SEND_CMD(isp, qe, NULL, 0);
3379 isp_dmafree(ispsoftc_t *isp, struct ccb_scsiio *csio)
3391 bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, op);
3392 bus_dmamap_unload(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap);
3401 isp_fcp_reset_crn(ispsoftc_t *isp, int chan, uint32_t tgt, int tgt_set)
3403 struct isp_fc *fc = ISP_FC_PC(isp, chan);
3408 isp_prt(isp, ISP_LOGDEBUG0,
3411 isp_prt(isp, ISP_LOGDEBUG0,
3423 isp_fcp_next_crn(ispsoftc_t *isp, uint8_t *crnp, XS_T *cmd)
3434 fc = ISP_FC_PC(isp, chan);
3470 ispsoftc_t *isp = arg;
3472 isp_tmcmd_restart(isp);
3474 callout_reset(&isp->isp_osinfo.tmo, isp_timer_count, isp_timer, isp);
3479 isp_get_ecmd(ispsoftc_t *isp)
3481 isp_ecmd_t *ecmd = isp->isp_osinfo.ecmd_free;
3483 isp->isp_osinfo.ecmd_free = ecmd->next;
3489 isp_put_ecmd(ispsoftc_t *isp, isp_ecmd_t *ecmd)
3491 ecmd->next = isp->isp_osinfo.ecmd_free;
3492 isp->isp_osinfo.ecmd_free = ecmd;