Lines Matching defs: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)) ?
214 struct isci_request *ireq,
221 idev = ireq->target_device;
247 /* task_context->type.ssp.tag = ireq->io_tag; */
250 ireq->post_context = (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
254 ISCI_TAG_TCI(ireq->io_tag));
260 dma_addr = sci_io_request_get_dma_addr(ireq, &ireq->ssp.cmd);
269 dma_addr = sci_io_request_get_dma_addr(ireq, &ireq->ssp.rsp);
294 static void scu_ssp_ireq_dif_insert(struct isci_request *ireq, u8 type, u8 op)
296 struct scu_task_context *tc = ireq->tc;
297 struct scsi_cmnd *scmd = ireq->ttype_ptr.io_task_ptr->uldd_task;
349 static void scu_ssp_ireq_dif_strip(struct isci_request *ireq, u8 type, u8 op)
351 struct scu_task_context *tc = ireq->tc;
352 struct scsi_cmnd *scmd = ireq->ttype_ptr.io_task_ptr->uldd_task;
413 static void scu_ssp_io_request_construct_task_context(struct isci_request *ireq,
417 struct scu_task_context *task_context = ireq->tc;
418 struct sas_task *sas_task = ireq->ttype_ptr.io_task_ptr;
423 scu_ssp_request_construct_task_context(ireq, task_context);
443 sci_request_build_sgl(ireq);
447 scu_ssp_ireq_dif_strip(ireq, prot_type, prot_op);
449 scu_ssp_ireq_dif_insert(ireq, prot_type, prot_op);
463 * @ireq: This parameter specifies the task request object being constructed.
465 static void scu_ssp_task_request_construct_task_context(struct isci_request *ireq)
467 struct scu_task_context *task_context = ireq->tc;
469 scu_ssp_request_construct_task_context(ireq, task_context);
484 * @ireq: The general IO request object which is to be used in
494 struct isci_request *ireq,
501 idev = ireq->target_device;
532 task_context->type.words[0] = *(u32 *)&ireq->stp.cmd;
534 ireq->post_context = (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
538 ISCI_TAG_TCI(ireq->io_tag));
544 dma_addr = sci_io_request_get_dma_addr(ireq,
545 ((char *) &ireq->stp.cmd) +
556 static void scu_stp_raw_request_construct_task_context(struct isci_request *ireq)
558 struct scu_task_context *task_context = ireq->tc;
560 scu_sata_request_construct_task_context(ireq, task_context);
569 static enum sci_status sci_stp_pio_request_construct(struct isci_request *ireq,
572 struct isci_stp_request *stp_req = &ireq->stp.req;
574 scu_stp_raw_request_construct_task_context(ireq);
581 sci_request_build_sgl(ireq);
593 * @ireq: This parameter specifies the request to be constructed as an
603 static void sci_stp_optimized_request_construct(struct isci_request *ireq,
608 struct scu_task_context *task_context = ireq->tc;
611 scu_sata_request_construct_task_context(ireq, task_context);
614 sci_request_build_sgl(ireq);
636 static void sci_atapi_construct(struct isci_request *ireq)
638 struct host_to_dev_fis *h2d_fis = &ireq->stp.cmd;
648 scu_stp_raw_request_construct_task_context(ireq);
650 task = isci_request_access_task(ireq);
657 ireq->stp.rsp.fis_type = 0;
661 sci_io_request_construct_sata(struct isci_request *ireq,
667 struct sas_task *task = isci_request_access_task(ireq);
668 struct domain_device *dev = ireq->target_device->domain_dev;
671 if (test_bit(IREQ_TMF, &ireq->flags)) {
672 struct isci_tmf *tmf = isci_request_access_tmf(ireq);
674 dev_err(&ireq->owning_controller->pdev->dev,
677 __func__, ireq, tmf->tmf_code);
683 dev_err(&ireq->owning_controller->pdev->dev,
694 sci_atapi_construct(ireq);
700 scu_stp_raw_request_construct_task_context(ireq);
706 sci_stp_optimized_request_construct(ireq,
714 sci_stp_optimized_request_construct(ireq,
719 return sci_stp_pio_request_construct(ireq, copy);
724 static enum sci_status sci_io_request_construct_basic_ssp(struct isci_request *ireq)
726 struct sas_task *task = isci_request_access_task(ireq);
728 ireq->protocol = SAS_PROTOCOL_SSP;
730 scu_ssp_io_request_construct_task_context(ireq,
734 sci_io_request_build_ssp_command_iu(ireq);
736 sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
741 void sci_task_request_construct_ssp(struct isci_request *ireq)
744 scu_ssp_task_request_construct_task_context(ireq);
747 sci_task_request_build_ssp_task_iu(ireq);
749 sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
752 static enum sci_status sci_io_request_construct_basic_sata(struct isci_request *ireq)
756 struct sas_task *task = isci_request_access_task(ireq);
758 ireq->protocol = SAS_PROTOCOL_STP;
762 status = sci_io_request_construct_sata(ireq,
768 sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
776 * @ireq: request that was terminated early
778 static u32 sci_req_tx_bytes(struct isci_request *ireq)
780 struct isci_host *ihost = ireq->owning_controller;
794 ((sizeof(struct scu_task_context)) * ISCI_TAG_TCI(ireq->io_tag)));
800 enum sci_status sci_request_start(struct isci_request *ireq)
803 struct scu_task_context *tc = ireq->tc;
804 struct isci_host *ihost = ireq->owning_controller;
806 state = ireq->sm.current_state_id;
814 tc->task_index = ISCI_TAG_TCI(ireq->io_tag);
820 tc->type.ssp.tag = ireq->io_tag;
826 * tc->type.stp.ncq_tag = ireq->ncq_tag;
841 ireq->post_context |= ISCI_TAG_TCI(ireq->io_tag);
844 sci_change_state(&ireq->sm, SCI_REQ_STARTED);
850 sci_io_request_terminate(struct isci_request *ireq)
854 state = ireq->sm.current_state_id;
859 set_bit(IREQ_TC_ABORT_POSTED, &ireq->flags);
860 ireq->scu_status = SCU_TASK_DONE_TASK_ABORT;
861 ireq->sci_status = SCI_FAILURE_IO_TERMINATED;
862 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
888 sci_change_state(&ireq->sm, SCI_REQ_ABORTING);
891 if (!isci_remote_device_is_safe_to_abort(ireq->target_device))
892 set_bit(IREQ_PENDING_ABORT, &ireq->flags);
894 clear_bit(IREQ_PENDING_ABORT, &ireq->flags);
901 dev_warn(&ireq->owning_controller->pdev->dev,
903 "state %d\n", __func__, ireq->sm.current_state_id);
910 enum sci_status sci_request_complete(struct isci_request *ireq)
913 struct isci_host *ihost = ireq->owning_controller;
915 state = ireq->sm.current_state_id;
921 if (ireq->saved_rx_frame_index != SCU_INVALID_FRAME_INDEX)
923 ireq->saved_rx_frame_index);
926 sci_change_state(&ireq->sm, SCI_REQ_FINAL);
930 enum sci_status sci_io_request_event_handler(struct isci_request *ireq,
934 struct isci_host *ihost = ireq->owning_controller;
936 state = ireq->sm.current_state_id;
950 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
970 static void sci_io_request_copy_response(struct isci_request *ireq)
975 struct isci_tmf *isci_tmf = isci_request_access_tmf(ireq);
977 ssp_response = &ireq->ssp.rsp;
989 request_started_state_tc_event(struct isci_request *ireq,
1000 ireq->scu_status = SCU_TASK_DONE_GOOD;
1001 ireq->sci_status = SCI_SUCCESS;
1011 struct ssp_response_iu *resp = &ireq->ssp.rsp;
1014 sci_swab32_cpy(&ireq->ssp.rsp,
1015 &ireq->ssp.rsp,
1019 ireq->scu_status = SCU_TASK_DONE_GOOD;
1020 ireq->sci_status = SCI_SUCCESS_IO_DONE_EARLY;
1022 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1023 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1030 sci_swab32_cpy(&ireq->ssp.rsp,
1031 &ireq->ssp.rsp,
1034 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1035 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1044 resp_iu = &ireq->ssp.rsp;
1049 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1050 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1052 ireq->scu_status = SCU_TASK_DONE_GOOD;
1053 ireq->sci_status = SCI_SUCCESS;
1068 if (ireq->protocol == SAS_PROTOCOL_STP) {
1069 ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1071 ireq->sci_status = SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
1073 ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1075 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1090 ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1092 ireq->sci_status = SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
1112 ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1114 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1123 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1128 request_aborting_state_tc_event(struct isci_request *ireq,
1134 ireq->scu_status = SCU_TASK_DONE_TASK_ABORT;
1135 ireq->sci_status = SCI_FAILURE_IO_TERMINATED;
1136 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1149 static enum sci_status ssp_task_request_await_tc_event(struct isci_request *ireq,
1154 ireq->scu_status = SCU_TASK_DONE_GOOD;
1155 ireq->sci_status = SCI_SUCCESS;
1156 sci_change_state(&ireq->sm, SCI_REQ_TASK_WAIT_TC_RESP);
1164 dev_warn(&ireq->owning_controller->pdev->dev,
1166 "ACK/NAK timeout\n", __func__, ireq,
1169 sci_change_state(&ireq->sm, SCI_REQ_TASK_WAIT_TC_RESP);
1177 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1178 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1179 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1187 smp_request_await_response_tc_event(struct isci_request *ireq,
1196 ireq->scu_status = SCU_TASK_DONE_GOOD;
1197 ireq->sci_status = SCI_SUCCESS;
1198 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1211 ireq->scu_status = SCU_TASK_DONE_SMP_RESP_TO_ERR;
1212 ireq->sci_status = SCI_FAILURE_RETRY_REQUIRED;
1213 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1219 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1220 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1221 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1229 smp_request_await_tc_event(struct isci_request *ireq,
1234 ireq->scu_status = SCU_TASK_DONE_GOOD;
1235 ireq->sci_status = SCI_SUCCESS;
1236 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1243 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1244 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1245 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1256 struct isci_request *ireq = to_ireq(stp_req);
1259 sgl_pair = to_sgl_element_pair(ireq, pio_sgl->index);
1277 sgl_pair = to_sgl_element_pair(ireq, pio_sgl->index);
1286 stp_request_non_data_await_h2d_tc_event(struct isci_request *ireq,
1291 ireq->scu_status = SCU_TASK_DONE_GOOD;
1292 ireq->sci_status = SCI_SUCCESS;
1293 sci_change_state(&ireq->sm, SCI_REQ_STP_NON_DATA_WAIT_D2H);
1301 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1302 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1303 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1316 struct isci_request *ireq,
1319 struct isci_stp_request *stp_req = &ireq->stp.req;
1320 struct scu_task_context *task_context = ireq->tc;
1327 sgl_pair = to_sgl_element_pair(ireq, stp_req->sgl.index);
1340 return sci_controller_continue_io(ireq);
1343 static enum sci_status sci_stp_request_pio_data_out_transmit_data(struct isci_request *ireq)
1345 struct isci_stp_request *stp_req = &ireq->stp.req;
1353 sgl_pair = to_sgl_element_pair(ireq, stp_req->sgl.index);
1369 status = sci_stp_request_pio_data_out_trasmit_data_frame(ireq, len);
1378 sci_stp_request_pio_data_out_trasmit_data_frame(ireq, stp_req->pio_len);
1404 struct isci_request *ireq;
1412 ireq = to_ireq(stp_req);
1413 task = isci_request_access_task(ireq);
1473 stp_request_pio_await_h2d_completion_tc_event(struct isci_request *ireq,
1478 ireq->scu_status = SCU_TASK_DONE_GOOD;
1479 ireq->sci_status = SCI_SUCCESS;
1480 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
1488 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1489 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1490 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1498 pio_data_out_tx_done_tc_event(struct isci_request *ireq,
1503 struct isci_stp_request *stp_req = &ireq->stp.req;
1509 status = sci_stp_request_pio_data_out_transmit_data(ireq);
1527 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
1537 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1538 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1539 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1546 static enum sci_status sci_stp_request_udma_general_frame_handler(struct isci_request *ireq,
1549 struct isci_host *ihost = ireq->owning_controller;
1564 sci_controller_copy_sata_response(&ireq->stp.rsp,
1574 static enum sci_status process_unsolicited_fis(struct isci_request *ireq,
1577 struct isci_host *ihost = ireq->owning_controller;
1590 dev_err(&ireq->isci_host->pdev->dev,
1600 sci_controller_copy_sata_response(&ireq->stp.rsp,
1610 static enum sci_status atapi_d2h_reg_frame_handler(struct isci_request *ireq,
1613 struct sas_task *task = isci_request_access_task(ireq);
1616 status = process_unsolicited_fis(ireq, frame_index);
1619 if (ireq->stp.rsp.status & ATA_ERR)
1626 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1627 ireq->sci_status = status;
1629 ireq->scu_status = SCU_TASK_DONE_GOOD;
1630 ireq->sci_status = SCI_SUCCESS;
1635 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1640 static void scu_atapi_reconstruct_raw_frame_task_context(struct isci_request *ireq)
1642 struct ata_device *dev = sas_to_ata_dev(ireq->target_device->domain_dev);
1643 void *atapi_cdb = ireq->ttype_ptr.io_task_ptr->ata_task.atapi_packet;
1644 struct scu_task_context *task_context = ireq->tc;
1650 memset(&ireq->stp.cmd, 0, sizeof(struct host_to_dev_fis));
1651 memcpy(((u8 *)&ireq->stp.cmd + sizeof(u32)), atapi_cdb, ATAPI_CDB_LEN);
1657 static void scu_atapi_construct_task_context(struct isci_request *ireq)
1659 struct ata_device *dev = sas_to_ata_dev(ireq->target_device->domain_dev);
1660 struct sas_task *task = isci_request_access_task(ireq);
1661 struct scu_task_context *task_context = ireq->tc;
1679 memset(&ireq->stp.cmd, 0, sizeof(ireq->stp.cmd));
1680 memcpy(&ireq->stp.cmd.lbal, task->ata_task.atapi_packet, cdb_len);
1693 sci_request_build_sgl(ireq);
1697 sci_io_request_frame_handler(struct isci_request *ireq,
1700 struct isci_host *ihost = ireq->owning_controller;
1701 struct isci_stp_request *stp_req = &ireq->stp.req;
1706 state = ireq->sm.current_state_id;
1727 sci_swab32_cpy(&ireq->ssp.rsp, resp_iu, word_cnt);
1729 resp_iu = &ireq->ssp.rsp;
1733 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1734 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1736 ireq->scu_status = SCU_TASK_DONE_GOOD;
1737 ireq->sci_status = SCI_SUCCESS;
1743 "frame %d type 0x%02x\n", __func__, ireq,
1757 sci_io_request_copy_response(ireq);
1758 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1763 struct sas_task *task = isci_request_access_task(ireq);
1788 ireq->scu_status = SCU_TASK_DONE_GOOD;
1789 ireq->sci_status = SCI_SUCCESS;
1790 sci_change_state(&ireq->sm, SCI_REQ_SMP_WAIT_TC_COMP);
1800 ireq,
1804 ireq->scu_status = SCU_TASK_DONE_SMP_FRM_TYPE_ERR;
1805 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1806 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1816 return sci_stp_request_udma_general_frame_handler(ireq,
1821 status = sci_stp_request_udma_general_frame_handler(ireq, frame_index);
1826 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1827 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1828 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1857 sci_controller_copy_sata_response(&ireq->stp.rsp,
1862 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1863 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1872 ireq->scu_status = SCU_TASK_DONE_UNEXP_FIS;
1873 ireq->sci_status = SCI_FAILURE_PROTOCOL_VIOLATION;
1877 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1886 struct sas_task *task = isci_request_access_task(ireq);
1921 sci_controller_copy_sata_response(&ireq->stp.rsp,
1925 ireq->stp.rsp.status = stp_req->status;
1931 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_DATA_IN);
1934 status = sci_stp_request_pio_data_out_transmit_data(ireq);
1937 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_DATA_OUT);
1942 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
1966 sci_controller_copy_sata_response(&ireq->stp.rsp,
1970 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1971 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1972 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2015 ireq->scu_status = SCU_TASK_DONE_GOOD;
2016 ireq->sci_status = SCI_FAILURE_IO_REQUIRES_SCSI_ABORT;
2017 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2025 ireq->saved_rx_frame_index = frame_index;
2046 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
2047 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
2048 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2050 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
2056 struct sas_task *task = isci_request_access_task(ireq);
2059 ireq->target_device->working_request = ireq;
2061 sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_TC_COMP);
2062 scu_atapi_reconstruct_raw_frame_task_context(ireq);
2064 sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_D2H);
2065 scu_atapi_construct_task_context(ireq);
2068 sci_controller_continue_io(ireq);
2072 return atapi_d2h_reg_frame_handler(ireq, frame_index);
2094 static enum sci_status stp_request_udma_await_tc_event(struct isci_request *ireq,
2099 ireq->scu_status = SCU_TASK_DONE_GOOD;
2100 ireq->sci_status = SCI_SUCCESS;
2101 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2109 if (ireq->stp.rsp.fis_type == FIS_REGD2H) {
2110 sci_remote_device_suspend(ireq->target_device,
2113 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
2114 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
2115 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2122 sci_change_state(&ireq->sm, SCI_REQ_STP_UDMA_WAIT_D2H);
2134 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
2135 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
2136 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2143 static enum sci_status atapi_raw_completion(struct isci_request *ireq, u32 completion_code,
2148 ireq->scu_status = SCU_TASK_DONE_GOOD;
2149 ireq->sci_status = SCI_SUCCESS;
2150 sci_change_state(&ireq->sm, next);
2157 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
2158 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
2160 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2167 static enum sci_status atapi_data_tc_completion_handler(struct isci_request *ireq,
2170 struct isci_remote_device *idev = ireq->target_device;
2171 struct dev_to_host_fis *d2h = &ireq->stp.rsp;
2176 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2180 u16 len = sci_req_tx_bytes(ireq);
2205 ireq->scu_status = SCU_TASK_DONE_GOOD;
2206 ireq->sci_status = SCI_SUCCESS_IO_DONE_EARLY;
2207 status = ireq->sci_status;
2219 ireq->scu_status = SCU_TASK_DONE_GOOD;
2220 ireq->sci_status = SCI_SUCCESS;
2221 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2227 status = ireq->sci_status;
2236 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
2237 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
2239 sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_D2H);
2336 struct isci_request *ireq,
2342 switch (ireq->protocol) {
2363 dev_warn(&ireq->isci_host->pdev->dev,
2365 __func__, ireq);
2372 &ireq->target_device->rnc,
2380 sci_io_request_tc_completion(struct isci_request *ireq,
2384 struct isci_host *ihost = ireq->owning_controller;
2386 state = ireq->sm.current_state_id;
2390 ireq, SCU_GET_COMPLETION_TL_STATUS(completion_code));
2394 return request_started_state_tc_event(ireq, completion_code);
2397 return ssp_task_request_await_tc_event(ireq,
2401 return smp_request_await_response_tc_event(ireq,
2405 return smp_request_await_tc_event(ireq, completion_code);
2408 return stp_request_udma_await_tc_event(ireq,
2412 return stp_request_non_data_await_h2d_tc_event(ireq,
2416 return stp_request_pio_await_h2d_completion_tc_event(ireq,
2420 return pio_data_out_tx_done_tc_event(ireq, completion_code);
2423 return request_aborting_state_tc_event(ireq,
2427 return atapi_raw_completion(ireq, completion_code,
2431 return atapi_raw_completion(ireq, completion_code,
2435 return atapi_data_tc_completion_handler(ireq, completion_code);
2953 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
2954 struct domain_device *dev = ireq->target_device->domain_dev;
2961 task = (test_bit(IREQ_TMF, &ireq->flags)) ? NULL : isci_request_access_task(ireq);
2991 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
2992 struct isci_host *ihost = ireq->owning_controller;
2995 if (!test_bit(IREQ_TMF, &ireq->flags))
2996 isci_request_io_request_complete(ihost, ireq,
2997 ireq->sci_status);
2999 isci_task_request_complete(ihost, ireq, ireq->sci_status);
3004 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
3007 ireq->tc->abort = 1;
3012 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
3014 ireq->target_device->working_request = ireq;
3019 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
3021 ireq->target_device->working_request = ireq;
3062 struct isci_request *ireq)
3064 sci_init_sm(&ireq->sm, sci_request_state_table, SCI_REQ_INIT);
3066 ireq->target_device = idev;
3067 ireq->protocol = SAS_PROTOCOL_NONE;
3068 ireq->saved_rx_frame_index = SCU_INVALID_FRAME_INDEX;
3070 ireq->sci_status = SCI_SUCCESS;
3071 ireq->scu_status = 0;
3072 ireq->post_context = 0xFFFFFFFF;
3078 struct isci_request *ireq)
3084 sci_general_request_construct(ihost, idev, ireq);
3092 memset(&ireq->stp.cmd, 0, sizeof(ireq->stp.cmd));
3098 memset(ireq->tc, 0, offsetof(struct scu_task_context, sgl_pair_ab));
3105 u16 io_tag, struct isci_request *ireq)
3111 sci_general_request_construct(ihost, idev, ireq);
3114 set_bit(IREQ_TMF, &ireq->flags);
3115 memset(ireq->tc, 0, sizeof(struct scu_task_context));
3119 ireq->protocol = SAS_PROTOCOL_STP;
3121 ireq->protocol = SAS_PROTOCOL_SSP;
3141 static enum sci_status isci_request_stp_request_construct(struct isci_request *ireq)
3143 struct sas_task *task = isci_request_access_task(ireq);
3144 struct host_to_dev_fis *fis = &ireq->stp.cmd;
3148 dev_dbg(&ireq->isci_host->pdev->dev,
3149 "%s: ireq = %p\n",
3151 ireq);
3158 status = sci_io_request_construct_basic_sata(ireq);
3166 ireq->tc->type.stp.ncq_tag = qc->tag;
3174 struct isci_request *ireq,
3217 ireq->protocol = SAS_PROTOCOL_SMP;
3221 task_context = ireq->tc;
3223 idev = ireq->target_device;
3275 ireq->post_context = (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
3279 ISCI_TAG_TCI(ireq->io_tag));
3291 sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
3298 * @ireq: This parameter points to the isci_request allocated in the
3303 static enum sci_status isci_smp_request_build(struct isci_request *ireq)
3305 struct sas_task *task = isci_request_access_task(ireq);
3306 struct device *dev = &ireq->isci_host->pdev->dev;
3309 status = sci_io_request_construct_smp(dev, ireq, task);
3311 dev_dbg(&ireq->isci_host->pdev->dev,
3395 struct isci_request *ireq;
3397 ireq = ihost->reqs[ISCI_TAG_TCI(tag)];
3398 ireq->io_tag = tag;
3399 ireq->io_request_completion = NULL;
3400 ireq->flags = 0;
3401 ireq->num_sg_entries = 0;
3403 return ireq;
3410 struct isci_request *ireq;
3412 ireq = isci_request_from_tag(ihost, tag);
3413 ireq->ttype_ptr.io_task_ptr = task;
3414 clear_bit(IREQ_TMF, &ireq->flags);
3415 task->lldd_task = ireq;
3417 return ireq;
3424 struct isci_request *ireq;
3426 ireq = isci_request_from_tag(ihost, tag);
3427 ireq->ttype_ptr.tmf_task_ptr = isci_tmf;
3428 set_bit(IREQ_TMF, &ireq->flags);
3430 return ireq;
3434 struct sas_task *task, struct isci_request *ireq)
3440 status = isci_io_request_build(ihost, ireq, idev);
3459 * ireq->is_task_management_request is false).
3463 ireq);
3470 ireq);
3489 set_bit(IREQ_TERMINATED, &ireq->flags);