Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound-2.6

[linux-2.6-omap-h63xx.git] / drivers / pci / pci-driver.c

diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index b4cdd690ae71ca9d05811a6ce6cd9bcd0de15b20..99d867bcf22aba89ba52e911b641757f6d971fc9 100644 (file)
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -300,6 +300,14 @@ static void pci_device_shutdown(struct device *dev)
 
 #ifdef CONFIG_PM_SLEEP
 
+static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
+{
+       struct pci_driver *drv = pci_dev->driver;
+
+       return drv && (drv->suspend || drv->suspend_late || drv->resume
+               || drv->resume_early);
+}
+
 /*
  * Default "suspend" method for devices that have no driver provided suspend,
  * or not even a driver at all.
@@ -317,14 +325,22 @@ static void pci_default_pm_suspend(struct pci_dev *pci_dev)
 
 /*
  * Default "resume" method for devices that have no driver provided resume,
- * or not even a driver at all.
+ * or not even a driver at all (first part).
  */
-static int pci_default_pm_resume(struct pci_dev *pci_dev)
+static void pci_default_pm_resume_early(struct pci_dev *pci_dev)
 {
-       int retval = 0;
-
        /* restore the PCI config space */
        pci_restore_state(pci_dev);
+}
+
+/*
+ * Default "resume" method for devices that have no driver provided resume,
+ * or not even a driver at all (second part).
+ */
+static int pci_default_pm_resume_late(struct pci_dev *pci_dev)
+{
+       int retval;
+
        /* if the device was enabled before suspend, reenable */
        retval = pci_reenable_device(pci_dev);
        /*
@@ -371,10 +387,12 @@ static int pci_legacy_resume(struct device *dev)
        struct pci_dev * pci_dev = to_pci_dev(dev);
        struct pci_driver * drv = pci_dev->driver;
 
-       if (drv && drv->resume)
+       if (drv && drv->resume) {
                error = drv->resume(pci_dev);
-       else
-               error = pci_default_pm_resume(pci_dev);
+       } else {
+               pci_default_pm_resume_early(pci_dev);
+               error = pci_default_pm_resume_late(pci_dev);
+       }
        return error;
 }
 
@@ -420,10 +438,8 @@ static int pci_pm_suspend(struct device *dev)
                if (drv->pm->suspend) {
                        error = drv->pm->suspend(dev);
                        suspend_report_result(drv->pm->suspend, error);
-               } else {
-                       pci_default_pm_suspend(pci_dev);
                }
-       } else {
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_suspend(dev, PMSG_SUSPEND);
        }
        pci_fixup_device(pci_fixup_suspend, pci_dev);
@@ -434,7 +450,7 @@ static int pci_pm_suspend(struct device *dev)
 static int pci_pm_suspend_noirq(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct device_driver *drv = dev->driver;
        int error = 0;
 
        if (drv && drv->pm) {
@@ -442,8 +458,10 @@ static int pci_pm_suspend_noirq(struct device *dev)
                        error = drv->pm->suspend_noirq(dev);
                        suspend_report_result(drv->pm->suspend_noirq, error);
                }
-       } else {
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_suspend_late(dev, PMSG_SUSPEND);
+       } else {
+               pci_default_pm_suspend(pci_dev);
        }
 
        return error;
@@ -453,15 +471,17 @@ static int pci_pm_resume(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
        struct device_driver *drv = dev->driver;
-       int error;
+       int error = 0;
 
        pci_fixup_device(pci_fixup_resume, pci_dev);
 
        if (drv && drv->pm) {
-               error = drv->pm->resume ? drv->pm->resume(dev) :
-                       pci_default_pm_resume(pci_dev);
-       } else {
+               if (drv->pm->resume)
+                       error = drv->pm->resume(dev);
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_resume(dev);
+       } else {
+               error = pci_default_pm_resume_late(pci_dev);
        }
 
        return error;
@@ -470,16 +490,18 @@ static int pci_pm_resume(struct device *dev)
 static int pci_pm_resume_noirq(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct device_driver *drv = dev->driver;
        int error = 0;
 
-       pci_fixup_device(pci_fixup_resume_early, pci_dev);
+       pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
 
        if (drv && drv->pm) {
                if (drv->pm->resume_noirq)
                        error = drv->pm->resume_noirq(dev);
-       } else {
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_resume_early(dev);
+       } else {
+               pci_default_pm_resume_early(pci_dev);
        }
 
        return error;
@@ -506,10 +528,8 @@ static int pci_pm_freeze(struct device *dev)
                if (drv->pm->freeze) {
                        error = drv->pm->freeze(dev);
                        suspend_report_result(drv->pm->freeze, error);
-               } else {
-                       pci_default_pm_suspend(pci_dev);
                }
-       } else {
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_suspend(dev, PMSG_FREEZE);
                pci_fixup_device(pci_fixup_suspend, pci_dev);
        }
@@ -520,7 +540,7 @@ static int pci_pm_freeze(struct device *dev)
 static int pci_pm_freeze_noirq(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct device_driver *drv = dev->driver;
        int error = 0;
 
        if (drv && drv->pm) {
@@ -528,8 +548,10 @@ static int pci_pm_freeze_noirq(struct device *dev)
                        error = drv->pm->freeze_noirq(dev);
                        suspend_report_result(drv->pm->freeze_noirq, error);
                }
-       } else {
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_suspend_late(dev, PMSG_FREEZE);
+       } else {
+               pci_default_pm_suspend(pci_dev);
        }
 
        return error;
@@ -537,14 +559,15 @@ static int pci_pm_freeze_noirq(struct device *dev)
 
 static int pci_pm_thaw(struct device *dev)
 {
+       struct pci_dev *pci_dev = to_pci_dev(dev);
        struct device_driver *drv = dev->driver;
        int error = 0;
 
        if (drv && drv->pm) {
                if (drv->pm->thaw)
                        error =  drv->pm->thaw(dev);
-       } else {
-               pci_fixup_device(pci_fixup_resume, to_pci_dev(dev));
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
+               pci_fixup_device(pci_fixup_resume, pci_dev);
                error = pci_legacy_resume(dev);
        }
 
@@ -554,14 +577,14 @@ static int pci_pm_thaw(struct device *dev)
 static int pci_pm_thaw_noirq(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct device_driver *drv = dev->driver;
        int error = 0;
 
        if (drv && drv->pm) {
                if (drv->pm->thaw_noirq)
                        error = drv->pm->thaw_noirq(dev);
-       } else {
-               pci_fixup_device(pci_fixup_resume_early, pci_dev);
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
+               pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
                error = pci_legacy_resume_early(dev);
        }
 
@@ -570,17 +593,18 @@ static int pci_pm_thaw_noirq(struct device *dev)
 
 static int pci_pm_poweroff(struct device *dev)
 {
+       struct pci_dev *pci_dev = to_pci_dev(dev);
        struct device_driver *drv = dev->driver;
        int error = 0;
 
-       pci_fixup_device(pci_fixup_suspend, to_pci_dev(dev));
+       pci_fixup_device(pci_fixup_suspend, pci_dev);
 
        if (drv && drv->pm) {
                if (drv->pm->poweroff) {
                        error = drv->pm->poweroff(dev);
                        suspend_report_result(drv->pm->poweroff, error);
                }
-       } else {
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_suspend(dev, PMSG_HIBERNATE);
        }
 
@@ -589,8 +613,7 @@ static int pci_pm_poweroff(struct device *dev)
 
 static int pci_pm_poweroff_noirq(struct device *dev)
 {
-       struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct device_driver *drv = dev->driver;
        int error = 0;
 
        if (drv && drv->pm) {
@@ -598,7 +621,7 @@ static int pci_pm_poweroff_noirq(struct device *dev)
                        error = drv->pm->poweroff_noirq(dev);
                        suspend_report_result(drv->pm->poweroff_noirq, error);
                }
-       } else {
+       } else if (pci_has_legacy_pm_support(to_pci_dev(dev))) {
                error = pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
        }
 
@@ -609,13 +632,15 @@ static int pci_pm_restore(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
        struct device_driver *drv = dev->driver;
-       int error;
+       int error = 0;
 
        if (drv && drv->pm) {
-               error = drv->pm->restore ? drv->pm->restore(dev) :
-                       pci_default_pm_resume(pci_dev);
-       } else {
+               if (drv->pm->restore)
+                       error = drv->pm->restore(dev);
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_resume(dev);
+       } else {
+               error = pci_default_pm_resume_late(pci_dev);
        }
        pci_fixup_device(pci_fixup_resume, pci_dev);
 
@@ -625,7 +650,7 @@ static int pci_pm_restore(struct device *dev)
 static int pci_pm_restore_noirq(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct device_driver *drv = dev->driver;
        int error = 0;
 
        pci_fixup_device(pci_fixup_resume, pci_dev);
@@ -633,8 +658,10 @@ static int pci_pm_restore_noirq(struct device *dev)
        if (drv && drv->pm) {
                if (drv->pm->restore_noirq)
                        error = drv->pm->restore_noirq(dev);
-       } else {
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_resume_early(dev);
+       } else {
+               pci_default_pm_resume_early(pci_dev);
        }
        pci_fixup_device(pci_fixup_resume_early, pci_dev);
 
@@ -654,17 +681,15 @@ static int pci_pm_restore_noirq(struct device *dev)
 
 #endif /* !CONFIG_HIBERNATION */
 
-struct pm_ext_ops pci_pm_ops = {
-       .base = {
-               .prepare = pci_pm_prepare,
-               .complete = pci_pm_complete,
-               .suspend = pci_pm_suspend,
-               .resume = pci_pm_resume,
-               .freeze = pci_pm_freeze,
-               .thaw = pci_pm_thaw,
-               .poweroff = pci_pm_poweroff,
-               .restore = pci_pm_restore,
-       },
+struct dev_pm_ops pci_dev_pm_ops = {
+       .prepare = pci_pm_prepare,
+       .complete = pci_pm_complete,
+       .suspend = pci_pm_suspend,
+       .resume = pci_pm_resume,
+       .freeze = pci_pm_freeze,
+       .thaw = pci_pm_thaw,
+       .poweroff = pci_pm_poweroff,
+       .restore = pci_pm_restore,
        .suspend_noirq = pci_pm_suspend_noirq,
        .resume_noirq = pci_pm_resume_noirq,
        .freeze_noirq = pci_pm_freeze_noirq,
@@ -673,7 +698,7 @@ struct pm_ext_ops pci_pm_ops = {
        .restore_noirq = pci_pm_restore_noirq,
 };
 
-#define PCI_PM_OPS_PTR &pci_pm_ops
+#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
 
 #else /* !CONFIG_PM_SLEEP */
 
@@ -703,9 +728,6 @@ int __pci_register_driver(struct pci_driver *drv, struct module *owner,
        drv->driver.owner = owner;
        drv->driver.mod_name = mod_name;
 
-       if (drv->pm)
-               drv->driver.pm = &drv->pm->base;
-
        spin_lock_init(&drv->dynids.lock);
        INIT_LIST_HEAD(&drv->dynids.list);