isci: unify isci_host and scic_sds_controller

Remove the distinction between these two implementations and unify on
isci_host (local instances named ihost).  Hmmm, we had two
'oem_parameters' instances, one was unused... nice.

Reported-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>

1 files changed, 489 insertions, 511 deletions

diff --git a/drivers/scsi/isci/host.c b/drivers/scsi/isci/host.c
index 45d7f71c609..bb298f8f609 100644
--- a/drivers/scsi/isci/host.c
+++ b/drivers/scsi/isci/host.c
@@ -181,35 +181,35 @@ void sci_change_state(struct sci_base_state_machine *sm, u32 next_state)
 }
 
 static bool scic_sds_controller_completion_queue_has_entries(
-	struct scic_sds_controller *scic)
+	struct isci_host *ihost)
 {
-	u32 get_value = scic->completion_queue_get;
+	u32 get_value = ihost->completion_queue_get;
 	u32 get_index = get_value & SMU_COMPLETION_QUEUE_GET_POINTER_MASK;
 
 	if (NORMALIZE_GET_POINTER_CYCLE_BIT(get_value) ==
-	    COMPLETION_QUEUE_CYCLE_BIT(scic->completion_queue[get_index]))
+	    COMPLETION_QUEUE_CYCLE_BIT(ihost->completion_queue[get_index]))
 		return true;
 
 	return false;
 }
 
-static bool scic_sds_controller_isr(struct scic_sds_controller *scic)
+static bool scic_sds_controller_isr(struct isci_host *ihost)
 {
-	if (scic_sds_controller_completion_queue_has_entries(scic)) {
+	if (scic_sds_controller_completion_queue_has_entries(ihost)) {
 		return true;
 	} else {
 		/*
 		 * we have a spurious interrupt it could be that we have already
 		 * emptied the completion queue from a previous interrupt */
-		writel(SMU_ISR_COMPLETION, &scic->smu_registers->interrupt_status);
+		writel(SMU_ISR_COMPLETION, &ihost->smu_registers->interrupt_status);
 
 		/*
 		 * There is a race in the hardware that could cause us not to be notified
 		 * of an interrupt completion if we do not take this step.  We will mask
 		 * then unmask the interrupts so if there is another interrupt pending
 		 * the clearing of the interrupt source we get the next interrupt message. */
-		writel(0xFF000000, &scic->smu_registers->interrupt_mask);
-		writel(0, &scic->smu_registers->interrupt_mask);
+		writel(0xFF000000, &ihost->smu_registers->interrupt_mask);
+		writel(0, &ihost->smu_registers->interrupt_mask);
 	}
 
 	return false;
@@ -219,18 +219,18 @@ irqreturn_t isci_msix_isr(int vec, void *data)
 {
 	struct isci_host *ihost = data;
 
-	if (scic_sds_controller_isr(&ihost->sci))
+	if (scic_sds_controller_isr(ihost))
 		tasklet_schedule(&ihost->completion_tasklet);
 
 	return IRQ_HANDLED;
 }
 
-static bool scic_sds_controller_error_isr(struct scic_sds_controller *scic)
+static bool scic_sds_controller_error_isr(struct isci_host *ihost)
 {
 	u32 interrupt_status;
 
 	interrupt_status =
-		readl(&scic->smu_registers->interrupt_status);
+		readl(&ihost->smu_registers->interrupt_status);
 	interrupt_status &= (SMU_ISR_QUEUE_ERROR | SMU_ISR_QUEUE_SUSPEND);
 
 	if (interrupt_status != 0) {
@@ -246,28 +246,27 @@ static bool scic_sds_controller_error_isr(struct scic_sds_controller *scic)
 	 * then unmask the error interrupts so if there was another interrupt
 	 * pending we will be notified.
 	 * Could we write the value of (SMU_ISR_QUEUE_ERROR | SMU_ISR_QUEUE_SUSPEND)? */
-	writel(0xff, &scic->smu_registers->interrupt_mask);
-	writel(0, &scic->smu_registers->interrupt_mask);
+	writel(0xff, &ihost->smu_registers->interrupt_mask);
+	writel(0, &ihost->smu_registers->interrupt_mask);
 
 	return false;
 }
 
-static void scic_sds_controller_task_completion(struct scic_sds_controller *scic,
+static void scic_sds_controller_task_completion(struct isci_host *ihost,
 						u32 completion_entry)
 {
 	u32 index = SCU_GET_COMPLETION_INDEX(completion_entry);
-	struct isci_host *ihost = scic_to_ihost(scic);
 	struct isci_request *ireq = ihost->reqs[index];
 
 	/* Make sure that we really want to process this IO request */
 	if (test_bit(IREQ_ACTIVE, &ireq->flags) &&
 	    ireq->io_tag != SCI_CONTROLLER_INVALID_IO_TAG &&
-	    ISCI_TAG_SEQ(ireq->io_tag) == scic->io_request_sequence[index])
+	    ISCI_TAG_SEQ(ireq->io_tag) == ihost->io_request_sequence[index])
 		/* Yep this is a valid io request pass it along to the io request handler */
 		scic_sds_io_request_tc_completion(ireq, completion_entry);
 }
 
-static void scic_sds_controller_sdma_completion(struct scic_sds_controller *scic,
+static void scic_sds_controller_sdma_completion(struct isci_host *ihost,
 						u32 completion_entry)
 {
 	u32 index;
@@ -279,8 +278,8 @@ static void scic_sds_controller_sdma_completion(struct scic_sds_controller *scic
 	switch (scu_get_command_request_type(completion_entry)) {
 	case SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC:
 	case SCU_CONTEXT_COMMAND_REQUEST_TYPE_DUMP_TC:
-		ireq = scic_to_ihost(scic)->reqs[index];
-		dev_warn(scic_to_dev(scic), "%s: %x for io request %p\n",
+		ireq = ihost->reqs[index];
+		dev_warn(&ihost->pdev->dev, "%s: %x for io request %p\n",
 			 __func__, completion_entry, ireq);
 		/* @todo For a post TC operation we need to fail the IO
 		 * request
@@ -289,27 +288,26 @@ static void scic_sds_controller_sdma_completion(struct scic_sds_controller *scic
 	case SCU_CONTEXT_COMMAND_REQUEST_TYPE_DUMP_RNC:
 	case SCU_CONTEXT_COMMAND_REQUEST_TYPE_OTHER_RNC:
 	case SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_RNC:
-		idev = scic->device_table[index];
-		dev_warn(scic_to_dev(scic), "%s: %x for device %p\n",
+		idev = ihost->device_table[index];
+		dev_warn(&ihost->pdev->dev, "%s: %x for device %p\n",
 			 __func__, completion_entry, idev);
 		/* @todo For a port RNC operation we need to fail the
 		 * device
 		 */
 		break;
 	default:
-		dev_warn(scic_to_dev(scic), "%s: unknown completion type %x\n",
+		dev_warn(&ihost->pdev->dev, "%s: unknown completion type %x\n",
 			 __func__, completion_entry);
 		break;
 	}
 }
 
-static void scic_sds_controller_unsolicited_frame(struct scic_sds_controller *scic,
+static void scic_sds_controller_unsolicited_frame(struct isci_host *ihost,
 						  u32 completion_entry)
 {
 	u32 index;
 	u32 frame_index;
 
-	struct isci_host *ihost = scic_to_ihost(scic);
 	struct scu_unsolicited_frame_header *frame_header;
 	struct isci_phy *iphy;
 	struct isci_remote_device *idev;
@@ -318,15 +316,15 @@ static void scic_sds_controller_unsolicited_frame(struct scic_sds_controller *sc
 
 	frame_index = SCU_GET_FRAME_INDEX(completion_entry);
 
-	frame_header = scic->uf_control.buffers.array[frame_index].header;
-	scic->uf_control.buffers.array[frame_index].state = UNSOLICITED_FRAME_IN_USE;
+	frame_header = ihost->uf_control.buffers.array[frame_index].header;
+	ihost->uf_control.buffers.array[frame_index].state = UNSOLICITED_FRAME_IN_USE;
 
 	if (SCU_GET_FRAME_ERROR(completion_entry)) {
 		/*
 		 * / @todo If the IAF frame or SIGNATURE FIS frame has an error will
 		 * /       this cause a problem? We expect the phy initialization will
 		 * /       fail if there is an error in the frame. */
-		scic_sds_controller_release_frame(scic, frame_index);
+		scic_sds_controller_release_frame(ihost, frame_index);
 		return;
 	}
 
@@ -347,15 +345,15 @@ static void scic_sds_controller_unsolicited_frame(struct scic_sds_controller *sc
 			iphy = &ihost->phys[index];
 			result = scic_sds_phy_frame_handler(iphy, frame_index);
 		} else {
-			if (index < scic->remote_node_entries)
-				idev = scic->device_table[index];
+			if (index < ihost->remote_node_entries)
+				idev = ihost->device_table[index];
 			else
 				idev = NULL;
 
 			if (idev != NULL)
 				result = scic_sds_remote_device_frame_handler(idev, frame_index);
 			else
-				scic_sds_controller_release_frame(scic, frame_index);
+				scic_sds_controller_release_frame(ihost, frame_index);
 		}
 	}
 
@@ -366,10 +364,9 @@ static void scic_sds_controller_unsolicited_frame(struct scic_sds_controller *sc
 	}
 }
 
-static void scic_sds_controller_event_completion(struct scic_sds_controller *scic,
+static void scic_sds_controller_event_completion(struct isci_host *ihost,
 						 u32 completion_entry)
 {
-	struct isci_host *ihost = scic_to_ihost(scic);
 	struct isci_remote_device *idev;
 	struct isci_request *ireq;
 	struct isci_phy *iphy;
@@ -380,11 +377,11 @@ static void scic_sds_controller_event_completion(struct scic_sds_controller *sci
 	switch (scu_get_event_type(completion_entry)) {
 	case SCU_EVENT_TYPE_SMU_COMMAND_ERROR:
 		/* / @todo The driver did something wrong and we need to fix the condtion. */
-		dev_err(scic_to_dev(scic),
+		dev_err(&ihost->pdev->dev,
 			"%s: SCIC Controller 0x%p received SMU command error "
 			"0x%x\n",
 			__func__,
-			scic,
+			ihost,
 			completion_entry);
 		break;
 
@@ -394,11 +391,11 @@ static void scic_sds_controller_event_completion(struct scic_sds_controller *sci
 		/*
 		 * / @todo This is a hardware failure and its likely that we want to
 		 * /       reset the controller. */
-		dev_err(scic_to_dev(scic),
+		dev_err(&ihost->pdev->dev,
 			"%s: SCIC Controller 0x%p received fatal controller "
 			"event  0x%x\n",
 			__func__,
-			scic,
+			ihost,
 			completion_entry);
 		break;
 
@@ -415,27 +412,27 @@ static void scic_sds_controller_event_completion(struct scic_sds_controller *sci
 			if (ireq != NULL)
 				scic_sds_io_request_event_handler(ireq, completion_entry);
 			else
-				dev_warn(scic_to_dev(scic),
+				dev_warn(&ihost->pdev->dev,
 					 "%s: SCIC Controller 0x%p received "
 					 "event 0x%x for io request object "
 					 "that doesnt exist.\n",
 					 __func__,
-					 scic,
+					 ihost,
 					 completion_entry);
 
 			break;
 
 		case SCU_EVENT_SPECIFIC_IT_NEXUS_TIMEOUT:
-			idev = scic->device_table[index];
+			idev = ihost->device_table[index];
 			if (idev != NULL)
 				scic_sds_remote_device_event_handler(idev, completion_entry);
 			else
-				dev_warn(scic_to_dev(scic),
+				dev_warn(&ihost->pdev->dev,
 					 "%s: SCIC Controller 0x%p received "
 					 "event 0x%x for remote device object "
 					 "that doesnt exist.\n",
 					 __func__,
-					 scic,
+					 ihost,
 					 completion_entry);
 
 			break;
@@ -459,25 +456,25 @@ static void scic_sds_controller_event_completion(struct scic_sds_controller *sci
 	case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
 	case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
 	case SCU_EVENT_TYPE_RNC_OPS_MISC:
-		if (index < scic->remote_node_entries) {
-			idev = scic->device_table[index];
+		if (index < ihost->remote_node_entries) {
+			idev = ihost->device_table[index];
 
 			if (idev != NULL)
 				scic_sds_remote_device_event_handler(idev, completion_entry);
 		} else
-			dev_err(scic_to_dev(scic),
+			dev_err(&ihost->pdev->dev,
 				"%s: SCIC Controller 0x%p received event 0x%x "
 				"for remote device object 0x%0x that doesnt "
 				"exist.\n",
 				__func__,
-				scic,
+				ihost,
 				completion_entry,
 				index);
 
 		break;
 
 	default:
-		dev_warn(scic_to_dev(scic),
+		dev_warn(&ihost->pdev->dev,
 			 "%s: SCIC Controller received unknown event code %x\n",
 			 __func__,
 			 completion_entry);
@@ -485,7 +482,7 @@ static void scic_sds_controller_event_completion(struct scic_sds_controller *sci
 	}
 }
 
-static void scic_sds_controller_process_completions(struct scic_sds_controller *scic)
+static void scic_sds_controller_process_completions(struct isci_host *ihost)
 {
 	u32 completion_count = 0;
 	u32 completion_entry;
@@ -494,47 +491,47 @@ static void scic_sds_controller_process_completions(struct scic_sds_controller *
 	u32 event_get;
 	u32 event_cycle;
 
-	dev_dbg(scic_to_dev(scic),
+	dev_dbg(&ihost->pdev->dev,
 		"%s: completion queue begining get:0x%08x\n",
 		__func__,
-		scic->completion_queue_get);
+		ihost->completion_queue_get);
 
 	/* Get the component parts of the completion queue */
-	get_index = NORMALIZE_GET_POINTER(scic->completion_queue_get);
-	get_cycle = SMU_CQGR_CYCLE_BIT & scic->completion_queue_get;
+	get_index = NORMALIZE_GET_POINTER(ihost->completion_queue_get);
+	get_cycle = SMU_CQGR_CYCLE_BIT & ihost->completion_queue_get;
 
-	event_get = NORMALIZE_EVENT_POINTER(scic->completion_queue_get);
-	event_cycle = SMU_CQGR_EVENT_CYCLE_BIT & scic->completion_queue_get;
+	event_get = NORMALIZE_EVENT_POINTER(ihost->completion_queue_get);
+	event_cycle = SMU_CQGR_EVENT_CYCLE_BIT & ihost->completion_queue_get;
 
 	while (
 		NORMALIZE_GET_POINTER_CYCLE_BIT(get_cycle)
-		== COMPLETION_QUEUE_CYCLE_BIT(scic->completion_queue[get_index])
+		== COMPLETION_QUEUE_CYCLE_BIT(ihost->completion_queue[get_index])
 		) {
 		completion_count++;
 
-		completion_entry = scic->completion_queue[get_index];
+		completion_entry = ihost->completion_queue[get_index];
 
 		/* increment the get pointer and check for rollover to toggle the cycle bit */
 		get_cycle ^= ((get_index+1) & SCU_MAX_COMPLETION_QUEUE_ENTRIES) <<
 			     (SMU_COMPLETION_QUEUE_GET_CYCLE_BIT_SHIFT - SCU_MAX_COMPLETION_QUEUE_SHIFT);
 		get_index = (get_index+1) & (SCU_MAX_COMPLETION_QUEUE_ENTRIES-1);
 
-		dev_dbg(scic_to_dev(scic),
+		dev_dbg(&ihost->pdev->dev,
 			"%s: completion queue entry:0x%08x\n",
 			__func__,
 			completion_entry);
 
 		switch (SCU_GET_COMPLETION_TYPE(completion_entry)) {
 		case SCU_COMPLETION_TYPE_TASK:
-			scic_sds_controller_task_completion(scic, completion_entry);
+			scic_sds_controller_task_completion(ihost, completion_entry);
 			break;
 
 		case SCU_COMPLETION_TYPE_SDMA:
-			scic_sds_controller_sdma_completion(scic, completion_entry);
+			scic_sds_controller_sdma_completion(ihost, completion_entry);
 			break;
 
 		case SCU_COMPLETION_TYPE_UFI:
-			scic_sds_controller_unsolicited_frame(scic, completion_entry);
+			scic_sds_controller_unsolicited_frame(ihost, completion_entry);
 			break;
 
 		case SCU_COMPLETION_TYPE_EVENT:
@@ -543,11 +540,11 @@ static void scic_sds_controller_process_completions(struct scic_sds_controller *
 				       (SMU_COMPLETION_QUEUE_GET_EVENT_CYCLE_BIT_SHIFT - SCU_MAX_EVENTS_SHIFT);
 			event_get = (event_get+1) & (SCU_MAX_EVENTS-1);
 
-			scic_sds_controller_event_completion(scic, completion_entry);
+			scic_sds_controller_event_completion(ihost, completion_entry);
 			break;
 		}
 		default:
-			dev_warn(scic_to_dev(scic),
+			dev_warn(&ihost->pdev->dev,
 				 "%s: SCIC Controller received unknown "
 				 "completion type %x\n",
 				 __func__,
@@ -558,7 +555,7 @@ static void scic_sds_controller_process_completions(struct scic_sds_controller *
 
 	/* Update the get register if we completed one or more entries */
 	if (completion_count > 0) {
-		scic->completion_queue_get =
+		ihost->completion_queue_get =
 			SMU_CQGR_GEN_BIT(ENABLE) |
 			SMU_CQGR_GEN_BIT(EVENT_ENABLE) |
 			event_cycle |
@@ -566,35 +563,35 @@ static void scic_sds_controller_process_completions(struct scic_sds_controller *
 			get_cycle |
 			SMU_CQGR_GEN_VAL(POINTER, get_index);
 
-		writel(scic->completion_queue_get,
-		       &scic->smu_registers->completion_queue_get);
+		writel(ihost->completion_queue_get,
+		       &ihost->smu_registers->completion_queue_get);
 
 	}
 
-	dev_dbg(scic_to_dev(scic),
+	dev_dbg(&ihost->pdev->dev,
 		"%s: completion queue ending get:0x%08x\n",
 		__func__,
-		scic->completion_queue_get);
+		ihost->completion_queue_get);
 
 }
 
-static void scic_sds_controller_error_handler(struct scic_sds_controller *scic)
+static void scic_sds_controller_error_handler(struct isci_host *ihost)
 {
 	u32 interrupt_status;
 
 	interrupt_status =
-		readl(&scic->smu_registers->interrupt_status);
+		readl(&ihost->smu_registers->interrupt_status);
 
 	if ((interrupt_status & SMU_ISR_QUEUE_SUSPEND) &&
-	    scic_sds_controller_completion_queue_has_entries(scic)) {
+	    scic_sds_controller_completion_queue_has_entries(ihost)) {
 
-		scic_sds_controller_process_completions(scic);
-		writel(SMU_ISR_QUEUE_SUSPEND, &scic->smu_registers->interrupt_status);
+		scic_sds_controller_process_completions(ihost);
+		writel(SMU_ISR_QUEUE_SUSPEND, &ihost->smu_registers->interrupt_status);
 	} else {
-		dev_err(scic_to_dev(scic), "%s: status: %#x\n", __func__,
+		dev_err(&ihost->pdev->dev, "%s: status: %#x\n", __func__,
 			interrupt_status);
 
-		sci_change_state(&scic->sm, SCIC_FAILED);
+		sci_change_state(&ihost->sm, SCIC_FAILED);
 
 		return;
 	}
@@ -602,22 +599,21 @@ static void scic_sds_controller_error_handler(struct scic_sds_controller *scic)
 	/* If we dont process any completions I am not sure that we want to do this.
 	 * We are in the middle of a hardware fault and should probably be reset.
 	 */
-	writel(0, &scic->smu_registers->interrupt_mask);
+	writel(0, &ihost->smu_registers->interrupt_mask);
 }
 
 irqreturn_t isci_intx_isr(int vec, void *data)
 {
 	irqreturn_t ret = IRQ_NONE;
 	struct isci_host *ihost = data;
-	struct scic_sds_controller *scic = &ihost->sci;
 
-	if (scic_sds_controller_isr(scic)) {
-		writel(SMU_ISR_COMPLETION, &scic->smu_registers->interrupt_status);
+	if (scic_sds_controller_isr(ihost)) {
+		writel(SMU_ISR_COMPLETION, &ihost->smu_registers->interrupt_status);
 		tasklet_schedule(&ihost->completion_tasklet);
 		ret = IRQ_HANDLED;
-	} else if (scic_sds_controller_error_isr(scic)) {
+	} else if (scic_sds_controller_error_isr(ihost)) {
 		spin_lock(&ihost->scic_lock);
-		scic_sds_controller_error_handler(scic);
+		scic_sds_controller_error_handler(ihost);
 		spin_unlock(&ihost->scic_lock);
 		ret = IRQ_HANDLED;
 	}
@@ -629,8 +625,8 @@ irqreturn_t isci_error_isr(int vec, void *data)
 {
 	struct isci_host *ihost = data;
 
-	if (scic_sds_controller_error_isr(&ihost->sci))
-		scic_sds_controller_error_handler(&ihost->sci);
+	if (scic_sds_controller_error_isr(ihost))
+		scic_sds_controller_error_handler(ihost);
 
 	return IRQ_HANDLED;
 }
@@ -685,11 +681,10 @@ int isci_host_scan_finished(struct Scsi_Host *shost, unsigned long time)
  * This method returns the number of milliseconds for the suggested start
  * operation timeout.
  */
-static u32 scic_controller_get_suggested_start_timeout(
-	struct scic_sds_controller *sc)
+static u32 scic_controller_get_suggested_start_timeout(struct isci_host *ihost)
 {
 	/* Validate the user supplied parameters. */
-	if (sc == NULL)
+	if (!ihost)
 		return 0;
 
 	/*
@@ -711,35 +706,32 @@ static u32 scic_controller_get_suggested_start_timeout(
 		+ ((SCI_MAX_PHYS - 1) * SCIC_SDS_CONTROLLER_POWER_CONTROL_INTERVAL);
 }
 
-static void scic_controller_enable_interrupts(
-	struct scic_sds_controller *scic)
+static void scic_controller_enable_interrupts(struct isci_host *ihost)
 {
-	BUG_ON(scic->smu_registers == NULL);
-	writel(0, &scic->smu_registers->interrupt_mask);
+	BUG_ON(ihost->smu_registers == NULL);
+	writel(0, &ihost->smu_registers->interrupt_mask);
 }
 
-void scic_controller_disable_interrupts(
-	struct scic_sds_controller *scic)
+void scic_controller_disable_interrupts(struct isci_host *ihost)
 {
-	BUG_ON(scic->smu_registers == NULL);
-	writel(0xffffffff, &scic->smu_registers->interrupt_mask);
+	BUG_ON(ihost->smu_registers == NULL);
+	writel(0xffffffff, &ihost->smu_registers->interrupt_mask);
 }
 
-static void scic_sds_controller_enable_port_task_scheduler(
-	struct scic_sds_controller *scic)
+static void scic_sds_controller_enable_port_task_scheduler(struct isci_host *ihost)
 {
 	u32 port_task_scheduler_value;
 
 	port_task_scheduler_value =
-		readl(&scic->scu_registers->peg0.ptsg.control);
+		readl(&ihost->scu_registers->peg0.ptsg.control);
 	port_task_scheduler_value |=
 		(SCU_PTSGCR_GEN_BIT(ETM_ENABLE) |
 		 SCU_PTSGCR_GEN_BIT(PTSG_ENABLE));
 	writel(port_task_scheduler_value,
-	       &scic->scu_registers->peg0.ptsg.control);
+	       &ihost->scu_registers->peg0.ptsg.control);
 }
 
-static void scic_sds_controller_assign_task_entries(struct scic_sds_controller *scic)
+static void scic_sds_controller_assign_task_entries(struct isci_host *ihost)
 {
 	u32 task_assignment;
 
@@ -749,32 +741,32 @@ static void scic_sds_controller_assign_task_entries(struct scic_sds_controller *
 	 */
 
 	task_assignment =
-		readl(&scic->smu_registers->task_context_assignment[0]);
+		readl(&ihost->smu_registers->task_context_assignment[0]);
 
 	task_assignment |= (SMU_TCA_GEN_VAL(STARTING, 0)) |
-		(SMU_TCA_GEN_VAL(ENDING,  scic->task_context_entries - 1)) |
+		(SMU_TCA_GEN_VAL(ENDING,  ihost->task_context_entries - 1)) |
 		(SMU_TCA_GEN_BIT(RANGE_CHECK_ENABLE));
 
 	writel(task_assignment,
-		&scic->smu_registers->task_context_assignment[0]);
+		&ihost->smu_registers->task_context_assignment[0]);
 
 }
 
-static void scic_sds_controller_initialize_completion_queue(struct scic_sds_controller *scic)
+static void scic_sds_controller_initialize_completion_queue(struct isci_host *ihost)
 {
 	u32 index;
 	u32 completion_queue_control_value;
 	u32 completion_queue_get_value;
 	u32 completion_queue_put_value;
 
-	scic->completion_queue_get = 0;
+	ihost->completion_queue_get = 0;
 
 	completion_queue_control_value =
 		(SMU_CQC_QUEUE_LIMIT_SET(SCU_MAX_COMPLETION_QUEUE_ENTRIES - 1) |
 		 SMU_CQC_EVENT_LIMIT_SET(SCU_MAX_EVENTS - 1));
 
 	writel(completion_queue_control_value,
-	       &scic->smu_registers->completion_queue_control);
+	       &ihost->smu_registers->completion_queue_control);
 
 
 	/* Set the completion queue get pointer and enable the queue */
@@ -786,7 +778,7 @@ static void scic_sds_controller_initialize_completion_queue(struct scic_sds_cont
 		);
 
 	writel(completion_queue_get_value,
-	       &scic->smu_registers->completion_queue_get);
+	       &ihost->smu_registers->completion_queue_get);
 
 	/* Set the completion queue put pointer */
 	completion_queue_put_value = (
@@ -795,7 +787,7 @@ static void scic_sds_controller_initialize_completion_queue(struct scic_sds_cont
 		);
 
 	writel(completion_queue_put_value,
-	       &scic->smu_registers->completion_queue_put);
+	       &ihost->smu_registers->completion_queue_put);
 
 	/* Initialize the cycle bit of the completion queue entries */
 	for (index = 0; index < SCU_MAX_COMPLETION_QUEUE_ENTRIES; index++) {
@@ -803,11 +795,11 @@ static void scic_sds_controller_initialize_completion_queue(struct scic_sds_cont
 		 * If get.cycle_bit != completion_queue.cycle_bit
 		 * its not a valid completion queue entry
 		 * so at system start all entries are invalid */
-		scic->completion_queue[index] = 0x80000000;
+		ihost->completion_queue[index] = 0x80000000;
 	}
 }
 
-static void scic_sds_controller_initialize_unsolicited_frame_queue(struct scic_sds_controller *scic)
+static void scic_sds_controller_initialize_unsolicited_frame_queue(struct isci_host *ihost)
 {
 	u32 frame_queue_control_value;
 	u32 frame_queue_get_value;
@@ -818,7 +810,7 @@ static void scic_sds_controller_initialize_unsolicited_frame_queue(struct scic_s
 		SCU_UFQC_GEN_VAL(QUEUE_SIZE, SCU_MAX_UNSOLICITED_FRAMES);
 
 	writel(frame_queue_control_value,
-	       &scic->scu_registers->sdma.unsolicited_frame_queue_control);
+	       &ihost->scu_registers->sdma.unsolicited_frame_queue_control);
 
 	/* Setup the get pointer for the unsolicited frame queue */
 	frame_queue_get_value = (
@@ -827,11 +819,11 @@ static void scic_sds_controller_initialize_unsolicited_frame_queue(struct scic_s
 		);
 
 	writel(frame_queue_get_value,
-	       &scic->scu_registers->sdma.unsolicited_frame_get_pointer);
+	       &ihost->scu_registers->sdma.unsolicited_frame_get_pointer);
 	/* Setup the put pointer for the unsolicited frame queue */
 	frame_queue_put_value = SCU_UFQPP_GEN_VAL(POINTER, 0);
 	writel(frame_queue_put_value,
-	       &scic->scu_registers->sdma.unsolicited_frame_put_pointer);
+	       &ihost->scu_registers->sdma.unsolicited_frame_put_pointer);
 }
 
 /**
@@ -846,17 +838,16 @@ static void scic_sds_controller_initialize_unsolicited_frame_queue(struct scic_s
  * none.
  */
 static void scic_sds_controller_transition_to_ready(
-	struct scic_sds_controller *scic,
+	struct isci_host *ihost,
 	enum sci_status status)
 {
-	struct isci_host *ihost = scic_to_ihost(scic);
 
-	if (scic->sm.current_state_id == SCIC_STARTING) {
+	if (ihost->sm.current_state_id == SCIC_STARTING) {
 		/*
 		 * We move into the ready state, because some of the phys/ports
 		 * may be up and operational.
 		 */
-		sci_change_state(&scic->sm, SCIC_READY);
+		sci_change_state(&ihost->sm, SCIC_READY);
 
 		isci_host_start_complete(ihost, status);
 	}
@@ -892,19 +883,18 @@ static bool is_phy_starting(struct isci_phy *iphy)
  * controller to the READY state and inform the user
  * (scic_cb_controller_start_complete()).
  */
-static enum sci_status scic_sds_controller_start_next_phy(struct scic_sds_controller *scic)
+static enum sci_status scic_sds_controller_start_next_phy(struct isci_host *ihost)
 {
-	struct isci_host *ihost = scic_to_ihost(scic);
-	struct scic_sds_oem_params *oem = &scic->oem_parameters.sds1;
+	struct scic_sds_oem_params *oem = &ihost->oem_parameters.sds1;
 	struct isci_phy *iphy;
 	enum sci_status status;
 
 	status = SCI_SUCCESS;
 
-	if (scic->phy_startup_timer_pending)
+	if (ihost->phy_startup_timer_pending)
 		return status;
 
-	if (scic->next_phy_to_start >= SCI_MAX_PHYS) {
+	if (ihost->next_phy_to_start >= SCI_MAX_PHYS) {
 		bool is_controller_start_complete = true;
 		u32 state;
 		u8 index;
@@ -934,16 +924,16 @@ static enum sci_status scic_sds_controller_start_next_phy(struct scic_sds_contro
 		 * The controller has successfully finished the start process.
 		 * Inform the SCI Core user and transition to the READY state. */
 		if (is_controller_start_complete == true) {
-			scic_sds_controller_transition_to_ready(scic, SCI_SUCCESS);
-			sci_del_timer(&scic->phy_timer);
-			scic->phy_startup_timer_pending = false;
+			scic_sds_controller_transition_to_ready(ihost, SCI_SUCCESS);
+			sci_del_timer(&ihost->phy_timer);
+			ihost->phy_startup_timer_pending = false;
 		}
 	} else {
-		iphy = &ihost->phys[scic->next_phy_to_start];
+		iphy = &ihost->phys[ihost->next_phy_to_start];
 
 		if (oem->controller.mode_type == SCIC_PORT_MANUAL_CONFIGURATION_MODE) {
 			if (phy_get_non_dummy_port(iphy) == NULL) {
-				scic->next_phy_to_start++;
+				ihost->next_phy_to_start++;
 
 				/* Caution recursion ahead be forwarned
 				 *
@@ -954,27 +944,27 @@ static enum sci_status scic_sds_controller_start_next_phy(struct scic_sds_contro
 				 * incorrectly for the PORT or it was never
 				 * assigned to a PORT
 				 */
-				return scic_sds_controller_start_next_phy(scic);
+				return scic_sds_controller_start_next_phy(ihost);
 			}
 		}
 
 		status = scic_sds_phy_start(iphy);
 
 		if (status == SCI_SUCCESS) {
-			sci_mod_timer(&scic->phy_timer,
+			sci_mod_timer(&ihost->phy_timer,
 				      SCIC_SDS_CONTROLLER_PHY_START_TIMEOUT);
-			scic->phy_startup_timer_pending = true;
+			ihost->phy_startup_timer_pending = true;
 		} else {
-			dev_warn(scic_to_dev(scic),
+			dev_warn(&ihost->pdev->dev,
 				 "%s: Controller stop operation failed "
 				 "to stop phy %d because of status "
 				 "%d.\n",
 				 __func__,
-				 ihost->phys[scic->next_phy_to_start].phy_index,
+				 ihost->phys[ihost->next_phy_to_start].phy_index,
 				 status);
 		}
 
-		scic->next_phy_to_start++;
+		ihost->next_phy_to_start++;
 	}
 
 	return status;
@@ -983,8 +973,7 @@ static enum sci_status scic_sds_controller_start_next_phy(struct scic_sds_contro
 static void phy_startup_timeout(unsigned long data)
 {
 	struct sci_timer *tmr = (struct sci_timer *)data;
-	struct scic_sds_controller *scic = container_of(tmr, typeof(*scic), phy_timer);
-	struct isci_host *ihost = scic_to_ihost(scic);
+	struct isci_host *ihost = container_of(tmr, typeof(*ihost), phy_timer);
 	unsigned long flags;
 	enum sci_status status;
 
@@ -993,10 +982,10 @@ static void phy_startup_timeout(unsigned long data)
 	if (tmr->cancel)
 		goto done;
 
-	scic->phy_startup_timer_pending = false;
+	ihost->phy_startup_timer_pending = false;
 
 	do {
-		status = scic_sds_controller_start_next_phy(scic);
+		status = scic_sds_controller_start_next_phy(ihost);
 	} while (status != SCI_SUCCESS);
 
 done:
@@ -1008,15 +997,14 @@ static u16 isci_tci_active(struct isci_host *ihost)
 	return CIRC_CNT(ihost->tci_head, ihost->tci_tail, SCI_MAX_IO_REQUESTS);
 }
 
-static enum sci_status scic_controller_start(struct scic_sds_controller *scic,
+static enum sci_status scic_controller_start(struct isci_host *ihost,
 					     u32 timeout)
 {
-	struct isci_host *ihost = scic_to_ihost(scic);
 	enum sci_status result;
 	u16 index;
 
-	if (scic->sm.current_state_id != SCIC_INITIALIZED) {
-		dev_warn(scic_to_dev(scic),
+	if (ihost->sm.current_state_id != SCIC_INITIALIZED) {
+		dev_warn(&ihost->pdev->dev,
 			 "SCIC Controller start operation requested in "
 			 "invalid state\n");
 		return SCI_FAILURE_INVALID_STATE;
@@ -1026,34 +1014,34 @@ static enum sci_status scic_controller_start(struct scic_sds_controller *scic,
 	BUILD_BUG_ON(SCI_MAX_IO_REQUESTS > 1 << sizeof(ihost->tci_pool[0]) * 8);
 	ihost->tci_head = 0;
 	ihost->tci_tail = 0;
-	for (index = 0; index < scic->task_context_entries; index++)
+	for (index = 0; index < ihost->task_context_entries; index++)
 		isci_tci_free(ihost, index);
 
 	/* Build the RNi free pool */
 	scic_sds_remote_node_table_initialize(
-			&scic->available_remote_nodes,
-			scic->remote_node_entries);
+			&ihost->available_remote_nodes,
+			ihost->remote_node_entries);
 
 	/*
 	 * Before anything else lets make sure we will not be
 	 * interrupted by the hardware.
 	 */
-	scic_controller_disable_interrupts(scic);
+	scic_controller_disable_interrupts(ihost);
 
 	/* Enable the port task scheduler */
-	scic_sds_controller_enable_port_task_scheduler(scic);
+	scic_sds_controller_enable_port_task_scheduler(ihost);
 
-	/* Assign all the task entries to scic physical function */
-	scic_sds_controller_assign_task_entries(scic);
+	/* Assign all the task entries to ihost physical function */
+	scic_sds_controller_assign_task_entries(ihost);
 
 	/* Now initialize the completion queue */
-	scic_sds_controller_initialize_completion_queue(scic);
+	scic_sds_controller_initialize_completion_queue(ihost);
 
 	/* Initialize the unsolicited frame queue for use */
-	scic_sds_controller_initialize_unsolicited_frame_queue(scic);
+	scic_sds_controller_initialize_unsolicited_frame_queue(ihost);
 
 	/* Start all of the ports on this controller */
-	for (index = 0; index < scic->logical_port_entries; index++) {
+	for (index = 0; index < ihost->logical_port_entries; index++) {
 		struct isci_port *iport = &ihost->ports[index];
 
 		result = scic_sds_port_start(iport);
@@ -1061,11 +1049,11 @@ static enum sci_status scic_controller_start(struct scic_sds_controller *scic,
 			return result;
 	}
 
-	scic_sds_controller_start_next_phy(scic);
+	scic_sds_controller_start_next_phy(ihost);
 
-	sci_mod_timer(&scic->timer, timeout);
+	sci_mod_timer(&ihost->timer, timeout);
 
-	sci_change_state(&scic->sm, SCIC_STARTING);
+	sci_change_state(&ihost->sm, SCIC_STARTING);
 
 	return SCI_SUCCESS;
 }
@@ -1073,35 +1061,35 @@ static enum sci_status scic_controller_start(struct scic_sds_controller *scic,
 void isci_host_scan_start(struct Scsi_Host *shost)
 {
 	struct isci_host *ihost = SHOST_TO_SAS_HA(shost)->lldd_ha;
-	unsigned long tmo = scic_controller_get_suggested_start_timeout(&ihost->sci);
+	unsigned long tmo = scic_controller_get_suggested_start_timeout(ihost);
 
 	set_bit(IHOST_START_PENDING, &ihost->flags);
 
 	spin_lock_irq(&ihost->scic_lock);
-	scic_controller_start(&ihost->sci, tmo);
-	scic_controller_enable_interrupts(&ihost->sci);
+	scic_controller_start(ihost, tmo);
+	scic_controller_enable_interrupts(ihost);
 	spin_unlock_irq(&ihost->scic_lock);
 }
 
 static void isci_host_stop_complete(struct isci_host *ihost, enum sci_status completion_status)
 {
 	isci_host_change_state(ihost, isci_stopped);
-	scic_controller_disable_interrupts(&ihost->sci);
+	scic_controller_disable_interrupts(ihost);
 	clear_bit(IHOST_STOP_PENDING, &ihost->flags);
 	wake_up(&ihost->eventq);
 }
 
-static void scic_sds_controller_completion_handler(struct scic_sds_controller *scic)
+static void scic_sds_controller_completion_handler(struct isci_host *ihost)
 {
 	/* Empty out the completion queue */
-	if (scic_sds_controller_completion_queue_has_entries(scic))
-		scic_sds_controller_process_completions(scic);
+	if (scic_sds_controller_completion_queue_has_entries(ihost))
+		scic_sds_controller_process_completions(ihost);
 
 	/* Clear the interrupt and enable all interrupts again */
-	writel(SMU_ISR_COMPLETION, &scic->smu_registers->interrupt_status);
+	writel(SMU_ISR_COMPLETION, &ihost->smu_registers->interrupt_status);
 	/* Could we write the value of SMU_ISR_COMPLETION? */
-	writel(0xFF000000, &scic->smu_registers->interrupt_mask);
-	writel(0, &scic->smu_registers->interrupt_mask);
+	writel(0xFF000000, &ihost->smu_registers->interrupt_mask);
+	writel(0, &ihost->smu_registers->interrupt_mask);
 }
 
 /**
@@ -1114,7 +1102,7 @@ static void scic_sds_controller_completion_handler(struct scic_sds_controller *s
  */
 static void isci_host_completion_routine(unsigned long data)
 {
-	struct isci_host *isci_host = (struct isci_host *)data;
+	struct isci_host *ihost = (struct isci_host *)data;
 	struct list_head    completed_request_list;
 	struct list_head    errored_request_list;
 	struct list_head    *current_position;
@@ -1126,20 +1114,20 @@ static void isci_host_completion_routine(unsigned long data)
 	INIT_LIST_HEAD(&completed_request_list);
 	INIT_LIST_HEAD(&errored_request_list);
 
-	spin_lock_irq(&isci_host->scic_lock);
+	spin_lock_irq(&ihost->scic_lock);
 
-	scic_sds_controller_completion_handler(&isci_host->sci);
+	scic_sds_controller_completion_handler(ihost);
 
 	/* Take the lists of completed I/Os from the host. */
 
-	list_splice_init(&isci_host->requests_to_complete,
+	list_splice_init(&ihost->requests_to_complete,
 			 &completed_request_list);
 
 	/* Take the list of errored I/Os from the host. */
-	list_splice_init(&isci_host->requests_to_errorback,
+	list_splice_init(&ihost->requests_to_errorback,
 			 &errored_request_list);
 
-	spin_unlock_irq(&isci_host->scic_lock);
+	spin_unlock_irq(&ihost->scic_lock);
 
 	/* Process any completions in the lists. */
 	list_for_each_safe(current_position, next_position,
@@ -1150,7 +1138,7 @@ static void isci_host_completion_routine(unsigned long data)
 		task = isci_request_access_task(request);
 
 		/* Normal notification (task_done) */
-		dev_dbg(&isci_host->pdev->dev,
+		dev_dbg(&ihost->pdev->dev,
 			"%s: Normal - request/task = %p/%p\n",
 			__func__,
 			request,
@@ -1169,9 +1157,9 @@ static void isci_host_completion_routine(unsigned long data)
 			}
 		}
 
-		spin_lock_irq(&isci_host->scic_lock);
-		isci_free_tag(isci_host, request->io_tag);
-		spin_unlock_irq(&isci_host->scic_lock);
+		spin_lock_irq(&ihost->scic_lock);
+		isci_free_tag(ihost, request->io_tag);
+		spin_unlock_irq(&ihost->scic_lock);
 	}
 	list_for_each_entry_safe(request, next_request, &errored_request_list,
 				 completed_node) {
@@ -1179,7 +1167,7 @@ static void isci_host_completion_routine(unsigned long data)
 		task = isci_request_access_task(request);
 
 		/* Use sas_task_abort */
-		dev_warn(&isci_host->pdev->dev,
+		dev_warn(&ihost->pdev->dev,
 			 "%s: Error - request/task = %p/%p\n",
 			 __func__,
 			 request,
@@ -1202,13 +1190,13 @@ static void isci_host_completion_routine(unsigned long data)
 			 * it.
 			 */
 
-			spin_lock_irq(&isci_host->scic_lock);
+			spin_lock_irq(&ihost->scic_lock);
 			/* Remove the request from the remote device's list
 			* of pending requests.
 			*/
 			list_del_init(&request->dev_node);
-			isci_free_tag(isci_host, request->io_tag);
-			spin_unlock_irq(&isci_host->scic_lock);
+			isci_free_tag(ihost, request->io_tag);
+			spin_unlock_irq(&ihost->scic_lock);
 		}
 	}
 
@@ -1232,18 +1220,18 @@ static void isci_host_completion_routine(unsigned long data)
  * controller is already in the STOPPED state. SCI_FAILURE_INVALID_STATE if the
  * controller is not either in the STARTED or STOPPED states.
  */
-static enum sci_status scic_controller_stop(struct scic_sds_controller *scic,
+static enum sci_status scic_controller_stop(struct isci_host *ihost,
 					    u32 timeout)
 {
-	if (scic->sm.current_state_id != SCIC_READY) {
-		dev_warn(scic_to_dev(scic),