mei: txe: add runtime pm framework

Add runtime pm framework for TXE devices.
The runtime pm handlers are used to run
txe power gating isolation protocol.

Signed-off-by: Alexander Usyskin <alexander.usyskin@intel.com>
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/misc/mei/hw-txe.h b/drivers/misc/mei/hw-txe.h
index 799f9f25f42427dc12699214dd128e9ef0e16642..e8dd2d165c25c8c90aefc306b269712bab9f7a27 100644 (file)
--- a/drivers/misc/mei/hw-txe.h
+++ b/drivers/misc/mei/hw-txe.h
@@ -22,6 +22,8 @@
 #include "hw.h"
 #include "hw-txe-regs.h"
 
+#define MEI_TXI_RPM_TIMEOUT    500 /* ms */
+
 /* Flatten Hierarchy interrupt cause */
 #define TXE_INTR_READINESS_BIT  0 /* HISR_INT_0_STS */
 #define TXE_INTR_READINESS      HISR_INT_0_STS

diff --git a/drivers/misc/mei/pci-txe.c b/drivers/misc/mei/pci-txe.c
index ad3adb009a1e4cd896225779b7391e264babd802..31d86e76fb7f8b26d8073250a25951f917b834e9 100644 (file)
--- a/drivers/misc/mei/pci-txe.c
+++ b/drivers/misc/mei/pci-txe.c
@@ -27,6 +27,7 @@
 #include <linux/jiffies.h>
 #include <linux/interrupt.h>
 #include <linux/workqueue.h>
+#include <linux/pm_runtime.h>
 
 #include <linux/mei.h>
 
@@ -137,12 +138,17 @@ static int mei_txe_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                goto release_irq;
        }
 
+       pm_runtime_set_autosuspend_delay(&pdev->dev, MEI_TXI_RPM_TIMEOUT);
+       pm_runtime_use_autosuspend(&pdev->dev);
+
        err = mei_register(dev);
        if (err)
                goto release_irq;
 
        pci_set_drvdata(pdev, dev);
 
+       pm_runtime_put_noidle(&pdev->dev);
+
        return 0;
 
 release_irq:
@@ -187,6 +193,8 @@ static void mei_txe_remove(struct pci_dev *pdev)
                return;
        }
 
+       pm_runtime_get_noresume(&pdev->dev);
+
        hw = to_txe_hw(dev);
 
        mei_stop(dev);
@@ -265,15 +273,100 @@ static int mei_txe_pci_resume(struct device *device)
 
        return err;
 }
+#endif /* CONFIG_PM_SLEEP */
+
+#ifdef CONFIG_PM_RUNTIME
+static int mei_txe_pm_runtime_idle(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct mei_device *dev;
+
+       dev_dbg(&pdev->dev, "rpm: txe: runtime_idle\n");
+
+       dev = pci_get_drvdata(pdev);
+       if (!dev)
+               return -ENODEV;
+       if (mei_write_is_idle(dev))
+               pm_schedule_suspend(device, MEI_TXI_RPM_TIMEOUT * 2);
+
+       return -EBUSY;
+}
+static int mei_txe_pm_runtime_suspend(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct mei_device *dev;
+       int ret;
+
+       dev_dbg(&pdev->dev, "rpm: txe: runtime suspend\n");
+
+       dev = pci_get_drvdata(pdev);
+       if (!dev)
+               return -ENODEV;
 
-static SIMPLE_DEV_PM_OPS(mei_txe_pm_ops,
-                        mei_txe_pci_suspend,
-                        mei_txe_pci_resume);
+       mutex_lock(&dev->device_lock);
+
+       if (mei_write_is_idle(dev))
+               ret = mei_txe_aliveness_set_sync(dev, 0);
+       else
+               ret = -EAGAIN;
+
+       /*
+        * If everything is okay we're about to enter PCI low
+        * power state (D3) therefor we need to disable the
+        * interrupts towards host.
+        * However if device is not wakeable we do not enter
+        * D-low state and we need to keep the interrupt kicking
+        */
+        if (!ret && pci_dev_run_wake(pdev))
+               mei_disable_interrupts(dev);
+
+       dev_dbg(&pdev->dev, "rpm: txe: runtime suspend ret=%d\n", ret);
+
+       mutex_unlock(&dev->device_lock);
+       return ret;
+}
+
+static int mei_txe_pm_runtime_resume(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct mei_device *dev;
+       int ret;
+
+       dev_dbg(&pdev->dev, "rpm: txe: runtime resume\n");
+
+       dev = pci_get_drvdata(pdev);
+       if (!dev)
+               return -ENODEV;
+
+       mutex_lock(&dev->device_lock);
+
+       mei_enable_interrupts(dev);
+
+       ret = mei_txe_aliveness_set_sync(dev, 1);
+
+       mutex_unlock(&dev->device_lock);
+
+       dev_dbg(&pdev->dev, "rpm: txe: runtime resume ret = %d\n", ret);
+
+       return ret;
+}
+#endif /* CONFIG_PM_RUNTIME */
+
+#ifdef CONFIG_PM
+static const struct dev_pm_ops mei_txe_pm_ops = {
+       SET_SYSTEM_SLEEP_PM_OPS(mei_txe_pci_suspend,
+                               mei_txe_pci_resume)
+       SET_RUNTIME_PM_OPS(
+               mei_txe_pm_runtime_suspend,
+               mei_txe_pm_runtime_resume,
+               mei_txe_pm_runtime_idle)
+};
 
 #define MEI_TXE_PM_OPS (&mei_txe_pm_ops)
 #else
 #define MEI_TXE_PM_OPS NULL
-#endif /* CONFIG_PM_SLEEP */
+#endif /* CONFIG_PM */
+
 /*
  *  PCI driver structure
  */