1 files changed, 397 insertions, 431 deletions

diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
index db9238f2ecb8..bc0cecc6ad62 100644
--- a/drivers/scsi/libsas/sas_ata.c
+++ b/drivers/scsi/libsas/sas_ata.c
@@ -23,6 +23,8 @@
 
 #include <linux/scatterlist.h>
 #include <linux/slab.h>
+#include <linux/async.h>
+#include <linux/export.h>
 
 #include <scsi/sas_ata.h>
 #include "sas_internal.h"
@@ -93,22 +95,47 @@ static enum ata_completion_errors sas_to_ata_err(struct task_status_struct *ts)
 static void sas_ata_task_done(struct sas_task *task)
 {
         struct ata_queued_cmd *qc = task->uldd_task;
-        struct domain_device *dev;
+        struct domain_device *dev = task->dev;
         struct task_status_struct *stat = &task->task_status;
         struct ata_task_resp *resp = (struct ata_task_resp *)stat->buf;
-        struct sas_ha_struct *sas_ha;
+        struct sas_ha_struct *sas_ha = dev->port->ha;
         enum ata_completion_errors ac;
         unsigned long flags;
         struct ata_link *link;
+        struct ata_port *ap;
+
+        spin_lock_irqsave(&dev->done_lock, flags);
+        if (test_bit(SAS_HA_FROZEN, &sas_ha->state))
+                task = NULL;
+        else if (qc && qc->scsicmd)
+                ASSIGN_SAS_TASK(qc->scsicmd, NULL);
+        spin_unlock_irqrestore(&dev->done_lock, flags);
+
+        /* check if libsas-eh got to the task before us */
+        if (unlikely(!task))
+                return;
 
         if (!qc)
                 goto qc_already_gone;
 
-        dev = qc->ap->private_data;
-        sas_ha = dev->port->ha;
-        link = &dev->sata_dev.ap->link;
+        ap = qc->ap;
+        link = &ap->link;
+
+        spin_lock_irqsave(ap->lock, flags);
+        /* check if we lost the race with libata/sas_ata_post_internal() */
+        if (unlikely(ap->pflags & ATA_PFLAG_FROZEN)) {
+                spin_unlock_irqrestore(ap->lock, flags);
+                if (qc->scsicmd)
+                        goto qc_already_gone;
+                else {
+                        /* if eh is not involved and the port is frozen then the
+                         * ata internal abort process has taken responsibility
+                         * for this sas_task
+                         */
+                        return;
+                }
+        }
 
-        spin_lock_irqsave(dev->sata_dev.ap->lock, flags);
         if (stat->stat == SAS_PROTO_RESPONSE || stat->stat == SAM_STAT_GOOD ||
             ((stat->stat == SAM_STAT_CHECK_CONDITION &&
               dev->sata_dev.command_set == ATAPI_COMMAND_SET))) {
@@ -121,10 +148,6 @@ static void sas_ata_task_done(struct sas_task *task)
                         if (unlikely(link->eh_info.err_mask))
                                 qc->flags |= ATA_QCFLAG_FAILED;
                 }
-
-                dev->sata_dev.sstatus = resp->sstatus;
-                dev->sata_dev.serror = resp->serror;
-                dev->sata_dev.scontrol = resp->scontrol;
         } else {
                 ac = sas_to_ata_err(stat);
                 if (ac) {
@@ -144,24 +167,8 @@ static void sas_ata_task_done(struct sas_task *task)
         }
 
         qc->lldd_task = NULL;
-        if (qc->scsicmd)
-                ASSIGN_SAS_TASK(qc->scsicmd, NULL);
         ata_qc_complete(qc);
-        spin_unlock_irqrestore(dev->sata_dev.ap->lock, flags);
-
-        /*
-         * If the sas_task has an ata qc, a scsi_cmnd and the aborted
-         * flag is set, then we must have come in via the libsas EH
-         * functions.  When we exit this function, we need to put the
-         * scsi_cmnd on the list of finished errors.  The ata_qc_complete
-         * call cleans up the libata side of things but we're protected
-         * from the scsi_cmnd going away because the scsi_cmnd is owned
-         * by the EH, making libata's call to scsi_done a NOP.
-         */
-        spin_lock_irqsave(&task->task_state_lock, flags);
-        if (qc->scsicmd && task->task_state_flags & SAS_TASK_STATE_ABORTED)
-                scsi_eh_finish_cmd(qc->scsicmd, &sas_ha->eh_done_q);
-        spin_unlock_irqrestore(&task->task_state_lock, flags);
+        spin_unlock_irqrestore(ap->lock, flags);
 
 qc_already_gone:
         list_del_init(&task->list);
@@ -170,23 +177,30 @@ qc_already_gone:
 
 static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc)
 {
-        int res;
+        unsigned long flags;
         struct sas_task *task;
-        struct domain_device *dev = qc->ap->private_data;
+        struct scatterlist *sg;
+        int ret = AC_ERR_SYSTEM;
+        unsigned int si, xfer = 0;
+        struct ata_port *ap = qc->ap;
+        struct domain_device *dev = ap->private_data;
         struct sas_ha_struct *sas_ha = dev->port->ha;
         struct Scsi_Host *host = sas_ha->core.shost;
         struct sas_internal *i = to_sas_internal(host->transportt);
-        struct scatterlist *sg;
-        unsigned int xfer = 0;
-        unsigned int si;
+
+        /* TODO: audit callers to ensure they are ready for qc_issue to
+         * unconditionally re-enable interrupts
+         */
+        local_irq_save(flags);
+        spin_unlock(ap->lock);
 
         /* If the device fell off, no sense in issuing commands */
-        if (dev->gone)
-                return AC_ERR_SYSTEM;
+        if (test_bit(SAS_DEV_GONE, &dev->state))
+                goto out;
 
         task = sas_alloc_task(GFP_ATOMIC);
         if (!task)
-                return AC_ERR_SYSTEM;
+                goto out;
         task->dev = dev;
         task->task_proto = SAS_PROTOCOL_STP;
         task->task_done = sas_ata_task_done;
@@ -231,21 +245,24 @@ static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc)
                 ASSIGN_SAS_TASK(qc->scsicmd, task);
 
         if (sas_ha->lldd_max_execute_num < 2)
-                res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC);
+                ret = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC);
         else
-                res = sas_queue_up(task);
+                ret = sas_queue_up(task);
 
         /* Examine */
-        if (res) {
-                SAS_DPRINTK("lldd_execute_task returned: %d\n", res);
+        if (ret) {
+                SAS_DPRINTK("lldd_execute_task returned: %d\n", ret);
 
                 if (qc->scsicmd)
                         ASSIGN_SAS_TASK(qc->scsicmd, NULL);
                 sas_free_task(task);
-                return AC_ERR_SYSTEM;
+                ret = AC_ERR_SYSTEM;
         }
 
-        return 0;
+ out:
+        spin_lock(ap->lock);
+        local_irq_restore(flags);
+        return ret;
 }
 
 static bool sas_ata_qc_fill_rtf(struct ata_queued_cmd *qc)
@@ -256,83 +273,222 @@ static bool sas_ata_qc_fill_rtf(struct ata_queued_cmd *qc)
         return true;
 }
 
-static int sas_ata_hard_reset(struct ata_link *link, unsigned int *class,
-                               unsigned long deadline)
+static struct sas_internal *dev_to_sas_internal(struct domain_device *dev)
+{
+        return to_sas_internal(dev->port->ha->core.shost->transportt);
+}
+
+static void sas_get_ata_command_set(struct domain_device *dev);
+
+int sas_get_ata_info(struct domain_device *dev, struct ex_phy *phy)
 {
+        if (phy->attached_tproto & SAS_PROTOCOL_STP)
+                dev->tproto = phy->attached_tproto;
+        if (phy->attached_sata_dev)
+                dev->tproto |= SATA_DEV;
+
+        if (phy->attached_dev_type == SATA_PENDING)
+                dev->dev_type = SATA_PENDING;
+        else {
+                int res;
+
+                dev->dev_type = SATA_DEV;
+                res = sas_get_report_phy_sata(dev->parent, phy->phy_id,
+                                              &dev->sata_dev.rps_resp);
+                if (res) {
+                        SAS_DPRINTK("report phy sata to %016llx:0x%x returned "
+                                    "0x%x\n", SAS_ADDR(dev->parent->sas_addr),
+                                    phy->phy_id, res);
+                        return res;
+                }
+                memcpy(dev->frame_rcvd, &dev->sata_dev.rps_resp.rps.fis,
+                       sizeof(struct dev_to_host_fis));
+                /* TODO switch to ata_dev_classify() */
+                sas_get_ata_command_set(dev);
+        }
+        return 0;
+}
+
+static int sas_ata_clear_pending(struct domain_device *dev, struct ex_phy *phy)
+{
+        int res;
+
+        /* we weren't pending, so successfully end the reset sequence now */
+        if (dev->dev_type != SATA_PENDING)
+                return 1;
+
+        /* hmmm, if this succeeds do we need to repost the domain_device to the
+         * lldd so it can pick up new parameters?
+         */
+        res = sas_get_ata_info(dev, phy);
+        if (res)
+                return 0; /* retry */
+        else
+                return 1;
+}
+
+static int smp_ata_check_ready(struct ata_link *link)
+{
+        int res;
         struct ata_port *ap = link->ap;
         struct domain_device *dev = ap->private_data;
-        struct sas_internal *i =
-                to_sas_internal(dev->port->ha->core.shost->transportt);
-        int res = TMF_RESP_FUNC_FAILED;
-        int ret = 0;
+        struct domain_device *ex_dev = dev->parent;
+        struct sas_phy *phy = sas_get_local_phy(dev);
+        struct ex_phy *ex_phy = &ex_dev->ex_dev.ex_phy[phy->number];
 
-        if (i->dft->lldd_I_T_nexus_reset)
-                res = i->dft->lldd_I_T_nexus_reset(dev);
+        res = sas_ex_phy_discover(ex_dev, phy->number);
+        sas_put_local_phy(phy);
 
-        if (res != TMF_RESP_FUNC_COMPLETE) {
-                SAS_DPRINTK("%s: Unable to reset I T nexus?\n", __func__);
-                ret = -EAGAIN;
+        /* break the wait early if the expander is unreachable,
+         * otherwise keep polling
+         */
+        if (res == -ECOMM)
+                return res;
+        if (res != SMP_RESP_FUNC_ACC)
+                return 0;
+
+        switch (ex_phy->attached_dev_type) {
+        case SATA_PENDING:
+                return 0;
+        case SAS_END_DEV:
+                if (ex_phy->attached_sata_dev)
+                        return sas_ata_clear_pending(dev, ex_phy);
+        default:
+                return -ENODEV;
         }
+}
 
-        switch (dev->sata_dev.command_set) {
-                case ATA_COMMAND_SET:
-                        SAS_DPRINTK("%s: Found ATA device.\n", __func__);
-                        *class = ATA_DEV_ATA;
-                        break;
-                case ATAPI_COMMAND_SET:
-                        SAS_DPRINTK("%s: Found ATAPI device.\n", __func__);
-                        *class = ATA_DEV_ATAPI;
-                        break;
-                default:
-                        SAS_DPRINTK("%s: Unknown SATA command set: %d.\n",
-                                    __func__,
-                                    dev->sata_dev.command_set);
-                        *class = ATA_DEV_UNKNOWN;
-                        break;
+static int local_ata_check_ready(struct ata_link *link)
+{
+        struct ata_port *ap = link->ap;
+        struct domain_device *dev = ap->private_data;
+        struct sas_internal *i = dev_to_sas_internal(dev);
+
+        if (i->dft->lldd_ata_check_ready)
+                return i->dft->lldd_ata_check_ready(dev);
+        else {
+                /* lldd's that don't implement 'ready' checking get the
+                 * old default behavior of not coordinating reset
+                 * recovery with libata
+                 */
+                return 1;
         }
+}
 
-        ap->cbl = ATA_CBL_SATA;
-        return ret;
+static int sas_ata_printk(const char *level, const struct domain_device *ddev,
+                          const char *fmt, ...)
+{
+        struct ata_port *ap = ddev->sata_dev.ap;
+        struct device *dev = &ddev->rphy->dev;
+        struct va_format vaf;
+        va_list args;
+        int r;
+
+        va_start(args, fmt);
+
+        vaf.fmt = fmt;
+        vaf.va = &args;
+
+        r = printk("%ssas: ata%u: %s: %pV",
+                   level, ap->print_id, dev_name(dev), &vaf);
+
+        va_end(args);
+
+        return r;
 }
 
-static int sas_ata_soft_reset(struct ata_link *link, unsigned int *class,
-                               unsigned long deadline)
+static int sas_ata_hard_reset(struct ata_link *link, unsigned int *class,
+                              unsigned long deadline)
 {
+        int ret = 0, res;
+        struct sas_phy *phy;
         struct ata_port *ap = link->ap;
+        int (*check_ready)(struct ata_link *link);
         struct domain_device *dev = ap->private_data;
-        struct sas_internal *i =
-                to_sas_internal(dev->port->ha->core.shost->transportt);
-        int res = TMF_RESP_FUNC_FAILED;
-        int ret = 0;
+        struct sas_internal *i = dev_to_sas_internal(dev);
 
-        if (i->dft->lldd_ata_soft_reset)
-                res = i->dft->lldd_ata_soft_reset(dev);
+        res = i->dft->lldd_I_T_nexus_reset(dev);
+        if (res == -ENODEV)
+                return res;
 
-        if (res != TMF_RESP_FUNC_COMPLETE) {
-                SAS_DPRINTK("%s: Unable to soft reset\n", __func__);
-                ret = -EAGAIN;
-        }
+        if (res != TMF_RESP_FUNC_COMPLETE)
+                sas_ata_printk(KERN_DEBUG, dev, "Unable to reset ata device?\n");
+
+        phy = sas_get_local_phy(dev);
+        if (scsi_is_sas_phy_local(phy))
+                check_ready = local_ata_check_ready;
+        else
+                check_ready = smp_ata_check_ready;
+        sas_put_local_phy(phy);
+
+        ret = ata_wait_after_reset(link, deadline, check_ready);
+        if (ret && ret != -EAGAIN)
+                sas_ata_printk(KERN_ERR, dev, "reset failed (errno=%d)\n", ret);
 
+        /* XXX: if the class changes during the reset the upper layer
+         * should be informed, if the device has gone away we assume
+         * libsas will eventually delete it
+         */
         switch (dev->sata_dev.command_set) {
         case ATA_COMMAND_SET:
-                SAS_DPRINTK("%s: Found ATA device.\n", __func__);
                 *class = ATA_DEV_ATA;
                 break;
         case ATAPI_COMMAND_SET:
-                SAS_DPRINTK("%s: Found ATAPI device.\n", __func__);
                 *class = ATA_DEV_ATAPI;
                 break;
-        default:
-                SAS_DPRINTK("%s: Unknown SATA command set: %d.\n",
-                            __func__, dev->sata_dev.command_set);
-                *class = ATA_DEV_UNKNOWN;
-                break;
         }
 
         ap->cbl = ATA_CBL_SATA;
         return ret;
 }
 
+/*
+ * notify the lldd to forget the sas_task for this internal ata command
+ * that bypasses scsi-eh
+ */
+static void sas_ata_internal_abort(struct sas_task *task)
+{
+        struct sas_internal *si = dev_to_sas_internal(task->dev);
+        unsigned long flags;
+        int res;
+
+        spin_lock_irqsave(&task->task_state_lock, flags);
+        if (task->task_state_flags & SAS_TASK_STATE_ABORTED ||
+            task->task_state_flags & SAS_TASK_STATE_DONE) {
+                spin_unlock_irqrestore(&task->task_state_lock, flags);
+                SAS_DPRINTK("%s: Task %p already finished.\n", __func__,
+                            task);
+                goto out;
+        }
+        task->task_state_flags |= SAS_TASK_STATE_ABORTED;
+        spin_unlock_irqrestore(&task->task_state_lock, flags);
+
+        res = si->dft->lldd_abort_task(task);
+
+        spin_lock_irqsave(&task->task_state_lock, flags);
+        if (task->task_state_flags & SAS_TASK_STATE_DONE ||
+            res == TMF_RESP_FUNC_COMPLETE) {
+                spin_unlock_irqrestore(&task->task_state_lock, flags);
+                goto out;
+        }
+
+        /* XXX we are not prepared to deal with ->lldd_abort_task()
+         * failures.  TODO: lldds need to unconditionally forget about
+         * aborted ata tasks, otherwise we (likely) leak the sas task
+         * here
+         */
+        SAS_DPRINTK("%s: Task %p leaked.\n", __func__, task);
+
+        if (!(task->task_state_flags & SAS_TASK_STATE_DONE))
+                task->task_state_flags &= ~SAS_TASK_STATE_ABORTED;
+        spin_unlock_irqrestore(&task->task_state_lock, flags);
+
+        return;
+ out:
+        list_del_init(&task->list);
+        sas_free_task(task);
+}
+
 static void sas_ata_post_internal(struct ata_queued_cmd *qc)
 {
         if (qc->flags & ATA_QCFLAG_FAILED)
@@ -340,30 +496,35 @@ static void sas_ata_post_internal(struct ata_queued_cmd *qc)
 
         if (qc->err_mask) {
                 /*
-                 * Find the sas_task and kill it.  By this point,
-                 * libata has decided to kill the qc, so we needn't
-                 * bother with sas_ata_task_done.  But we still
-                 * ought to abort the task.
+                 * Find the sas_task and kill it.  By this point, libata
+                 * has decided to kill the qc and has frozen the port.
+                 * In this state sas_ata_task_done() will no longer free
+                 * the sas_task, so we need to notify the lldd (via
+                 * ->lldd_abort_task) that the task is dead and free it
+                 *  ourselves.
                  */
                 struct sas_task *task = qc->lldd_task;
-                unsigned long flags;
 
                 qc->lldd_task = NULL;
-                if (task) {
-                        /* Should this be a AT(API) device reset? */
-                        spin_lock_irqsave(&task->task_state_lock, flags);
-                        task->task_state_flags |= SAS_TASK_NEED_DEV_RESET;
-                        spin_unlock_irqrestore(&task->task_state_lock, flags);
-
-                        task->uldd_task = NULL;
-                        __sas_task_abort(task);
-                }
+                if (!task)
+                        return;
+                task->uldd_task = NULL;
+                sas_ata_internal_abort(task);
         }
 }
 
+
+static void sas_ata_set_dmamode(struct ata_port *ap, struct ata_device *ata_dev)
+{
+        struct domain_device *dev = ap->private_data;
+        struct sas_internal *i = dev_to_sas_internal(dev);
+
+        if (i->dft->lldd_ata_set_dmamode)
+                i->dft->lldd_ata_set_dmamode(dev);
+}
+
 static struct ata_port_operations sas_sata_ops = {
         .prereset               = ata_std_prereset,
-        .softreset              = sas_ata_soft_reset,
         .hardreset              = sas_ata_hard_reset,
         .postreset              = ata_std_postreset,
         .error_handler          = ata_std_error_handler,
@@ -374,6 +535,7 @@ static struct ata_port_operations sas_sata_ops = {
         .qc_fill_rtf            = sas_ata_qc_fill_rtf,
         .port_start             = ata_sas_port_start,
         .port_stop              = ata_sas_port_stop,
+        .set_dmamode            = sas_ata_set_dmamode,
 };
 
 static struct ata_port_info sata_port_info = {
@@ -384,11 +546,10 @@ static struct ata_port_info sata_port_info = {
         .port_ops = &sas_sata_ops
 };
 
-int sas_ata_init_host_and_port(struct domain_device *found_dev,
-                               struct scsi_target *starget)
+int sas_ata_init_host_and_port(struct domain_device *found_dev)
 {
-        struct Scsi_Host *shost = dev_to_shost(&starget->dev);
-        struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
+        struct sas_ha_struct *ha = found_dev->port->ha;
+        struct Scsi_Host *shost = ha->core.shost;
         struct ata_port *ap;
 
         ata_host_init(&found_dev->sata_dev.ata_host,
@@ -406,6 +567,8 @@ int sas_ata_init_host_and_port(struct domain_device *found_dev,
         ap->private_data = found_dev;
         ap->cbl = ATA_CBL_SATA;
         ap->scsi_host = shost;
+        /* publish initialized ata port */
+        smp_wmb();
         found_dev->sata_dev.ap = ap;
 
         return 0;
@@ -436,168 +599,14 @@ void sas_ata_task_abort(struct sas_task *task)
         complete(waiting);
 }
 
-static void sas_task_timedout(unsigned long _task)
-{
-        struct sas_task *task = (void *) _task;
-        unsigned long flags;
-
-        spin_lock_irqsave(&task->task_state_lock, flags);
-        if (!(task->task_state_flags & SAS_TASK_STATE_DONE))
-                task->task_state_flags |= SAS_TASK_STATE_ABORTED;
-        spin_unlock_irqrestore(&task->task_state_lock, flags);
-
-        complete(&task->completion);
-}
-
-static void sas_disc_task_done(struct sas_task *task)
-{
-        if (!del_timer(&task->timer))
-                return;
-        complete(&task->completion);
-}
-
-#define SAS_DEV_TIMEOUT 10
-
-/**
- * sas_execute_task -- Basic task processing for discovery
- * @task: the task to be executed
- * @buffer: pointer to buffer to do I/O
- * @size: size of @buffer
- * @dma_dir: DMA direction.  DMA_xxx
- */
-static int sas_execute_task(struct sas_task *task, void *buffer, int size,
-                            enum dma_data_direction dma_dir)
-{
-        int res = 0;
-        struct scatterlist *scatter = NULL;
-        struct task_status_struct *ts = &task->task_status;
-        int num_scatter = 0;
-        int retries = 0;
-        struct sas_internal *i =
-                to_sas_internal(task->dev->port->ha->core.shost->transportt);
-
-        if (dma_dir != DMA_NONE) {
-                scatter = kzalloc(sizeof(*scatter), GFP_KERNEL);
-                if (!scatter)
-                        goto out;
-
-                sg_init_one(scatter, buffer, size);
-                num_scatter = 1;
-        }
-
-        task->task_proto = task->dev->tproto;
-        task->scatter = scatter;
-        task->num_scatter = num_scatter;
-        task->total_xfer_len = size;
-        task->data_dir = dma_dir;
-        task->task_done = sas_disc_task_done;
-        if (dma_dir != DMA_NONE &&
-            sas_protocol_ata(task->task_proto)) {
-                task->num_scatter = dma_map_sg(task->dev->port->ha->dev,
-                                               task->scatter,
-                                               task->num_scatter,
-                                               task->data_dir);
-        }
-
-        for (retries = 0; retries < 5; retries++) {
-                task->task_state_flags = SAS_TASK_STATE_PENDING;
-                init_completion(&task->completion);
-
-                task->timer.data = (unsigned long) task;
-                task->timer.function = sas_task_timedout;
-                task->timer.expires = jiffies + SAS_DEV_TIMEOUT*HZ;
-                add_timer(&task->timer);
-
-                res = i->dft->lldd_execute_task(task, 1, GFP_KERNEL);
-                if (res) {
-                        del_timer(&task->timer);
-                        SAS_DPRINTK("executing SAS discovery task failed:%d\n",
-                                    res);
-                        goto ex_err;
-                }
-                wait_for_completion(&task->completion);
-                res = -ECOMM;
-                if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
-                        int res2;
-                        SAS_DPRINTK("task aborted, flags:0x%x\n",
-                                    task->task_state_flags);
-                        res2 = i->dft->lldd_abort_task(task);
-                        SAS_DPRINTK("came back from abort task\n");
-                        if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
-                                if (res2 == TMF_RESP_FUNC_COMPLETE)
-                                        continue; /* Retry the task */
-                                else
-                                        goto ex_err;
-                        }
-                }
-                if (task->task_status.stat == SAM_STAT_BUSY ||
-                           task->task_status.stat == SAM_STAT_TASK_SET_FULL ||
-                           task->task_status.stat == SAS_QUEUE_FULL) {
-                        SAS_DPRINTK("task: q busy, sleeping...\n");
-                        schedule_timeout_interruptible(HZ);
-                } else if (task->task_status.stat == SAM_STAT_CHECK_CONDITION) {
-                        struct scsi_sense_hdr shdr;
-
-                        if (!scsi_normalize_sense(ts->buf, ts->buf_valid_size,
-                                                  &shdr)) {
-                                SAS_DPRINTK("couldn't normalize sense\n");
-                                continue;
-                        }
-                        if ((shdr.sense_key == 6 && shdr.asc == 0x29) ||
-                            (shdr.sense_key == 2 && shdr.asc == 4 &&
-                             shdr.ascq == 1)) {
-                                SAS_DPRINTK("device %016llx LUN: %016llx "
-                                            "powering up or not ready yet, "
-                                            "sleeping...\n",
-                                            SAS_ADDR(task->dev->sas_addr),
-                                            SAS_ADDR(task->ssp_task.LUN));
-
-                                schedule_timeout_interruptible(5*HZ);
-                        } else if (shdr.sense_key == 1) {
-                                res = 0;
-                                break;
-                        } else if (shdr.sense_key == 5) {
-                                break;
-                        } else {
-                                SAS_DPRINTK("dev %016llx LUN: %016llx "
-                                            "sense key:0x%x ASC:0x%x ASCQ:0x%x"
-                                            "\n",
-                                            SAS_ADDR(task->dev->sas_addr),
-                                            SAS_ADDR(task->ssp_task.LUN),
-                                            shdr.sense_key,
-                                            shdr.asc, shdr.ascq);
-                        }
-                } else if (task->task_status.resp != SAS_TASK_COMPLETE ||
-                           task->task_status.stat != SAM_STAT_GOOD) {
-                        SAS_DPRINTK("task finished with resp:0x%x, "
-                                    "stat:0x%x\n",
-                                    task->task_status.resp,
-                                    task->task_status.stat);
-                        goto ex_err;
-                } else {
-                        res = 0;
-                        break;
-                }
-        }
-ex_err:
-        if (dma_dir != DMA_NONE) {
-                if (sas_protocol_ata(task->task_proto))
-                        dma_unmap_sg(task->dev->port->ha->dev,
-                                     task->scatter, task->num_scatter,
-                                     task->data_dir);
-                kfree(scatter);
-        }
-out:
-        return res;
-}
-
-/* ---------- SATA ---------- */
-
 static void sas_get_ata_command_set(struct domain_device *dev)
 {
         struct dev_to_host_fis *fis =
                 (struct dev_to_host_fis *) dev->frame_rcvd;
 
+        if (dev->dev_type == SATA_PENDING)
+                return;
+
         if ((fis->sector_count == 1 && /* ATA */
              fis->lbal         == 1 &&
              fis->lbam         == 0 &&
@@ -636,224 +645,152 @@ static void sas_get_ata_command_set(struct domain_device *dev)
                 dev->sata_dev.command_set = ATAPI_COMMAND_SET;
 }
 
-/**
- * sas_issue_ata_cmd -- Basic SATA command processing for discovery
- * @dev: the device to send the command to
- * @command: the command register
- * @features: the features register
- * @buffer: pointer to buffer to do I/O
- * @size: size of @buffer
- * @dma_dir: DMA direction.  DMA_xxx
- */
-static int sas_issue_ata_cmd(struct domain_device *dev, u8 command,
-                             u8 features, void *buffer, int size,
-                             enum dma_data_direction dma_dir)
-{
-        int res = 0;
-        struct sas_task *task;
-        struct dev_to_host_fis *d2h_fis = (struct dev_to_host_fis *)
-                &dev->frame_rcvd[0];
-
-        res = -ENOMEM;
-        task = sas_alloc_task(GFP_KERNEL);
-        if (!task)
-                goto out;
-
-        task->dev = dev;
-
-        task->ata_task.fis.fis_type = 0x27;
-        task->ata_task.fis.command = command;
-        task->ata_task.fis.features = features;
-        task->ata_task.fis.device = d2h_fis->device;
-        task->ata_task.retry_count = 1;
-
-        res = sas_execute_task(task, buffer, size, dma_dir);
-
-        sas_free_task(task);
-out:
-        return res;
-}
-
-#define ATA_IDENTIFY_DEV         0xEC
-#define ATA_IDENTIFY_PACKET_DEV  0xA1
-#define ATA_SET_FEATURES         0xEF
-#define ATA_FEATURE_PUP_STBY_SPIN_UP 0x07
-
-/**
- * sas_discover_sata_dev -- discover a STP/SATA device (SATA_DEV)
- * @dev: STP/SATA device of interest (ATA/ATAPI)
- *
- * The LLDD has already been notified of this device, so that we can
- * send FISes to it.  Here we try to get IDENTIFY DEVICE or IDENTIFY
- * PACKET DEVICE, if ATAPI device, so that the LLDD can fine-tune its
- * performance for this device.
- */
-static int sas_discover_sata_dev(struct domain_device *dev)
+void sas_probe_sata(struct asd_sas_port *port)
 {
-        int     res;
-        __le16  *identify_x;
-        u8      command;
+        struct domain_device *dev, *n;
+        int err;
 
-        identify_x = kzalloc(512, GFP_KERNEL);
-        if (!identify_x)
-                return -ENOMEM;
-
-        if (dev->sata_dev.command_set == ATA_COMMAND_SET) {
-                dev->sata_dev.identify_device = identify_x;
-                command = ATA_IDENTIFY_DEV;
-        } else {
-                dev->sata_dev.identify_packet_device = identify_x;
-                command = ATA_IDENTIFY_PACKET_DEV;
-        }
+        mutex_lock(&port->ha->disco_mutex);
+        list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) {
+                if (!dev_is_sata(dev))
+                        continue;
 
-        res = sas_issue_ata_cmd(dev, command, 0, identify_x, 512,
-                                DMA_FROM_DEVICE);
-        if (res)
-                goto out_err;
-
-        /* lives on the media? */
-        if (le16_to_cpu(identify_x[0]) & 4) {
-                /* incomplete response */
-                SAS_DPRINTK("sending SET FEATURE/PUP_STBY_SPIN_UP to "
-                            "dev %llx\n", SAS_ADDR(dev->sas_addr));
-                if (!(identify_x[83] & cpu_to_le16(1<<6)))
-                        goto cont1;
-                res = sas_issue_ata_cmd(dev, ATA_SET_FEATURES,
-                                        ATA_FEATURE_PUP_STBY_SPIN_UP,
-                                        NULL, 0, DMA_NONE);
-                if (res)
-                        goto cont1;
-
-                schedule_timeout_interruptible(5*HZ); /* More time? */
-                res = sas_issue_ata_cmd(dev, command, 0, identify_x, 512,
-                                        DMA_FROM_DEVICE);
-                if (res)
-                        goto out_err;
+                err = sas_ata_init_host_and_port(dev);
+                if (err)
+                        sas_fail_probe(dev, __func__, err);
+                else
+                        ata_sas_async_port_init(dev->sata_dev.ap);
         }
-cont1:
-        /* XXX Hint: register this SATA device with SATL.
-           When this returns, dev->sata_dev->lu is alive and
-           present.
-        sas_satl_register_dev(dev);
-        */
+        mutex_unlock(&port->ha->disco_mutex);
 
-        sas_fill_in_rphy(dev, dev->rphy);
+        list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) {
+                if (!dev_is_sata(dev))
+                        continue;
 
-        return 0;
-out_err:
-        dev->sata_dev.identify_packet_device = NULL;
-        dev->sata_dev.identify_device = NULL;
-        kfree(identify_x);
-        return res;
-}
+                sas_ata_wait_eh(dev);
 
-static int sas_discover_sata_pm(struct domain_device *dev)
-{
-        return -ENODEV;
+                /* if libata could not bring the link up, don't surface
+                 * the device
+                 */
+                if (ata_dev_disabled(sas_to_ata_dev(dev)))
+                        sas_fail_probe(dev, __func__, -ENODEV);
+        }
 }
 
 /**
  * sas_discover_sata -- discover an STP/SATA domain device
  * @dev: pointer to struct domain_device of interest
  *
- * First we notify the LLDD of this device, so we can send frames to
- * it.  Then depending on the type of device we call the appropriate
- * discover functions.  Once device discover is done, we notify the
- * LLDD so that it can fine-tune its parameters for the device, by
- * removing it and then adding it.  That is, the second time around,
- * the driver would have certain fields, that it is looking at, set.
- * Finally we initialize the kobj so that the device can be added to
- * the system at registration time.  Devices directly attached to a HA
- * port, have no parents.  All other devices do, and should have their
- * "parent" pointer set appropriately before calling this function.
+ * Devices directly attached to a HA port, have no parents.  All other
+ * devices do, and should have their "parent" pointer set appropriately
+ * before calling this function.
  */
 int sas_discover_sata(struct domain_device *dev)
 {
         int res;
 
+        if (dev->dev_type == SATA_PM)
+                return -ENODEV;
+
         sas_get_ata_command_set(dev);
+        sas_fill_in_rphy(dev, dev->rphy);
 
         res = sas_notify_lldd_dev_found(dev);
         if (res)
                 return res;
 
-        switch (dev->dev_type) {
-        case SATA_DEV:
-                res = sas_discover_sata_dev(dev);
-                break;
-        case SATA_PM:
-                res = sas_discover_sata_pm(dev);
-                break;
-        default:
-                break;
-        }
-        sas_notify_lldd_dev_gone(dev);
-        if (!res) {
-                sas_notify_lldd_dev_found(dev);
-                res = sas_rphy_add(dev->rphy);
-        }
-
-        return res;
+        sas_discover_event(dev->port, DISCE_PROBE);
+        return 0;
 }
 
-void sas_ata_strategy_handler(struct Scsi_Host *shost)
+static void async_sas_ata_eh(void *data, async_cookie_t cookie)
 {
-        struct scsi_device *sdev;
+        struct domain_device *dev = data;
+        struct ata_port *ap = dev->sata_dev.ap;
+        struct sas_ha_struct *ha = dev->port->ha;
 
-        shost_for_each_device(sdev, shost) {
-                struct domain_device *ddev = sdev_to_domain_dev(sdev);
-                struct ata_port *ap = ddev->sata_dev.ap;
+        /* hold a reference over eh since we may be racing with final
+         * remove once all commands are completed
+         */
+        kref_get(&dev->kref);
+        sas_ata_printk(KERN_DEBUG, dev, "dev error handler\n");
+        ata_scsi_port_error_handler(ha->core.shost, ap);
+        sas_put_device(dev);
+}
 
-                if (!dev_is_sata(ddev))
-                        continue;
+static bool sas_ata_dev_eh_valid(struct domain_device *dev)
+{
+        struct ata_port *ap;
 
-                ata_port_printk(ap, KERN_DEBUG, "sas eh calling libata port error handler");
-                ata_scsi_port_error_handler(shost, ap);
-        }
+        if (!dev_is_sata(dev))
+                return false;
+        ap = dev->sata_dev.ap;
+        /* consume fully initialized ata ports */
+        smp_rmb();
+        return !!ap;
 }
 
-int sas_ata_timed_out(struct scsi_cmnd *cmd, struct sas_task *task,
-                      enum blk_eh_timer_return *rtn)
+void sas_ata_strategy_handler(struct Scsi_Host *shost)
 {
-        struct domain_device *ddev = cmd_to_domain_dev(cmd);
+        struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
+        LIST_HEAD(async);
+        int i;
+
+        /* it's ok to defer revalidation events during ata eh, these
+         * disks are in one of three states:
+         * 1/ present for initial domain discovery, and these
+         *    resets will cause bcn flutters
+         * 2/ hot removed, we'll discover that after eh fails
+         * 3/ hot added after initial discovery, lost the race, and need
+         *    to catch the next train.
+         */
+        sas_disable_revalidation(sas_ha);
 
-        if (!dev_is_sata(ddev) || task)
-                return 0;
+        spin_lock_irq(&sas_ha->phy_port_lock);
+        for (i = 0; i < sas_ha->num_phys; i++) {
+                struct asd_sas_port *port = sas_ha->sas_port[i];
+                struct domain_device *dev;
 
-        /* we're a sata device with no task, so this must be a libata
-         * eh timeout.  Ideally should hook into libata timeout
-         * handling, but there's no point, it just wants to activate
-         * the eh thread */
-        *rtn = BLK_EH_NOT_HANDLED;
-        return 1;
+                spin_lock(&port->dev_list_lock);
+                list_for_each_entry(dev, &port->dev_list, dev_list_node) {
+                        if (!sas_ata_dev_eh_valid(dev))
+                                continue;
+                        async_schedule_domain(async_sas_ata_eh, dev, &async);
+                }
+                spin_unlock(&port->dev_list_lock);
+        }
+        spin_unlock_irq(&sas_ha->phy_port_lock);
+
+        async_synchronize_full_domain(&async);
+
+        sas_enable_revalidation(sas_ha);
 }
 
-int sas_ata_eh(struct Scsi_Host *shost, struct list_head *work_q,
-               struct list_head *done_q)
+void sas_ata_eh(struct Scsi_Host *shost, struct list_head *work_q,
+                struct list_head *done_q)
 {
-        int rtn = 0;
         struct scsi_cmnd *cmd, *n;
-        struct ata_port *ap;
+        struct domain_device *eh_dev;
 
         do {
                 LIST_HEAD(sata_q);
-
-                ap = NULL;
+                eh_dev = NULL;
 
                 list_for_each_entry_safe(cmd, n, work_q, eh_entry) {
                         struct domain_device *ddev = cmd_to_domain_dev(cmd);
 
                         if (!dev_is_sata(ddev) || TO_SAS_TASK(cmd))
                                 continue;
-                        if (ap && ap != ddev->sata_dev.ap)
+                        if (eh_dev && eh_dev != ddev)
                                 continue;
-                        ap = ddev->sata_dev.ap;
-                        rtn = 1;
+                        eh_dev = ddev;
                         list_move(&cmd->eh_entry, &sata_q);
                 }
 
                 if (!list_empty(&sata_q)) {
-                        ata_port_printk(ap, KERN_DEBUG, "sas eh calling libata cmd error handler\n");
+                        struct ata_port *ap = eh_dev->sata_dev.ap;
+
+                        sas_ata_printk(KERN_DEBUG, eh_dev, "cmd error handler\n");
                         ata_scsi_cmd_error_handler(shost, ap, &sata_q);
                         /*
                          * ata's error handler may leave the cmd on the list
@@ -869,7 +806,36 @@ int sas_ata_eh(struct Scsi_Host *shost, struct list_head *work_q,
                         while (!list_empty(&sata_q))
                                 list_del_init(sata_q.next);
                 }
-        } while (ap);
+        } while (eh_dev);
+}
+
+void sas_ata_schedule_reset(struct domain_device *dev)
+{
+        struct ata_eh_info *ehi;
+        struct ata_port *ap;
+        unsigned long flags;
+
+        if (!dev_is_sata(dev))
+                return;
+
+        ap = dev->sata_dev.ap;
+        ehi = &ap->link.eh_info;
+
+        spin_lock_irqsave(ap->lock, flags);
+        ehi->err_mask |= AC_ERR_TIMEOUT;
+        ehi->action |= ATA_EH_RESET;
+        ata_port_schedule_eh(ap);
+        spin_unlock_irqrestore(ap->lock, flags);
+}
+EXPORT_SYMBOL_GPL(sas_ata_schedule_reset);
+
+void sas_ata_wait_eh(struct domain_device *dev)
+{
+        struct ata_port *ap;
+
+        if (!dev_is_sata(dev))
+                return;
 
-        return rtn;
+        ap = dev->sata_dev.ap;
+        ata_port_wait_eh(ap);
 }