Lines Matching defs:isp
31 __FBSDID("$FreeBSD: releng/10.3/sys/dev/isp/isp_freebsd.c 292921 2015-12-30 11:49:48Z mav $");
33 #include <dev/isp/isp_freebsd.h>
39 #include <dev/isp/isp_ioctl.h>
50 MODULE_VERSION(isp, 1);
51 MODULE_DEPEND(isp, cam, 1, 1, 1);
59 static void isp_loop_changed(ispsoftc_t *isp, int chan);
75 .d_name = "isp",
81 ispsoftc_t *isp = (ispsoftc_t *)arg1;
85 value = FCPARAM(isp, chan)->role;
94 ISP_LOCK(isp);
95 old = FCPARAM(isp, chan)->role;
102 ISP_UNLOCK(isp);
107 error = isp_control(isp, ISPCTL_CHANGE_ROLE, chan, value);
108 ISP_UNLOCK(isp);
113 isp_attach_chan(ispsoftc_t *isp, struct cam_devq *devq, int chan)
122 sim = cam_sim_alloc(isp_action, isp_poll, "isp", isp, device_get_unit(isp->isp_dev), &isp->isp_osinfo.lock, isp->isp_maxcmds, isp->isp_maxcmds, devq);
128 ISP_LOCK(isp);
129 if (xpt_bus_register(sim, isp->isp_dev, chan) != CAM_SUCCESS) {
130 ISP_UNLOCK(isp);
134 ISP_UNLOCK(isp);
136 ISP_LOCK(isp);
138 ISP_UNLOCK(isp);
148 ISP_LOCK(isp);
150 ISP_UNLOCK(isp);
152 if (IS_SCSI(isp)) {
153 struct isp_spi *spi = ISP_SPI_PC(isp, chan);
157 fcparam *fcp = FCPARAM(isp, chan);
158 struct isp_fc *fc = ISP_FC_PC(isp, chan);
159 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(isp->isp_osinfo.dev);
160 struct sysctl_oid *tree = device_get_sysctl_tree(isp->isp_osinfo.dev);
163 ISP_LOCK(isp);
166 fc->isp = isp;
169 callout_init_mtx(&fc->gdt, &isp->isp_osinfo.lock, 0);
171 isp_loop_changed(isp, chan);
172 ISP_UNLOCK(isp);
173 if (THREAD_CREATE(isp_kthread, fc, &fc->kproc, 0, 0, "%s: fc_thrd%d", device_get_nameunit(isp->isp_osinfo.dev), chan)) {
175 ISP_LOCK(isp);
177 ISP_UNLOCK(isp);
205 "role", CTLTYPE_INT | CTLFLAG_RW, isp, chan,
227 isp_detach_chan(ispsoftc_t *isp, int chan)
234 ISP_GET_PC(isp, chan, sim, sim);
235 ISP_GET_PC(isp, chan, path, path);
236 ISP_GET_PC_ADDR(isp, chan, num_threads, num_threads);
249 wakeup(isp->isp_osinfo.pc.ptr);
251 mtx_sleep(isp, &isp->isp_osinfo.lock, PRIBIO, "isp_reap", 100);
255 isp_attach(ispsoftc_t *isp)
257 const char *nu = device_get_nameunit(isp->isp_osinfo.dev);
258 int du = device_get_unit(isp->isp_dev);
261 isp->isp_osinfo.ehook.ich_func = isp_intr_enable;
262 isp->isp_osinfo.ehook.ich_arg = isp;
268 isp->isp_osinfo.ehook_active = 1;
269 if (config_intrhook_establish(&isp->isp_osinfo.ehook) != 0) {
270 isp_prt(isp, ISP_LOGERR, "could not establish interrupt enable hook");
277 isp->isp_osinfo.devq = cam_simq_alloc(isp->isp_maxcmds);
278 if (isp->isp_osinfo.devq == NULL) {
279 config_intrhook_disestablish(&isp->isp_osinfo.ehook);
283 for (chan = 0; chan < isp->isp_nchan; chan++) {
284 if (isp_attach_chan(isp, isp->isp_osinfo.devq, chan)) {
289 callout_init_mtx(&isp->isp_osinfo.tmo, &isp->isp_osinfo.lock, 0);
291 callout_reset(&isp->isp_osinfo.tmo, isp_timer_count, isp_timer, isp);
292 isp->isp_osinfo.timer_active = 1;
294 isp->isp_osinfo.cdev = make_dev(&isp_cdevsw, du, UID_ROOT, GID_OPERATOR, 0600, "%s", nu);
295 if (isp->isp_osinfo.cdev) {
296 isp->isp_osinfo.cdev->si_drv1 = isp;
305 ISP_GET_PC(isp, chan, sim, sim);
306 ISP_GET_PC(isp, chan, path, path);
308 ISP_LOCK(isp);
310 ISP_UNLOCK(isp);
313 if (isp->isp_osinfo.ehook_active) {
314 config_intrhook_disestablish(&isp->isp_osinfo.ehook);
315 isp->isp_osinfo.ehook_active = 0;
317 if (isp->isp_osinfo.cdev) {
318 destroy_dev(isp->isp_osinfo.cdev);
319 isp->isp_osinfo.cdev = NULL;
321 cam_simq_free(isp->isp_osinfo.devq);
322 isp->isp_osinfo.devq = NULL;
327 isp_detach(ispsoftc_t *isp)
332 ISP_LOCK(isp);
333 for (chan = isp->isp_nchan - 1; chan >= 0; chan -= 1) {
334 ISP_GET_PC(isp, chan, sim, sim);
336 ISP_UNLOCK(isp);
341 isp->isp_osinfo.is_exiting = 1;
342 if (isp->isp_osinfo.timer_active) {
343 callout_stop(&isp->isp_osinfo.tmo);
344 isp->isp_osinfo.timer_active = 0;
346 for (chan = isp->isp_nchan - 1; chan >= 0; chan -= 1)
347 isp_detach_chan(isp, chan);
348 ISP_UNLOCK(isp);
350 if (isp->isp_osinfo.cdev) {
351 destroy_dev(isp->isp_osinfo.cdev);
352 isp->isp_osinfo.cdev = NULL;
354 if (isp->isp_osinfo.ehook_active) {
355 config_intrhook_disestablish(&isp->isp_osinfo.ehook);
356 isp->isp_osinfo.ehook_active = 0;
358 if (isp->isp_osinfo.devq != NULL) {
359 cam_simq_free(isp->isp_osinfo.devq);
360 isp->isp_osinfo.devq = NULL;
366 isp_freeze_loopdown(ispsoftc_t *isp, int chan)
368 if (IS_FC(isp)) {
369 struct isp_fc *fc = ISP_FC_PC(isp, chan);
371 isp_prt(isp, ISP_LOGDEBUG0,
379 isp_prt(isp, ISP_LOGDEBUG0,
387 isp_unfreeze_loopdown(ispsoftc_t *isp, int chan)
389 if (IS_FC(isp)) {
390 struct isp_fc *fc = ISP_FC_PC(isp, chan);
394 isp_prt(isp, ISP_LOGDEBUG0,
408 ispsoftc_t *isp;
411 isp = dev->si_drv1;
416 int olddblev = isp->isp_dblev;
417 isp->isp_dblev = *(int *)addr;
424 if (chan < 0 || chan >= isp->isp_nchan) {
428 if (IS_FC(isp)) {
429 *(int *)addr = FCPARAM(isp, chan)->role;
436 if (IS_SCSI(isp))
440 if (chan < 0 || chan >= isp->isp_nchan) {
449 ISP_LOCK(isp);
450 *(int *)addr = FCPARAM(isp, chan)->role;
451 retval = isp_control(isp, ISPCTL_CHANGE_ROLE, chan, nr);
452 ISP_UNLOCK(isp);
457 ISP_LOCK(isp);
458 isp_reinit(isp, 0);
459 ISP_UNLOCK(isp);
464 if (IS_FC(isp)) {
466 if (chan < 0 || chan >= isp->isp_nchan) {
470 ISP_LOCK(isp);
471 if (isp_fc_runstate(isp, chan, 5 * 1000000) != LOOP_READY) {
476 ISP_UNLOCK(isp);
481 if (IS_FC(isp)) {
483 if (chan < 0 || chan >= isp->isp_nchan) {
487 ISP_LOCK(isp);
488 if (isp_control(isp, ISPCTL_SEND_LIP, chan)) {
493 ISP_UNLOCK(isp);
501 if (IS_SCSI(isp)) {
508 lp = &FCPARAM(isp, ifc->chan)->portdb[ifc->loopid];
527 sp->isp_type = isp->isp_type;
528 sp->isp_revision = isp->isp_revision;
529 ISP_LOCK(isp);
530 sp->isp_stats[ISP_INTCNT] = isp->isp_intcnt;
531 sp->isp_stats[ISP_INTBOGUS] = isp->isp_intbogus;
532 sp->isp_stats[ISP_INTMBOXC] = isp->isp_intmboxc;
533 sp->isp_stats[ISP_INGOASYNC] = isp->isp_intoasync;
534 sp->isp_stats[ISP_RSLTCCMPLT] = isp->isp_rsltccmplt;
535 sp->isp_stats[ISP_FPHCCMCPLT] = isp->isp_fphccmplt;
536 sp->isp_stats[ISP_RSCCHIWAT] = isp->isp_rscchiwater;
537 sp->isp_stats[ISP_FPCCHIWAT] = isp->isp_fpcchiwater;
538 ISP_UNLOCK(isp);
543 ISP_LOCK(isp);
544 isp->isp_intcnt = 0;
545 isp->isp_intbogus = 0;
546 isp->isp_intmboxc = 0;
547 isp->isp_intoasync = 0;
548 isp->isp_rsltccmplt = 0;
549 isp->isp_fphccmplt = 0;
550 isp->isp_rscchiwater = 0;
551 isp->isp_fpcchiwater = 0;
552 ISP_UNLOCK(isp);
560 if (chan < 0 || chan >= isp->isp_nchan) {
564 hba->fc_fw_major = ISP_FW_MAJORX(isp->isp_fwrev);
565 hba->fc_fw_minor = ISP_FW_MINORX(isp->isp_fwrev);
566 hba->fc_fw_micro = ISP_FW_MICROX(isp->isp_fwrev);
567 hba->fc_nchannels = isp->isp_nchan;
568 if (IS_FC(isp)) {
570 hba->fc_speed = FCPARAM(isp, hba->fc_channel)->isp_gbspeed;
571 hba->fc_topology = FCPARAM(isp, chan)->isp_topo + 1;
572 hba->fc_loopid = FCPARAM(isp, chan)->isp_loopid;
573 hba->nvram_node_wwn = FCPARAM(isp, chan)->isp_wwnn_nvram;
574 hba->nvram_port_wwn = FCPARAM(isp, chan)->isp_wwpn_nvram;
575 hba->active_node_wwn = FCPARAM(isp, chan)->isp_wwnn;
576 hba->active_port_wwn = FCPARAM(isp, chan)->isp_wwpn;
596 if (IS_SCSI(isp)) {
601 if (chan < 0 || chan >= isp->isp_nchan) {
608 ISP_LOCK(isp);
609 if (IS_24XX(isp)) {
613 fcparam *fcp = FCPARAM(isp, chan);
625 ISP_UNLOCK(isp);
638 tmf->tmf_vpidx = ISP_GET_VPIDX(isp, chan);
668 ISP_UNLOCK(isp);
679 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
680 ISP_UNLOCK(isp);
684 isp_put_24xx_tmf(isp, tmf, fcp->isp_scratch);
685 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, QENTRY_LEN, chan);
688 retval = isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
689 MEMORYBARRIER(isp, SYNC_SFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
690 isp_get_24xx_response(isp, &((isp24xx_statusreq_t *)fcp->isp_scratch)[1], sp);
691 FC_SCRATCH_RELEASE(isp, chan);
693 FC_SCRATCH_RELEASE(isp, chan);
703 if (ISP_CAP_2KLOGIN(isp) == 0) {
741 FCPARAM(isp, chan)->sendmarker = 1;
743 retval = isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
749 ISP_UNLOCK(isp);
762 ispsoftc_t *isp = arg;
763 ISP_LOCK(isp);
764 if (IS_FC(isp)) {
765 for (chan = 0; chan < isp->isp_nchan; chan++) {
766 if (FCPARAM(isp, chan)->role != ISP_ROLE_NONE) {
767 ISP_ENABLE_INTS(isp);
772 ISP_ENABLE_INTS(isp);
774 isp->isp_osinfo.ehook_active = 0;
775 ISP_UNLOCK(isp);
777 config_intrhook_disestablish(&isp->isp_osinfo.ehook);
788 isp_get_pcmd(ispsoftc_t *isp, union ccb *ccb)
790 ISP_PCMD(ccb) = isp->isp_osinfo.pcmd_free;
794 isp->isp_osinfo.pcmd_free = ((struct isp_pcmd *)ISP_PCMD(ccb))->next;
799 isp_free_pcmd(ispsoftc_t *isp, union ccb *ccb)
808 PISP_PCMD(ccb)->next = isp->isp_osinfo.pcmd_free;
809 isp->isp_osinfo.pcmd_free = ISP_PCMD(ccb);
850 is_lun_enabled(ispsoftc_t *isp, int bus, lun_id_t lun)
855 ISP_GET_PC_ADDR(isp, bus, lun_hash[LUN_HASH_FUNC(lun)], lhp);
865 dump_tstates(ispsoftc_t *isp, int bus)
871 if (bus >= isp->isp_nchan) {
875 ISP_GET_PC_ADDR(isp, bus, lun_hash[i], lhp);
885 get_lun_statep(ispsoftc_t *isp, int bus, lun_id_t lun)
890 if (bus < isp->isp_nchan) {
891 ISP_GET_PC_ADDR(isp, bus, lun_hash[LUN_HASH_FUNC(lun)], lhp);
903 get_lun_statep_from_tag(ispsoftc_t *isp, int bus, uint32_t tagval)
910 if (bus < isp->isp_nchan && tagval != 0) {
912 ISP_GET_PC_ADDR(isp, bus, lun_hash[i], lhp);
914 atp = isp_find_atpd(isp, tptr, tagval);
926 get_ntp_from_tagdata(ispsoftc_t *isp, uint32_t tag_id, uint32_t seq_id, tstate_t **rslt)
933 for (bus = 0; bus < isp->isp_nchan; bus++) {
935 ISP_GET_PC_ADDR(isp, bus, lun_hash[i], lhp);
937 ntp = isp_find_ntpd(isp, tptr, tag_id, seq_id);
950 rls_lun_statep(ispsoftc_t *isp, tstate_t *tptr)
957 isp_tmcmd_restart(ispsoftc_t *isp)
966 for (bus = 0; bus < isp->isp_nchan; bus++) {
968 ISP_GET_PC_ADDR(isp, bus, lun_hash[i], lhp);
975 if (IS_24XX(isp)) {
976 isp_prt(isp, ISP_LOGTDEBUG0, "%s: restarting resrc deprived %x", __func__, ((at7_entry_t *)ntp->rd.data)->at_rxid);
977 isp_handle_platform_atio7(isp, (at7_entry_t *) ntp->rd.data);
979 isp_prt(isp, ISP_LOGTDEBUG0, "%s: restarting resrc deprived %x", __func__, ((at2_entry_t *)ntp->rd.data)->at_rxid);
980 isp_handle_platform_atio2(isp, (at2_entry_t *) ntp->rd.data);
982 isp_put_ntpd(isp, tptr, ntp);
999 isp_target_start_ctio(isp, ccb, FROM_TIMER);
1007 isp_get_atpd(ispsoftc_t *isp, tstate_t *tptr, uint32_t tag)
1021 isp_find_atpd(ispsoftc_t *isp, tstate_t *tptr, uint32_t tag)
1033 isp_put_atpd(ispsoftc_t *isp, tstate_t *tptr, atio_private_data_t *atp)
1036 isp_put_ecmd(isp, atp->ests);
1044 isp_dump_atpd(ispsoftc_t *isp, tstate_t *tptr)
1057 isp_get_ntpd(ispsoftc_t *isp, tstate_t *tptr)
1068 isp_find_ntpd(ispsoftc_t *isp, tstate_t *tptr, uint32_t tag_id, uint32_t seq_id)
1080 isp_put_ntpd(ispsoftc_t *isp, tstate_t *tptr, inot_private_data_t *ntp)
1088 create_lun_state(ispsoftc_t *isp, int bus, struct cam_path *path, tstate_t **rslt)
1098 if (ISP_MAX_LUNS(isp) > 0 && lun >= ISP_MAX_LUNS(isp)) {
1102 if (is_lun_enabled(isp, bus, lun)) {
1127 ISP_GET_PC_ADDR(isp, bus, lun_hash[LUN_HASH_FUNC(lun)], lhp);
1130 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, path, "created tstate\n");
1135 destroy_lun_state(ispsoftc_t *isp, tstate_t *tptr)
1158 ISP_GET_PC_ADDR(isp, cam_sim_bus(xpt_path_sim(tptr->owner)), lun_hash[LUN_HASH_FUNC(tptr->ts_lun)], lhp);
1160 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, tptr->owner, "destroyed tstate\n");
1166 isp_enable_lun(ispsoftc_t *isp, union ccb *ccb)
1173 if (!IS_FC(isp) || !ISP_CAP_TMODE(isp) || !ISP_CAP_SCCFW(isp)) {
1187 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0|ISP_LOGCONFIG, ccb->ccb_h.path,
1196 tptr = get_lun_statep(isp, bus, lun);
1202 ccb->ccb_h.status = create_lun_state(isp, bus, ccb->ccb_h.path, &tptr);
1208 rls_lun_statep(isp, tptr);
1214 isp_disable_lun(ispsoftc_t *isp, union ccb *ccb)
1224 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0|ISP_LOGCONFIG, ccb->ccb_h.path,
1233 if ((tptr = get_lun_statep(isp, bus, lun)) == NULL) {
1239 destroy_lun_state(isp, tptr);
1245 isp_target_start_ctio(ispsoftc_t *isp, union ccb *ccb, enum Start_Ctio_How how)
1255 tptr = get_lun_statep(isp, XS_CHANNEL(ccb), XS_LUN(ccb));
1257 tptr = get_lun_statep(isp, XS_CHANNEL(ccb), CAM_LUN_WILDCARD);
1259 isp_prt(isp, ISP_LOGERR, "%s: [0x%x] cannot find tstate pointer", __func__, ccb->csio.tag_id);
1265 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,
1290 ISP_PATH_PRT(isp, ISP_LOGERR, ccb->ccb_h.path, "a data transfer length of zero but no status to send is wrong\n");
1297 atp = isp_find_atpd(isp, tptr, cso->tag_id);
1299 isp_prt(isp, ISP_LOGERR, "%s: [0x%x] cannot find private data adjunct in %s", __func__, cso->tag_id, __func__);
1300 isp_dump_atpd(isp, tptr);
1310 isp_prt(isp, ISP_LOGERR, "%s: [0x%x] not sending a CTIO for a dead command", __func__, cso->tag_id);
1319 fcp = FCPARAM(isp, XS_CHANNEL(ccb));
1321 isp_prt(isp, ISP_LOGERR, "%s: [0x%x] stopping sending a CTIO because we're no longer in target mode", __func__, cso->tag_id);
1332 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);
1351 isp_prt(isp, ISP_LOGTINFO, "[0x%x] now sending synthesized status orig_dl=%u xfered=%u bit=%u",
1388 isp_prt(isp, ISP_LOGERR, "%s: [0x%x] data overflow by %u bytes", __func__, cso->tag_id, tmp - atp->orig_datalen);
1394 if (IS_24XX(isp)) {
1406 cto->ct_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(ccb));
1448 atp->ests = isp_get_ecmd(isp);
1473 isp_put_fcp_rsp_iu(isp, rp, atp->ests);
1476 isp_put_fcp_rsp_iu(isp, rp, atp->ests);
1478 if (isp->isp_dblev & ISP_LOGTDEBUG1) {
1479 isp_print_bytes(isp, "FCP Response Frame After Swizzling", MIN_FCP_RESPONSE_SIZE + sense_length, atp->ests);
1481 addr = isp->isp_osinfo.ecmd_dma;
1482 addr += ((((isp_ecmd_t *)atp->ests) - isp->isp_osinfo.ecmd_base) * XCMD_SIZE);
1483 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,
1484 (uintmax_t) isp->isp_osinfo.ecmd_dma, (uintmax_t)addr, MIN_FCP_RESPONSE_SIZE + sense_length);
1491 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__,
1495 isp_prt(isp, ISP_LOGDEBUG0, "%s: CTIO7[0x%x] seq %u nc %d CDB0=%x sstatus=0x%x flags=0x%x resid=%d", __func__,
1516 if (ISP_FC_PC(isp, XS_CHANNEL(ccb))->inject_lost_data_frame && xfrlen > ISP_FC_PC(isp, XS_CHANNEL(ccb))->inject_lost_data_frame) {
1517 isp_prt(isp, ISP_LOGWARN, "%s: truncating data frame with xfrlen %d to %d", __func__, xfrlen, xfrlen - (xfrlen >> 2));
1518 ISP_FC_PC(isp, XS_CHANNEL(ccb))->inject_lost_data_frame = 0;
1538 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__,
1544 if (isp->isp_osinfo.sixtyfourbit)
1551 if (ISP_CAP_2KLOGIN(isp)) {
1555 if (ISP_CAP_SCCFW(isp) == 0) {
1603 atp->ests = isp_get_ecmd(isp);
1627 isp_put_fcp_rsp_iu(isp, rp, atp->ests);
1630 isp_put_fcp_rsp_iu(isp, rp, atp->ests);
1632 if (isp->isp_dblev & ISP_LOGTDEBUG1) {
1633 isp_print_bytes(isp, "FCP Response Frame After Swizzling", MIN_FCP_RESPONSE_SIZE + sense_length, atp->ests);
1635 addr = isp->isp_osinfo.ecmd_dma;
1636 addr += ((((isp_ecmd_t *)atp->ests) - isp->isp_osinfo.ecmd_base) * XCMD_SIZE);
1637 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,
1638 (uintmax_t) isp->isp_osinfo.ecmd_dma, (uintmax_t)addr, MIN_FCP_RESPONSE_SIZE + sense_length);
1640 if (isp->isp_osinfo.sixtyfourbit) {
1650 isp_prt(isp, ISP_LOGTDEBUG0, "%s: CTIO2[0x%x] seq %u nc %d CDB0=%x sstatus=0x%x flags=0x%x resid=%d sense: %x %x/%x/%x", __func__,
1654 isp_prt(isp, ISP_LOGTDEBUG0, "%s: CTIO2[0x%x] seq %u nc %d CDB0=%x sstatus=0x%x flags=0x%x resid=%d", __func__, cto->ct_rxid,
1688 isp_prt(isp, ISP_LOGTDEBUG0, "%s: CTIO2[%x] seq %u nc %d CDB0=%x scsi status %x flags %x resid %d xfrlen %u offset %u", __func__, cto->ct_rxid,
1692 if (isp_get_pcmd(isp, ccb)) {
1693 ISP_PATH_PRT(isp, ISP_LOGWARN, ccb->ccb_h.path, "out of PCMDs\n");
1697 handle = isp_allocate_handle(isp, ccb, ISP_HANDLE_TARGET);
1699 ISP_PATH_PRT(isp, ISP_LOGWARN, ccb->ccb_h.path, "No XFLIST pointers for %s\n", __func__);
1701 isp_free_pcmd(isp, ccb);
1717 if (IS_24XX(isp)) {
1725 dmaresult = ISP_DMASETUP(isp, cso, (ispreq_t *) local);
1727 isp_destroy_handle(isp, handle);
1728 isp_free_pcmd(isp, ccb);
1737 isp->isp_nactive++;
1747 rls_lun_statep(isp, tptr);
1763 ispsoftc_t *isp = tp->isp;
1765 ISP_ASSERT_LOCKED(isp);
1766 if (isp_notify_ack(isp, tp->not)) {
1777 ispsoftc_t *isp;
1782 isp = XS_ISP(ccb);
1784 qe = isp_getrqentry(isp);
1797 if (ISP_CAP_SCCFW(isp)) {
1809 isp_put_atio2(isp, at, qe);
1810 ISP_TDQE(isp, "isp_target_putback_atio", isp->isp_reqidx, qe);
1811 ISP_SYNC_REQUEST(isp);
1825 isp_handle_platform_atio2(ispsoftc_t *isp, at2_entry_t *aep)
1843 isp_prt(isp, ISP_LOGWARN, "bogus atio (0x%x) leaked to platform", aep->at_status);
1844 isp_endcmd(isp, aep, SCSI_STATUS_BUSY, 0);
1848 fcp = FCPARAM(isp, 0);
1849 if (ISP_CAP_SCCFW(isp)) {
1857 if (ISP_CAP_2KLOGIN(isp)) {
1862 tptr = get_lun_statep(isp, 0, lun);
1864 tptr = get_lun_statep(isp, 0, CAM_LUN_WILDCARD);
1866 isp_prt(isp, ISP_LOGWARN, "%s: [0x%x] no state pointer for lun %d or wildcard", __func__, aep->at_rxid, lun);
1868 isp_endcmd(isp, aep, SCSI_STATUS_BUSY, 0);
1870 isp_endcmd(isp, aep, SCSI_STATUS_CHECK_COND | ECMD_SVALID | (0x5 << 12) | (0x25 << 16), 0);
1885 isp_prt(isp, ISP_LOGTDEBUG0, "%s: restarting resrc deprived %x", __func__, ((at2_entry_t *)ntp->rd.data)->at_rxid);
1886 isp_handle_platform_atio2(isp, (at2_entry_t *) ntp->rd.data);
1887 isp_put_ntpd(isp, tptr, ntp);
1910 atp = isp_get_atpd(isp, tptr, aep->at_rxid);
1918 isp_prt(isp, ISP_LOGTDEBUG2, "Take FREE ATIO count now %d", tptr->atio_count);
1930 if (IS_2100(isp))
1933 if ((isp_find_pdb_by_handle(isp, 0, nphdl, &lp) == 0 ||
1940 isp_add_wwn_entry(isp, 0, wwpn, INI_NONE,
1944 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, 0,
1946 isp_find_pdb_by_handle(isp, 0, nphdl, &lp);
1948 atiop->init_id = FC_PORTDB_TGT(isp, 0, lp);
1984 isp_prt(isp, ISP_LOGTDEBUG0, "ATIO2[0x%x] CDB=0x%x lun %d datalen %u", aep->at_rxid, atp->cdb0, lun, atp->orig_datalen);
1985 rls_lun_statep(isp, tptr);
1988 ntp = isp_get_ntpd(isp, tptr);
1990 rls_lun_statep(isp, tptr);
1991 isp_endcmd(isp, aep, nphdl, 0, SCSI_STATUS_BUSY, 0);
1997 rls_lun_statep(isp, tptr);
2001 isp_handle_platform_atio7(ispsoftc_t *isp, at7_entry_t *aep)
2029 if (ISP_CAP_MULTI_ID(isp) && isp->isp_nchan > 1) {
2033 isp_find_chan_by_did(isp, did, &chan);
2043 if (NANOTIME_SUB(&isp->isp_init_time, &now) > 2000000000ULL) {
2044 isp_prt(isp, ISP_LOGWARN, "%s: [RX_ID 0x%x] D_ID %x not found on any channel- dropping", __func__, aep->at_rxid, did);
2045 isp_endcmd(isp, aep, NIL_HANDLE, ISP_NOCHAN, ECMD_TERMINATE, 0);
2048 tptr = get_lun_statep(isp, 0, 0);
2050 tptr = get_lun_statep(isp, 0, CAM_LUN_WILDCARD);
2052 isp_prt(isp, ISP_LOGWARN, "%s: [RX_ID 0x%x] D_ID %x not found on any channel and no tptr- dropping", __func__, aep->at_rxid, did);
2053 isp_endcmd(isp, aep, NIL_HANDLE, ISP_NOCHAN, ECMD_TERMINATE, 0);
2057 isp_prt(isp, ISP_LOGWARN, "%s: [RX_ID 0x%x] D_ID %x not found on any channel- deferring", __func__, aep->at_rxid, did);
2060 isp_prt(isp, ISP_LOGTDEBUG0, "%s: [RX_ID 0x%x] D_ID 0x%06x found on Chan %d for S_ID 0x%06x", __func__, aep->at_rxid, did, chan, sid);
2068 if (isp_find_pdb_by_portid(isp, chan, sid, &lp) == 0) {
2072 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",
2074 isp_dump_portdb(isp, chan);
2075 isp_endcmd(isp, aep, NIL_HANDLE, chan, ECMD_TERMINATE, 0);
2083 tptr = get_lun_statep(isp, chan, lun);
2085 tptr = get_lun_statep(isp, chan, CAM_LUN_WILDCARD);
2087 isp_prt(isp, ISP_LOGWARN,
2091 isp_endcmd(isp, aep, nphdl, SCSI_STATUS_BUSY, 0);
2093 isp_endcmd(isp, aep, nphdl, chan, SCSI_STATUS_CHECK_COND | ECMD_SVALID | (0x5 << 12) | (0x25 << 16), 0);
2108 isp_prt(isp, ISP_LOGTDEBUG0, "%s: restarting resrc deprived %x", __func__, ((at7_entry_t *)ntp->rd.data)->at_rxid);
2109 isp_handle_platform_atio7(isp, (at7_entry_t *) ntp->rd.data);
2110 isp_put_ntpd(isp, tptr, ntp);
2117 isp_prt(isp, ISP_LOGTDEBUG0, "%s: restart queue refilling", __func__);
2135 rls_lun_statep(isp, tptr);
2136 isp_endcmd(isp, aep, nphdl, chan, SCSI_BUSY, 0);
2145 isp_prt(isp, ISP_LOGTDEBUG0, "[0x%x] out of atios", aep->at_rxid);
2149 oatp = isp_find_atpd(isp, tptr, aep->at_rxid);
2151 isp_prt(isp, ISP_LOGTDEBUG0, "[0x%x] tag wraparound in isp_handle_platforms_atio7 (N-Port Handle 0x%04x S_ID 0x%04x OX_ID 0x%04x) oatp state %d",
2158 atp = isp_get_atpd(isp, tptr, aep->at_rxid);
2160 isp_prt(isp, ISP_LOGTDEBUG0, "[0x%x] out of atps", aep->at_rxid);
2167 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, atiop->ccb_h.path, "Take FREE ATIO count now %d\n", tptr->atio_count);
2168 atiop->init_id = FC_PORTDB_TGT(isp, chan, lp);
2169 atiop->ccb_h.target_id = FCPARAM(isp, chan)->isp_loopid;
2174 isp_prt(isp, ISP_LOGWARN, "additional CDBLEN ignored");
2211 isp_prt(isp, ISP_LOGTDEBUG0, "ATIO7[0x%x] CDB=0x%x lun %jx datalen %u",
2214 rls_lun_statep(isp, tptr);
2218 isp_put_atpd(isp, tptr, atp);
2220 ntp = isp_get_ntpd(isp, tptr);
2222 rls_lun_statep(isp, tptr);
2223 isp_endcmd(isp, aep, nphdl, chan, SCSI_STATUS_BUSY, 0);
2229 rls_lun_statep(isp, tptr);
2240 isp_handle_srr_start(ispsoftc_t *isp, tstate_t *tptr, atio_private_data_t *atp)
2252 isp_prt(isp, ISP_LOGWARN, "SRR[0x%x] null ccb", atp->tag);
2268 isp_prt(isp, ISP_LOGWARN, "SRR[0x%x] SRR offset 0x%x but current CCB doesn't transfer data", atp->tag, srr_off);
2272 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);
2275 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);
2278 isp_prt(isp, ISP_LOGTINFO, "SRR[0x%x] Got an FCP RSP SRR- resending status", atp->tag);
2288 isp_prt(isp, ISP_LOGWARN, "Got an FCP DATA IN SRR- dropping");
2292 isp_prt(isp, ISP_LOGWARN, "Got an unknown information (%x) SRR- dropping", inot->in_srr_iu);
2301 if (isp_notify_ack(isp, inot)) {
2302 isp_prt(isp, ISP_LOGWARN, "could not push positive ack for SRR- you lose");
2305 isp_target_start_ctio(isp, ccb, FROM_SRR);
2309 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot);
2315 if (isp_notify_ack(isp, inot)) {
2316 isp_prt(isp, ISP_LOGWARN, "could not push positive ack for SRR- you lose");
2338 isp_handle_srr_notify(ispsoftc_t *isp, void *inot_raw)
2346 if (!IS_24XX(isp)) {
2347 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot_raw);
2351 tptr = get_lun_statep_from_tag(isp, bus, tag);
2353 isp_prt(isp, ISP_LOGERR, "%s: cannot find tptr for tag %x in SRR Notify", __func__, tag);
2354 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot);
2357 atp = isp_find_atpd(isp, tptr, tag);
2359 rls_lun_statep(isp, tptr);
2360 isp_prt(isp, ISP_LOGERR, "%s: cannot find adjunct for %x in SRR Notify", __func__, tag);
2361 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot);
2366 isp_prt(isp, ISP_LOGTINFO /* ISP_LOGTDEBUG0 */, "SRR[0x%x] inot->in_rxid flags 0x%x srr_iu=%x reloff 0x%x", inot->in_rxid, inot->in_flags, inot->in_srr_iu,
2369 isp_handle_srr_start(isp, tptr, atp);
2370 rls_lun_statep(isp, tptr);
2374 isp_handle_platform_ctio(ispsoftc_t *isp, void *arg)
2384 ccb = isp_find_xs(isp, handle);
2386 isp_print_bytes(isp, "null ccb in isp_handle_platform_ctio", QENTRY_LEN, arg);
2389 isp_destroy_handle(isp, handle);
2391 isp_free_pcmd(isp, ccb);
2392 if (isp->isp_nactive) {
2393 isp->isp_nactive--;
2397 tptr = get_lun_statep(isp, bus, XS_LUN(ccb));
2399 tptr = get_lun_statep(isp, bus, CAM_LUN_WILDCARD);
2402 isp_prt(isp, ISP_LOGERR, "%s: cannot find tptr for tag %x after I/O", __func__, ccb->csio.tag_id);
2406 if (IS_24XX(isp)) {
2407 atp = isp_find_atpd(isp, tptr, ((ct7_entry_t *)arg)->ct_rxid);
2409 atp = isp_find_atpd(isp, tptr, ((ct2_entry_t *)arg)->ct_rxid);
2417 atp = isp_find_atpd(isp, tptr, ccb->csio.tag_id);
2420 rls_lun_statep(isp, tptr);
2421 isp_prt(isp, ISP_LOGERR, "%s: cannot find adjunct for %x after I/O", __func__, ccb->csio.tag_id);
2429 if (IS_24XX(isp)) {
2435 isp_handle_srr_start(isp, tptr, atp);
2436 rls_lun_statep(isp, tptr);
2450 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),
2457 isp_handle_srr_start(isp, tptr, atp);
2458 rls_lun_statep(isp, tptr);
2473 isp_prt(isp, ok? ISP_LOGTDEBUG0 : ISP_LOGWARN, "%s: CTIO2[%x] seq %u nc %d sts 0x%x flg 0x%x sns %d resid %d %s", __func__, ct->ct_rxid, ATPD_GET_SEQNO(ct),
2493 rls_lun_statep(isp, tptr);
2499 isp_prt(isp, ISP_LOGTDEBUG0, "%s CTIO[0x%x] done (ok=%d nc=%d nowsendstatus=%d ccb ss=%d)",
2503 isp_target_start_ctio(isp, ccb, FROM_CTIO_DONE);
2520 if (ok || IS_24XX(isp)) {
2528 isp_handle_platform_notify_fc(ispsoftc_t *isp, in_fcentry_t *inp)
2537 isp_prt(isp, ISP_LOGWARN, "port logout of S_ID 0x%x", inp->in_iid);
2540 isp_prt(isp, ISP_LOGWARN, "port changed for S_ID 0x%x", inp->in_iid);
2543 isp_del_all_wwn_entries(isp, 0);
2544 isp_prt(isp, ISP_LOGINFO, "all ports logged out");
2556 if (ISP_CAP_SCCFW(isp)) {
2564 if (ISP_CAP_2KLOGIN(isp)) {
2569 if (isp_find_pdb_by_handle(isp, 0, nphdl, &lp)) {
2576 tptr = get_lun_statep(isp, 0, lun);
2578 tptr = get_lun_statep(isp, 0, CAM_LUN_WILDCARD);
2580 isp_prt(isp, ISP_LOGWARN, "ABORT TASK for lun %x, but no tstate", lun);
2584 atp = isp_find_atpd(isp, tptr, inp->in_seqid);
2588 isp_prt(isp, ISP_LOGTDEBUG0, "ABORT TASK RX_ID %x WWN 0x%016llx state %d", inp->in_seqid, (unsigned long long) wwn, atp->state);
2592 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, inot->ccb_h.path, "%s: Take FREE INOT count now %d\n", __func__, tptr->inot_count);
2594 ISP_PATH_PRT(isp, ISP_LOGWARN, tptr->owner, "out of INOT structures\n");
2597 ISP_PATH_PRT(isp, ISP_LOGWARN, tptr->owner, "abort task RX_ID %x from wwn 0x%016llx, state unknown\n", inp->in_seqid, wwn);
2602 nt->nt_hba = isp;
2603 nt->nt_tgt = FCPARAM(isp, 0)->isp_wwpn;
2613 isp_handle_platform_target_tmf(isp, nt);
2616 rls_lun_statep(isp, tptr);
2623 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inp);
2628 isp_handle_platform_notify_24xx(ispsoftc_t *isp, in_fcentry_24xx_t *inot)
2649 int chan = ISP_GET_VPIDX(isp, inot->in_vpidx);
2660 isp_del_wwn_entry(isp, chan, wwpn, nphdl, portid);
2669 isp_add_wwn_entry(isp, chan, wwpn, wwnn,
2678 isp_add_wwn_entry(isp, chan, wwpn, wwnn,
2693 isp_prt(isp, ISP_LOGERR, "%s Chan %d ELS N-port handle %x PortID 0x%06x marked as needing a PUREX response", msg, chan, nphdl, portid);
2696 isp_prt(isp, ISP_LOGTDEBUG0, "%s Chan %d ELS N-port handle %x PortID 0x%06x RX_ID 0x%x OX_ID 0x%x", msg, chan, nphdl, portid,
2698 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot);
2704 if (isp_find_pdb_by_handle(isp, ISP_GET_VPIDX(isp, inot->in_vpidx), nphdl, &lp)) {
2705 isp_del_wwn_entry(isp, ISP_GET_VPIDX(isp, inot->in_vpidx), lp->port_wwn, nphdl, lp->portid);
2715 isp_prt(isp, ISP_LOGINFO, "Chan %d %s (sub-status 0x%x) for N-port handle 0x%x", ISP_GET_VPIDX(isp, inot->in_vpidx), msg, inot->in_status_subcode, nphdl);
2723 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot);
2728 isp_handle_srr_notify(isp, inot);
2742 isp_prt(isp, ISP_LOGWARN, "Chan %d %s", ISP_GET_VPIDX(isp, inot->in_vpidx), msg);
2743 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot);
2749 isp_handle_platform_target_notify_ack(ispsoftc_t *isp, isp_notify_t *mp)
2752 if (isp->isp_state != ISP_RUNSTATE) {
2753 isp_prt(isp, ISP_LOGTINFO, "Notify Code 0x%x (qevalid=%d) acked- h/w not ready (dropping)", mp->nt_ncode, mp->nt_lreserved != NULL);
2760 if (IS_24XX(isp) && mp->nt_lreserved && ((isphdr_t *)mp->nt_lreserved)->rqs_entry_type == RQSTYPE_ATIO) {
2768 if (isp_find_pdb_by_portid(isp, mp->nt_channel, sid, &lp)) {
2784 return (isp_target_put_entry(isp, &local));
2790 if (IS_24XX(isp) && mp->nt_lreserved && ((isphdr_t *)mp->nt_lreserved)->rqs_entry_type == RQSTYPE_ABTS_RCVD) {
2801 isp_prt(isp, ISP_LOGTDEBUG0, "%s: [%x] terminating after ABTS received", __func__, abts->abts_rxid_task);
2811 if (isp_target_put_entry(isp, cto)) {
2816 if (isp_acknak_abts(isp, mp->nt_lreserved, 0) == ENOMEM) {
2827 isp_del_all_wwn_entries(isp, mp->nt_channel);
2831 if (!IS_2100(isp) && IS_FC(isp)) {
2832 isp_del_wwn_entries(isp, mp);
2840 isp_prt(isp, ISP_LOGTINFO, "Notify Code 0x%x (qevalid=%d) being acked", mp->nt_ncode, mp->nt_lreserved != NULL);
2844 return (isp_notify_ack(isp, mp->nt_lreserved));
2857 isp_handle_platform_target_tmf(ispsoftc_t *isp, isp_notify_t *notify)
2865 isp_prt(isp, ISP_LOGTDEBUG0, "%s: code 0x%x sid 0x%x tagval 0x%016llx chan %d lun 0x%x", __func__, notify->nt_ncode,
2878 tptr = get_lun_statep(isp, notify->nt_channel, lun);
2880 tptr = get_lun_statep(isp, notify->nt_channel, CAM_LUN_WILDCARD);
2882 isp_prt(isp, ISP_LOGWARN, "%s: no state pointer found for chan %d lun 0x%x", __func__, notify->nt_channel, lun);
2888 isp_prt(isp, ISP_LOGWARN, "%s: out of immediate notify structures for chan %d lun 0x%x", __func__, notify->nt_channel, lun);
2892 if (isp_find_pdb_by_portid(isp, notify->nt_channel, notify->nt_sid, &lp) == 0 &&
2893 isp_find_pdb_by_handle(isp, notify->nt_channel, notify->nt_nphdl, &lp) == 0) {
2896 inot->initiator_id = FC_PORTDB_TGT(isp, notify->nt_channel, lp);
2903 isp_target_mark_aborted_early(isp, tptr, inot->tag_id);
2907 isp_target_mark_aborted_early(isp, tptr, TAG_ANY);
2929 isp_prt(isp, ISP_LOGWARN, "%s: unknown TMF code 0x%x for chan %d lun 0x%x", __func__, notify->nt_ncode, notify->nt_channel, lun);
2933 ntp = isp_get_ntpd(isp, tptr);
2935 isp_prt(isp, ISP_LOGWARN, "%s: out of inotify private structures", __func__);
2948 rls_lun_statep(isp, tptr);
2949 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, inot->ccb_h.path, "%s: Take FREE INOT count now %d\n", __func__, tptr->inot_count);
2955 rls_lun_statep(isp, tptr);
2959 if (isp_acknak_abts(isp, notify->nt_lreserved, ENOMEM)) {
2960 isp_prt(isp, ISP_LOGWARN, "you lose- unable to send an ACKNAK");
2963 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, notify->nt_lreserved);
2973 isp_target_mark_aborted(ispsoftc_t *isp, union ccb *ccb)
2979 tptr = get_lun_statep(isp, XS_CHANNEL(accb), XS_LUN(accb));
2981 tptr = get_lun_statep(isp, XS_CHANNEL(accb), CAM_LUN_WILDCARD);
2988 atp = isp_find_atpd(isp, tptr, accb->atio.tag_id);
2995 rls_lun_statep(isp, tptr);
2999 isp_target_mark_aborted_early(ispsoftc_t *isp, tstate_t *tptr, uint32_t tag_id)
3014 if (IS_24XX(isp)) {
3020 isp_put_ntpd(isp, tptr, ntp);
3043 ispsoftc_t *isp;
3046 isp = (ispsoftc_t *) cam_sim_softc(sim);
3052 if (IS_SCSI(isp)) {
3054 sdparam *sdp = SDPARAM(isp, bus);
3059 if (isp->isp_loaded_fw) {
3066 (void) isp_control(isp, ISPCTL_UPDATE_PARAMS, bus);
3072 isp_prt(isp, ISP_LOGWARN, "isp_cam_async: Code 0x%x", code);
3080 ispsoftc_t *isp = cam_sim_softc(sim);
3083 if (ISP_READ_ISR(isp, &isr, &sema, &info))
3084 isp_intr(isp, isr, sema, info);
3092 ispsoftc_t *isp;
3095 isp = XS_ISP(xs);
3097 handle = isp_find_handle(isp, xs);
3104 if (ISP_READ_ISR(isp, &isr, &sema, &info) != 0)
3105 isp_intr(isp, isr, sema, info);
3107 handle = isp_find_handle(isp, xs);
3118 if (isp_control(isp, ISPCTL_ABORT_CMD, xs) == 0) {
3126 xs = isp_find_xs(isp, handle);
3140 ISP_DMAFREE(isp, xs, handle);
3142 isp_destroy_handle(isp, handle);
3143 isp_prt(isp, ISP_LOGERR, "%s: timeout for handle 0x%x", __func__, handle);
3146 isp_prt_endcmd(isp, xs);
3150 isp_prt(isp, ISP_LOGWARN, "%s: timeout for handle 0x%x, recovered during interrupt", __func__, ohandle);
3152 isp_prt(isp, ISP_LOGWARN, "%s: timeout for handle already free", __func__);
3158 isp_make_here(ispsoftc_t *isp, fcportdb_t *fcp, int chan, int tgt)
3161 struct isp_fc *fc = ISP_FC_PC(isp, chan);
3168 isp_prt(isp, ISP_LOGWARN, "Chan %d unable to alloc CCB for rescan", chan);
3173 isp_prt(isp, ISP_LOGWARN, "unable to create path for rescan");
3181 isp_make_gone(ispsoftc_t *isp, fcportdb_t *fcp, int chan, int tgt)
3184 struct isp_fc *fc = ISP_FC_PC(isp, chan);
3213 ispsoftc_t *isp = fc->isp;
3214 int chan = fc - isp->isp_osinfo.pc.fc;
3220 ISP_LOCK(isp);
3221 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GDT timer expired", chan);
3223 lp = &FCPARAM(isp, chan)->portdb[dbidx];
3233 isp_prt(isp, ISP_LOGCONFIG, prom3, chan, dbidx, lp->portid, "Gone Device Timeout");
3236 isp_make_gone(isp, lp, chan, dbidx);
3255 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Stopping Gone Device Timer @ %lu", chan, (unsigned long) time_uptime);
3258 ISP_UNLOCK(isp);
3271 isp_loop_changed(ispsoftc_t *isp, int chan)
3273 fcparam *fcp = FCPARAM(isp, chan);
3274 struct isp_fc *fc = ISP_FC_PC(isp, chan);
3278 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0, "Chan %d Loop changed", chan);
3280 isp_freeze_loopdown(isp, chan);
3287 isp_loop_up(ispsoftc_t *isp, int chan)
3289 struct isp_fc *fc = ISP_FC_PC(isp, chan);
3291 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0, "Chan %d Loop is up", chan);
3295 isp_unfreeze_loopdown(isp, chan);
3299 isp_loop_dead(ispsoftc_t *isp, int chan)
3301 fcparam *fcp = FCPARAM(isp, chan);
3302 struct isp_fc *fc = ISP_FC_PC(isp, chan);
3308 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0, "Chan %d Loop is dead", chan);
3322 for (i = 0; i < isp->isp_maxcmds; i++) {
3325 if (ISP_H2HT(isp->isp_xflist[i].handle) != ISP_HANDLE_INITIATOR) {
3328 if ((xs = isp->isp_xflist[i].cmd) == NULL) {
3334 isp_prt(isp, ISP_LOGWARN, "command handle 0x%x for %d.%d.%jx orphaned by loop down timeout",
3335 isp->isp_xflist[i].handle, chan, XS_TGT(xs),
3339 isp_prt(isp, ISP_LOGCONFIG, prom3, chan, dbidx, lp->portid, "Loop Down Timeout");
3342 isp_make_gone(isp, lp, chan, dbidx);
3356 isp_unfreeze_loopdown(isp, chan);
3365 ispsoftc_t *isp = fc->isp;
3366 int chan = fc - isp->isp_osinfo.pc.fc;
3370 mtx_lock(&isp->isp_osinfo.lock);
3372 while (isp->isp_osinfo.is_exiting == 0) {
3373 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0,
3375 lb = isp_fc_runstate(isp, chan, 250000);
3376 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0,
3418 isp_loop_up(isp, chan);
3420 isp_loop_dead(isp, chan);
3423 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGDEBUG0,
3425 msleep(fc, &isp->isp_osinfo.lock, PRIBIO, "ispf", slp * hz);
3428 mtx_unlock(&isp->isp_osinfo.lock);
3436 ispsoftc_t *isp;
3441 isp = (ispsoftc_t *)cam_sim_softc(sim);
3442 mtx_assert(&isp->isp_lock, MA_OWNED);
3443 isp_prt(isp, ISP_LOGDEBUG2, "isp_action code %x", ccb->ccb_h.func_code);
3461 if (ccb->ccb_h.target_id >= ISP_MAX_TARGETS(isp)) {
3464 } else if (ISP_MAX_LUNS(isp) > 0 &&
3465 ccb->ccb_h.target_lun >= ISP_MAX_LUNS(isp)) {
3475 if (isp_get_pcmd(isp, ccb)) {
3476 isp_prt(isp, ISP_LOGWARN, "out of PCMDs");
3502 if (ISP_FC_PC(isp, bus)->loop_dead) {
3503 isp_prt(isp, ISP_LOGDEBUG0,
3510 isp_prt(isp, ISP_LOGDEBUG0, "%d.%jx retry later",
3515 isp_free_pcmd(isp, ccb);
3519 isp_free_pcmd(isp, ccb);
3529 isp_prt(isp, ISP_LOGERR, "What's this? 0x%x at %d in file %s", error, __LINE__, __FILE__);
3531 isp_free_pcmd(isp, ccb);
3539 isp_enable_lun(isp, ccb);
3541 isp_disable_lun(isp, ccb);
3548 tstate_t *tptr = get_lun_statep(isp, XS_CHANNEL(ccb), ccb->ccb_h.target_lun);
3550 tptr = get_lun_statep(isp, XS_CHANNEL(ccb), CAM_LUN_WILDCARD);
3563 ISP_PATH_PRT(isp, ISP_LOGWARN, ccb->ccb_h.path, "%s: [0x%x] no state pointer found for %s\n", __func__, tag, str);
3564 dump_tstates(isp, XS_CHANNEL(ccb));
3569 ccb->ccb_h.spriv_ptr1 = isp;
3573 atio_private_data_t *atp = isp_find_atpd(isp, tptr, ccb->atio.tag_id);
3575 isp_put_atpd(isp, tptr, atp);
3580 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, ccb->ccb_h.path, "Put FREE ATIO (tag id 0x%x), count now %d\n",
3585 inot_private_data_t *ntp = isp_find_ntpd(isp, tptr, ccb->cin1.tag_id, ccb->cin1.seq_id);
3587 isp_put_ntpd(isp, tptr, ntp);
3592 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, ccb->ccb_h.path, "Put FREE INOT, (seq id 0x%x) count now %d\n",
3598 ISP_PATH_PRT(isp, ISP_LOGTDEBUG2, ccb->ccb_h.path, "Put FREE INOT, (seq id 0x%x) count now %d\n",
3602 rls_lun_statep(isp, tptr);
3621 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);
3622 ntp = get_ntp_from_tagdata(isp, ccb->cna2.tag_id, ccb->cna2.seq_id, &tptr);
3624 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__,
3630 if (isp_handle_platform_target_notify_ack(isp, &ntp->rd.nt)) {
3631 rls_lun_statep(isp, tptr);
3638 isp_put_ntpd(isp, tptr, ntp);
3639 rls_lun_statep(isp, tptr);
3641 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);
3646 isp_target_start_ctio(isp, ccb, FROM_CAM);
3654 error = isp_control(isp, ISPCTL_RESET_DEV, bus, tgt);
3663 if (IS_FC(isp))
3664 isp_fcp_reset_crn(isp, bus, tgt, /*tgt_set*/ 1);
3676 isp_target_mark_aborted(isp, ccb);
3680 error = isp_control(isp, ISPCTL_ABORT_CMD, accb);
3707 if (IS_SCSI(isp)) {
3710 sdparam *sdp = SDPARAM(isp, bus);
3760 isp_prt(isp, ISP_LOGDEBUG0, "SET (%d.%d.%d) to flags %x off %x per %x", bus, tgt, cts->ccb_h.target_lun, sdp->isp_devparam[tgt].goal_flags,
3772 if (IS_FC(isp)) {
3773 fcparam *fcp = FCPARAM(isp, bus);
3797 sdparam *sdp = SDPARAM(isp, bus);
3803 (void) isp_control(isp, ISPCTL_UPDATE_PARAMS, bus);
3847 isp_prt(isp, ISP_LOGDEBUG0, "GET %s (%d.%d.%d) to flags %x off %x per %x", IS_CURRENT_SETTINGS(cts)? "ACTIVE" : "NVRAM",
3861 error = isp_control(isp, ISPCTL_RESET_BUS, bus);
3870 if (IS_FC(isp)) {
3871 xpt_async(AC_BUS_RESET, ISP_FC_PC(isp, bus)->path, 0);
3873 xpt_async(AC_BUS_RESET, ISP_SPI_PC(isp, bus)->path, 0);
3889 if (!IS_FC(isp)) {
3896 fcp = FCPARAM(isp, bus);
3899 fcp->isp_wwnn = ISP_FC_PC(isp, bus)->def_wwnn = kp->xport_specific.fc.wwnn;
3900 fcp->isp_wwpn = ISP_FC_PC(isp, bus)->def_wwpn = kp->xport_specific.fc.wwpn;
3901 isp_prt(isp, ISP_LOGALL, "Setting Channel %d wwns to 0x%jx 0x%jx", bus, fcp->isp_wwnn, fcp->isp_wwpn);
3935 ISP_PATH_PRT(isp, ISP_LOGCONFIG, ccb->ccb_h.path, "changing role on from %d to %d\n", fcp->role, newrole);
3936 if (isp_control(isp, ISPCTL_CHANGE_ROLE,
3951 if (IS_FC(isp)) {
3955 fcp = FCPARAM(isp, bus);
3987 if (IS_FC(isp) && ISP_CAP_TMODE(isp) && ISP_CAP_SCCFW(isp))
3993 cpi->max_target = ISP_MAX_TARGETS(isp) - 1;
3994 cpi->max_lun = ISP_MAX_LUNS(isp) == 0 ?
3995 255 : ISP_MAX_LUNS(isp) - 1;
3997 if (isp->isp_osinfo.sixtyfourbit)
4003 if (IS_FC(isp)) {
4004 fcparam *fcp = FCPARAM(isp, bus);
4023 if (IS_25XX(isp)) {
4025 } else if (IS_24XX(isp)) {
4027 } else if (IS_23XX(isp)) {
4040 sdparam *sdp = SDPARAM(isp, bus);
4070 ispsoftc_t *isp = XS_ISP(sccb);
4089 isp_prt(isp, ISP_LOGDEBUG0,
4093 else if ((IS_FC(isp))
4097 fcp = FCPARAM(isp, XS_CHANNEL(sccb));
4113 isp_free_pcmd(isp, (union ccb *) sccb);
4119 isp_async(ispsoftc_t *isp, ispasync_t cmd, ...)
4148 sdp = SDPARAM(isp, bus);
4150 if (xpt_create_path(&tmppath, NULL, cam_sim_path(ISP_SPI_PC(isp, bus)->sim), tgt, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
4151 isp_prt(isp, ISP_LOGWARN, "isp_async cannot make temp path for %d.%d", tgt, bus);
4183 isp_prt(isp, ISP_LOGDEBUG2, "NEW_TGT_PARAMS bus %d tgt %d period %x offset %x flags %x", bus, tgt, sdp->isp_devparam[tgt].actv_period, sdp->isp_devparam[tgt].actv_offset, flags);
4194 isp_prt(isp, ISP_LOGINFO, "SCSI bus reset on bus %d detected", bus);
4195 if (IS_FC(isp)) {
4196 xpt_async(AC_BUS_RESET, ISP_FC_PC(isp, bus)->path, NULL);
4198 xpt_async(AC_BUS_RESET, ISP_SPI_PC(isp, bus)->path, NULL);
4216 isp_fcp_reset_crn(isp, bus, /*tgt*/0, /*tgt_set*/ 0);
4217 isp_loop_changed(isp, bus);
4218 isp_prt(isp, ISP_LOGINFO, "Chan %d %s", bus, msg);
4224 isp_loop_changed(isp, bus);
4225 isp_prt(isp, ISP_LOGINFO, "Chan %d Loop UP", bus);
4232 fc = ISP_FC_PC(isp, bus);
4233 tgt = FC_PORTDB_TGT(isp, bus, lp);
4235 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->portid, lp->handle, buf, "arrived");
4236 if ((FCPARAM(isp, bus)->role & ISP_ROLE_INITIATOR) &&
4239 isp_fcp_reset_crn(isp, bus, tgt, /*tgt_set*/ 1);
4240 isp_make_here(isp, lp, bus, tgt);
4242 if ((FCPARAM(isp, bus)->role & ISP_ROLE_TARGET) &&
4259 fc = ISP_FC_PC(isp, bus);
4260 tgt = FC_PORTDB_TGT(isp, bus, lp);
4262 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->new_portid, lp->handle, buf, "changed");
4265 ((FCPARAM(isp, bus)->role & ISP_ROLE_INITIATOR) &&
4269 isp_fcp_reset_crn(isp, bus, tgt, /*tgt_set*/ 1);
4270 isp_make_here(isp, lp, bus, tgt);
4272 isp_make_gone(isp, lp, bus, tgt);
4273 isp_fcp_reset_crn(isp, bus, tgt, /*tgt_set*/ 1);
4277 ((FCPARAM(isp, bus)->role & ISP_ROLE_TARGET) &&
4294 fc = ISP_FC_PC(isp, bus);
4295 tgt = FC_PORTDB_TGT(isp, bus, lp);
4297 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->portid, lp->handle, buf, "stayed");
4304 fc = ISP_FC_PC(isp, bus);
4305 tgt = FC_PORTDB_TGT(isp, bus, lp);
4314 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->portid, lp->handle, buf, "gone zombie");
4316 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);
4321 isp_prt(isp, ISP_LOGCONFIG, prom, bus, tgt, lp->port_wwn, lp->portid, lp->handle, buf, "gone");
4342 fc = ISP_FC_PC(isp, bus);
4346 isp_prt(isp, ISP_LOGINFO,
4351 isp_prt(isp, ISP_LOGINFO, "Chan %d %s (PortID 0x%06x)",
4355 isp_prt(isp, ISP_LOGINFO, "Chan %d %s", bus, msg);
4357 isp_loop_changed(isp, bus);
4379 isp_handle_platform_target_tmf(isp, notify);
4395 isp_handle_platform_target_notify_ack(isp, notify);
4398 isp_prt(isp, ISP_LOGALL, "target notify code 0x%x", notify->nt_ncode);
4399 isp_handle_platform_target_notify_ack(isp, notify);
4410 if (isp_notify_ack(isp, inot)) {
4413 tp->isp = isp;
4420 callout_init_mtx(&tp->timer, &isp->isp_lock, 0);
4424 isp_prt(isp, ISP_LOGERR, "you lose- cannot allocate a notify refire");
4438 isp_prt(isp, ISP_LOGWARN, "%s: unhandled target action 0x%x", __func__, hp->rqs_entry_type);
4441 if (IS_24XX(isp)) {
4442 isp_handle_platform_notify_24xx(isp, (in_fcentry_24xx_t *) hp);
4444 isp_handle_platform_notify_fc(isp, (in_fcentry_t *) hp);
4448 isp_handle_platform_atio7(isp, (at7_entry_t *) hp);
4451 isp_handle_platform_atio2(isp, (at2_entry_t *) hp);
4457 isp_handle_platform_ctio(isp, hp);
4472 nt->nt_hba = isp;
4476 isp_find_chan_by_did(isp, did, &chan);
4480 nt->nt_tgt = FCPARAM(isp, chan)->isp_wwpn;
4481 if (isp_find_pdb_by_handle(isp, chan, abts->abts_nphdl, &lp)) {
4490 tptr = get_lun_statep_from_tag(isp, chan, abts->abts_rxid_task);
4493 rls_lun_statep(isp, tptr);
4501 isp_prt(isp, ISP_LOGTINFO, "[0x%x] ABTS from N-Port handle 0x%x Port 0x%06x has no task id (rx_id 0x%04x ox_id 0x%04x)",
4504 isp_prt(isp, ISP_LOGTINFO, "[0x%x] ABTS from N-Port handle 0x%x Port 0x%06x for task 0x%x (rx_id 0x%04x ox_id 0x%04x)",
4510 isp_handle_platform_target_tmf(isp, nt);
4520 mbox1 = ISP_READ(isp, OUTMAILBOX1);
4521 if (IS_DUALBUS(isp)) {
4522 mbox6 = ISP_READ(isp, OUTMAILBOX6);
4526 isp_prt(isp, ISP_LOGERR, "Internal Firmware Error on bus %d @ RISC Address 0x%x", mbox6, mbox1);
4527 mbox1 = isp->isp_osinfo.mbox_sleep_ok;
4528 isp->isp_osinfo.mbox_sleep_ok = 0;
4529 isp_reinit(isp, 1);
4530 isp->isp_osinfo.mbox_sleep_ok = mbox1;
4531 isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
4535 isp_prt(isp, ISP_LOGERR, "unknown isp_async event %d", cmd);
4545 isp_uninit(ispsoftc_t *isp)
4547 if (IS_24XX(isp)) {
4548 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
4550 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
4552 ISP_DISABLE_INTS(isp);
4556 isp_default_wwn(ispsoftc_t * isp, int chan, int isactive, int iswwnn)
4559 struct isp_fc *fc = ISP_FC_PC(isp, chan);
4568 seed = iswwnn ? FCPARAM(isp, chan)->isp_wwnn_nvram :
4569 FCPARAM(isp, chan)->isp_wwpn_nvram;
4576 seed = iswwnn ? ISP_FC_PC(isp, 0)->def_wwnn :
4577 ISP_FC_PC(isp, 0)->def_wwpn;
4579 seed = iswwnn ? FCPARAM(isp, 0)->isp_wwnn_nvram :
4580 FCPARAM(isp, 0)->isp_wwpn_nvram;
4586 seed = 0x400000007F000000ull + device_get_unit(isp->isp_dev);
4606 isp_prt(ispsoftc_t *isp, int level, const char *fmt, ...)
4612 if (level != ISP_LOGALL && (level & isp->isp_dblev) == 0) {
4615 snprintf(lbuf, sizeof (lbuf), "%s: ", device_get_nameunit(isp->isp_dev));
4624 isp_xs_prt(ispsoftc_t *isp, XS_T *xs, int level, const char *fmt, ...)
4627 if (level != ISP_LOGALL && (level & isp->isp_dblev) == 0) {
4650 isp_mbox_acquire(ispsoftc_t *isp)
4652 if (isp->isp_osinfo.mboxbsy) {
4655 isp->isp_osinfo.mboxcmd_done = 0;
4656 isp->isp_osinfo.mboxbsy = 1;
4662 isp_mbox_wait_complete(ispsoftc_t *isp, mbreg_t *mbp)
4670 max = isp->isp_mbxwrk0 + 1;
4672 if (isp->isp_osinfo.mbox_sleep_ok) {
4675 isp->isp_osinfo.mbox_sleep_ok = 0;
4676 isp->isp_osinfo.mbox_sleeping = 1;
4678 msleep(&isp->isp_mbxworkp, &isp->isp_osinfo.lock, PRIBIO, "ispmbx_sleep", isp_mstohz(ms));
4679 if (isp->isp_osinfo.mboxcmd_done) {
4683 isp->isp_osinfo.mbox_sleep_ok = 1;
4684 isp->isp_osinfo.mbox_sleeping = 0;
4689 if (isp->isp_osinfo.mboxcmd_done) {
4692 if (ISP_READ_ISR(isp, &isr, &sema, &info)) {
4693 isp_intr(isp, isr, sema, info);
4694 if (isp->isp_osinfo.mboxcmd_done) {
4700 if (isp->isp_osinfo.mboxcmd_done) {
4705 if (isp->isp_osinfo.mboxcmd_done == 0) {
4706 isp_prt(isp, ISP_LOGWARN, "%s Mailbox Command (0x%x) Timeout (%uus) (started @ %s:%d)",
4707 isp->isp_osinfo.mbox_sleep_ok? "Interrupting" : "Polled", isp->isp_lastmbxcmd, usecs, mbp->func, mbp->lineno);
4709 isp->isp_osinfo.mboxcmd_done = 1;
4714 isp_mbox_notify_done(ispsoftc_t *isp)
4716 if (isp->isp_osinfo.mbox_sleeping) {
4717 wakeup(&isp->isp_mbxworkp);
4719 isp->isp_osinfo.mboxcmd_done = 1;
4723 isp_mbox_release(ispsoftc_t *isp)
4725 isp->isp_osinfo.mboxbsy = 0;
4729 isp_fc_scratch_acquire(ispsoftc_t *isp, int chan)
4732 if (isp->isp_osinfo.pc.fc[chan].fcbsy) {
4735 isp->isp_osinfo.pc.fc[chan].fcbsy = 1;
4760 ispsoftc_t *isp = arg;
4763 ISP_LOCK(isp);
4764 isp->isp_intcnt++;
4765 if (ISP_READ_ISR(isp, &isr, &sema, &info))
4766 isp_intr(isp, isr, sema, info);
4768 isp->isp_intbogus++;
4769 ISP_UNLOCK(isp);
4773 isp_common_dmateardown(ispsoftc_t *isp, struct ccb_scsiio *csio, uint32_t hdl)
4776 bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, BUS_DMASYNC_POSTREAD);
4778 bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, BUS_DMASYNC_POSTWRITE);
4780 bus_dmamap_unload(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap);
4789 isp_fcp_reset_crn(ispsoftc_t *isp, int chan, uint32_t tgt, int tgt_set)
4791 struct isp_fc *fc = ISP_FC_PC(isp, chan);
4796 isp_prt(isp, ISP_LOGDEBUG0,
4799 isp_prt(isp, ISP_LOGDEBUG0,
4811 isp_fcp_next_crn(ispsoftc_t *isp, uint8_t *crnp, XS_T *cmd)
4819 if (IS_2100(isp))
4825 fc = &isp->isp_osinfo.pc.fc[chan];
4862 ispsoftc_t *isp = arg;
4864 isp_tmcmd_restart(isp);
4866 callout_reset(&isp->isp_osinfo.tmo, isp_timer_count, isp_timer, isp);
4870 isp_get_ecmd(ispsoftc_t *isp)
4872 isp_ecmd_t *ecmd = isp->isp_osinfo.ecmd_free;
4874 isp->isp_osinfo.ecmd_free = ecmd->next;
4880 isp_put_ecmd(ispsoftc_t *isp, isp_ecmd_t *ecmd)
4882 ecmd->next = isp->isp_osinfo.ecmd_free;
4883 isp->isp_osinfo.ecmd_free = ecmd;