HID: intel-thc-hid: intel-quicki2c: Add PM implementation

Implement THC QuickI2C driver power management callbacks.

Co-developed-by: Xinpeng Sun <xinpeng.sun@intel.com>
Signed-off-by: Xinpeng Sun <xinpeng.sun@intel.com>
Signed-off-by: Even Xu <even.xu@intel.com>
Tested-by: Rui Zhang <rui1.zhang@intel.com>
Tested-by: Mark Pearson <mpearson-lenovo@squebb.ca>
Reviewed-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
Reviewed-by: Mark Pearson <mpearson-lenovo@squebb.ca>
Tested-by: Aaron Ma <aaron.ma@canonical.com>
Signed-off-by: Jiri Kosina <jkosina@suse.com>

diff --git a/drivers/hid/intel-thc-hid/intel-quicki2c/pci-quicki2c.c b/drivers/hid/intel-thc-hid/intel-quicki2c/pci-quicki2c.c
index d417972ae9b01f4231ba034a7b64b5fe6212efd5..b56c72124821fd17ea34fe7b3e6f9b62945ea9cd 100644 (file)
--- a/drivers/hid/intel-thc-hid/intel-quicki2c/pci-quicki2c.c
+++ b/drivers/hid/intel-thc-hid/intel-quicki2c/pci-quicki2c.c
@@ -9,6 +9,7 @@
 #include <linux/irqreturn.h>
 #include <linux/pci.h>
 #include <linux/sizes.h>
+#include <linux/pm_runtime.h>
 
 #include "intel-thc-dev.h"
 #include "intel-thc-hw.h"
@@ -289,10 +290,15 @@ static irqreturn_t quicki2c_irq_thread_handler(int irq, void *dev_id)
        struct quicki2c_device *qcdev = dev_id;
        int err_recover = 0;
        int int_mask;
+       int ret;
 
        if (qcdev->state == QUICKI2C_DISABLED)
                return IRQ_HANDLED;
 
+       ret = pm_runtime_resume_and_get(qcdev->dev);
+       if (ret)
+               return IRQ_HANDLED;
+
        int_mask = thc_interrupt_handler(qcdev->thc_hw);
 
        if (int_mask & BIT(THC_FATAL_ERR_INT) || int_mask & BIT(THC_TXN_ERR_INT) ||
@@ -314,6 +320,9 @@ exit:
                if (try_recover(qcdev))
                        qcdev->state = QUICKI2C_DISABLED;
 
+       pm_runtime_mark_last_busy(qcdev->dev);
+       pm_runtime_put_autosuspend(qcdev->dev);
+
        return IRQ_HANDLED;
 }
 
@@ -639,6 +648,13 @@ static int quicki2c_probe(struct pci_dev *pdev,
 
        qcdev->state = QUICKI2C_ENABLED;
 
+       /* Enable runtime power management */
+       pm_runtime_use_autosuspend(qcdev->dev);
+       pm_runtime_set_autosuspend_delay(qcdev->dev, DEFAULT_AUTO_SUSPEND_DELAY_MS);
+       pm_runtime_mark_last_busy(qcdev->dev);
+       pm_runtime_put_noidle(qcdev->dev);
+       pm_runtime_put_autosuspend(qcdev->dev);
+
        dev_dbg(&pdev->dev, "QuickI2C probe success\n");
 
        return 0;
@@ -674,6 +690,8 @@ static void quicki2c_remove(struct pci_dev *pdev)
        quicki2c_hid_remove(qcdev);
        quicki2c_dma_deinit(qcdev);
 
+       pm_runtime_get_noresume(qcdev->dev);
+
        quicki2c_dev_deinit(qcdev);
 
        pcim_iounmap_regions(pdev, BIT(0));
@@ -703,6 +721,220 @@ static void quicki2c_shutdown(struct pci_dev *pdev)
        quicki2c_dev_deinit(qcdev);
 }
 
+static int quicki2c_suspend(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct quicki2c_device *qcdev;
+       int ret;
+
+       qcdev = pci_get_drvdata(pdev);
+       if (!qcdev)
+               return -ENODEV;
+
+       /*
+        * As I2C is THC subsystem, no register auto save/restore support,
+        * need driver to do that explicitly for every D3 case.
+        */
+       ret = thc_i2c_subip_regs_save(qcdev->thc_hw);
+       if (ret)
+               return ret;
+
+       ret = thc_interrupt_quiesce(qcdev->thc_hw, true);
+       if (ret)
+               return ret;
+
+       thc_interrupt_enable(qcdev->thc_hw, false);
+
+       thc_dma_unconfigure(qcdev->thc_hw);
+
+       return 0;
+}
+
+static int quicki2c_resume(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct quicki2c_device *qcdev;
+       int ret;
+
+       qcdev = pci_get_drvdata(pdev);
+       if (!qcdev)
+               return -ENODEV;
+
+       ret = thc_port_select(qcdev->thc_hw, THC_PORT_TYPE_I2C);
+       if (ret)
+               return ret;
+
+       ret = thc_i2c_subip_regs_restore(qcdev->thc_hw);
+       if (ret)
+               return ret;
+
+       thc_interrupt_config(qcdev->thc_hw);
+
+       thc_interrupt_enable(qcdev->thc_hw, true);
+
+       ret = thc_dma_configure(qcdev->thc_hw);
+       if (ret)
+               return ret;
+
+       ret = thc_interrupt_quiesce(qcdev->thc_hw, false);
+       if (ret)
+               return ret;
+
+       return 0;
+}
+
+static int quicki2c_freeze(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct quicki2c_device *qcdev;
+       int ret;
+
+       qcdev = pci_get_drvdata(pdev);
+       if (!qcdev)
+               return -ENODEV;
+
+       ret = thc_interrupt_quiesce(qcdev->thc_hw, true);
+       if (ret)
+               return ret;
+
+       thc_interrupt_enable(qcdev->thc_hw, false);
+
+       thc_dma_unconfigure(qcdev->thc_hw);
+
+       return 0;
+}
+
+static int quicki2c_thaw(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct quicki2c_device *qcdev;
+       int ret;
+
+       qcdev = pci_get_drvdata(pdev);
+       if (!qcdev)
+               return -ENODEV;
+
+       ret = thc_dma_configure(qcdev->thc_hw);
+       if (ret)
+               return ret;
+
+       thc_interrupt_enable(qcdev->thc_hw, true);
+
+       ret = thc_interrupt_quiesce(qcdev->thc_hw, false);
+       if (ret)
+               return ret;
+
+       return 0;
+}
+
+static int quicki2c_poweroff(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct quicki2c_device *qcdev;
+       int ret;
+
+       qcdev = pci_get_drvdata(pdev);
+       if (!qcdev)
+               return -ENODEV;
+
+       ret = thc_interrupt_quiesce(qcdev->thc_hw, true);
+       if (ret)
+               return ret;
+
+       thc_interrupt_enable(qcdev->thc_hw, false);
+
+       thc_ltr_unconfig(qcdev->thc_hw);
+
+       quicki2c_dma_deinit(qcdev);
+
+       return 0;
+}
+
+static int quicki2c_restore(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct quicki2c_device *qcdev;
+       int ret;
+
+       qcdev = pci_get_drvdata(pdev);
+       if (!qcdev)
+               return -ENODEV;
+
+       /* Reconfig THC HW when back from hibernate */
+       ret = thc_port_select(qcdev->thc_hw, THC_PORT_TYPE_I2C);
+       if (ret)
+               return ret;
+
+       ret = thc_i2c_subip_init(qcdev->thc_hw, qcdev->i2c_slave_addr,
+                                qcdev->i2c_speed_mode,
+                                qcdev->i2c_clock_hcnt,
+                                qcdev->i2c_clock_lcnt);
+       if (ret)
+               return ret;
+
+       thc_interrupt_config(qcdev->thc_hw);
+
+       thc_interrupt_enable(qcdev->thc_hw, true);
+
+       ret = thc_interrupt_quiesce(qcdev->thc_hw, false);
+       if (ret)
+               return ret;
+
+       ret = thc_dma_configure(qcdev->thc_hw);
+       if (ret)
+               return ret;
+
+       thc_ltr_config(qcdev->thc_hw,
+                      qcdev->active_ltr_val,
+                      qcdev->low_power_ltr_val);
+
+       thc_change_ltr_mode(qcdev->thc_hw, THC_LTR_MODE_ACTIVE);
+
+       return 0;
+}
+
+static int quicki2c_runtime_suspend(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct quicki2c_device *qcdev;
+
+       qcdev = pci_get_drvdata(pdev);
+       if (!qcdev)
+               return -ENODEV;
+
+       thc_change_ltr_mode(qcdev->thc_hw, THC_LTR_MODE_LP);
+
+       pci_save_state(pdev);
+
+       return 0;
+}
+
+static int quicki2c_runtime_resume(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct quicki2c_device *qcdev;
+
+       qcdev = pci_get_drvdata(pdev);
+       if (!qcdev)
+               return -ENODEV;
+
+       thc_change_ltr_mode(qcdev->thc_hw, THC_LTR_MODE_ACTIVE);
+
+       return 0;
+}
+
+static const struct dev_pm_ops quicki2c_pm_ops = {
+       .suspend = quicki2c_suspend,
+       .resume = quicki2c_resume,
+       .freeze = quicki2c_freeze,
+       .thaw = quicki2c_thaw,
+       .poweroff = quicki2c_poweroff,
+       .restore = quicki2c_restore,
+       .runtime_suspend = quicki2c_runtime_suspend,
+       .runtime_resume = quicki2c_runtime_resume,
+       .runtime_idle = NULL,
+};
+
 static const struct pci_device_id quicki2c_pci_tbl[] = {
        {PCI_VDEVICE(INTEL, THC_LNL_DEVICE_ID_I2C_PORT1), },
        {PCI_VDEVICE(INTEL, THC_LNL_DEVICE_ID_I2C_PORT2), },
@@ -720,6 +952,7 @@ static struct pci_driver quicki2c_driver = {
        .probe = quicki2c_probe,
        .remove = quicki2c_remove,
        .shutdown = quicki2c_shutdown,
+       .driver.pm = &quicki2c_pm_ops,
        .driver.probe_type = PROBE_PREFER_ASYNCHRONOUS,
 };
 

diff --git a/drivers/hid/intel-thc-hid/intel-quicki2c/quicki2c-dev.h b/drivers/hid/intel-thc-hid/intel-quicki2c/quicki2c-dev.h
index 0fdac6ba1b04dad2bb3514377b77b0597d57c8ef..6ddb584bd611034471d8a72fd42a3aecc1044886 100644 (file)
--- a/drivers/hid/intel-thc-hid/intel-quicki2c/quicki2c-dev.h
+++ b/drivers/hid/intel-thc-hid/intel-quicki2c/quicki2c-dev.h
@@ -36,6 +36,14 @@
 #define QUICKI2C_DEFAULT_LP_LTR_VALUE          500
 #define QUICKI2C_RPM_TIMEOUT_MS                        500
 
+/*
+ * THC uses runtime auto suspend to dynamically switch between THC active LTR
+ * and low power LTR to save CPU power.
+ * Default value is 5000ms, that means if no touch event in this time, THC will
+ * change to low power LTR mode.
+ */
+#define DEFAULT_AUTO_SUSPEND_DELAY_MS                  5000
+
 enum quicki2c_dev_state {
        QUICKI2C_NONE,
        QUICKI2C_RESETING,

diff --git a/drivers/hid/intel-thc-hid/intel-quicki2c/quicki2c-hid.c b/drivers/hid/intel-thc-hid/intel-quicki2c/quicki2c-hid.c
index e8e6f10b79526c84798f1b8821e6e9491a9becc1..5c3ec95bb3fdd29f58097e26f387944b9b563ebb 100644 (file)
--- a/drivers/hid/intel-thc-hid/intel-quicki2c/quicki2c-hid.c
+++ b/drivers/hid/intel-thc-hid/intel-quicki2c/quicki2c-hid.c
@@ -3,6 +3,7 @@
 
 #include <linux/hid.h>
 #include <linux/input.h>
+#include <linux/pm_runtime.h>
 
 #include "quicki2c-dev.h"
 #include "quicki2c-hid.h"
@@ -55,6 +56,10 @@ static int quicki2c_hid_raw_request(struct hid_device *hid,
        struct quicki2c_device *qcdev = hid->driver_data;
        int ret = 0;
 
+       ret = pm_runtime_resume_and_get(qcdev->dev);
+       if (ret)
+               return ret;
+
        switch (reqtype) {
        case HID_REQ_GET_REPORT:
                ret = quicki2c_get_report(qcdev, rtype, reportnum, buf, len);
@@ -67,6 +72,9 @@ static int quicki2c_hid_raw_request(struct hid_device *hid,
                break;
        }
 
+       pm_runtime_mark_last_busy(qcdev->dev);
+       pm_runtime_put_autosuspend(qcdev->dev);
+
        return ret;
 }