USB: Extend pci resume function to handle PM events

Currently, the pci_resume method has only a flag indicating whether the
system is resuming from hibernation. In order to handle all PM events like
AUTO_RESUME (runtime resume from device in D3), RESUME (system resume from
s2idle, S3 or S4 states) etc change the pci_resume method to handle all PM
events.

Signed-off-by: Basavaraj Natikar <Basavaraj.Natikar@amd.com>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Acked-by: Mathias Nyman <mathias.nyman@linux.intel.com>
Link: https://lore.kernel.org/r/20230428140056.1318981-2-Basavaraj.Natikar@amd.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index ab2f3737764e4331f3e1e9d037cb75d449c861b7..990280688b254d913d843bde17dae0a8be203778 100644 (file)
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -415,12 +415,15 @@ static int check_root_hub_suspended(struct device *dev)
        return 0;
 }
 
-static int suspend_common(struct device *dev, bool do_wakeup)
+static int suspend_common(struct device *dev, pm_message_t msg)
 {
        struct pci_dev          *pci_dev = to_pci_dev(dev);
        struct usb_hcd          *hcd = pci_get_drvdata(pci_dev);
+       bool                    do_wakeup;
        int                     retval;
 
+       do_wakeup = PMSG_IS_AUTO(msg) ? true : device_may_wakeup(dev);
+
        /* Root hub suspend should have stopped all downstream traffic,
         * and all bus master traffic.  And done so for both the interface
         * and the stub usb_device (which we check here).  But maybe it
@@ -447,7 +450,7 @@ static int suspend_common(struct device *dev, bool do_wakeup)
                                (retval == 0 && do_wakeup && hcd->shared_hcd &&
                                 HCD_WAKEUP_PENDING(hcd->shared_hcd))) {
                        if (hcd->driver->pci_resume)
-                               hcd->driver->pci_resume(hcd, false);
+                               hcd->driver->pci_resume(hcd, msg);
                        retval = -EBUSY;
                }
                if (retval)
@@ -470,7 +473,7 @@ static int suspend_common(struct device *dev, bool do_wakeup)
        return retval;
 }
 
-static int resume_common(struct device *dev, int event)
+static int resume_common(struct device *dev, pm_message_t msg)
 {
        struct pci_dev          *pci_dev = to_pci_dev(dev);
        struct usb_hcd          *hcd = pci_get_drvdata(pci_dev);
@@ -498,12 +501,11 @@ static int resume_common(struct device *dev, int event)
                 * No locking is needed because PCI controller drivers do not
                 * get unbound during system resume.
                 */
-               if (pci_dev->class == CL_EHCI && event != PM_EVENT_AUTO_RESUME)
+               if (pci_dev->class == CL_EHCI && msg.event != PM_EVENT_AUTO_RESUME)
                        for_each_companion(pci_dev, hcd,
                                        ehci_wait_for_companions);
 
-               retval = hcd->driver->pci_resume(hcd,
-                               event == PM_EVENT_RESTORE);
+               retval = hcd->driver->pci_resume(hcd, msg);
                if (retval) {
                        dev_err(dev, "PCI post-resume error %d!\n", retval);
                        usb_hc_died(hcd);
@@ -516,7 +518,7 @@ static int resume_common(struct device *dev, int event)
 
 static int hcd_pci_suspend(struct device *dev)
 {
-       return suspend_common(dev, device_may_wakeup(dev));
+       return suspend_common(dev, PMSG_SUSPEND);
 }
 
 static int hcd_pci_suspend_noirq(struct device *dev)
@@ -577,12 +579,12 @@ static int hcd_pci_resume_noirq(struct device *dev)
 
 static int hcd_pci_resume(struct device *dev)
 {
-       return resume_common(dev, PM_EVENT_RESUME);
+       return resume_common(dev, PMSG_RESUME);
 }
 
 static int hcd_pci_restore(struct device *dev)
 {
-       return resume_common(dev, PM_EVENT_RESTORE);
+       return resume_common(dev, PMSG_RESTORE);
 }
 
 #else
@@ -600,7 +602,7 @@ static int hcd_pci_runtime_suspend(struct device *dev)
 {
        int     retval;
 
-       retval = suspend_common(dev, true);
+       retval = suspend_common(dev, PMSG_AUTO_SUSPEND);
        if (retval == 0)
                powermac_set_asic(to_pci_dev(dev), 0);
        dev_dbg(dev, "hcd_pci_runtime_suspend: %d\n", retval);
@@ -612,7 +614,7 @@ static int hcd_pci_runtime_resume(struct device *dev)
        int     retval;
 
        powermac_set_asic(to_pci_dev(dev), 1);
-       retval = resume_common(dev, PM_EVENT_AUTO_RESUME);
+       retval = resume_common(dev, PMSG_AUTO_RESUME);
        dev_dbg(dev, "hcd_pci_runtime_resume: %d\n", retval);
        return retval;
 }

diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index 4b148fe5e43b28f0b64167c679a1625db0fcfb98..889dc4426271173f5a5bcb7a445d7089426284b1 100644 (file)
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -354,10 +354,11 @@ done:
  * Also they depend on separate root hub suspend/resume.
  */
 
-static int ehci_pci_resume(struct usb_hcd *hcd, bool hibernated)
+static int ehci_pci_resume(struct usb_hcd *hcd, pm_message_t msg)
 {
        struct ehci_hcd         *ehci = hcd_to_ehci(hcd);
        struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
+       bool                    hibernated = (msg.event == PM_EVENT_RESTORE);
 
        if (ehci_resume(hcd, hibernated) != 0)
                (void) ehci_pci_reinit(ehci, pdev);

diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
index d7b4f40f9ff4eb82178020573011b2b64ab9c0bd..900ea0d368e0343e8da6f5e418d2f43a206aef65 100644 (file)
--- a/drivers/usb/host/ohci-pci.c
+++ b/drivers/usb/host/ohci-pci.c
@@ -301,6 +301,12 @@ static struct pci_driver ohci_pci_driver = {
 #endif
 };
 
+#ifdef CONFIG_PM
+static int ohci_pci_resume(struct usb_hcd *hcd, pm_message_t msg)
+{
+       return ohci_resume(hcd, msg.event == PM_EVENT_RESTORE);
+}
+#endif
 static int __init ohci_pci_init(void)
 {
        if (usb_disabled())
@@ -311,7 +317,7 @@ static int __init ohci_pci_init(void)
 #ifdef CONFIG_PM
        /* Entries for the PCI suspend/resume callbacks are special */
        ohci_pci_hc_driver.pci_suspend = ohci_suspend;
-       ohci_pci_hc_driver.pci_resume = ohci_resume;
+       ohci_pci_hc_driver.pci_resume = ohci_pci_resume;
 #endif
 
        return pci_register_driver(&ohci_pci_driver);

diff --git a/drivers/usb/host/uhci-pci.c b/drivers/usb/host/uhci-pci.c
index 3592f757fe05ddfbce622b7bf91b93cc76b30ce2..5df4a1832b09bbbde270b76072bf09cc36b70781 100644 (file)
--- a/drivers/usb/host/uhci-pci.c
+++ b/drivers/usb/host/uhci-pci.c
@@ -167,7 +167,7 @@ static void uhci_shutdown(struct pci_dev *pdev)
 
 #ifdef CONFIG_PM
 
-static int uhci_pci_resume(struct usb_hcd *hcd, bool hibernated);
+static int uhci_pci_resume(struct usb_hcd *hcd, pm_message_t state);
 
 static int uhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
 {
@@ -202,14 +202,15 @@ done_okay:
 
        /* Check for race with a wakeup request */
        if (do_wakeup && HCD_WAKEUP_PENDING(hcd)) {
-               uhci_pci_resume(hcd, false);
+               uhci_pci_resume(hcd, PMSG_SUSPEND);
                rc = -EBUSY;
        }
        return rc;
 }
 
-static int uhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
+static int uhci_pci_resume(struct usb_hcd *hcd, pm_message_t msg)
 {
+       bool hibernated = (msg.event == PM_EVENT_RESTORE);
        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
 
        dev_dbg(uhci_dev(uhci), "%s\n", __func__);

diff --git a/drivers/usb/host/xhci-histb.c b/drivers/usb/host/xhci-histb.c
index 08369857686e731f809cc95bb529416a26b65e8a..91ce97821de5180d62b9685f575b6b23a1fdbf15 100644 (file)
--- a/drivers/usb/host/xhci-histb.c
+++ b/drivers/usb/host/xhci-histb.c
@@ -367,7 +367,7 @@ static int __maybe_unused xhci_histb_resume(struct device *dev)
        if (!device_may_wakeup(dev))
                xhci_histb_host_enable(histb);
 
-       return xhci_resume(xhci, 0);
+       return xhci_resume(xhci, PMSG_RESUME);
 }
 
 static const struct dev_pm_ops xhci_histb_pm_ops = {

diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index ddb79f23fb3b7ce0a54b93f388e46db6508aecff..e834c77e188e539a59d9e076103c2d99af895d89 100644 (file)
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -824,7 +824,7 @@ static int xhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
        return ret;
 }
 
-static int xhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
+static int xhci_pci_resume(struct usb_hcd *hcd, pm_message_t msg)
 {
        struct xhci_hcd         *xhci = hcd_to_xhci(hcd);
        struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
@@ -859,7 +859,7 @@ static int xhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
        if (xhci->quirks & XHCI_PME_STUCK_QUIRK)
                xhci_pme_quirk(hcd);
 
-       retval = xhci_resume(xhci, hibernated);
+       retval = xhci_resume(xhci, msg);
        return retval;
 }
 

diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index b0c8e8efc43b6f04222d9376b2fb582b2a530292..f36633fa83624f1e2bceffd4bb8679ac62804c1f 100644 (file)
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -478,7 +478,7 @@ static int __maybe_unused xhci_plat_resume(struct device *dev)
        if (ret)
                return ret;
 
-       ret = xhci_resume(xhci, 0);
+       ret = xhci_resume(xhci, PMSG_RESUME);
        if (ret)
                return ret;
 
@@ -507,7 +507,7 @@ static int __maybe_unused xhci_plat_runtime_resume(struct device *dev)
        struct usb_hcd  *hcd = dev_get_drvdata(dev);
        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
 
-       return xhci_resume(xhci, 0);
+       return xhci_resume(xhci, PMSG_AUTO_RESUME);
 }
 
 const struct dev_pm_ops xhci_plat_pm_ops = {

diff --git a/drivers/usb/host/xhci-tegra.c b/drivers/usb/host/xhci-tegra.c
index c75d9324414366c993a9d9729c0c0d7066381dbb..8a9c7deb7686e9cc654a2788c080b191fe105692 100644 (file)
--- a/drivers/usb/host/xhci-tegra.c
+++ b/drivers/usb/host/xhci-tegra.c
@@ -2272,7 +2272,7 @@ static int tegra_xusb_exit_elpg(struct tegra_xusb *tegra, bool runtime)
        if (wakeup)
                tegra_xhci_disable_phy_sleepwalk(tegra);
 
-       err = xhci_resume(xhci, 0);
+       err = xhci_resume(xhci, runtime ? PMSG_AUTO_RESUME : PMSG_RESUME);
        if (err < 0) {
                dev_err(tegra->dev, "failed to resume XHCI: %d\n", err);
                goto disable_phy;

diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 78790dc13c5f143f1262e4dd171402d8ed9a15ba..65d54c8a249286f80f51d557ce922d2c924a59fc 100644 (file)
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -960,8 +960,9 @@ EXPORT_SYMBOL_GPL(xhci_suspend);
  * This is called when the machine transition from S3/S4 mode.
  *
  */
-int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
+int xhci_resume(struct xhci_hcd *xhci, pm_message_t msg)
 {
+       bool                    hibernated = (msg.event == PM_EVENT_RESTORE);
        u32                     command, temp = 0;
        struct usb_hcd          *hcd = xhci_to_hcd(xhci);
        int                     retval = 0;

diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 08d721921b7bb22606d82cea5b4736208beb0a9c..047b290404b4d5ed28ebc2707d459ba11778e203 100644 (file)
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -2140,7 +2140,7 @@ int xhci_disable_slot(struct xhci_hcd *xhci, u32 slot_id);
 int xhci_ext_cap_init(struct xhci_hcd *xhci);
 
 int xhci_suspend(struct xhci_hcd *xhci, bool do_wakeup);
-int xhci_resume(struct xhci_hcd *xhci, bool hibernated);
+int xhci_resume(struct xhci_hcd *xhci, pm_message_t msg);
 
 irqreturn_t xhci_irq(struct usb_hcd *hcd);
 irqreturn_t xhci_msi_irq(int irq, void *hcd);

diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index 094c77eaf455165c435baa1679e56860ca39413e..30ab8994f0c19fe12e7c705d5e66931c3b5492e9 100644 (file)
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -267,7 +267,7 @@ struct hc_driver {
        int     (*pci_suspend)(struct usb_hcd *hcd, bool do_wakeup);
 
        /* called after entering D0 (etc), before resuming the hub */
-       int     (*pci_resume)(struct usb_hcd *hcd, bool hibernated);
+       int     (*pci_resume)(struct usb_hcd *hcd, pm_message_t state);
 
        /* called just before hibernate final D3 state, allows host to poweroff parts */
        int     (*pci_poweroff_late)(struct usb_hcd *hcd, bool do_wakeup);