Lines Matching refs:req
157 * @req: IO req structure.
163 csio_scsi_fcp_cmnd(struct csio_ioreq *req, void *addr)
166 struct scsi_cmnd *scmnd = csio_scsi_cmnd(req);
178 if (req->nsge)
179 if (req->datadir == DMA_TO_DEVICE)
194 * @req: IO req structure.
201 csio_scsi_init_cmd_wr(struct csio_ioreq *req, void *addr, uint32_t size)
203 struct csio_hw *hw = req->lnode->hwp;
204 struct csio_rnode *rn = req->rnode;
215 wr->cookie = (uintptr_t) req;
216 wr->iqid = cpu_to_be16(csio_q_physiqid(hw, req->iq_idx));
217 wr->tmo_val = (uint8_t) req->tmo;
222 dma_buf = &req->dma_buf;
236 csio_scsi_fcp_cmnd(req, (void *)((uintptr_t)addr +
249 * @req: IO req structure.
255 csio_scsi_cmd(struct csio_ioreq *req)
258 struct csio_hw *hw = req->lnode->hwp;
262 req->drv_status = csio_wr_get(hw, req->eq_idx, size, &wrp);
263 if (unlikely(req->drv_status != 0))
268 csio_scsi_init_cmd_wr(req, wrp.addr1, size);
270 uint8_t *tmpwr = csio_q_eq_wrap(hw, req->eq_idx);
276 csio_scsi_init_cmd_wr(req, (void *)tmpwr, size);
285 * @req: IO request
290 csio_scsi_init_ultptx_dsgl(struct csio_hw *hw, struct csio_ioreq *req,
299 struct scsi_cmnd *scmnd = csio_scsi_cmnd(req);
302 ULPTX_NSGE_V(req->nsge));
304 if (likely(!req->dcopy)) {
305 scsi_for_each_sg(scmnd, sgel, req->nsge, i) {
328 list_for_each(tmp, &req->gen_list) {
353 * @req: IO req structure.
360 csio_scsi_init_read_wr(struct csio_ioreq *req, void *wrp, uint32_t size)
362 struct csio_hw *hw = req->lnode->hwp;
363 struct csio_rnode *rn = req->rnode;
368 struct scsi_cmnd *scmnd = csio_scsi_cmnd(req);
374 wr->cookie = (uintptr_t)req;
375 wr->iqid = cpu_to_be16(csio_q_physiqid(hw, req->iq_idx));
376 wr->tmo_val = (uint8_t)(req->tmo);
381 dma_buf = &req->dma_buf;
393 csio_scsi_fcp_cmnd(req, (void *)((uintptr_t)wrp +
401 csio_scsi_init_ultptx_dsgl(hw, req, sgl);
406 * @req: IO req structure.
413 csio_scsi_init_write_wr(struct csio_ioreq *req, void *wrp, uint32_t size)
415 struct csio_hw *hw = req->lnode->hwp;
416 struct csio_rnode *rn = req->rnode;
421 struct scsi_cmnd *scmnd = csio_scsi_cmnd(req);
427 wr->cookie = (uintptr_t)req;
428 wr->iqid = cpu_to_be16(csio_q_physiqid(hw, req->iq_idx));
429 wr->tmo_val = (uint8_t)(req->tmo);
434 dma_buf = &req->dma_buf;
446 csio_scsi_fcp_cmnd(req, (void *)((uintptr_t)wrp +
454 csio_scsi_init_ultptx_dsgl(hw, req, sgl);
458 #define CSIO_SCSI_DATA_WRSZ(req, oper, sz, imm) \
464 if (unlikely((req)->nsge > 1)) \
466 (ALIGN(((req)->nsge - 1), 2) / 2)); \
472 * @req: IO req structure.
479 csio_scsi_read(struct csio_ioreq *req)
483 struct csio_hw *hw = req->lnode->hwp;
486 CSIO_SCSI_DATA_WRSZ(req, read, size, scsim->proto_cmd_len);
489 req->drv_status = csio_wr_get(hw, req->eq_idx, size, &wrp);
490 if (likely(req->drv_status == 0)) {
493 csio_scsi_init_read_wr(req, wrp.addr1, size);
495 uint8_t *tmpwr = csio_q_eq_wrap(hw, req->eq_idx);
500 csio_scsi_init_read_wr(req, (void *)tmpwr, size);
509 * @req: IO req structure.
516 csio_scsi_write(struct csio_ioreq *req)
520 struct csio_hw *hw = req->lnode->hwp;
523 CSIO_SCSI_DATA_WRSZ(req, write, size, scsim->proto_cmd_len);
526 req->drv_status = csio_wr_get(hw, req->eq_idx, size, &wrp);
527 if (likely(req->drv_status == 0)) {
530 csio_scsi_init_write_wr(req, wrp.addr1, size);
532 uint8_t *tmpwr = csio_q_eq_wrap(hw, req->eq_idx);
537 csio_scsi_init_write_wr(req, (void *)tmpwr, size);
546 * @req: IO req structure.
553 csio_setup_ddp(struct csio_scsim *scsim, struct csio_ioreq *req)
556 struct csio_hw *hw = req->lnode->hwp;
559 struct scsi_cmnd *scmnd = csio_scsi_cmnd(req);
569 scsi_for_each_sg(scmnd, sgel, req->nsge, i) {
583 if ((i != (req->nsge - 1)) &&
593 req->dcopy = 0;
594 csio_scsi_read(req);
604 req->dcopy = 1;
607 INIT_LIST_HEAD(&req->gen_list);
615 req->drv_status = -EBUSY;
619 /* Added to IO req */
620 list_add_tail(&dma_buf->list, &req->gen_list);
624 if (!req->drv_status) {
626 req->nsge = i;
627 csio_scsi_read(req);
633 csio_put_scsi_ddp_list(scsim, &req->gen_list, i);
638 * @req: IO req structure.
646 csio_scsi_init_abrt_cls_wr(struct csio_ioreq *req, void *addr, uint32_t size,
649 struct csio_hw *hw = req->lnode->hwp;
650 struct csio_rnode *rn = req->rnode;
658 wr->cookie = (uintptr_t) req;
659 wr->iqid = cpu_to_be16(csio_q_physiqid(hw, req->iq_idx));
660 wr->tmo_val = (uint8_t) req->tmo;
670 wr->t_cookie = (uintptr_t) req;
674 csio_scsi_abrt_cls(struct csio_ioreq *req, bool abort)
677 struct csio_hw *hw = req->lnode->hwp;
680 req->drv_status = csio_wr_get(hw, req->eq_idx, size, &wrp);
681 if (req->drv_status != 0)
686 csio_scsi_init_abrt_cls_wr(req, wrp.addr1, size, abort);
688 uint8_t *tmpwr = csio_q_eq_wrap(hw, req->eq_idx);
693 csio_scsi_init_abrt_cls_wr(req, (void *)tmpwr, size, abort);
703 csio_scsis_uninit(struct csio_ioreq *req, enum csio_scsi_ev evt)
705 struct csio_hw *hw = req->lnode->hwp;
711 if (req->nsge) {
712 if (req->datadir == DMA_TO_DEVICE) {
713 req->dcopy = 0;
714 csio_scsi_write(req);
716 csio_setup_ddp(scsim, req);
718 csio_scsi_cmd(req);
721 if (likely(req->drv_status == 0)) {
723 csio_set_state(&req->sm, csio_scsis_io_active);
724 list_add_tail(&req->sm.sm_list, &scsim->active_q);
725 csio_wr_issue(hw, req->eq_idx, false);
733 csio_scsi_cmd(req);
734 if (req->drv_status == 0) {
743 csio_set_state(&req->sm, csio_scsis_tm_active);
744 list_add_tail(&req->sm.sm_list, &scsim->active_q);
745 csio_wr_issue(hw, req->eq_idx, false);
762 req->drv_status = -EINVAL;
763 csio_warn(hw, "Trying to abort/close completed IO:%p!\n", req);
767 csio_dbg(hw, "Unhandled event:%d sent to req:%p\n", evt, req);
773 csio_scsis_io_active(struct csio_ioreq *req, enum csio_scsi_ev evt)
775 struct csio_hw *hw = req->lnode->hwp;
782 list_del_init(&req->sm.sm_list);
783 csio_set_state(&req->sm, csio_scsis_uninit);
799 if (unlikely(req->wr_status != FW_SUCCESS)) {
800 rn = req->rnode;
805 if (csio_scsi_itnexus_loss_error(req->wr_status) &&
807 csio_set_state(&req->sm,
809 list_add_tail(&req->sm.sm_list,
817 csio_scsi_abrt_cls(req, SCSI_ABORT);
818 if (req->drv_status == 0) {
819 csio_wr_issue(hw, req->eq_idx, false);
820 csio_set_state(&req->sm, csio_scsis_aborting);
825 csio_scsi_abrt_cls(req, SCSI_CLOSE);
826 if (req->drv_status == 0) {
827 csio_wr_issue(hw, req->eq_idx, false);
828 csio_set_state(&req->sm, csio_scsis_closing);
833 req->wr_status = FW_HOSTERROR;
835 csio_set_state(&req->sm, csio_scsis_uninit);
839 csio_dbg(hw, "Unhandled event:%d sent to req:%p\n", evt, req);
845 csio_scsis_tm_active(struct csio_ioreq *req, enum csio_scsi_ev evt)
847 struct csio_hw *hw = req->lnode->hwp;
853 list_del_init(&req->sm.sm_list);
854 csio_set_state(&req->sm, csio_scsis_uninit);
859 csio_scsi_abrt_cls(req, SCSI_ABORT);
860 if (req->drv_status == 0) {
861 csio_wr_issue(hw, req->eq_idx, false);
862 csio_set_state(&req->sm, csio_scsis_aborting);
868 csio_scsi_abrt_cls(req, SCSI_CLOSE);
869 if (req->drv_status == 0) {
870 csio_wr_issue(hw, req->eq_idx, false);
871 csio_set_state(&req->sm, csio_scsis_closing);
876 req->wr_status = FW_HOSTERROR;
878 csio_set_state(&req->sm, csio_scsis_uninit);
882 csio_dbg(hw, "Unhandled event:%d sent to req:%p\n", evt, req);
888 csio_scsis_aborting(struct csio_ioreq *req, enum csio_scsi_ev evt)
890 struct csio_hw *hw = req->lnode->hwp;
897 "in aborting st\n", req, req->wr_status);
907 req->drv_status = -ECANCELED;
917 req, req->wr_status, req->drv_status);
922 if (req->drv_status != -ECANCELED) {
925 " req:%p\n", req);
952 if ((req->wr_status == FW_SUCCESS) ||
953 (req->wr_status == FW_EINVAL) ||
954 csio_scsi_itnexus_loss_error(req->wr_status))
955 req->wr_status = FW_SCSI_ABORT_REQUESTED;
958 list_del_init(&req->sm.sm_list);
959 csio_set_state(&req->sm, csio_scsis_uninit);
963 req->wr_status = FW_HOSTERROR;
965 csio_set_state(&req->sm, csio_scsis_uninit);
979 csio_dbg(hw, "Unhandled event:%d sent to req:%p\n", evt, req);
985 csio_scsis_closing(struct csio_ioreq *req, enum csio_scsi_ev evt)
987 struct csio_hw *hw = req->lnode->hwp;
994 "in closing st\n", req, req->wr_status);
1004 req->drv_status = -ECANCELED;
1012 if (req->drv_status != -ECANCELED) {
1015 " req:%p\n", req);
1024 CSIO_DB_ASSERT((req->wr_status == FW_SUCCESS) ||
1025 (req->wr_status == FW_EINVAL));
1026 req->wr_status = FW_SCSI_CLOSE_REQUESTED;
1029 list_del_init(&req->sm.sm_list);
1030 csio_set_state(&req->sm, csio_scsis_uninit);
1037 req->wr_status = FW_HOSTERROR;
1039 csio_set_state(&req->sm, csio_scsis_uninit);
1043 csio_dbg(hw, "Unhandled event:%d sent to req:%p\n", evt, req);
1049 csio_scsis_shost_cmpl_await(struct csio_ioreq *req, enum csio_scsi_ev evt)
1070 req->drv_status = 0;
1073 csio_set_state(&req->sm, csio_scsis_uninit);
1076 csio_dbg(req->lnode->hwp, "Unhandled event:%d sent to req:%p\n",
1077 evt, req);
1489 csio_scsi_copy_to_sgl(struct csio_hw *hw, struct csio_ioreq *req)
1491 struct scsi_cmnd *scmnd = (struct scsi_cmnd *)csio_scsi_cmnd(req);
1504 dma_buf = (struct csio_dma_buf *)csio_list_next(&req->gen_list);
1531 sg, req);
1554 * @req: IO request.
1558 csio_scsi_err_handler(struct csio_hw *hw, struct csio_ioreq *req)
1560 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)csio_scsi_cmnd(req);
1571 switch (req->wr_status) {
1581 dma_buf = &req->dma_buf;
1647 csio_dbg(hw, "Req %p cmd:%p op:%x %s\n", req, cmnd,
1649 (req->wr_status == FW_SCSI_CLOSE_REQUESTED) ?
1656 if (req->wr_status == FW_SCSI_CLOSE_REQUESTED)
1664 csio_dbg(hw, "FW timed out abort req:%p cmnd:%p status:%x\n",
1665 req, cmnd, req->wr_status);
1706 csio_err(hw, "Unknown SCSI FW WR status:%d req:%p cmnd:%p\n",
1707 req->wr_status, req, cmnd);
1716 if (req->nsge > 0) {
1718 if (req->dcopy && (host_status == DID_OK))
1719 host_status = csio_scsi_copy_to_sgl(hw, req);
1726 csio_scsi_cmnd(req) = NULL;
1727 complete(&req->cmplobj);
1733 * @req: IO request.
1737 csio_scsi_cbfn(struct csio_hw *hw, struct csio_ioreq *req)
1739 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)csio_scsi_cmnd(req);
1743 if (likely(req->wr_status == FW_SUCCESS)) {
1744 if (req->nsge > 0) {
1746 if (req->dcopy)
1747 host_status = csio_scsi_copy_to_sgl(hw, req);
1752 csio_scsi_cmnd(req) = NULL;
1756 csio_scsi_err_handler(hw, req);
1804 /* Get req->nsge, if there are SG elements to be mapped */
1970 csio_err(hw, "Abort timed out -- req: %p\n", ioreq);
2006 * @req: IO request.
2013 csio_tm_cbfn(struct csio_hw *hw, struct csio_ioreq *req)
2015 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)csio_scsi_cmnd(req);
2021 csio_dbg(hw, "req: %p in csio_tm_cbfn status: %d\n",
2022 req, req->wr_status);
2025 cmnd->SCp.Status = req->wr_status;
2038 if (req->wr_status == FW_SCSI_RSP_ERR) {
2039 dma_buf = &req->dma_buf;
2054 csio_scsi_cmnd(req) = NULL;
2151 csio_err(hw, "Failed to issue LUN reset, req:%p, status:%d\n",