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)) ?
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);
742 struct isci_request *ireq)
745 scu_ssp_task_request_construct_task_context(ireq);
748 sci_task_request_build_ssp_task_iu(ireq);
750 sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
755 static enum sci_status sci_io_request_construct_basic_sata(struct isci_request *ireq)
759 struct sas_task *task = isci_request_access_task(ireq);
761 ireq->protocol = SAS_PROTOCOL_STP;
765 status = sci_io_request_construct_sata(ireq,
771 sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
779 * @ireq: request that was terminated early
781 static u32 sci_req_tx_bytes(struct isci_request *ireq)
783 struct isci_host *ihost = ireq->owning_controller;
797 ((sizeof(struct scu_task_context)) * ISCI_TAG_TCI(ireq->io_tag)));
803 enum sci_status sci_request_start(struct isci_request *ireq)
806 struct scu_task_context *tc = ireq->tc;
807 struct isci_host *ihost = ireq->owning_controller;
809 state = ireq->sm.current_state_id;
817 tc->task_index = ISCI_TAG_TCI(ireq->io_tag);
823 tc->type.ssp.tag = ireq->io_tag;
829 * tc->type.stp.ncq_tag = ireq->ncq_tag;
844 ireq->post_context |= ISCI_TAG_TCI(ireq->io_tag);
847 sci_change_state(&ireq->sm, SCI_REQ_STARTED);
853 sci_io_request_terminate(struct isci_request *ireq)
857 state = ireq->sm.current_state_id;
862 set_bit(IREQ_TC_ABORT_POSTED, &ireq->flags);
863 ireq->scu_status = SCU_TASK_DONE_TASK_ABORT;
864 ireq->sci_status = SCI_FAILURE_IO_TERMINATED;
865 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
891 sci_change_state(&ireq->sm, SCI_REQ_ABORTING);
894 if (!isci_remote_device_is_safe_to_abort(ireq->target_device))
895 set_bit(IREQ_PENDING_ABORT, &ireq->flags);
897 clear_bit(IREQ_PENDING_ABORT, &ireq->flags);
904 dev_warn(&ireq->owning_controller->pdev->dev,
906 "state %d\n", __func__, ireq->sm.current_state_id);
913 enum sci_status sci_request_complete(struct isci_request *ireq)
916 struct isci_host *ihost = ireq->owning_controller;
918 state = ireq->sm.current_state_id;
924 if (ireq->saved_rx_frame_index != SCU_INVALID_FRAME_INDEX)
926 ireq->saved_rx_frame_index);
929 sci_change_state(&ireq->sm, SCI_REQ_FINAL);
933 enum sci_status sci_io_request_event_handler(struct isci_request *ireq,
937 struct isci_host *ihost = ireq->owning_controller;
939 state = ireq->sm.current_state_id;
953 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
973 static void sci_io_request_copy_response(struct isci_request *ireq)
978 struct isci_tmf *isci_tmf = isci_request_access_tmf(ireq);
980 ssp_response = &ireq->ssp.rsp;
992 request_started_state_tc_event(struct isci_request *ireq,
1003 ireq->scu_status = SCU_TASK_DONE_GOOD;
1004 ireq->sci_status = SCI_SUCCESS;
1014 struct ssp_response_iu *resp = &ireq->ssp.rsp;
1017 sci_swab32_cpy(&ireq->ssp.rsp,
1018 &ireq->ssp.rsp,
1022 ireq->scu_status = SCU_TASK_DONE_GOOD;
1023 ireq->sci_status = SCI_SUCCESS_IO_DONE_EARLY;
1025 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1026 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1033 sci_swab32_cpy(&ireq->ssp.rsp,
1034 &ireq->ssp.rsp,
1037 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1038 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1047 resp_iu = &ireq->ssp.rsp;
1052 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1053 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1055 ireq->scu_status = SCU_TASK_DONE_GOOD;
1056 ireq->sci_status = SCI_SUCCESS;
1071 if (ireq->protocol == SAS_PROTOCOL_STP) {
1072 ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1074 ireq->sci_status = SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
1076 ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1078 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1093 ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1095 ireq->sci_status = SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
1115 ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1117 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1126 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1131 request_aborting_state_tc_event(struct isci_request *ireq,
1137 ireq->scu_status = SCU_TASK_DONE_TASK_ABORT;
1138 ireq->sci_status = SCI_FAILURE_IO_TERMINATED;
1139 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1152 static enum sci_status ssp_task_request_await_tc_event(struct isci_request *ireq,
1157 ireq->scu_status = SCU_TASK_DONE_GOOD;
1158 ireq->sci_status = SCI_SUCCESS;
1159 sci_change_state(&ireq->sm, SCI_REQ_TASK_WAIT_TC_RESP);
1167 dev_warn(&ireq->owning_controller->pdev->dev,
1169 "ACK/NAK timeout\n", __func__, ireq,
1172 sci_change_state(&ireq->sm, SCI_REQ_TASK_WAIT_TC_RESP);
1180 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1181 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1182 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1190 smp_request_await_response_tc_event(struct isci_request *ireq,
1199 ireq->scu_status = SCU_TASK_DONE_GOOD;
1200 ireq->sci_status = SCI_SUCCESS;
1201 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1214 ireq->scu_status = SCU_TASK_DONE_SMP_RESP_TO_ERR;
1215 ireq->sci_status = SCI_FAILURE_RETRY_REQUIRED;
1216 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1222 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1223 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1224 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1232 smp_request_await_tc_event(struct isci_request *ireq,
1237 ireq->scu_status = SCU_TASK_DONE_GOOD;
1238 ireq->sci_status = SCI_SUCCESS;
1239 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1246 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1247 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1248 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1259 struct isci_request *ireq = to_ireq(stp_req);
1262 sgl_pair = to_sgl_element_pair(ireq, pio_sgl->index);
1280 sgl_pair = to_sgl_element_pair(ireq, pio_sgl->index);
1289 stp_request_non_data_await_h2d_tc_event(struct isci_request *ireq,
1294 ireq->scu_status = SCU_TASK_DONE_GOOD;
1295 ireq->sci_status = SCI_SUCCESS;
1296 sci_change_state(&ireq->sm, SCI_REQ_STP_NON_DATA_WAIT_D2H);
1304 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1305 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1306 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1319 struct isci_request *ireq,
1322 struct isci_stp_request *stp_req = &ireq->stp.req;
1323 struct scu_task_context *task_context = ireq->tc;
1330 sgl_pair = to_sgl_element_pair(ireq, stp_req->sgl.index);
1343 return sci_controller_continue_io(ireq);
1346 static enum sci_status sci_stp_request_pio_data_out_transmit_data(struct isci_request *ireq)
1348 struct isci_stp_request *stp_req = &ireq->stp.req;
1356 sgl_pair = to_sgl_element_pair(ireq, stp_req->sgl.index);
1372 status = sci_stp_request_pio_data_out_trasmit_data_frame(ireq, len);
1381 sci_stp_request_pio_data_out_trasmit_data_frame(ireq, stp_req->pio_len);
1407 struct isci_request *ireq;
1415 ireq = to_ireq(stp_req);
1416 task = isci_request_access_task(ireq);
1476 stp_request_pio_await_h2d_completion_tc_event(struct isci_request *ireq,
1481 ireq->scu_status = SCU_TASK_DONE_GOOD;
1482 ireq->sci_status = SCI_SUCCESS;
1483 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
1491 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1492 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1493 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1501 pio_data_out_tx_done_tc_event(struct isci_request *ireq,
1506 struct isci_stp_request *stp_req = &ireq->stp.req;
1512 status = sci_stp_request_pio_data_out_transmit_data(ireq);
1530 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
1540 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1541 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1542 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1549 static enum sci_status sci_stp_request_udma_general_frame_handler(struct isci_request *ireq,
1552 struct isci_host *ihost = ireq->owning_controller;
1567 sci_controller_copy_sata_response(&ireq->stp.rsp,
1577 static enum sci_status process_unsolicited_fis(struct isci_request *ireq,
1580 struct isci_host *ihost = ireq->owning_controller;
1593 dev_err(&ireq->isci_host->pdev->dev,
1603 sci_controller_copy_sata_response(&ireq->stp.rsp,
1613 static enum sci_status atapi_d2h_reg_frame_handler(struct isci_request *ireq,
1616 struct sas_task *task = isci_request_access_task(ireq);
1619 status = process_unsolicited_fis(ireq, frame_index);
1622 if (ireq->stp.rsp.status & ATA_ERR)
1629 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1630 ireq->sci_status = status;
1632 ireq->scu_status = SCU_TASK_DONE_GOOD;
1633 ireq->sci_status = SCI_SUCCESS;
1638 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1643 static void scu_atapi_reconstruct_raw_frame_task_context(struct isci_request *ireq)
1645 struct ata_device *dev = sas_to_ata_dev(ireq->target_device->domain_dev);
1646 void *atapi_cdb = ireq->ttype_ptr.io_task_ptr->ata_task.atapi_packet;
1647 struct scu_task_context *task_context = ireq->tc;
1653 memset(&ireq->stp.cmd, 0, sizeof(struct host_to_dev_fis));
1654 memcpy(((u8 *)&ireq->stp.cmd + sizeof(u32)), atapi_cdb, ATAPI_CDB_LEN);
1660 static void scu_atapi_construct_task_context(struct isci_request *ireq)
1662 struct ata_device *dev = sas_to_ata_dev(ireq->target_device->domain_dev);
1663 struct sas_task *task = isci_request_access_task(ireq);
1664 struct scu_task_context *task_context = ireq->tc;
1682 memset(&ireq->stp.cmd, 0, sizeof(ireq->stp.cmd));
1683 memcpy(&ireq->stp.cmd.lbal, task->ata_task.atapi_packet, cdb_len);
1696 sci_request_build_sgl(ireq);
1700 sci_io_request_frame_handler(struct isci_request *ireq,
1703 struct isci_host *ihost = ireq->owning_controller;
1704 struct isci_stp_request *stp_req = &ireq->stp.req;
1709 state = ireq->sm.current_state_id;
1730 sci_swab32_cpy(&ireq->ssp.rsp, resp_iu, word_cnt);
1732 resp_iu = &ireq->ssp.rsp;
1736 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1737 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1739 ireq->scu_status = SCU_TASK_DONE_GOOD;
1740 ireq->sci_status = SCI_SUCCESS;
1746 "frame %d type 0x%02x\n", __func__, ireq,
1760 sci_io_request_copy_response(ireq);
1761 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1766 struct sas_task *task = isci_request_access_task(ireq);
1791 ireq->scu_status = SCU_TASK_DONE_GOOD;
1792 ireq->sci_status = SCI_SUCCESS;
1793 sci_change_state(&ireq->sm, SCI_REQ_SMP_WAIT_TC_COMP);
1803 ireq,
1807 ireq->scu_status = SCU_TASK_DONE_SMP_FRM_TYPE_ERR;
1808 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1809 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1819 return sci_stp_request_udma_general_frame_handler(ireq,
1824 status = sci_stp_request_udma_general_frame_handler(ireq, frame_index);
1829 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1830 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1831 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1860 sci_controller_copy_sata_response(&ireq->stp.rsp,
1865 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1866 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1875 ireq->scu_status = SCU_TASK_DONE_UNEXP_FIS;
1876 ireq->sci_status = SCI_FAILURE_PROTOCOL_VIOLATION;
1880 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1889 struct sas_task *task = isci_request_access_task(ireq);
1924 sci_controller_copy_sata_response(&ireq->stp.rsp,
1928 ireq->stp.rsp.status = stp_req->status;
1934 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_DATA_IN);
1937 status = sci_stp_request_pio_data_out_transmit_data(ireq);
1940 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_DATA_OUT);
1945 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
1969 sci_controller_copy_sata_response(&ireq->stp.rsp,
1973 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1974 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1975 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2018 ireq->scu_status = SCU_TASK_DONE_GOOD;
2019 ireq->sci_status = SCI_FAILURE_IO_REQUIRES_SCSI_ABORT;
2020 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2028 ireq->saved_rx_frame_index = frame_index;
2049 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
2050 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
2051 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2053 sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
2059 struct sas_task *task = isci_request_access_task(ireq);
2062 ireq->target_device->working_request = ireq;
2064 sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_TC_COMP);
2065 scu_atapi_reconstruct_raw_frame_task_context(ireq);
2067 sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_D2H);
2068 scu_atapi_construct_task_context(ireq);
2071 sci_controller_continue_io(ireq);
2075 return atapi_d2h_reg_frame_handler(ireq, frame_index);
2097 static enum sci_status stp_request_udma_await_tc_event(struct isci_request *ireq,
2102 ireq->scu_status = SCU_TASK_DONE_GOOD;
2103 ireq->sci_status = SCI_SUCCESS;
2104 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2112 if (ireq->stp.rsp.fis_type == FIS_REGD2H) {
2113 sci_remote_device_suspend(ireq->target_device,
2116 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
2117 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
2118 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2125 sci_change_state(&ireq->sm, SCI_REQ_STP_UDMA_WAIT_D2H);
2137 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
2138 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
2139 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2146 static enum sci_status atapi_raw_completion(struct isci_request *ireq, u32 completion_code,
2151 ireq->scu_status = SCU_TASK_DONE_GOOD;
2152 ireq->sci_status = SCI_SUCCESS;
2153 sci_change_state(&ireq->sm, next);
2160 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
2161 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
2163 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2170 static enum sci_status atapi_data_tc_completion_handler(struct isci_request *ireq,
2173 struct isci_remote_device *idev = ireq->target_device;
2174 struct dev_to_host_fis *d2h = &ireq->stp.rsp;
2179 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2183 u16 len = sci_req_tx_bytes(ireq);
2208 ireq->scu_status = SCU_TASK_DONE_GOOD;
2209 ireq->sci_status = SCI_SUCCESS_IO_DONE_EARLY;
2210 status = ireq->sci_status;
2222 ireq->scu_status = SCU_TASK_DONE_GOOD;
2223 ireq->sci_status = SCI_SUCCESS;
2224 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2230 status = ireq->sci_status;
2239 ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
2240 ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
2242 sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_D2H);
2339 struct isci_request *ireq,
2345 switch (ireq->protocol) {
2366 dev_warn(&ireq->isci_host->pdev->dev,
2368 __func__, ireq);
2375 &ireq->target_device->rnc,
2383 sci_io_request_tc_completion(struct isci_request *ireq,
2387 struct isci_host *ihost = ireq->owning_controller;
2389 state = ireq->sm.current_state_id;
2393 ireq, SCU_GET_COMPLETION_TL_STATUS(completion_code));
2397 return request_started_state_tc_event(ireq, completion_code);
2400 return ssp_task_request_await_tc_event(ireq,
2404 return smp_request_await_response_tc_event(ireq,
2408 return smp_request_await_tc_event(ireq, completion_code);
2411 return stp_request_udma_await_tc_event(ireq,
2415 return stp_request_non_data_await_h2d_tc_event(ireq,
2419 return stp_request_pio_await_h2d_completion_tc_event(ireq,
2423 return pio_data_out_tx_done_tc_event(ireq, completion_code);
2426 return request_aborting_state_tc_event(ireq,
2430 return atapi_raw_completion(ireq, completion_code,
2434 return atapi_raw_completion(ireq, completion_code,
2438 return atapi_data_tc_completion_handler(ireq, completion_code);
2956 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
2957 struct domain_device *dev = ireq->target_device->domain_dev;
2964 task = (test_bit(IREQ_TMF, &ireq->flags)) ? NULL : isci_request_access_task(ireq);
2994 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
2995 struct isci_host *ihost = ireq->owning_controller;
2998 if (!test_bit(IREQ_TMF, &ireq->flags))
2999 isci_request_io_request_complete(ihost, ireq,
3000 ireq->sci_status);
3002 isci_task_request_complete(ihost, ireq, ireq->sci_status);
3007 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
3010 ireq->tc->abort = 1;
3015 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
3017 ireq->target_device->working_request = ireq;
3022 struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
3024 ireq->target_device->working_request = ireq;
3065 struct isci_request *ireq)
3067 sci_init_sm(&ireq->sm, sci_request_state_table, SCI_REQ_INIT);
3069 ireq->target_device = idev;
3070 ireq->protocol = SAS_PROTOCOL_NONE;
3071 ireq->saved_rx_frame_index = SCU_INVALID_FRAME_INDEX;
3073 ireq->sci_status = SCI_SUCCESS;
3074 ireq->scu_status = 0;
3075 ireq->post_context = 0xFFFFFFFF;
3081 struct isci_request *ireq)
3087 sci_general_request_construct(ihost, idev, ireq);
3095 memset(&ireq->stp.cmd, 0, sizeof(ireq->stp.cmd));
3101 memset(ireq->tc, 0, offsetof(struct scu_task_context, sgl_pair_ab));
3108 u16 io_tag, struct isci_request *ireq)
3114 sci_general_request_construct(ihost, idev, ireq);
3117 set_bit(IREQ_TMF, &ireq->flags);
3118 memset(ireq->tc, 0, sizeof(struct scu_task_context));
3122 ireq->protocol = SAS_PROTOCOL_STP;
3124 ireq->protocol = SAS_PROTOCOL_SSP;
3144 static enum sci_status isci_request_stp_request_construct(struct isci_request *ireq)
3146 struct sas_task *task = isci_request_access_task(ireq);
3147 struct host_to_dev_fis *fis = &ireq->stp.cmd;
3151 dev_dbg(&ireq->isci_host->pdev->dev,
3152 "%s: ireq = %p\n",
3154 ireq);
3161 status = sci_io_request_construct_basic_sata(ireq);
3169 ireq->tc->type.stp.ncq_tag = qc->tag;
3177 struct isci_request *ireq,
3220 ireq->protocol = SAS_PROTOCOL_SMP;
3224 task_context = ireq->tc;
3226 idev = ireq->target_device;
3278 ireq->post_context = (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
3282 ISCI_TAG_TCI(ireq->io_tag));
3294 sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
3301 * @ireq: This parameter points to the isci_request allocated in the
3306 static enum sci_status isci_smp_request_build(struct isci_request *ireq)
3308 struct sas_task *task = isci_request_access_task(ireq);
3309 struct device *dev = &ireq->isci_host->pdev->dev;
3312 status = sci_io_request_construct_smp(dev, ireq, task);
3314 dev_dbg(&ireq->isci_host->pdev->dev,
3398 struct isci_request *ireq;
3400 ireq = ihost->reqs[ISCI_TAG_TCI(tag)];
3401 ireq->io_tag = tag;
3402 ireq->io_request_completion = NULL;
3403 ireq->flags = 0;
3404 ireq->num_sg_entries = 0;
3406 return ireq;
3413 struct isci_request *ireq;
3415 ireq = isci_request_from_tag(ihost, tag);
3416 ireq->ttype_ptr.io_task_ptr = task;
3417 clear_bit(IREQ_TMF, &ireq->flags);
3418 task->lldd_task = ireq;
3420 return ireq;
3427 struct isci_request *ireq;
3429 ireq = isci_request_from_tag(ihost, tag);
3430 ireq->ttype_ptr.tmf_task_ptr = isci_tmf;
3431 set_bit(IREQ_TMF, &ireq->flags);
3433 return ireq;
3437 struct sas_task *task, struct isci_request *ireq)
3443 status = isci_io_request_build(ihost, ireq, idev);
3462 * ireq->is_task_management_request is false).
3466 ireq);
3473 ireq);
3492 set_bit(IREQ_TERMINATED, &ireq->flags);