[RFC 3/3] ipr: Use new libata EH API

[Brian King <brking@linux.vnet.ibm.com>]

This patch converts ipr to use the new libata EH API. This simplifies
a lot of the code, should make it more maintainable, and also provides
more robust error handling.

Signed-off-by: Brian King <brking@linux.vnet.ibm.com>
---

 linux-2.6-bjking1/drivers/scsi/ipr.c |  822 +++++++++++++++++++++++------------
 linux-2.6-bjking1/drivers/scsi/ipr.h |   15 
 2 files changed, 562 insertions(+), 275 deletions(-)

diff -puN drivers/scsi/ipr.c~ipr_sata_scsi_host2 drivers/scsi/ipr.c
--- linux-2.6/drivers/scsi/ipr.c~ipr_sata_scsi_host2	2007-10-29 13:04:12.000000000 -0500
+++ linux-2.6-bjking1/drivers/scsi/ipr.c	2007-10-29 14:26:24.000000000 -0500
@@ -613,6 +613,54 @@ static int ipr_set_pcix_cmd_reg(struct i
 }
 
 /**
+ * ipr_sata_qc_complete - Schedule completion of a SATA command
+ * @ioa_cfg:	ioa config struct
+ * @done_qc:	ATA qc to complete
+ *
+ * Return value:
+ * 	nothing
+ **/
+static void ipr_sata_qc_complete(struct ipr_ioa_cfg *ioa_cfg,
+				 struct ata_queued_cmd *done_qc)
+{
+	unsigned long flags;
+	struct ata_queued_cmd *qc;
+
+	spin_lock_irqsave(&ioa_cfg->qc_done_lock, flags);
+	if (!ioa_cfg->qc_done)
+		ioa_cfg->qc_done = done_qc;
+	else {
+		for (qc = ioa_cfg->qc_done; qc->lldd_task; qc = qc->lldd_task) {}
+		qc->lldd_task = done_qc;
+	}
+	spin_unlock_irqrestore(&ioa_cfg->qc_done_lock, flags);
+
+	tasklet_schedule(&ioa_cfg->tasklet);
+}
+
+/**
+ * ipr_sata_frozen_done - Done function for a SATA command on a frozen port
+ * @ipr_cmd:	ipr command struct
+ *
+ * Once one of our SATA ports is frozen by libata, we can no longer
+ * call ata_qc_complete for it. We change its ipr internal done function
+ * to this function to simply free up the ipr command struct.
+ *
+ * Return value:
+ * 	nothing
+ **/
+static void ipr_sata_frozen_done(struct ipr_cmnd *ipr_cmd)
+{
+	struct ata_queued_cmd *qc = ipr_cmd->qc;
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(qc->ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
+
+	ipr_cmd->ioa_cfg->request_limit++;
+	sata_port->active_requests--;
+	list_add_tail(&ipr_cmd->queue, &ipr_cmd->ioa_cfg->free_q);
+}
+
+/**
  * ipr_sata_eh_done - done function for aborted SATA commands
  * @ipr_cmd:	ipr command struct
  *
@@ -626,12 +674,15 @@ static void ipr_sata_eh_done(struct ipr_
 {
 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
 	struct ata_queued_cmd *qc = ipr_cmd->qc;
-	struct ipr_sata_port *sata_port = qc->ap->private_data;
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(qc->ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
 
 	qc->err_mask |= AC_ERR_OTHER;
 	sata_port->ioasa.status |= ATA_BUSY;
+	ioa_cfg->request_limit++;
+	sata_port->active_requests--;
 	list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
-	ata_qc_complete(qc);
+	ipr_sata_qc_complete(ioa_cfg, qc);
 }
 
 /**
@@ -652,6 +703,7 @@ static void ipr_scsi_eh_done(struct ipr_
 	scsi_cmd->result |= (DID_ERROR << 16);
 
 	scsi_dma_unmap(ipr_cmd->scsi_cmd);
+	ioa_cfg->request_limit++;
 	scsi_cmd->scsi_done(scsi_cmd);
 	list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
 }
@@ -2351,6 +2403,187 @@ static void ipr_release_dump(struct kref
 }
 
 /**
+ * ipr_show_sata_adapter_address - Show the adapter's resource address for this device
+ * @class_dev:	class device struct
+ * @buf:		buffer
+ *
+ * Return value:
+ * 	number of bytes printed to buffer
+ **/
+static ssize_t ipr_show_sata_adapter_address(struct class_device *class_dev, char *buf)
+{
+	struct Scsi_Host *host = class_to_shost(class_dev);
+	struct ata_port *ap = ata_shost_to_port(host);
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
+	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
+	ssize_t len = -ENXIO;
+	unsigned long flags = 0;
+
+	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
+	if (sata_port && sata_port->res)
+		len = snprintf(buf, PAGE_SIZE, "%d:%d:%d:%d\n",
+			       ioa_cfg->host->host_no,
+			       sata_port->res->cfgte.res_addr.bus,
+			       sata_port->res->cfgte.res_addr.target,
+			       sata_port->res->cfgte.res_addr.lun);
+	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+	return len;
+}
+
+static struct class_device_attribute ipr_sata_adapter_address_attr = {
+	.attr = {
+		.name = 	"adapter_address",
+		.mode =		S_IRUSR,
+	},
+	.show = ipr_show_sata_adapter_address
+};
+
+/**
+ * ipr_show_sata_adapter_handle - Show the adapter's resource handle for this SATA rphy
+ * @class_dev:	class device struct
+ * @buf:		buffer
+ *
+ * Return value:
+ * 	number of bytes printed to buffer
+ **/
+static ssize_t ipr_show_sata_adapter_handle(struct class_device *class_dev, char *buf)
+{
+	struct Scsi_Host *host = class_to_shost(class_dev);
+	struct ata_port *ap = ata_shost_to_port(host);
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
+	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
+	ssize_t len = -ENXIO;
+	unsigned long flags = 0;
+
+	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
+	if (sata_port && sata_port->res)
+		len = snprintf(buf, PAGE_SIZE, "%08X\n", sata_port->res->cfgte.res_handle);
+	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+	return len;
+}
+
+static struct class_device_attribute ipr_sata_adapter_handle_attr = {
+	.attr = {
+		.name = 	"adapter_handle",
+		.mode =		S_IRUSR,
+	},
+	.show = ipr_show_sata_adapter_handle
+};
+
+static struct class_device_attribute *ipr_sata_attrs[] = {
+	&ipr_sata_adapter_handle_attr,
+	&ipr_sata_adapter_address_attr,
+	NULL,
+};
+
+/**
+ * ipr_sata_info - Get information about the sata port
+ * @scsi_host:	scsi host struct
+ *
+ * Return value:
+ * 	pointer to buffer with description string
+ **/
+static const char * ipr_sata_info(struct Scsi_Host *host)
+{
+	static char buffer[512];
+	struct ata_port *ap = ata_shost_to_port(host);
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
+	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
+	struct ipr_resource_entry *res = sata_port->res;
+
+	sprintf(buffer, "IBM %X Storage Adapter SATA Port: %d:%d:%d:%d",
+		ioa_cfg->type, ioa_cfg->host->host_no, res->cfgte.res_addr.bus,
+		res->cfgte.res_addr.target, res->cfgte.res_addr.lun);
+
+	return buffer;
+}
+
+static struct ata_port_info sata_port_info;
+
+static struct scsi_host_template sata_driver_template = {
+	.module = THIS_MODULE,
+	.name = "IPR",
+	.info = ipr_sata_info,
+	.ioctl = ata_scsi_ioctl,
+	.queuecommand = ata_scsi_queuecmd,
+	.slave_configure = ata_scsi_slave_config,
+	.slave_destroy = ata_scsi_slave_destroy,
+	.change_queue_depth = ata_scsi_change_queue_depth,
+	.bios_param = ata_std_bios_param,
+	.can_queue = 1,
+	.this_id = -1,
+	.sg_tablesize = IPR_MAX_SGLIST,
+	.max_sectors = IPR_IOA_MAX_SECTORS,
+	.cmd_per_lun = 1,
+	.emulated = ATA_SHT_EMULATED,
+	.use_clustering = ENABLE_CLUSTERING,
+	.shost_attrs = ipr_sata_attrs,
+	.proc_name = IPR_NAME
+};
+
+/**
+ * ipr_add_sata_dev - Add a SATA device
+ * @ioa_cfg:	ioa config struct
+ * @res:		resource entry struct
+ *
+ * This function adds a SATA rphy to the device hierarchy.
+ *
+ * Return value:
+ * 	nothing
+ **/
+static void ipr_add_sata_dev(struct ipr_ioa_cfg *ioa_cfg,
+			     struct ipr_resource_entry *res)
+{
+	int rc;
+	unsigned long flags;
+	struct ata_sas_rphy *rphy;
+	struct device *dev;
+	struct ipr_sata_port *sata_port;
+
+	rphy = ata_sas_rphy_alloc(&ioa_cfg->host->shost_gendev,
+				  &ioa_cfg->pdev->dev, &sata_port_info,
+				  sizeof(*sata_port));
+
+	if (!rphy)
+		return;
+
+	sata_port = rphy_to_sata_port(rphy);
+	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
+	if (!ipr_is_gata(res)) {
+		spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+		ata_sas_rphy_free(rphy);
+		return;
+	}
+
+	sata_port->ioa_cfg = ioa_cfg;
+	sata_port->res = res;
+	res->sata_port = sata_port;
+	res->add_to_ml = 0;
+	list_add_tail(&sata_port->queue, &ioa_cfg->sata_ports);
+
+	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+
+	rc = ata_sas_rphy_add(rphy, &sata_driver_template);
+
+	if (rc) {
+		spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
+		dev = get_device(&sata_port->rphy.dev);
+		list_del(&sata_port->queue);
+		spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+
+		ata_sas_rphy_free(rphy);
+
+		spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
+		sata_port->res->sata_port = NULL;
+		spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+		put_device(dev);
+	}
+}
+
+/**
  * ipr_worker_thread - Worker thread
  * @work:		ioa config struct
  *
@@ -2366,11 +2599,12 @@ static void ipr_worker_thread(struct wor
 	unsigned long lock_flags;
 	struct ipr_resource_entry *res;
 	struct scsi_device *sdev;
+	struct device *dev;
 	struct ipr_dump *dump;
+	struct ipr_sata_port *sata_port;
 	struct ipr_ioa_cfg *ioa_cfg =
 		container_of(work, struct ipr_ioa_cfg, work_q);
 	u8 bus, target, lun;
-	int did_work;
 
 	ENTER;
 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
@@ -2394,42 +2628,64 @@ static void ipr_worker_thread(struct wor
 	}
 
 restart:
-	do {
-		did_work = 0;
-		if (!ioa_cfg->allow_cmds || !ioa_cfg->allow_ml_add_del) {
-			spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-			return;
-		}
+	if (!ioa_cfg->allow_cmds || !ioa_cfg->allow_ml_add_del) {
+		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+		return;
+	}
 
-		list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
-			if (res->del_from_ml && res->sdev) {
-				did_work = 1;
-				sdev = res->sdev;
-				if (!scsi_device_get(sdev)) {
-					list_move_tail(&res->queue, &ioa_cfg->free_res_q);
-					spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-					scsi_remove_device(sdev);
-					scsi_device_put(sdev);
-					spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
-				}
-				break;
+	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
+		if (res->del_from_ml && res->sdev) {
+			sdev = res->sdev;
+			if (!scsi_device_get(sdev)) {
+				list_move_tail(&res->queue, &ioa_cfg->free_res_q);
+				spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+				scsi_remove_device(sdev);
+				scsi_device_put(sdev);
+				spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
 			}
+			goto restart;
 		}
-	} while(did_work);
+	}
 
-	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
-		if (res->add_to_ml) {
-			bus = res->cfgte.res_addr.bus;
-			target = res->cfgte.res_addr.target;
-			lun = res->cfgte.res_addr.lun;
-			res->add_to_ml = 0;
+	list_for_each_entry(sata_port, &ioa_cfg->sata_ports, queue) {
+		if (sata_port->res->del_from_ml) {
+			dev = get_device(&sata_port->rphy.dev);
+			list_del(&sata_port->queue);
 			spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-			scsi_add_device(ioa_cfg->host, bus, target, lun);
+
+			ata_sas_rphy_delete(&sata_port->rphy);
+
+			spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
+			sata_port->res->sata_port = NULL;
+			list_move_tail(&sata_port->res->queue, &ioa_cfg->free_res_q);
+			spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+
+			put_device(dev);
 			spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
 			goto restart;
 		}
 	}
 
+	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
+		if (res->add_to_ml) {
+			if (ipr_is_gata(res)) {
+				spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+				ipr_add_sata_dev(ioa_cfg, res);
+				spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
+			} else {
+				bus = res->cfgte.res_addr.bus;
+				target = res->cfgte.res_addr.target;
+				lun = res->cfgte.res_addr.lun;
+				res->add_to_ml = 0;
+				spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+				scsi_add_device(ioa_cfg->host, bus, target, lun);
+				spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
+			}
+
+			goto restart;
+		}
+	}
+
 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
 	kobject_uevent(&ioa_cfg->host->shost_classdev.kobj, KOBJ_CHANGE);
 	LEAVE;
@@ -3366,17 +3622,6 @@ static int ipr_free_dump(struct ipr_ioa_
  **/
 static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth)
 {
-	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
-	struct ipr_resource_entry *res;
-	unsigned long lock_flags = 0;
-
-	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
-	res = (struct ipr_resource_entry *)sdev->hostdata;
-
-	if (res && ipr_is_gata(res) && qdepth > IPR_MAX_CMD_PER_ATA_LUN)
-		qdepth = IPR_MAX_CMD_PER_ATA_LUN;
-	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-
 	scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
 	return sdev->queue_depth;
 }
@@ -3492,100 +3737,6 @@ static int ipr_biosparam(struct scsi_dev
 }
 
 /**
- * ipr_find_starget - Find target based on bus/target.
- * @starget:	scsi target struct
- *
- * Return value:
- * 	resource entry pointer if found / NULL if not found
- **/
-static struct ipr_resource_entry *ipr_find_starget(struct scsi_target *starget)
-{
-	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
-	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
-	struct ipr_resource_entry *res;
-
-	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
-		if ((res->cfgte.res_addr.bus == starget->channel) &&
-		    (res->cfgte.res_addr.target == starget->id) &&
-		    (res->cfgte.res_addr.lun == 0)) {
-			return res;
-		}
-	}
-
-	return NULL;
-}
-
-static struct ata_port_info sata_port_info;
-
-/**
- * ipr_target_alloc - Prepare for commands to a SCSI target
- * @starget:	scsi target struct
- *
- * If the device is a SATA device, this function allocates an
- * ATA port with libata, else it does nothing.
- *
- * Return value:
- * 	0 on success / non-0 on failure
- **/
-static int ipr_target_alloc(struct scsi_target *starget)
-{
-	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
-	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
-	struct ipr_sata_port *sata_port;
-	struct ata_port *ap;
-	struct ipr_resource_entry *res;
-	unsigned long lock_flags;
-
-	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
-	res = ipr_find_starget(starget);
-	starget->hostdata = NULL;
-
-	if (res && ipr_is_gata(res)) {
-		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-		sata_port = kzalloc(sizeof(*sata_port), GFP_KERNEL);
-		if (!sata_port)
-			return -ENOMEM;
-
-		ap = ata_sas_port_alloc(&ioa_cfg->ata_host, &sata_port_info, shost);
-		if (ap) {
-			spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
-			sata_port->ioa_cfg = ioa_cfg;
-			sata_port->ap = ap;
-			sata_port->res = res;
-
-			res->sata_port = sata_port;
-			ap->private_data = sata_port;
-			starget->hostdata = sata_port;
-		} else {
-			kfree(sata_port);
-			return -ENOMEM;
-		}
-	}
-	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-
-	return 0;
-}
-
-/**
- * ipr_target_destroy - Destroy a SCSI target
- * @starget:	scsi target struct
- *
- * If the device was a SATA device, this function frees the libata
- * ATA port, else it does nothing.
- *
- **/
-static void ipr_target_destroy(struct scsi_target *starget)
-{
-	struct ipr_sata_port *sata_port = starget->hostdata;
-
-	if (sata_port) {
-		starget->hostdata = NULL;
-		ata_sas_port_destroy(sata_port->ap);
-		kfree(sata_port);
-	}
-}
-
-/**
  * ipr_find_sdev - Find device based on bus/target/lun.
  * @sdev:	scsi device struct
  *
@@ -3625,11 +3776,8 @@ static void ipr_slave_destroy(struct scs
 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
 	res = (struct ipr_resource_entry *) sdev->hostdata;
 	if (res) {
-		if (res->sata_port)
-			ata_port_disable(res->sata_port->ap);
 		sdev->hostdata = NULL;
 		res->sdev = NULL;
-		res->sata_port = NULL;
 	}
 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
 }
@@ -3664,45 +3812,13 @@ static int ipr_slave_configure(struct sc
 		}
 		if (ipr_is_vset_device(res) || ipr_is_scsi_disk(res))
 			sdev->allow_restart = 1;
-		if (ipr_is_gata(res) && res->sata_port) {
-			scsi_adjust_queue_depth(sdev, 0, IPR_MAX_CMD_PER_ATA_LUN);
-			ata_sas_slave_configure(sdev, res->sata_port->ap);
-		} else {
-			scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
-		}
+		scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
 	}
 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
 	return 0;
 }
 
 /**
- * ipr_ata_slave_alloc - Prepare for commands to a SATA device
- * @sdev:	scsi device struct
- *
- * This function initializes an ATA port so that future commands
- * sent through queuecommand will work.
- *
- * Return value:
- * 	0 on success
- **/
-static int ipr_ata_slave_alloc(struct scsi_device *sdev)
-{
-	struct ipr_sata_port *sata_port = NULL;
-	int rc = -ENXIO;
-
-	ENTER;
-	if (sdev->sdev_target)
-		sata_port = sdev->sdev_target->hostdata;
-	if (sata_port)
-		rc = ata_sas_port_init(sata_port->ap);
-	if (rc)
-		ipr_slave_destroy(sdev);
-
-	LEAVE;
-	return rc;
-}
-
-/**
  * ipr_slave_alloc - Prepare for commands to a device.
  * @sdev:	scsi device struct
  *
@@ -3726,7 +3842,7 @@ static int ipr_slave_alloc(struct scsi_d
 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
 
 	res = ipr_find_sdev(sdev);
-	if (res) {
+	if (res && !ipr_is_gata(res)) {
 		res->sdev = sdev;
 		res->add_to_ml = 0;
 		res->in_erp = 0;
@@ -3734,10 +3850,6 @@ static int ipr_slave_alloc(struct scsi_d
 		if (!ipr_is_naca_model(res))
 			res->needs_sync_complete = 1;
 		rc = 0;
-		if (ipr_is_gata(res)) {
-			spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-			return ipr_ata_slave_alloc(sdev);
-		}
 	}
 
 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
@@ -3845,7 +3957,8 @@ static int ipr_device_reset(struct ipr_i
 static int ipr_sata_reset(struct ata_link *link, unsigned int *classes,
 				unsigned long deadline)
 {
-	struct ipr_sata_port *sata_port = link->ap->private_data;
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(link->ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
 	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
 	struct ipr_resource_entry *res;
 	unsigned long lock_flags = 0;
@@ -3859,9 +3972,21 @@ static int ipr_sata_reset(struct ata_lin
 		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
 	}
 
+	if (!ioa_cfg->request_limit) {
+		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+		return -EIO;
+	}
+
 	res = sata_port->res;
 	if (res) {
+		ioa_cfg->request_limit--;
+		sata_port->active_requests++;
+
 		rc = ipr_device_reset(ioa_cfg, res);
+
+		ioa_cfg->request_limit++;
+		sata_port->active_requests--;
+
 		switch(res->cfgte.proto) {
 		case IPR_PROTO_SATA:
 		case IPR_PROTO_SAS_STP:
@@ -3898,7 +4023,6 @@ static int __ipr_eh_dev_reset(struct scs
 	struct ipr_cmnd *ipr_cmd;
 	struct ipr_ioa_cfg *ioa_cfg;
 	struct ipr_resource_entry *res;
-	struct ata_port *ap;
 	int rc = 0;
 
 	ENTER;
@@ -3917,37 +4041,19 @@ static int __ipr_eh_dev_reset(struct scs
 		return FAILED;
 	if (ioa_cfg->ioa_is_dead)
 		return FAILED;
+	if (ipr_is_gata(res))
+		return FAILED;
 
 	list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
 		if (ipr_cmd->ioarcb.res_handle == res->cfgte.res_handle) {
 			if (ipr_cmd->scsi_cmd)
 				ipr_cmd->done = ipr_scsi_eh_done;
-			if (ipr_cmd->qc)
-				ipr_cmd->done = ipr_sata_eh_done;
-			if (ipr_cmd->qc && !(ipr_cmd->qc->flags & ATA_QCFLAG_FAILED)) {
-				ipr_cmd->qc->err_mask |= AC_ERR_TIMEOUT;
-				ipr_cmd->qc->flags |= ATA_QCFLAG_FAILED;
-			}
 		}
 	}
 
 	res->resetting_device = 1;
 	scmd_printk(KERN_ERR, scsi_cmd, "Resetting device\n");
-
-	if (ipr_is_gata(res) && res->sata_port) {
-		ap = res->sata_port->ap;
-		spin_unlock_irq(scsi_cmd->device->host->host_lock);
-		ata_do_eh(ap, NULL, NULL, ipr_sata_reset, NULL);
-		spin_lock_irq(scsi_cmd->device->host->host_lock);
-
-		list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
-			if (ipr_cmd->ioarcb.res_handle == res->cfgte.res_handle) {
-				rc = -EIO;
-				break;
-			}
-		}
-	} else
-		rc = ipr_device_reset(ioa_cfg, res);
+	rc = ipr_device_reset(ioa_cfg, res);
 	res->resetting_device = 0;
 
 	LEAVE;
@@ -4389,6 +4495,7 @@ static void ipr_erp_done(struct ipr_cmnd
 		res->in_erp = 0;
 	}
 	scsi_dma_unmap(ipr_cmd->scsi_cmd);
+	ioa_cfg->request_limit++;
 	list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
 	scsi_cmd->scsi_done(scsi_cmd);
 }
@@ -4767,6 +4874,7 @@ static void ipr_erp_start(struct ipr_ioa
 	}
 
 	scsi_dma_unmap(ipr_cmd->scsi_cmd);
+	ioa_cfg->request_limit++;
 	list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
 	scsi_cmd->scsi_done(scsi_cmd);
 }
@@ -4791,6 +4899,7 @@ static void ipr_scsi_done(struct ipr_cmn
 
 	if (likely(IPR_IOASC_SENSE_KEY(ioasc) == 0)) {
 		scsi_dma_unmap(ipr_cmd->scsi_cmd);
+		ioa_cfg->request_limit++;
 		list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
 		scsi_cmd->scsi_done(scsi_cmd);
 	} else
@@ -4842,8 +4951,8 @@ static int ipr_queuecommand(struct scsi_
 		return 0;
 	}
 
-	if (ipr_is_gata(res) && res->sata_port)
-		return ata_sas_queuecmd(scsi_cmd, done, res->sata_port->ap);
+	if (!ioa_cfg->request_limit)
+		return SCSI_MLQUEUE_HOST_BUSY;
 
 	ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
 	ioarcb = &ipr_cmd->ioarcb;
@@ -4878,6 +4987,7 @@ static int ipr_queuecommand(struct scsi_
 		rc = ipr_build_ioadl(ioa_cfg, ipr_cmd);
 
 	if (likely(rc == 0)) {
+		ioa_cfg->request_limit--;
 		mb();
 		writel(be32_to_cpu(ipr_cmd->ioarcb.ioarcb_host_pci_addr),
 		       ioa_cfg->regs.ioarrin_reg);
@@ -4890,26 +5000,6 @@ static int ipr_queuecommand(struct scsi_
 }
 
 /**
- * ipr_ioctl - IOCTL handler
- * @sdev:	scsi device struct
- * @cmd:	IOCTL cmd
- * @arg:	IOCTL arg
- *
- * Return value:
- * 	0 on success / other on failure
- **/
-static int ipr_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
-{
-	struct ipr_resource_entry *res;
-
-	res = (struct ipr_resource_entry *)sdev->hostdata;
-	if (res && ipr_is_gata(res))
-		return ata_scsi_ioctl(sdev, cmd, arg);
-
-	return -EINVAL;
-}
-
-/**
  * ipr_info - Get information about the card/driver
  * @scsi_host:	scsi host struct
  *
@@ -4935,7 +5025,6 @@ static struct scsi_host_template driver_
 	.module = THIS_MODULE,
 	.name = "IPR",
 	.info = ipr_ioa_info,
-	.ioctl = ipr_ioctl,
 	.queuecommand = ipr_queuecommand,
 	.eh_abort_handler = ipr_eh_abort,
 	.eh_device_reset_handler = ipr_eh_dev_reset,
@@ -4943,8 +5032,6 @@ static struct scsi_host_template driver_
 	.slave_alloc = ipr_slave_alloc,
 	.slave_configure = ipr_slave_configure,
 	.slave_destroy = ipr_slave_destroy,
-	.target_alloc = ipr_target_alloc,
-	.target_destroy = ipr_target_destroy,
 	.change_queue_depth = ipr_change_queue_depth,
 	.change_queue_type = ipr_change_queue_type,
 	.bios_param = ipr_biosparam,
@@ -4960,56 +5047,118 @@ static struct scsi_host_template driver_
 };
 
 /**
- * ipr_ata_phy_reset - libata phy_reset handler
- * @ap:		ata port to reset
+ * ipr_tasklet - ipr tasklet for deferred interrupt processing
+ * @data:	ioa_config struct
+ *
+ * Call ata_qc_complete on any completed ATA commands.
  *
+ * Return value:
+ * 	none
  **/
-static void ipr_ata_phy_reset(struct ata_port *ap)
+static void ipr_tasklet(unsigned long data)
 {
+	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)data;
 	unsigned long flags;
-	struct ipr_sata_port *sata_port = ap->private_data;
-	struct ipr_resource_entry *res = sata_port->res;
+	struct ata_port *ap;
+	struct ata_queued_cmd *qc, *next_qc = NULL;
+
+	spin_lock_irqsave(&ioa_cfg->qc_done_lock, flags);
+	qc = ioa_cfg->qc_done;
+	ioa_cfg->qc_done = NULL;
+	spin_unlock_irqrestore(&ioa_cfg->qc_done_lock, flags);
+
+	while (qc) {
+		next_qc = qc->lldd_task;
+		ap = qc->ap;
+		spin_lock_irqsave(ap->lock, flags);
+		ata_qc_complete(qc);
+		spin_unlock_irqrestore(ap->lock, flags);
+		qc = next_qc;
+	}
+}
+
+/**
+ * ipr_sata_error_handler - libata error handler
+ * @ap:	ATA port to perform error recovery on
+ *
+ * Return value:
+ * 	none
+ **/
+static void ipr_sata_error_handler(struct ata_port *ap)
+{
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
 	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
-	int rc;
+	struct ipr_cmnd *ipr_cmd;
+	unsigned long flags;
 
-	ENTER;
+	ata_do_eh(ap, NULL, NULL, ipr_sata_reset, NULL);
+
+	/* If commands are still outstanding, reset the adapter */
 	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
-	while(ioa_cfg->in_reset_reload) {
-		spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
-		wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
-		spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
+	list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
+		if (ipr_cmd->qc && ipr_cmd->qc->ap == ap) {
+			ipr_reset_reload(ioa_cfg, IPR_SHUTDOWN_ABBREV);
+			break;
+		}
 	}
 
-	if (!ioa_cfg->allow_cmds)
-		goto out_unlock;
+	ioa_cfg->request_limit += sata_port->active_requests;
+	sata_port->active_requests = 0;
+	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+}
 
-	rc = ipr_device_reset(ioa_cfg, res);
+/**
+ * ipr_sata_freeze - libata freeze handler
+ * @ap:	ATA port to freeze
+ *
+ * Since ipr does not have the ability to freeze a port like a
+ * SATA adapter can, we simply ensure we never call ata_qc_complete for
+ * any commands that are still outstanding to this ATA port.
+ *
+ * Return value:
+ * 	none
+ **/
+static void ipr_sata_freeze(struct ata_port *ap)
+{
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
+	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
+	struct ipr_cmnd *ipr_cmd;
+	struct ata_queued_cmd *sqc, *dqc, *qc;
+	unsigned long flags;
 
-	if (rc) {
-		ata_port_disable(ap);
-		goto out_unlock;
+	ENTER;
+	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
+	list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
+		if (ipr_cmd->qc && ipr_cmd->qc->ap == ap)
+			ipr_cmd->done = ipr_sata_frozen_done;
 	}
+	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
 
-	switch(res->cfgte.proto) {
-	case IPR_PROTO_SATA:
-	case IPR_PROTO_SAS_STP:
-		ap->link.device[0].class = ATA_DEV_ATA;
-		break;
-	case IPR_PROTO_SATA_ATAPI:
-	case IPR_PROTO_SAS_STP_ATAPI:
-		ap->link.device[0].class = ATA_DEV_ATAPI;
-		break;
-	default:
-		ap->link.device[0].class = ATA_DEV_UNKNOWN;
-		ata_port_disable(ap);
-		break;
-	};
+	spin_lock_irqsave(&ioa_cfg->qc_done_lock, flags);
+	sqc = ioa_cfg->qc_done;
+	ioa_cfg->qc_done = NULL;
+	dqc = NULL;
+	for (qc = sqc; qc; qc = qc->lldd_task) {
+		if (qc->ap != ap) {
+			if (!dqc)
+				ioa_cfg->qc_done = qc;
+			else
+				dqc->lldd_task = qc;
+			dqc = qc;
+		}
+	}
+
+	if (dqc)
+		dqc->lldd_task = NULL;
+	spin_unlock_irqrestore(&ioa_cfg->qc_done_lock, flags);
 
-out_unlock:
-	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
 	LEAVE;
 }
 
+static void ipr_sata_thaw(struct ata_port *ap) { }
+
 /**
  * ipr_ata_post_internal - Cleanup after an internal command
  * @qc:	ATA queued command
@@ -5019,7 +5168,9 @@ out_unlock:
  **/
 static void ipr_ata_post_internal(struct ata_queued_cmd *qc)
 {
-	struct ipr_sata_port *sata_port = qc->ap->private_data;
+	struct ata_port *ap = qc->ap;
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
 	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
 	struct ipr_cmnd *ipr_cmd;
 	unsigned long flags;
@@ -5032,11 +5183,28 @@ static void ipr_ata_post_internal(struct
 	}
 
 	list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
-		if (ipr_cmd->qc == qc) {
+		if (ipr_cmd->qc == qc && ioa_cfg->request_limit) {
+			ioa_cfg->request_limit--;
+			sata_port->active_requests++;
+
 			ipr_device_reset(ioa_cfg, sata_port->res);
+
+			ioa_cfg->request_limit++;
+			sata_port->active_requests--;
 			break;
 		}
 	}
+
+	/* If command is still outstanding, reset the adapter */
+	list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
+		if (ipr_cmd->qc == qc) {
+			ipr_reset_reload(ioa_cfg, IPR_SHUTDOWN_ABBREV);
+			break;
+		}
+	}
+
+	ioa_cfg->request_limit += sata_port->active_requests;
+	sata_port->active_requests = 0;
 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
 }
 
@@ -5050,9 +5218,13 @@ static void ipr_ata_post_internal(struct
  **/
 static void ipr_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
 {
-	struct ipr_sata_port *sata_port = ap->private_data;
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
+	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
 	struct ipr_ioasa_gata *g = &sata_port->ioasa;
+	unsigned long flags;
 
+	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
 	tf->feature = g->error;
 	tf->nsect = g->nsect;
 	tf->lbal = g->lbal;
@@ -5065,6 +5237,7 @@ static void ipr_tf_read(struct ata_port 
 	tf->hob_lbam = g->hob_lbam;
 	tf->hob_lbah = g->hob_lbah;
 	tf->ctl = g->alt_status;
+	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
 }
 
 /**
@@ -5107,7 +5280,8 @@ static void ipr_sata_done(struct ipr_cmn
 {
 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
 	struct ata_queued_cmd *qc = ipr_cmd->qc;
-	struct ipr_sata_port *sata_port = qc->ap->private_data;
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(qc->ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
 	struct ipr_resource_entry *res = sata_port->res;
 	u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
 
@@ -5116,15 +5290,17 @@ static void ipr_sata_done(struct ipr_cmn
 	ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
 
 	if (be32_to_cpu(ipr_cmd->ioasa.ioasc_specific) & IPR_ATA_DEVICE_WAS_RESET)
-		scsi_report_device_reset(ioa_cfg->host, res->cfgte.res_addr.bus,
-					 res->cfgte.res_addr.target);
+		scsi_report_device_reset(qc->ap->scsi_host, qc->dev->sdev->channel,
+					 qc->dev->sdev->id);
 
 	if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
 		qc->err_mask |= __ac_err_mask(ipr_cmd->ioasa.u.gata.status);
 	else
 		qc->err_mask |= ac_err_mask(ipr_cmd->ioasa.u.gata.status);
+	ioa_cfg->request_limit++;
+	sata_port->active_requests--;
 	list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
-	ata_qc_complete(qc);
+	ipr_sata_qc_complete(ioa_cfg, qc);
 }
 
 /**
@@ -5172,6 +5348,34 @@ static void ipr_build_ata_ioadl(struct i
 }
 
 /**
+ * ipr_sata_qc_defer - Check to see if a qc needs to be deferred
+ * @qc:	queued command
+ *
+ * Return value:
+ * 	0 if success, ATA_DEFER_PORT is qc needs to be deferred
+ **/
+static int ipr_sata_qc_defer(struct ata_queued_cmd *qc)
+{
+	struct ata_port *ap = qc->ap;
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
+	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
+	unsigned long flags;
+
+	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
+	if (unlikely(!ioa_cfg->request_limit ||
+		     (!ioa_cfg->allow_cmds && !ioa_cfg->ioa_is_dead))) {
+		spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+		return ATA_DEFER_PORT;
+	}
+
+	ioa_cfg->request_limit--;
+	sata_port->active_requests++;
+	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+	return 0;
+}
+
+/**
  * ipr_qc_issue - Issue a SATA qc to a device
  * @qc:	queued command
  *
@@ -5181,15 +5385,25 @@ static void ipr_build_ata_ioadl(struct i
 static unsigned int ipr_qc_issue(struct ata_queued_cmd *qc)
 {
 	struct ata_port *ap = qc->ap;
-	struct ipr_sata_port *sata_port = ap->private_data;
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
 	struct ipr_resource_entry *res = sata_port->res;
 	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
 	struct ipr_cmnd *ipr_cmd;
 	struct ipr_ioarcb *ioarcb;
 	struct ipr_ioarcb_ata_regs *regs;
+	unsigned long flags;
+
+	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
+	if (unlikely(!ioa_cfg->allow_cmds || ioa_cfg->ioa_is_dead)) {
+		spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+		return AC_ERR_SYSTEM;
+	}
 
-	if (unlikely(!ioa_cfg->allow_cmds || ioa_cfg->ioa_is_dead))
+	if (qc->tag == ATA_TAG_INTERNAL && !ioa_cfg->request_limit) {
+		spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
 		return AC_ERR_SYSTEM;
+	}
 
 	ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
 	ioarcb = &ipr_cmd->ioarcb;
@@ -5206,6 +5420,7 @@ static unsigned int ipr_qc_issue(struct 
 	ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
 	ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
 	ipr_cmd->dma_use_sg = qc->pad_len ? qc->n_elem + 1 : qc->n_elem;
+	qc->lldd_task = NULL;
 
 	ipr_build_ata_ioadl(ipr_cmd, qc);
 	regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
@@ -5234,12 +5449,18 @@ static unsigned int ipr_qc_issue(struct 
 
 	default:
 		WARN_ON(1);
+		spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
 		return AC_ERR_INVALID;
 	}
 
+	if (qc->tag == ATA_TAG_INTERNAL) {
+		ioa_cfg->request_limit--;
+		sata_port->active_requests++;
+	}
 	mb();
 	writel(be32_to_cpu(ioarcb->ioarcb_host_pci_addr),
 	       ioa_cfg->regs.ioarrin_reg);
+	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
 	return 0;
 }
 
@@ -5252,7 +5473,8 @@ static unsigned int ipr_qc_issue(struct 
  **/
 static u8 ipr_ata_check_status(struct ata_port *ap)
 {
-	struct ipr_sata_port *sata_port = ap->private_data;
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
 	return sata_port->ioasa.status;
 }
 
@@ -5265,7 +5487,8 @@ static u8 ipr_ata_check_status(struct at
  **/
 static u8 ipr_ata_check_altstatus(struct ata_port *ap)
 {
-	struct ipr_sata_port *sata_port = ap->private_data;
+	struct ata_sas_rphy *rphy = dev_to_sata_rphy(ap->dev);
+	struct ipr_sata_port *sata_port = rphy_to_sata_port(rphy);
 	return sata_port->ioasa.alt_status;
 }
 
@@ -5273,13 +5496,16 @@ static struct ata_port_operations ipr_sa
 	.check_status = ipr_ata_check_status,
 	.check_altstatus = ipr_ata_check_altstatus,
 	.dev_select = ata_noop_dev_select,
-	.phy_reset = ipr_ata_phy_reset,
+	.error_handler = ipr_sata_error_handler,
+	.freeze = ipr_sata_freeze,
+	.thaw = ipr_sata_thaw,
 	.post_internal_cmd = ipr_ata_post_internal,
 	.tf_read = ipr_tf_read,
+	.qc_defer = ipr_sata_qc_defer,
 	.qc_prep = ata_noop_qc_prep,
 	.qc_issue = ipr_qc_issue,
 	.port_start = ata_sas_port_start,
-	.port_stop = ata_sas_port_stop
+	.port_stop = ata_sas_port_stop,
 };
 
 static struct ata_port_info sata_port_info = {
@@ -7357,6 +7583,7 @@ static void __devinit ipr_init_ioa_cfg(s
 	ioa_cfg->pdev = pdev;
 	ioa_cfg->log_level = ipr_log_level;
 	ioa_cfg->doorbell = IPR_DOORBELL;
+	ioa_cfg->request_limit = IPR_MAX_COMMANDS;
 	sprintf(ioa_cfg->eye_catcher, IPR_EYECATCHER);
 	sprintf(ioa_cfg->trace_start, IPR_TRACE_START_LABEL);
 	sprintf(ioa_cfg->ipr_free_label, IPR_FREEQ_LABEL);
@@ -7372,7 +7599,10 @@ static void __devinit ipr_init_ioa_cfg(s
 	INIT_LIST_HEAD(&ioa_cfg->hostrcb_pending_q);
 	INIT_LIST_HEAD(&ioa_cfg->free_res_q);
 	INIT_LIST_HEAD(&ioa_cfg->used_res_q);
+	INIT_LIST_HEAD(&ioa_cfg->sata_ports);
 	INIT_WORK(&ioa_cfg->work_q, ipr_worker_thread);
+	spin_lock_init(&ioa_cfg->qc_done_lock);
+	tasklet_init(&ioa_cfg->tasklet, ipr_tasklet, (unsigned long) ioa_cfg);
 	init_waitqueue_head(&ioa_cfg->reset_wait_q);
 	ioa_cfg->sdt_state = INACTIVE;
 	if (ipr_enable_cache)
@@ -7460,8 +7690,6 @@ static int __devinit ipr_probe_ioa(struc
 
 	ioa_cfg = (struct ipr_ioa_cfg *)host->hostdata;
 	memset(ioa_cfg, 0, sizeof(struct ipr_ioa_cfg));
-	ata_host_init(&ioa_cfg->ata_host, &pdev->dev,
-		      sata_port_info.flags, &ipr_sata_ops);
 
 	ioa_cfg->chip_cfg = ipr_get_chip_cfg(dev_id);
 
@@ -7640,6 +7868,45 @@ static void ipr_initiate_ioa_bringdown(s
 }
 
 /**
+ * ipr_remove_sata_devs - Remove all SATA devices from the adapter
+ * @ioa_cfg:		ioa config struct
+ *
+ * Description: This function will delete all previously allocated
+ * SATA rphys.
+ *
+ * Return value:
+ * 	none
+ **/
+static void ipr_remove_sata_devs(struct ipr_ioa_cfg *ioa_cfg)
+{
+	struct ipr_sata_port *sata_port;
+	struct device *dev;
+	unsigned long flags;
+
+	ENTER;
+restart:
+	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
+	list_for_each_entry(sata_port, &ioa_cfg->sata_ports, queue) {
+		dev = get_device(&sata_port->rphy.dev);
+		list_del(&sata_port->queue);
+		spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+
+		ata_sas_rphy_delete(&sata_port->rphy);
+
+		spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
+		sata_port->res->sata_port = NULL;
+		list_move_tail(&sata_port->res->queue, &ioa_cfg->free_res_q);
+		spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+
+		if (dev)
+			put_device(dev);
+		goto restart;
+	}
+	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+	LEAVE;
+}
+
+/**
  * __ipr_remove - Remove a single adapter
  * @pdev:	pci device struct
  *
@@ -7655,6 +7922,15 @@ static void __ipr_remove(struct pci_dev 
 	ENTER;
 
 	spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
+	ioa_cfg->allow_ml_add_del = 0;
+	spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
+
+	flush_scheduled_work();
+	ipr_remove_sata_devs(ioa_cfg);
+	tasklet_disable(&ioa_cfg->tasklet);
+	ipr_tasklet((unsigned long)ioa_cfg);
+
+	spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
 	while(ioa_cfg->in_reset_reload) {
 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
 		wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
@@ -7662,11 +7938,10 @@ static void __ipr_remove(struct pci_dev 
 	}
 
 	ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL);
-
 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
 	wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
+	schedule_work(&ioa_cfg->work_q);
 	flush_scheduled_work();
-	spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
 
 	spin_lock(&ipr_driver_lock);
 	list_del(&ioa_cfg->queue);
@@ -7765,6 +8040,7 @@ static int __devinit ipr_probe(struct pc
 	ioa_cfg->allow_ml_add_del = 1;
 	ioa_cfg->host->max_channel = IPR_VSET_BUS;
 	schedule_work(&ioa_cfg->work_q);
+	flush_scheduled_work();
 	return 0;
 }
 
diff -puN drivers/scsi/ipr.h~ipr_sata_scsi_host2 drivers/scsi/ipr.h
--- linux-2.6/drivers/scsi/ipr.h~ipr_sata_scsi_host2	2007-10-29 13:04:13.000000000 -0500
+++ linux-2.6-bjking1/drivers/scsi/ipr.h	2007-10-29 14:00:22.000000000 -0500
@@ -951,11 +951,16 @@ struct ipr_bus_attributes {
 	u32 max_xfer_rate;
 };
 
+#define rphy_to_sata_port(d) \
+	container_of((d), struct ipr_sata_port, rphy)
+
 struct ipr_sata_port {
+	struct ata_sas_rphy rphy;
+	unsigned int active_requests;
 	struct ipr_ioa_cfg *ioa_cfg;
-	struct ata_port *ap;
 	struct ipr_resource_entry *res;
 	struct ipr_ioasa_gata ioasa;
+	struct list_head queue;
 };
 
 struct ipr_resource_entry {
@@ -1137,6 +1142,8 @@ struct ipr_ioa_cfg {
 	struct list_head free_res_q;
 	struct list_head used_res_q;
 
+	struct list_head sata_ports;
+
 	char ipr_hcam_label[8];
 #define IPR_HCAM_LABEL			"hcams"
 	struct ipr_hostrcb *hostrcb[IPR_NUM_HCAMS];
@@ -1170,6 +1177,7 @@ struct ipr_ioa_cfg {
 
 	u32 errors_logged;
 	u32 doorbell;
+	unsigned int request_limit;
 
 	struct Scsi_Host *host;
 	struct pci_dev *pdev;
@@ -1177,6 +1185,7 @@ struct ipr_ioa_cfg {
 	u8 saved_mode_page_len;
 
 	struct work_struct work_q;
+	struct tasklet_struct tasklet;
 
 	wait_queue_head_t reset_wait_q;
 
@@ -1191,7 +1200,9 @@ struct ipr_ioa_cfg {
 	struct ipr_cmnd *reset_cmd;
 	int (*reset) (struct ipr_cmnd *);
 
-	struct ata_host ata_host;
+	spinlock_t	qc_done_lock;
+	struct ata_queued_cmd *qc_done;
+
 	char ipr_cmd_label[8];
 #define IPR_CMD_LABEL		"ipr_cmnd"
 	struct ipr_cmnd *ipr_cmnd_list[IPR_NUM_CMD_BLKS];
_