[SCSI] libsas: suspend / resume support

libsas power management routines to suspend and recover the sas domain
based on a model where the lldd is allowed and expected to be
"forgetful".

sas_suspend_ha - disable event processing allowing the lldd to take down
                 links without concern for causing hotplug events.
                 Regardless of whether the lldd actually posts link down
                 messages libsas notifies the lldd that all
                 domain_devices are gone.

sas_prep_resume_ha - on the way back up before the lldd starts link
                     training clean out any spurious events that were
                     generated on the way down, and re-enable event
                     processing

sas_resume_ha - after the lldd has started and decided that all phys
		have posted link-up events this routine is called to let
		libsas start it's own timeout of any phys that did not
		resume.  After the timeout an lldd can cancel the
                phy teardown by posting a link-up event.

Storage for ex_change_count (u16) and phy_change_count (u8) are changed
to int so they can be set to -1 to indicate 'invalidated'.

Signed-off-by: Dan Williams <dan.j.williams@intel.com>
Reviewed-by: Jacek Danecki <jacek.danecki@intel.com>
Tested-by: Maciej Patelczyk <maciej.patelczyk@intel.com>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>

1 files changed, 86 insertions, 0 deletions

diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
index a59fcdc8fd63..905ae45133fc 100644
--- a/drivers/scsi/libsas/sas_ata.c
+++ b/drivers/scsi/libsas/sas_ata.c
@@ -700,6 +700,92 @@ void sas_probe_sata(struct asd_sas_port *port)
                 if (ata_dev_disabled(sas_to_ata_dev(dev)))
                         sas_fail_probe(dev, __func__, -ENODEV);
         }
+
+}
+
+static bool sas_ata_flush_pm_eh(struct asd_sas_port *port, const char *func)
+{
+        struct domain_device *dev, *n;
+        bool retry = false;
+
+        list_for_each_entry_safe(dev, n, &port->dev_list, dev_list_node) {
+                int rc;
+
+                if (!dev_is_sata(dev))
+                        continue;
+
+                sas_ata_wait_eh(dev);
+                rc = dev->sata_dev.pm_result;
+                if (rc == -EAGAIN)
+                        retry = true;
+                else if (rc) {
+                        /* since we don't have a
+                         * ->port_{suspend|resume} routine in our
+                         *  ata_port ops, and no entanglements with
+                         *  acpi, suspend should just be mechanical trip
+                         *  through eh, catch cases where these
+                         *  assumptions are invalidated
+                         */
+                        WARN_ONCE(1, "failed %s %s error: %d\n", func,
+                                 dev_name(&dev->rphy->dev), rc);
+                }
+
+                /* if libata failed to power manage the device, tear it down */
+                if (ata_dev_disabled(sas_to_ata_dev(dev)))
+                        sas_fail_probe(dev, func, -ENODEV);
+        }
+
+        return retry;
+}
+
+void sas_suspend_sata(struct asd_sas_port *port)
+{
+        struct domain_device *dev;
+
+ retry:
+        mutex_lock(&port->ha->disco_mutex);
+        list_for_each_entry(dev, &port->dev_list, dev_list_node) {
+                struct sata_device *sata;
+
+                if (!dev_is_sata(dev))
+                        continue;
+
+                sata = &dev->sata_dev;
+                if (sata->ap->pm_mesg.event == PM_EVENT_SUSPEND)
+                        continue;
+
+                sata->pm_result = -EIO;
+                ata_sas_port_async_suspend(sata->ap, &sata->pm_result);
+        }
+        mutex_unlock(&port->ha->disco_mutex);
+
+        if (sas_ata_flush_pm_eh(port, __func__))
+                goto retry;
+}
+
+void sas_resume_sata(struct asd_sas_port *port)
+{
+        struct domain_device *dev;
+
+ retry:
+        mutex_lock(&port->ha->disco_mutex);
+        list_for_each_entry(dev, &port->dev_list, dev_list_node) {
+                struct sata_device *sata;
+
+                if (!dev_is_sata(dev))
+                        continue;
+
+                sata = &dev->sata_dev;
+                if (sata->ap->pm_mesg.event == PM_EVENT_ON)
+                        continue;
+
+                sata->pm_result = -EIO;
+                ata_sas_port_async_resume(sata->ap, &sata->pm_result);
+        }
+        mutex_unlock(&port->ha->disco_mutex);
+
+        if (sas_ata_flush_pm_eh(port, __func__))
+                goto retry;
 }
 
 /**