Lines Matching refs:ireq
74 static struct scu_sgl_element_pair *to_sgl_element_pair(struct isci_request *ireq,
78 return &ireq->tc->sgl_pair_ab;
80 return &ireq->tc->sgl_pair_cd;
84 return &ireq->sg_table[idx - 2];
88 struct isci_request *ireq, u32 idx)
93 offset = (void *) &ireq->tc->sgl_pair_ab -
97 offset = (void *) &ireq->tc->sgl_pair_cd -
102 return sci_io_request_get_dma_addr(ireq, &ireq->sg_table[idx - 2]);
113 static void sci_request_build_sgl(struct isci_request *ireq)
115 struct isci_host *ihost = ireq->isci_host;
116 struct sas_task *task = isci_request_access_task(ireq);
127 scu_sg = to_sgl_element_pair(ireq, sg_idx);
138 ireq,
151 scu_sg = to_sgl_element_pair(ireq, sg_idx);
158 ireq->zero_scatter_daddr = dma_addr;
171 static void sci_io_request_build_ssp_command_iu(struct isci_request *ireq)
174 struct sas_task *task = isci_request_access_task(ireq);
176 cmd_iu = &ireq->ssp.cmd;
191 static void sci_task_request_build_ssp_task_iu(struct isci_request *ireq)
194 struct sas_task *task = isci_request_access_task(ireq);
195 struct isci_tmf *isci_tmf = isci_request_access_tmf(ireq);
197 task_iu = &ireq->ssp.tmf;
205 (test_bit(IREQ_TMF, &ireq->flags)) ?
217 struct isci_request *ireq,
224 idev = ireq->target_device;
250 /* task_context->type.ssp.tag = ireq->io_tag; */
253 ireq->post_context = (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
257 ISCI_TAG_TCI(ireq->io_tag));
263 dma_addr = sci_io_request_get_dma_addr(ireq, &ireq->ssp.cmd);
272 dma_addr = sci_io_request_get_dma_addr(ireq, &ireq->ssp.rsp);
297 static void scu_ssp_ireq_dif_insert(struct isci_request *ireq, u8 type, u8 op)
299 struct scu_task_context *tc = ireq->tc;
300 struct scsi_cmnd *scmd = ireq->ttype_ptr.io_task_ptr->uldd_task;
352 static void scu_ssp_ireq_dif_strip(struct isci_request *ireq, u8 type, u8 op)
354 struct scu_task_context *tc = ireq->tc;
355 struct scsi_cmnd *scmd = ireq->ttype_ptr.io_task_ptr->uldd_task;
418 static void scu_ssp_io_request_construct_task_context(struct isci_request *ireq,
422 struct scu_task_context *task_context = ireq->tc;
423 struct sas_task *sas_task = ireq->ttype_ptr.io_task_ptr;
428 scu_ssp_request_construct_task_context(ireq, task_context);
448 sci_request_build_sgl(ireq);
452 scu_ssp_ireq_dif_strip(ireq, prot_type, prot_op);
454 scu_ssp_ireq_dif_insert(ireq, prot_type, prot_op);
471 static void scu_ssp_task_request_construct_task_context(struct isci_request *ireq)
473 struct scu_task_context *task_context = ireq->tc;
475 scu_ssp_request_construct_task_context(ireq, task_context);
499 struct isci_request *ireq,
506 idev = ireq->target_device;
537 task_context->type.words[0] = *(u32 *)&ireq->stp.cmd;
539 ireq->post_context = (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
543 ISCI_TAG_TCI(ireq->io_tag));
549 dma_addr = sci_io_request_get_dma_addr(ireq,
550 ((char *) &ireq->stp.cmd) +
561 static void scu_stp_raw_request_construct_task_context(struct isci_request *ireq)
563 struct scu_task_context *task_context = ireq->tc;
565 scu_sata_request_construct_task_context(ireq, task_context);
574 static enum sci_status sci_stp_pio_request_construct(struct isci_request *ireq,
577 struct isci_stp_request *stp_req = &ireq->stp.req;
579 scu_stp_raw_request_construct_task_context(ireq);
586 sci_request_build_sgl(ireq);
608 static void sci_stp_optimized_request_construct(struct isci_request *ireq,
613 struct scu_task_context *task_context = ireq->tc;
616 scu_sata_request_construct_task_context(ireq, task_context);
619 sci_request_build_sgl(ireq);
641 static void sci_atapi_construct(struct isci_request *ireq)
643 struct host_to_dev_fis *h2d_fis = &ireq->stp.cmd;
653 scu_stp_raw_request_construct_task_context(ireq);
655 task = isci_request_access_task(ireq);
662 ireq->stp.rsp.fis_type = 0;
666 sci_io_request_construct_sata(struct isci_request *ireq,
672 struct sas_task *task = isci_request_access_task(ireq);
673 struct domain_device *dev = ireq->target_device->domain_dev;
676 if (test_bit(IREQ_TMF, &ireq->flags)) {
677 struct isci_tmf *tmf = isci_request_access_tmf(ireq);
679 dev_err(&ireq->owning_controller->pdev->dev,
682 __func__, ireq, tmf->tmf_code);
688 dev_err(&ireq->owning_controller->pdev->dev,
699 sci_atapi_construct(ireq);
705 scu_stp_raw_request_construct_task_context(ireq);
711 sci_stp_optimized_request_construct(ireq,
719 sci_stp_optimized_request_construct(ireq,
724 return sci_stp_pio_request_construct(ireq, copy);
729 static enum sci_status sci_io_request_construct_basic_ssp(struct isci_request *ireq)
731 struct sas_task *task = isci_request_access_task(ireq);
733 ireq->protocol = SAS_PROTOCOL_SSP;
735 scu_ssp_io_request_construct_task_context(ireq,
739 sci_io_request_build_ssp_command_iu(ireq);
741 sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
747 struct isci_request *ireq)
750 scu_ssp_task_request_construct_task_context(ireq);
753 sci_task_request_build_ssp_task_iu(ireq);
755 sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
760 static enum sci_status sci_io_request_construct_basic_sata(struct isci_request *ireq)
764 struct sas_task *task = isci_request_access_task(ireq);
766 ireq->protocol = SAS_PROTOCOL_STP;
770 status = sci_io_request_construct_sata(ireq,
776 sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
783 * @ireq: request that was terminated early
786 static u32 sci_req_tx_bytes(struct isci_request *ireq)
788 struct isci_host *ihost = ireq->owning_controller;
802 ((sizeof(struct scu_task_context)) * ISCI_TAG_TCI(ireq->io_tag)));
808 enum sci_status sci_request_start(struct isci_request *ireq)
811 struct scu_task_context *tc = ireq->tc;
812 struct isci_host *ihost = ireq->owning_controller;
814 state = ireq->sm.current_state_id;
822 tc->task_index = ISCI_TAG_TCI(ireq->io_tag);
828 tc->type.ssp.tag = ireq->io_tag;
834 * tc->type.stp.ncq_tag = ireq->ncq_tag;
849 ireq->post_context |= ISCI_TAG_TCI(ireq->io_tag);
852 sci_change_state(&ireq->sm, SCI_REQ_STARTED);
858 sci_io_request_terminate(struct isci_request *ireq)
862 state = ireq->sm.current_state_id;
867 set_bit(IREQ_TC_ABORT_POSTED, &ireq->flags);
868 ireq->scu_status = SCU_TASK_DONE_TASK_ABORT;
869 ireq->sci_status = SCI_FAILURE_IO_TERMINATED;
870 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
896 sci_change_state(&ireq->sm, SCI_REQ_ABORTING);
899 if (!isci_remote_device_is_safe_to_abort(ireq->target_device))
900 set_bit(IREQ_PENDING_ABORT, &ireq->flags);
902 clear_bit(IREQ_PENDING_ABORT, &ireq->flags);
909 dev_warn(&ireq->owning_controller->pdev->dev,
911 "state %d\n", __func__, ireq->sm.current_state_id);
918 enum sci_status sci_request_complete(struct isci_request *ireq)
921 struct isci_host *ihost = ireq->owning_controller;
923 state = ireq->sm.current_state_id;
929 if (ireq->saved_rx_frame_index != SCU_INVALID_FRAME_INDEX)
931 ireq->saved_rx_frame_index);
934 sci_change_state(&ireq->sm, SCI_REQ_FINAL);
938 enum sci_status sci_io_request_event_handler(struct isci_request *ireq,
942 struct isci_host *ihost = ireq->owning_controller;
944 state = ireq->sm.current_state_id;
958 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
978 static void sci_io_request_copy_response(struct isci_request *ireq)
983 struct isci_tmf *isci_tmf = isci_request_access_tmf(ireq);
985 ssp_response = &ireq->ssp.rsp;
997 request_started_state_tc_event(struct isci_request *ireq,
1008 ireq->scu_status = SCU_TASK_DONE_GOOD;
1009 ireq->sci_status = SCI_SUCCESS;
1019 struct ssp_response_iu *resp = &ireq->ssp.rsp;
1022 sci_swab32_cpy(&ireq->ssp.rsp,
1023 &ireq->ssp.rsp,
1027 ireq->scu_status = SCU_TASK_DONE_GOOD;
1028 ireq->sci_status = SCI_SUCCESS_IO_DONE_EARLY;
1030 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1031 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1038 sci_swab32_cpy(&ireq->ssp.rsp,
1039 &ireq->ssp.rsp,
1042 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1043 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1052 resp_iu = &ireq->ssp.rsp;
1056 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1057 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1059 ireq->scu_status = SCU_TASK_DONE_GOOD;
1060 ireq->sci_status = SCI_SUCCESS;
1075 if (ireq->protocol == SAS_PROTOCOL_STP) {
1076 ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1078 ireq->sci_status = SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
1080 ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1082 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1097 ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1099 ireq->sci_status = SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
1119 ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1121 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1130 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1135 request_aborting_state_tc_event(struct isci_request *ireq,
1141 ireq->scu_status = SCU_TASK_DONE_TASK_ABORT;
1142 ireq->sci_status = SCI_FAILURE_IO_TERMINATED;
1143 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1156 static enum sci_status ssp_task_request_await_tc_event(struct isci_request *ireq,
1161 ireq->scu_status = SCU_TASK_DONE_GOOD;
1162 ireq->sci_status = SCI_SUCCESS;
1163 sci_change_state(&ireq->sm, SCI_REQ_TASK_WAIT_TC_RESP);
1171 dev_warn(&ireq->owning_controller->pdev->dev,
1173 "ACK/NAK timeout\n", __func__, ireq,
1176 sci_change_state(&ireq->sm, SCI_REQ_TASK_WAIT_TC_RESP);
1184 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1185 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1186 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1194 smp_request_await_response_tc_event(struct isci_request *ireq,
1203 ireq->scu_status = SCU_TASK_DONE_GOOD;
1204 ireq->sci_status = SCI_SUCCESS;
1205 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1218 ireq->scu_status = SCU_TASK_DONE_SMP_RESP_TO_ERR;
1219 ireq->sci_status = SCI_FAILURE_RETRY_REQUIRED;
1220 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1226 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1227 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1228 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1236 smp_request_await_tc_event(struct isci_request *ireq,
1241 ireq->scu_status = SCU_TASK_DONE_GOOD;
1242 ireq->sci_status = SCI_SUCCESS;
1243 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1250 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1251 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1252 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1263 struct isci_request *ireq = to_ireq(stp_req);
1266 sgl_pair = to_sgl_element_pair(ireq, pio_sgl->index);
1284 sgl_pair = to_sgl_element_pair(ireq, pio_sgl->index);
1293 stp_request_non_data_await_h2d_tc_event(struct isci_request *ireq,
1298 ireq->scu_status = SCU_TASK_DONE_GOOD;
1299 ireq->sci_status = SCI_SUCCESS;
1300 sci_change_state(&ireq->sm, SCI_REQ_STP_NON_DATA_WAIT_D2H);
1308 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1309 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1310 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1323 struct isci_request *ireq,
1326 struct isci_stp_request *stp_req = &ireq->stp.req;
1327 struct scu_task_context *task_context = ireq->tc;
1334 sgl_pair = to_sgl_element_pair(ireq, stp_req->sgl.index);
1347 return sci_controller_continue_io(ireq);
1350 static enum sci_status sci_stp_request_pio_data_out_transmit_data(struct isci_request *ireq)
1352 struct isci_stp_request *stp_req = &ireq->stp.req;
1360 sgl_pair = to_sgl_element_pair(ireq, stp_req->sgl.index);
1376 status = sci_stp_request_pio_data_out_trasmit_data_frame(ireq, len);
1385 sci_stp_request_pio_data_out_trasmit_data_frame(ireq, stp_req->pio_len);
1411 struct isci_request *ireq;
1419 ireq = to_ireq(stp_req);
1420 task = isci_request_access_task(ireq);
1480 stp_request_pio_await_h2d_completion_tc_event(struct isci_request *ireq,
1487 ireq->scu_status = SCU_TASK_DONE_GOOD;
1488 ireq->sci_status = SCI_SUCCESS;
1489 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
1497 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1498 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1499 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1507 pio_data_out_tx_done_tc_event(struct isci_request *ireq,
1512 struct isci_stp_request *stp_req = &ireq->stp.req;
1518 status = sci_stp_request_pio_data_out_transmit_data(ireq);
1536 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
1546 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1547 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1548 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1555 static enum sci_status sci_stp_request_udma_general_frame_handler(struct isci_request *ireq,
1558 struct isci_host *ihost = ireq->owning_controller;
1573 sci_controller_copy_sata_response(&ireq->stp.rsp,
1583 static enum sci_status process_unsolicited_fis(struct isci_request *ireq,
1586 struct isci_host *ihost = ireq->owning_controller;
1599 dev_err(&ireq->isci_host->pdev->dev,
1609 sci_controller_copy_sata_response(&ireq->stp.rsp,
1619 static enum sci_status atapi_d2h_reg_frame_handler(struct isci_request *ireq,
1622 struct sas_task *task = isci_request_access_task(ireq);
1625 status = process_unsolicited_fis(ireq, frame_index);
1628 if (ireq->stp.rsp.status & ATA_ERR)
1635 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1636 ireq->sci_status = status;
1638 ireq->scu_status = SCU_TASK_DONE_GOOD;
1639 ireq->sci_status = SCI_SUCCESS;
1644 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1649 static void scu_atapi_reconstruct_raw_frame_task_context(struct isci_request *ireq)
1651 struct ata_device *dev = sas_to_ata_dev(ireq->target_device->domain_dev);
1652 void *atapi_cdb = ireq->ttype_ptr.io_task_ptr->ata_task.atapi_packet;
1653 struct scu_task_context *task_context = ireq->tc;
1659 memset(&ireq->stp.cmd, 0, sizeof(struct host_to_dev_fis));
1660 memcpy(((u8 *)&ireq->stp.cmd + sizeof(u32)), atapi_cdb, ATAPI_CDB_LEN);
1666 static void scu_atapi_construct_task_context(struct isci_request *ireq)
1668 struct ata_device *dev = sas_to_ata_dev(ireq->target_device->domain_dev);
1669 struct sas_task *task = isci_request_access_task(ireq);
1670 struct scu_task_context *task_context = ireq->tc;
1688 memset(&ireq->stp.cmd, 0, sizeof(ireq->stp.cmd));
1689 memcpy(&ireq->stp.cmd.lbal, task->ata_task.atapi_packet, cdb_len);
1702 sci_request_build_sgl(ireq);
1706 sci_io_request_frame_handler(struct isci_request *ireq,
1709 struct isci_host *ihost = ireq->owning_controller;
1710 struct isci_stp_request *stp_req = &ireq->stp.req;
1715 state = ireq->sm.current_state_id;
1736 sci_swab32_cpy(&ireq->ssp.rsp, resp_iu, word_cnt);
1738 resp_iu = &ireq->ssp.rsp;
1742 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1743 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1745 ireq->scu_status = SCU_TASK_DONE_GOOD;
1746 ireq->sci_status = SCI_SUCCESS;
1752 "frame %d type 0x%02x\n", __func__, ireq,
1766 sci_io_request_copy_response(ireq);
1767 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1772 struct sas_task *task = isci_request_access_task(ireq);
1797 ireq->scu_status = SCU_TASK_DONE_GOOD;
1798 ireq->sci_status = SCI_SUCCESS;
1799 sci_change_state(&ireq->sm, SCI_REQ_SMP_WAIT_TC_COMP);
1809 ireq,
1813 ireq->scu_status = SCU_TASK_DONE_SMP_FRM_TYPE_ERR;
1814 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1815 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1825 return sci_stp_request_udma_general_frame_handler(ireq,
1830 status = sci_stp_request_udma_general_frame_handler(ireq, frame_index);
1835 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1836 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1837 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1866 sci_controller_copy_sata_response(&ireq->stp.rsp,
1871 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1872 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1881 ireq->scu_status = SCU_TASK_DONE_UNEXP_FIS;
1882 ireq->sci_status = SCI_FAILURE_PROTOCOL_VIOLATION;
1886 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1895 struct sas_task *task = isci_request_access_task(ireq);
1930 sci_controller_copy_sata_response(&ireq->stp.rsp,
1934 ireq->stp.rsp.status = stp_req->status;
1940 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_DATA_IN);
1943 status = sci_stp_request_pio_data_out_transmit_data(ireq);
1946 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_DATA_OUT);
1951 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
1975 sci_controller_copy_sata_response(&ireq->stp.rsp,
1979 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1980 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1981 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2024 ireq->scu_status = SCU_TASK_DONE_GOOD;
2025 ireq->sci_status = SCI_FAILURE_IO_REQUIRES_SCSI_ABORT;
2026 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2034 ireq->saved_rx_frame_index = frame_index;
2055 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
2056 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
2057 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2059 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
2065 struct sas_task *task = isci_request_access_task(ireq);
2068 ireq->target_device->working_request = ireq;
2070 sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_TC_COMP);
2071 scu_atapi_reconstruct_raw_frame_task_context(ireq);
2073 sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_D2H);
2074 scu_atapi_construct_task_context(ireq);
2077 sci_controller_continue_io(ireq);
2081 return atapi_d2h_reg_frame_handler(ireq, frame_index);
2103 static enum sci_status stp_request_udma_await_tc_event(struct isci_request *ireq,
2110 ireq->scu_status = SCU_TASK_DONE_GOOD;
2111 ireq->sci_status = SCI_SUCCESS;
2112 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2120 if (ireq->stp.rsp.fis_type == FIS_REGD2H) {
2121 sci_remote_device_suspend(ireq->target_device,
2124 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
2125 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
2126 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2133 sci_change_state(&ireq->sm, SCI_REQ_STP_UDMA_WAIT_D2H);
2145 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
2146 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
2147 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2154 static enum sci_status atapi_raw_completion(struct isci_request *ireq, u32 completion_code,
2161 ireq->scu_status = SCU_TASK_DONE_GOOD;
2162 ireq->sci_status = SCI_SUCCESS;
2163 sci_change_state(&ireq->sm, next);
2170 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
2171 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
2173 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2180 static enum sci_status atapi_data_tc_completion_handler(struct isci_request *ireq,
2183 struct isci_remote_device *idev = ireq->target_device;
2184 struct dev_to_host_fis *d2h = &ireq->stp.rsp;
2189 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2193 u16 len = sci_req_tx_bytes(ireq);
2218 ireq->scu_status = SCU_TASK_DONE_GOOD;
2219 ireq->sci_status = SCI_SUCCESS_IO_DONE_EARLY;
2220 status = ireq->sci_status;
2232 ireq->scu_status = SCU_TASK_DONE_GOOD;
2233 ireq->sci_status = SCI_SUCCESS;
2234 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2240 status = ireq->sci_status;
2249 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
2250 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
2252 sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_D2H);
2349 struct isci_request *ireq,
2355 switch (ireq->protocol) {
2376 dev_warn(&ireq->isci_host->pdev->dev,
2378 __func__, ireq);
2385 &ireq->target_device->rnc,
2393 sci_io_request_tc_completion(struct isci_request *ireq,
2397 struct isci_host *ihost = ireq->owning_controller;
2399 state = ireq->sm.current_state_id;
2403 ireq, SCU_GET_COMPLETION_TL_STATUS(completion_code));
2407 return request_started_state_tc_event(ireq, completion_code);
2410 return ssp_task_request_await_tc_event(ireq,
2414 return smp_request_await_response_tc_event(ireq,
2418 return smp_request_await_tc_event(ireq, completion_code);
2421 return stp_request_udma_await_tc_event(ireq,
2425 return stp_request_non_data_await_h2d_tc_event(ireq,
2429 return stp_request_pio_await_h2d_completion_tc_event(ireq,
2433 return pio_data_out_tx_done_tc_event(ireq, completion_code);
2436 return request_aborting_state_tc_event(ireq,
2440 return atapi_raw_completion(ireq, completion_code,
2444 return atapi_raw_completion(ireq, completion_code,
2448 return atapi_data_tc_completion_handler(ireq, completion_code);
2964 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
2965 struct domain_device *dev = ireq->target_device->domain_dev;
2972 task = (test_bit(IREQ_TMF, &ireq->flags)) ? NULL : isci_request_access_task(ireq);
3002 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
3003 struct isci_host *ihost = ireq->owning_controller;
3006 if (!test_bit(IREQ_TMF, &ireq->flags))
3007 isci_request_io_request_complete(ihost, ireq,
3008 ireq->sci_status);
3010 isci_task_request_complete(ihost, ireq, ireq->sci_status);
3015 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
3018 ireq->tc->abort = 1;
3023 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
3025 ireq->target_device->working_request = ireq;
3030 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
3032 ireq->target_device->working_request = ireq;
3073 struct isci_request *ireq)
3075 sci_init_sm(&ireq->sm, sci_request_state_table, SCI_REQ_INIT);
3077 ireq->target_device = idev;
3078 ireq->protocol = SAS_PROTOCOL_NONE;
3079 ireq->saved_rx_frame_index = SCU_INVALID_FRAME_INDEX;
3081 ireq->sci_status = SCI_SUCCESS;
3082 ireq->scu_status = 0;
3083 ireq->post_context = 0xFFFFFFFF;
3089 struct isci_request *ireq)
3095 sci_general_request_construct(ihost, idev, ireq);
3103 memset(&ireq->stp.cmd, 0, sizeof(ireq->stp.cmd));
3109 memset(ireq->tc, 0, offsetof(struct scu_task_context, sgl_pair_ab));
3116 u16 io_tag, struct isci_request *ireq)
3122 sci_general_request_construct(ihost, idev, ireq);
3125 set_bit(IREQ_TMF, &ireq->flags);
3126 memset(ireq->tc, 0, sizeof(struct scu_task_context));
3130 ireq->protocol = SAS_PROTOCOL_STP;
3132 ireq->protocol = SAS_PROTOCOL_SSP;
3152 static enum sci_status isci_request_stp_request_construct(struct isci_request *ireq)
3154 struct sas_task *task = isci_request_access_task(ireq);
3155 struct host_to_dev_fis *fis = &ireq->stp.cmd;
3159 dev_dbg(&ireq->isci_host->pdev->dev,
3160 "%s: ireq = %p\n",
3162 ireq);
3169 status = sci_io_request_construct_basic_sata(ireq);
3177 ireq->tc->type.stp.ncq_tag = qc->tag;
3185 struct isci_request *ireq,
3228 ireq->protocol = SAS_PROTOCOL_SMP;
3232 task_context = ireq->tc;
3234 idev = ireq->target_device;
3286 ireq->post_context = (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
3290 ISCI_TAG_TCI(ireq->io_tag));
3302 sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
3309 * @ireq: This parameter points to the isci_request allocated in the
3314 static enum sci_status isci_smp_request_build(struct isci_request *ireq)
3316 struct sas_task *task = isci_request_access_task(ireq);
3317 struct device *dev = &ireq->isci_host->pdev->dev;
3320 status = sci_io_request_construct_smp(dev, ireq, task);
3322 dev_dbg(&ireq->isci_host->pdev->dev,
3406 struct isci_request *ireq;
3408 ireq = ihost->reqs[ISCI_TAG_TCI(tag)];
3409 ireq->io_tag = tag;
3410 ireq->io_request_completion = NULL;
3411 ireq->flags = 0;
3412 ireq->num_sg_entries = 0;
3414 return ireq;
3421 struct isci_request *ireq;
3423 ireq = isci_request_from_tag(ihost, tag);
3424 ireq->ttype_ptr.io_task_ptr = task;
3425 clear_bit(IREQ_TMF, &ireq->flags);
3426 task->lldd_task = ireq;
3428 return ireq;
3435 struct isci_request *ireq;
3437 ireq = isci_request_from_tag(ihost, tag);
3438 ireq->ttype_ptr.tmf_task_ptr = isci_tmf;
3439 set_bit(IREQ_TMF, &ireq->flags);
3441 return ireq;
3448 struct isci_request *ireq;
3453 ireq = isci_io_request_from_tag(ihost, task, tag);
3455 status = isci_io_request_build(ihost, ireq, idev);
3474 * ireq->is_task_management_request is false).
3478 ireq);
3485 ireq);
3504 set_bit(IREQ_TERMINATED, &ireq->flags);