Lines Matching refs:lpfc_cmd
117 * @lpfc_cmd: lpfc scsi command object pointer.
124 struct lpfc_io_buf *lpfc_cmd)
126 struct sli4_sge *sgl = (struct sli4_sge *)lpfc_cmd->dma_sgl;
138 * @lpfc_cmd: lpfc scsi command object pointer.
144 lpfc_update_stats(struct lpfc_vport *vport, struct lpfc_io_buf *lpfc_cmd)
149 struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
160 latency = jiffies_to_msecs((long)jiffies - (long)lpfc_cmd->start_time);
161 rdata = lpfc_cmd->rdata;
594 struct lpfc_io_buf *lpfc_cmd = NULL;
599 list_remove_head(scsi_buf_list_get, lpfc_cmd, struct lpfc_io_buf,
601 if (!lpfc_cmd) {
606 list_remove_head(scsi_buf_list_get, lpfc_cmd,
612 if (lpfc_ndlp_check_qdepth(phba, ndlp) && lpfc_cmd) {
614 lpfc_cmd->flags |= LPFC_SBUF_BUMP_QDEPTH;
616 return lpfc_cmd;
633 struct lpfc_io_buf *lpfc_cmd;
651 lpfc_cmd = lpfc_get_io_buf(phba, ndlp, idx,
653 if (!lpfc_cmd) {
662 lpfc_cmd->cur_iocbq.iocb_flag = LPFC_IO_FCP;
663 lpfc_cmd->prot_seg_cnt = 0;
664 lpfc_cmd->seg_cnt = 0;
665 lpfc_cmd->timeout = 0;
666 lpfc_cmd->flags = 0;
667 lpfc_cmd->start_time = jiffies;
668 lpfc_cmd->waitq = NULL;
669 lpfc_cmd->cpu = cpu;
671 lpfc_cmd->prot_data_type = 0;
673 tmp = lpfc_get_cmd_rsp_buf_per_hdwq(phba, lpfc_cmd);
675 lpfc_release_io_buf(phba, lpfc_cmd, lpfc_cmd->hdwq);
679 lpfc_cmd->fcp_cmnd = tmp->fcp_cmnd;
680 lpfc_cmd->fcp_rsp = tmp->fcp_rsp;
687 sgl = (struct sli4_sge *)lpfc_cmd->dma_sgl;
710 iocb = &lpfc_cmd->cur_iocbq.iocb;
726 lpfc_cmd->flags |= LPFC_SBUF_BUMP_QDEPTH;
728 return lpfc_cmd;
823 * @lpfc_cmd: The scsi buffer which is going to be mapped.
826 * field of @lpfc_cmd for device with SLI-3 interface spec. This routine scans
835 lpfc_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
837 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
839 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
840 struct ulp_bde64 *bpl = (struct ulp_bde64 *)lpfc_cmd->dma_sgl;
841 struct lpfc_iocbq *iocbq = &lpfc_cmd->cur_iocbq;
842 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
868 lpfc_cmd->seg_cnt = nseg;
869 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
874 lpfc_cmd->seg_cnt);
875 WARN_ON_ONCE(lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt);
876 lpfc_cmd->seg_cnt = 0;
929 physaddr = lpfc_cmd->dma_handle;
988 struct lpfc_io_buf *lpfc_cmd = NULL;
1047 lpfc_cmd = (struct lpfc_io_buf *)sc->host_scribble;
1075 if (lpfc_cmd) {
1076 lpfc_cmd->prot_data_type =
1078 lpfc_cmd->prot_data_segment =
1080 lpfc_cmd->prot_data =
1196 if (lpfc_cmd) {
1197 lpfc_cmd->prot_data_type =
1199 lpfc_cmd->prot_data_segment =
1201 lpfc_cmd->prot_data =
1950 struct lpfc_io_buf *lpfc_cmd)
2038 sgl_xtra = lpfc_get_sgl_per_hdwq(phba, lpfc_cmd);
2041 lpfc_cmd->seg_cnt = 0;
2130 struct lpfc_io_buf *lpfc_cmd)
2199 sgl_xtra = lpfc_get_sgl_per_hdwq(phba, lpfc_cmd);
2326 lpfc_cmd);
2469 * @lpfc_cmd: The scsi buffer which is going to be adjusted.
2478 struct lpfc_io_buf *lpfc_cmd)
2480 struct scsi_cmnd *sc = lpfc_cmd->pCmd;
2510 * @lpfc_cmd: The scsi buffer which is going to be prep'ed.
2521 struct lpfc_io_buf *lpfc_cmd)
2523 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
2524 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
2525 struct ulp_bde64 *bpl = (struct ulp_bde64 *)lpfc_cmd->dma_sgl;
2526 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
2552 lpfc_cmd->seg_cnt = datasegcnt;
2555 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
2556 WARN_ON_ONCE(lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt);
2567 if ((lpfc_cmd->seg_cnt + 2) > phba->cfg_total_seg_cnt) {
2595 lpfc_cmd->prot_seg_cnt = protsegcnt;
2601 if ((lpfc_cmd->prot_seg_cnt * 4) >
2620 lpfc_cmd->seg_cnt = 0;
2640 fcpdl = lpfc_bg_scsi_adjust_dl(phba, lpfc_cmd);
2659 if (lpfc_cmd->seg_cnt)
2661 if (lpfc_cmd->prot_seg_cnt)
2669 lpfc_cmd->seg_cnt, lpfc_cmd->prot_seg_cnt,
2673 lpfc_cmd->seg_cnt = 0;
2674 lpfc_cmd->prot_seg_cnt = 0;
2713 lpfc_calc_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
2717 struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
2747 protsegcnt = lpfc_cmd->prot_seg_cnt;
2898 lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd,
2901 struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
3026 lpfc_calc_bg_err(phba, lpfc_cmd);
3035 * @lpfc_cmd: The scsi buffer which is going to be mapped.
3038 * field of @lpfc_cmd for device with SLI-4 interface spec.
3046 lpfc_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
3048 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
3050 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
3051 struct sli4_sge *sgl = (struct sli4_sge *)lpfc_cmd->dma_sgl;
3053 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
3087 lpfc_cmd->seg_cnt = nseg;
3089 lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
3095 lpfc_cmd->seg_cnt);
3096 WARN_ON_ONCE(lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt);
3097 lpfc_cmd->seg_cnt = 0;
3133 phba, lpfc_cmd);
3136 lpfc_cmd->seg_cnt = 0;
3237 lpfc_cmd->cur_iocbq.iocb_flag |= (LPFC_IO_OAS | LPFC_IO_FOF);
3238 lpfc_cmd->cur_iocbq.priority = ((struct lpfc_device_data *)
3248 * @lpfc_cmd: The scsi buffer which is going to be mapped.
3260 struct lpfc_io_buf *lpfc_cmd)
3262 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
3263 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
3264 struct sli4_sge *sgl = (struct sli4_sge *)(lpfc_cmd->dma_sgl);
3265 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
3297 lpfc_cmd->seg_cnt = datasegcnt;
3300 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt &&
3302 WARN_ON_ONCE(lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt);
3312 if (((lpfc_cmd->seg_cnt + 1) >
3320 datasegcnt, lpfc_cmd);
3343 lpfc_cmd->prot_seg_cnt = protsegcnt;
3348 if (((lpfc_cmd->prot_seg_cnt * 3) >
3356 datasegcnt, protsegcnt, lpfc_cmd);
3370 lpfc_cmd->seg_cnt = 0;
3382 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_STRIP;
3386 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_INSERT;
3390 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_PASS;
3394 fcpdl = lpfc_bg_scsi_adjust_dl(phba, lpfc_cmd);
3417 lpfc_cmd->cur_iocbq.iocb_flag |= (LPFC_IO_OAS | LPFC_IO_FOF);
3421 if (lpfc_cmd->seg_cnt)
3423 if (lpfc_cmd->prot_seg_cnt)
3431 lpfc_cmd->seg_cnt, lpfc_cmd->prot_seg_cnt,
3435 lpfc_cmd->seg_cnt = 0;
3436 lpfc_cmd->prot_seg_cnt = 0;
3443 * @lpfc_cmd: The scsi buffer which is going to be mapped.
3453 lpfc_scsi_prep_dma_buf(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
3455 return phba->lpfc_scsi_prep_dma_buf(phba, lpfc_cmd);
3462 * @lpfc_cmd: The scsi buffer which is going to be mapped.
3472 lpfc_bg_scsi_prep_dma_buf(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
3474 return phba->lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
3481 * @lpfc_cmd: Pointer to lpfc scsi command which reported the error.
3489 struct lpfc_io_buf *lpfc_cmd, struct lpfc_iocbq *rsp_iocb) {
3490 struct scsi_cmnd *cmnd = lpfc_cmd->pCmd;
3491 struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
3496 struct lpfc_nodelist *pnode = lpfc_cmd->rdata->pnode;
3578 * field of @lpfc_cmd for device with SLI-3 interface spec.
3600 * @lpfc_cmd: Pointer to lpfc_io_buf data structure.
3608 lpfc_handle_fcp_err(struct lpfc_vport *vport, struct lpfc_io_buf *lpfc_cmd,
3612 struct scsi_cmnd *cmnd = lpfc_cmd->pCmd;
3613 struct fcp_cmnd *fcpcmd = lpfc_cmd->fcp_cmnd;
3614 struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
3627 * scsi packet associated with this lpfc_cmd. The driver
3755 lpfc_cmd->cur_iocbq.sli4_xritag :
3783 lpfc_send_scsi_error_event(vport->phba, vport, lpfc_cmd, rsp_iocb);
3800 struct lpfc_io_buf *lpfc_cmd =
3803 struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
3813 spin_lock(&lpfc_cmd->buf_lock);
3816 cmd = lpfc_cmd->pCmd;
3820 spin_unlock(&lpfc_cmd->buf_lock);
3824 idx = lpfc_cmd->cur_iocbq.hba_wqidx;
3834 lpfc_cmd->result = (pIocbOut->iocb.un.ulpWord[4] & IOERR_PARAM_MASK);
3835 lpfc_cmd->status = pIocbOut->iocb.ulpStatus;
3838 lpfc_cmd->flags |= LPFC_SBUF_XBUSY;
3840 lpfc_cmd->flags &= ~LPFC_SBUF_XBUSY;
3843 if (lpfc_cmd->prot_data_type) {
3846 src = (struct scsi_dif_tuple *)lpfc_cmd->prot_data_segment;
3851 switch (lpfc_cmd->prot_data_type) {
3854 lpfc_cmd->prot_data;
3858 (uint16_t)lpfc_cmd->prot_data;
3862 (uint16_t)lpfc_cmd->prot_data;
3868 lpfc_cmd->prot_data = 0;
3869 lpfc_cmd->prot_data_type = 0;
3870 lpfc_cmd->prot_data_segment = NULL;
3874 if (unlikely(lpfc_cmd->status)) {
3875 if (lpfc_cmd->status == IOSTAT_LOCAL_REJECT &&
3876 (lpfc_cmd->result & IOERR_DRVR_MASK))
3877 lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
3878 else if (lpfc_cmd->status >= IOSTAT_CNT)
3879 lpfc_cmd->status = IOSTAT_DEFAULT;
3880 if (lpfc_cmd->status == IOSTAT_FCP_RSP_ERROR &&
3881 !lpfc_cmd->fcp_rsp->rspStatus3 &&
3882 (lpfc_cmd->fcp_rsp->rspStatus2 & RESID_UNDER) &&
3895 lpfc_cmd->status, lpfc_cmd->result,
3899 lpfc_cmd->cur_iocbq.sli4_xritag : 0xffff,
3901 lpfc_cmd->cur_iocbq.iocb.ulpIoTag);
3903 switch (lpfc_cmd->status) {
3906 lpfc_handle_fcp_err(vport, lpfc_cmd, pIocbOut);
3917 (lpfc_cmd->status == IOSTAT_NPORT_BSY) ?
3938 if (lpfc_cmd->result == IOERR_ELXSEC_KEY_UNWRAP_ERROR ||
3939 lpfc_cmd->result ==
3941 lpfc_cmd->result == IOERR_ELXSEC_CRYPTO_ERROR ||
3942 lpfc_cmd->result ==
3947 if (lpfc_cmd->result == IOERR_INVALID_RPI ||
3948 lpfc_cmd->result == IOERR_NO_RESOURCES ||
3949 lpfc_cmd->result == IOERR_ABORT_REQUESTED ||
3950 lpfc_cmd->result == IOERR_SLER_CMD_RCV_FAILURE) {
3954 if ((lpfc_cmd->result == IOERR_RX_DMA_FAILED ||
3955 lpfc_cmd->result == IOERR_TX_DMA_FAILED) &&
3962 lpfc_parse_bg_err(phba, lpfc_cmd,
3972 if ((lpfc_cmd->status == IOSTAT_REMOTE_STOP)
3980 lpfc_cmd->cur_iocbq.sli4_lxritag,
3996 if (cmd->result || lpfc_cmd->fcp_rsp->rspSnsLen) {
4007 lpfc_update_stats(vport, lpfc_cmd);
4009 time_after(jiffies, lpfc_cmd->start_time +
4026 lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
4028 lpfc_cmd->pCmd = NULL;
4029 spin_unlock(&lpfc_cmd->buf_lock);
4032 if (lpfc_cmd->ts_cmd_start) {
4033 lpfc_cmd->ts_isr_cmpl = pIocbIn->isr_timestamp;
4034 lpfc_cmd->ts_data_io = ktime_get_ns();
4035 phba->ktime_last_cmd = lpfc_cmd->ts_data_io;
4036 lpfc_io_ktime(phba, lpfc_cmd);
4046 spin_lock(&lpfc_cmd->buf_lock);
4047 lpfc_cmd->cur_iocbq.iocb_flag &= ~LPFC_DRIVER_ABORTED;
4048 if (lpfc_cmd->waitq)
4049 wake_up(lpfc_cmd->waitq);
4050 spin_unlock(&lpfc_cmd->buf_lock);
4052 lpfc_release_scsi_buf(phba, lpfc_cmd);
4076 * @lpfc_cmd: The scsi command which needs to send.
4083 lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_io_buf *lpfc_cmd,
4087 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
4088 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
4089 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
4090 struct lpfc_iocbq *piocbq = &(lpfc_cmd->cur_iocbq);
4101 lpfc_cmd->fcp_rsp->rspSnsLen = 0;
4103 lpfc_cmd->fcp_cmnd->fcpCntl2 = 0;
4105 int_to_scsilun(lpfc_cmd->pCmd->device->lun,
4106 &lpfc_cmd->fcp_cmnd->fcp_lun);
4119 idx = lpfc_cmd->hdwq_no;
4177 piocbq->context1 = lpfc_cmd;
4179 piocbq->iocb.ulpTimeout = lpfc_cmd->timeout;
4186 * @lpfc_cmd: Pointer to lpfc_io_buf data structure.
4199 struct lpfc_io_buf *lpfc_cmd,
4206 struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
4213 piocbq = &(lpfc_cmd->cur_iocbq);
4218 fcp_cmnd = lpfc_cmd->fcp_cmnd;
4238 if (lpfc_cmd->timeout > 0xff) {
4245 piocb->ulpTimeout = lpfc_cmd->timeout;
4248 lpfc_sli4_set_rsp_sgl_last(vport->phba, lpfc_cmd);
4301 * routine. This routine release scsi buffer associated with lpfc_cmd.
4308 struct lpfc_io_buf *lpfc_cmd =
4310 if (lpfc_cmd)
4311 lpfc_release_scsi_buf(phba, lpfc_cmd);
4508 struct lpfc_io_buf *lpfc_cmd;
4580 lpfc_cmd = lpfc_get_scsi_buf(phba, ndlp, cmnd);
4581 if (lpfc_cmd == NULL) {
4594 lpfc_cmd->pCmd = cmnd;
4595 lpfc_cmd->rdata = rdata;
4596 lpfc_cmd->ndlp = ndlp;
4597 cmnd->host_scribble = (unsigned char *)lpfc_cmd;
4611 err = lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
4623 err = lpfc_scsi_prep_dma_buf(phba, lpfc_cmd);
4634 lpfc_scsi_prep_cmnd(vport, lpfc_cmd, ndlp);
4641 &lpfc_cmd->cur_iocbq, SLI_IOCB_RET_IOCB);
4644 lpfc_cmd->ts_cmd_start = start;
4645 lpfc_cmd->ts_last_cmd = phba->ktime_last_cmd;
4646 lpfc_cmd->ts_cmd_wqput = ktime_get_ns();
4648 lpfc_cmd->ts_cmd_start = 0;
4662 lpfc_cmd->cur_iocbq.sli4_xritag : 0xffff,
4663 lpfc_cmd->cur_iocbq.iocb.ulpContext,
4664 lpfc_cmd->cur_iocbq.iocb.ulpIoTag,
4665 lpfc_cmd->cur_iocbq.iocb.ulpTimeout,
4680 lpfc_keep_pvt_pool_above_lowwm(phba, lpfc_cmd->hdwq_no);
4685 idx = lpfc_cmd->hdwq_no;
4686 lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
4688 switch (lpfc_cmd->fcp_cmnd->fcpCntl3) {
4699 lpfc_release_scsi_buf(phba, lpfc_cmd);
4707 lpfc_release_scsi_buf(phba, lpfc_cmd);
4733 struct lpfc_io_buf *lpfc_cmd;
4745 lpfc_cmd = (struct lpfc_io_buf *)cmnd->host_scribble;
4746 if (!lpfc_cmd)
4760 spin_lock(&lpfc_cmd->buf_lock);
4762 if (!lpfc_cmd->pCmd) {
4770 iocb = &lpfc_cmd->cur_iocbq;
4793 if (lpfc_cmd->pCmd != cmnd) {
4800 BUG_ON(iocb->context1 != lpfc_cmd);
4808 spin_unlock(&lpfc_cmd->buf_lock);
4853 lpfc_cmd->waitq = &waitq;
4867 lpfc_cmd->waitq = NULL;
4868 spin_unlock(&lpfc_cmd->buf_lock);
4876 spin_unlock(&lpfc_cmd->buf_lock);
4886 (lpfc_cmd->pCmd != cmnd),
4889 spin_lock(&lpfc_cmd->buf_lock);
4891 if (lpfc_cmd->pCmd == cmnd) {
4901 lpfc_cmd->waitq = NULL;
4903 spin_unlock(&lpfc_cmd->buf_lock);
4910 spin_unlock(&lpfc_cmd->buf_lock);
4948 * @lpfc_cmd: Pointer to lpfc_io_buf data structure.
4957 lpfc_check_fcp_rsp(struct lpfc_vport *vport, struct lpfc_io_buf *lpfc_cmd)
4959 struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
5037 struct lpfc_io_buf *lpfc_cmd;
5050 lpfc_cmd = lpfc_get_scsi_buf(phba, pnode, NULL);
5051 if (lpfc_cmd == NULL)
5053 lpfc_cmd->timeout = phba->cfg_task_mgmt_tmo;
5054 lpfc_cmd->rdata = rdata;
5055 lpfc_cmd->pCmd = cmnd;
5056 lpfc_cmd->ndlp = pnode;
5058 status = lpfc_scsi_prep_task_mgmt_cmd(vport, lpfc_cmd, lun_id,
5061 lpfc_release_scsi_buf(phba, lpfc_cmd);
5065 iocbq = &lpfc_cmd->cur_iocbq;
5068 lpfc_release_scsi_buf(phba, lpfc_cmd);
5081 iocbq, iocbqrsp, lpfc_cmd->timeout);
5099 ret = lpfc_check_fcp_rsp(vport, lpfc_cmd);
5113 lpfc_release_scsi_buf(phba, lpfc_cmd);