4 files changed, 80 insertions, 5 deletions

diff --git a/drivers/misc/mei/client.c b/drivers/misc/mei/client.c
index 1e99ef6a54a2..b2b9f4382d77 100644
--- a/drivers/misc/mei/client.c
+++ b/drivers/misc/mei/client.c
@@ -699,7 +699,7 @@ void mei_host_client_init(struct work_struct *work)
 bool mei_hbuf_acquire(struct mei_device *dev)
 {
         if (mei_pg_state(dev) == MEI_PG_ON ||
-            dev->pg_event == MEI_PG_EVENT_WAIT) {
+            mei_pg_in_transition(dev)) {
                 dev_dbg(dev->dev, "device is in pg\n");
                 return false;
         }
diff --git a/drivers/misc/mei/hw-me.c b/drivers/misc/mei/hw-me.c
index 6fb75e62a764..43d7101ff993 100644
--- a/drivers/misc/mei/hw-me.c
+++ b/drivers/misc/mei/hw-me.c
@@ -663,11 +663,27 @@ int mei_me_pg_exit_sync(struct mei_device *dev)
         mutex_lock(&dev->device_lock);
 
 reply:
-        if (dev->pg_event == MEI_PG_EVENT_RECEIVED)
-                ret = mei_hbm_pg(dev, MEI_PG_ISOLATION_EXIT_RES_CMD);
+        if (dev->pg_event != MEI_PG_EVENT_RECEIVED) {
+                ret = -ETIME;
+                goto out;
+        }
+
+        dev->pg_event = MEI_PG_EVENT_INTR_WAIT;
+        ret = mei_hbm_pg(dev, MEI_PG_ISOLATION_EXIT_RES_CMD);
+        if (ret)
+                return ret;
+
+        mutex_unlock(&dev->device_lock);
+        wait_event_timeout(dev->wait_pg,
+                dev->pg_event == MEI_PG_EVENT_INTR_RECEIVED, timeout);
+        mutex_lock(&dev->device_lock);
+
+        if (dev->pg_event == MEI_PG_EVENT_INTR_RECEIVED)
+                ret = 0;
         else
                 ret = -ETIME;
 
+out:
         dev->pg_event = MEI_PG_EVENT_IDLE;
         hw->pg_state = MEI_PG_OFF;
 
@@ -675,6 +691,19 @@ reply:
 }
 
 /**
+ * mei_me_pg_in_transition - is device now in pg transition
+ *
+ * @dev: the device structure
+ *
+ * Return: true if in pg transition, false otherwise
+ */
+static bool mei_me_pg_in_transition(struct mei_device *dev)
+{
+        return dev->pg_event >= MEI_PG_EVENT_WAIT &&
+               dev->pg_event <= MEI_PG_EVENT_INTR_WAIT;
+}
+
+/**
  * mei_me_pg_is_enabled - detect if PG is supported by HW
  *
  * @dev: the device structure
@@ -705,6 +734,24 @@ notsupported:
 }
 
 /**
+ * mei_me_pg_intr - perform pg processing in interrupt thread handler
+ *
+ * @dev: the device structure
+ */
+static void mei_me_pg_intr(struct mei_device *dev)
+{
+        struct mei_me_hw *hw = to_me_hw(dev);
+
+        if (dev->pg_event != MEI_PG_EVENT_INTR_WAIT)
+                return;
+
+        dev->pg_event = MEI_PG_EVENT_INTR_RECEIVED;
+        hw->pg_state = MEI_PG_OFF;
+        if (waitqueue_active(&dev->wait_pg))
+                wake_up(&dev->wait_pg);
+}
+
+/**
  * mei_me_irq_quick_handler - The ISR of the MEI device
  *
  * @irq: The irq number
@@ -761,6 +808,8 @@ irqreturn_t mei_me_irq_thread_handler(int irq, void *dev_id)
                 goto end;
         }
 
+        mei_me_pg_intr(dev);
+
         /*  check if we need to start the dev */
         if (!mei_host_is_ready(dev)) {
                 if (mei_hw_is_ready(dev)) {
@@ -797,9 +846,10 @@ irqreturn_t mei_me_irq_thread_handler(int irq, void *dev_id)
         /*
          * During PG handshake only allowed write is the replay to the
          * PG exit message, so block calling write function
-         * if the pg state is not idle
+         * if the pg event is in PG handshake
          */
-        if (dev->pg_event == MEI_PG_EVENT_IDLE) {
+        if (dev->pg_event != MEI_PG_EVENT_WAIT &&
+            dev->pg_event != MEI_PG_EVENT_RECEIVED) {
                 rets = mei_irq_write_handler(dev, &complete_list);
                 dev->hbuf_is_ready = mei_hbuf_is_ready(dev);
         }
@@ -824,6 +874,7 @@ static const struct mei_hw_ops mei_me_hw_ops = {
         .hw_config = mei_me_hw_config,
         .hw_start = mei_me_hw_start,
 
+        .pg_in_transition = mei_me_pg_in_transition,
         .pg_is_enabled = mei_me_pg_is_enabled,
 
         .intr_clear = mei_me_intr_clear,
diff --git a/drivers/misc/mei/hw-txe.c b/drivers/misc/mei/hw-txe.c
index 7abafe7d120d..964136b35733 100644
--- a/drivers/misc/mei/hw-txe.c
+++ b/drivers/misc/mei/hw-txe.c
@@ -302,6 +302,18 @@ int mei_txe_aliveness_set_sync(struct mei_device *dev, u32 req)
 }
 
 /**
+ * mei_txe_pg_in_transition - is device now in pg transition
+ *
+ * @dev: the device structure
+ *
+ * Return: true if in pg transition, false otherwise
+ */
+static bool mei_txe_pg_in_transition(struct mei_device *dev)
+{
+        return dev->pg_event == MEI_PG_EVENT_WAIT;
+}
+
+/**
  * mei_txe_pg_is_enabled - detect if PG is supported by HW
  *
  * @dev: the device structure
@@ -1138,6 +1150,7 @@ static const struct mei_hw_ops mei_txe_hw_ops = {
         .hw_config = mei_txe_hw_config,
         .hw_start = mei_txe_hw_start,
 
+        .pg_in_transition = mei_txe_pg_in_transition,
         .pg_is_enabled = mei_txe_pg_is_enabled,
 
         .intr_clear = mei_txe_intr_clear,
diff --git a/drivers/misc/mei/mei_dev.h b/drivers/misc/mei/mei_dev.h
index f066ecd71939..f84c39ee28a8 100644
--- a/drivers/misc/mei/mei_dev.h
+++ b/drivers/misc/mei/mei_dev.h
@@ -271,6 +271,7 @@ struct mei_cl {
 
  * @fw_status        : get fw status registers
  * @pg_state         : power gating state of the device
+ * @pg_in_transition : is device now in pg transition
  * @pg_is_enabled    : is power gating enabled
 
  * @intr_clear       : clear pending interrupts
@@ -300,6 +301,7 @@ struct mei_hw_ops {
 
         int (*fw_status)(struct mei_device *dev, struct mei_fw_status *fw_sts);
         enum mei_pg_state (*pg_state)(struct mei_device *dev);
+        bool (*pg_in_transition)(struct mei_device *dev);
         bool (*pg_is_enabled)(struct mei_device *dev);
 
         void (*intr_clear)(struct mei_device *dev);
@@ -398,11 +400,15 @@ struct mei_cl_device {
  * @MEI_PG_EVENT_IDLE: the driver is not in power gating transition
  * @MEI_PG_EVENT_WAIT: the driver is waiting for a pg event to complete
  * @MEI_PG_EVENT_RECEIVED: the driver received pg event
+ * @MEI_PG_EVENT_INTR_WAIT: the driver is waiting for a pg event interrupt
+ * @MEI_PG_EVENT_INTR_RECEIVED: the driver received pg event interrupt
  */
 enum mei_pg_event {
         MEI_PG_EVENT_IDLE,
         MEI_PG_EVENT_WAIT,
         MEI_PG_EVENT_RECEIVED,
+        MEI_PG_EVENT_INTR_WAIT,
+        MEI_PG_EVENT_INTR_RECEIVED,
 };
 
 /**
@@ -717,6 +723,11 @@ static inline enum mei_pg_state mei_pg_state(struct mei_device *dev)
         return dev->ops->pg_state(dev);
 }
 
+static inline bool mei_pg_in_transition(struct mei_device *dev)
+{
+        return dev->ops->pg_in_transition(dev);
+}
+
 static inline bool mei_pg_is_enabled(struct mei_device *dev)
 {
         return dev->ops->pg_is_enabled(dev);