HID: add suspend/resume helpers

There is a lot of duplication of code in the HID low level drivers.
Better have everything in one place so we can eventually extend it
in a generic way.

Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Link: https://lore.kernel.org/r/20211202095334.14399-4-benjamin.tissoires@redhat.com

diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index dbed2524fd47bfe18ff0e64f5762f5e5a707220f..5402329d6eca63b6b919341897f1e93e82470348 100644 (file)
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -2126,6 +2126,35 @@ void hid_hw_close(struct hid_device *hdev)
 }
 EXPORT_SYMBOL_GPL(hid_hw_close);
 
+#ifdef CONFIG_PM
+int hid_driver_suspend(struct hid_device *hdev, pm_message_t state)
+{
+       if (hdev->driver && hdev->driver->suspend)
+               return hdev->driver->suspend(hdev, state);
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(hid_driver_suspend);
+
+int hid_driver_reset_resume(struct hid_device *hdev)
+{
+       if (hdev->driver && hdev->driver->reset_resume)
+               return hdev->driver->reset_resume(hdev);
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(hid_driver_reset_resume);
+
+int hid_driver_resume(struct hid_device *hdev)
+{
+       if (hdev->driver && hdev->driver->resume)
+               return hdev->driver->resume(hdev);
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(hid_driver_resume);
+#endif /* CONFIG_PM */
+
 struct hid_dynid {
        struct list_head list;
        struct hid_device_id id;

diff --git a/drivers/hid/i2c-hid/i2c-hid-core.c b/drivers/hid/i2c-hid/i2c-hid-core.c
index 517141138b007990d0335fe4c28f57d6a9626f99..4cdd862ca1cb65fa921112ffa2d46992f0783414 100644 (file)
--- a/drivers/hid/i2c-hid/i2c-hid-core.c
+++ b/drivers/hid/i2c-hid/i2c-hid-core.c
@@ -1063,11 +1063,9 @@ static int i2c_hid_core_suspend(struct device *dev)
        int ret;
        int wake_status;
 
-       if (hid->driver && hid->driver->suspend) {
-               ret = hid->driver->suspend(hid, PMSG_SUSPEND);
-               if (ret < 0)
-                       return ret;
-       }
+       ret = hid_driver_suspend(hid, PMSG_SUSPEND);
+       if (ret < 0)
+               return ret;
 
        /* Save some power */
        i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
@@ -1125,12 +1123,7 @@ static int i2c_hid_core_resume(struct device *dev)
        if (ret)
                return ret;
 
-       if (hid->driver && hid->driver->reset_resume) {
-               ret = hid->driver->reset_resume(hid);
-               return ret;
-       }
-
-       return 0;
+       return hid_driver_reset_resume(hid);
 }
 #endif
 

diff --git a/drivers/hid/surface-hid/surface_hid_core.c b/drivers/hid/surface-hid/surface_hid_core.c
index 5571e74abe91b803398ddf19a11136dd70b21781..e46330b2e561a4a85f7dd72ba79bcd4aeb31c269 100644 (file)
--- a/drivers/hid/surface-hid/surface_hid_core.c
+++ b/drivers/hid/surface-hid/surface_hid_core.c
@@ -204,50 +204,35 @@ static int surface_hid_suspend(struct device *dev)
 {
        struct surface_hid_device *d = dev_get_drvdata(dev);
 
-       if (d->hid->driver && d->hid->driver->suspend)
-               return d->hid->driver->suspend(d->hid, PMSG_SUSPEND);
-
-       return 0;
+       return hid_driver_suspend(d->hid, PMSG_SUSPEND);
 }
 
 static int surface_hid_resume(struct device *dev)
 {
        struct surface_hid_device *d = dev_get_drvdata(dev);
 
-       if (d->hid->driver && d->hid->driver->resume)
-               return d->hid->driver->resume(d->hid);
-
-       return 0;
+       return hid_driver_resume(d->hid);
 }
 
 static int surface_hid_freeze(struct device *dev)
 {
        struct surface_hid_device *d = dev_get_drvdata(dev);
 
-       if (d->hid->driver && d->hid->driver->suspend)
-               return d->hid->driver->suspend(d->hid, PMSG_FREEZE);
-
-       return 0;
+       return hid_driver_suspend(d->hid, PMSG_FREEZE);
 }
 
 static int surface_hid_poweroff(struct device *dev)
 {
        struct surface_hid_device *d = dev_get_drvdata(dev);
 
-       if (d->hid->driver && d->hid->driver->suspend)
-               return d->hid->driver->suspend(d->hid, PMSG_HIBERNATE);
-
-       return 0;
+       return hid_driver_suspend(d->hid, PMSG_HIBERNATE);
 }
 
 static int surface_hid_restore(struct device *dev)
 {
        struct surface_hid_device *d = dev_get_drvdata(dev);
 
-       if (d->hid->driver && d->hid->driver->reset_resume)
-               return d->hid->driver->reset_resume(d->hid);
-
-       return 0;
+       return hid_driver_reset_resume(d->hid);
 }
 
 const struct dev_pm_ops surface_hid_pm_ops = {

diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index 2dcaf31eb9cdf66a897699e815db6a16fa5df2da..54752c85604b153ddf27dd524af0e3727edca1fa 100644 (file)
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -1563,8 +1563,8 @@ static int hid_resume_common(struct hid_device *hid, bool driver_suspended)
        int status = 0;
 
        hid_restart_io(hid);
-       if (driver_suspended && hid->driver && hid->driver->resume)
-               status = hid->driver->resume(hid);
+       if (driver_suspended)
+               status = hid_driver_resume(hid);
        return status;
 }
 
@@ -1588,11 +1588,9 @@ static int hid_suspend(struct usb_interface *intf, pm_message_t message)
                {
                        set_bit(HID_SUSPENDED, &usbhid->iofl);
                        spin_unlock_irq(&usbhid->lock);
-                       if (hid->driver && hid->driver->suspend) {
-                               status = hid->driver->suspend(hid, message);
-                               if (status < 0)
-                                       goto failed;
-                       }
+                       status = hid_driver_suspend(hid, message);
+                       if (status < 0)
+                               goto failed;
                        driver_suspended = true;
                } else {
                        usbhid_mark_busy(usbhid);
@@ -1602,8 +1600,7 @@ static int hid_suspend(struct usb_interface *intf, pm_message_t message)
 
        } else {
                /* TODO: resume() might need to handle suspend failure */
-               if (hid->driver && hid->driver->suspend)
-                       status = hid->driver->suspend(hid, message);
+               status = hid_driver_suspend(hid, message);
                driver_suspended = true;
                spin_lock_irq(&usbhid->lock);
                set_bit(HID_SUSPENDED, &usbhid->iofl);
@@ -1644,8 +1641,8 @@ static int hid_reset_resume(struct usb_interface *intf)
        int status;
 
        status = hid_post_reset(intf);
-       if (status >= 0 && hid->driver && hid->driver->reset_resume) {
-               int ret = hid->driver->reset_resume(hid);
+       if (status >= 0) {
+               int ret = hid_driver_reset_resume(hid);
                if (ret < 0)
                        status = ret;
        }

diff --git a/include/linux/hid.h b/include/linux/hid.h
index 9e067f937dbc24a82b1126542a2437078b0101c9..ebe3ec98db6b650c9edae3b344bb1529d908f348 100644 (file)
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -923,6 +923,16 @@ s32 hid_snto32(__u32 value, unsigned n);
 __u32 hid_field_extract(const struct hid_device *hid, __u8 *report,
                     unsigned offset, unsigned n);
 
+#ifdef CONFIG_PM
+int hid_driver_suspend(struct hid_device *hdev, pm_message_t state);
+int hid_driver_reset_resume(struct hid_device *hdev);
+int hid_driver_resume(struct hid_device *hdev);
+#else
+static inline int hid_driver_suspend(struct hid_device *hdev, pm_message_t state) { return 0; }
+static inline int hid_driver_reset_resume(struct hid_device *hdev) { return 0; }
+static inline int hid_driver_resume(struct hid_device *hdev) { return 0; }
+#endif
+
 /**
  * hid_device_io_start - enable HID input during probe, remove
  *