isci: Convert of sci_ssp_response_iu to ssp_response_iu

Converting to Linux native format. However the isci driver does a lot of
the calculation based on the max size of this data structure and the
Linux data structure only has a pointer to the response data. Thus the
sizeof(struct ssp_response_iu) will be incorrect and we need to define
the max size.

Signed-off-by: Dave Jiang <dave.jiang@intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>

1 files changed, 34 insertions, 66 deletions

diff --git a/drivers/scsi/isci/task.c b/drivers/scsi/isci/task.c
index c4db959..8449d8a 100644
--- a/drivers/scsi/isci/task.c
+++ b/drivers/scsi/isci/task.c
@@ -55,6 +55,7 @@
 
 #include <linux/completion.h>
 #include <linux/irqflags.h>
+#include "sas.h"
 #include "scic_task_request.h"
 #include "scic_io_request.h"
 #include "remote_device.h"
@@ -63,7 +64,8 @@
 #include "request.h"
 #include "sata.h"
 #include "task.h"
-#include "core/scic_sds_request.h"
+#include "scic_sds_stp_request.h"
+
 /**
 * isci_task_refuse() - complete the request to the upper layer driver in
 *     the case where an I/O needs to be completed back in the submit path.
@@ -1411,109 +1413,75 @@ int isci_task_query_task(
 		return TMF_RESP_FUNC_SUCC;
 }
 
-/**
+/*
  * isci_task_request_complete() - This function is called by the sci core when
  *    an task request completes.
- * @isci_host: This parameter specifies the ISCI host object
- * @request: This parameter is the completed isci_request object.
+ * @ihost: This parameter specifies the ISCI host object
+ * @ireq: This parameter is the completed isci_request object.
  * @completion_status: This parameter specifies the completion status from the
  *    sci core.
  *
  * none.
  */
-void isci_task_request_complete(
-	struct isci_host *isci_host,
-	struct isci_request *request,
-	enum sci_task_status completion_status)
+void
+isci_task_request_complete(struct isci_host *ihost,
+			   struct isci_request *ireq,
+			   enum sci_task_status completion_status)
 {
-	struct isci_remote_device *isci_device = request->isci_device;
+	struct isci_remote_device *idev = ireq->isci_device;
 	enum isci_request_status old_state;
-	struct isci_tmf *tmf = isci_request_access_tmf(request);
+	struct isci_tmf *tmf = isci_request_access_tmf(ireq);
 	struct completion *tmf_complete;
+	struct scic_sds_request *sci_req = ireq->sci_request_handle;
+	struct scic_sds_stp_request *stp_req =
+		container_of(sci_req, typeof(*stp_req), parent);
 
-	dev_dbg(&isci_host->pdev->dev,
+	dev_dbg(&ihost->pdev->dev,
 		"%s: request = %p, status=%d\n",
-		__func__, request, completion_status);
+		__func__, ireq, completion_status);
 
-	old_state = isci_request_change_state(request, completed);
+	old_state = isci_request_change_state(ireq, completed);
 
 	tmf->status = completion_status;
-	request->complete_in_target = true;
-
-	if (SAS_PROTOCOL_SSP == tmf->proto) {
+	ireq->complete_in_target = true;
 
+	if (tmf->proto == SAS_PROTOCOL_SSP) {
 		memcpy(&tmf->resp.resp_iu,
-		       scic_io_request_get_response_iu_address(
-			       request->sci_request_handle
-			       ),
-		       sizeof(struct sci_ssp_response_iu));
-
-	} else if (SAS_PROTOCOL_SATA == tmf->proto) {
-
+		       sci_req->response_buffer,
+		       SSP_RESP_IU_MAX_SIZE);
+	} else if (tmf->proto == SAS_PROTOCOL_SATA) {
 		memcpy(&tmf->resp.d2h_fis,
-		       scic_stp_io_request_get_d2h_reg_address(
-			       request->sci_request_handle),
+		       &stp_req->d2h_reg_fis,
 		       sizeof(struct dev_to_host_fis));
 	}
 
 	/* Manage the timer if it is still running. */
 	if (tmf->timeout_timer) {
-		isci_del_timer(isci_host, tmf->timeout_timer);
+		isci_del_timer(ihost, tmf->timeout_timer);
 		tmf->timeout_timer = NULL;
 	}
 
 	/* PRINT_TMF( ((struct isci_tmf *)request->task)); */
 	tmf_complete = tmf->complete;
 
-	scic_controller_complete_io(
-		isci_host->core_controller,
-		&isci_device->sci,
-		request->sci_request_handle);
-	/* NULL the request handle to make sure it cannot be terminated
+	scic_controller_complete_io(ihost->core_controller,
+				    &idev->sci,
+				    ireq->sci_request_handle);
+
+	/*
+	 * NULL the request handle to make sure it cannot be terminated
 	 *  or completed again.
 	 */
-	request->sci_request_handle = NULL;
+	ireq->sci_request_handle = NULL;
 
-	isci_request_change_state(request, unallocated);
-	list_del_init(&request->dev_node);
+	isci_request_change_state(ireq, unallocated);
+	list_del_init(&ireq->dev_node);
 
 	/* The task management part completes last. */
 	complete(tmf_complete);
 }
 
 /**
- * isci_task_ssp_request_get_response_data_address() - This function is called
- *    by the sci core to retrieve the response data address for a given task
- *    request.
- * @request: This parameter is the isci_request object.
- *
- * response data address for specified task request.
- */
-void *isci_task_ssp_request_get_response_data_address(
-	struct isci_request *request)
-{
-	struct isci_tmf *isci_tmf = isci_request_access_tmf(request);
-
-	return &isci_tmf->resp.resp_iu;
-}
-
-/**
- * isci_task_ssp_request_get_response_data_length() - This function is called
- *    by the sci core to retrieve the response data length for a given task
- *    request.
- * @request: This parameter is the isci_request object.
- *
- * response data length for specified task request.
- */
-u32 isci_task_ssp_request_get_response_data_length(
-	struct isci_request *request)
-{
-	struct isci_tmf *isci_tmf = isci_request_access_tmf(request);
-
-	return sizeof(isci_tmf->resp.resp_iu);
-}
-
-/**
  * isci_bus_reset_handler() - This function performs a target reset of the
  *    device referenced by "cmd'.  This function is exported through the
  *    "struct scsi_host_template" structure such that it is called when an I/O