mei: wd: decouple and revamp watchdog state machine

Before ME watchdog was exported through standard watchdog interface
it was closed and started together with the mei device.

The major issue is that closing ME watchdog disabled also MEI device,
to fix this the watchdog state machine has to be independent from MEI
state machine.

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

diff --git a/drivers/misc/mei/init.c b/drivers/misc/mei/init.c
index cd6a7f1ff9160f8bfb3c5c3843ca84b7ac5e454f..98f1430e3e1446b272725bffbf25da609c0aa3e7 100644 (file)
--- a/drivers/misc/mei/init.c
+++ b/drivers/misc/mei/init.c
@@ -330,7 +330,6 @@ void mei_reset(struct mei_device *dev, int interrupts_enabled)
 
        dev->me_clients_num = 0;
        dev->rd_msg_hdr = 0;
-       dev->stop = false;
        dev->wd_pending = false;
 
        /* update the state of the registers after reset */

diff --git a/drivers/misc/mei/interface.h b/drivers/misc/mei/interface.h
index c1988f564aa29a030657891b46bd41d7b1547811..ec6c785a3961db4cd82e347436b23817326a026b 100644 (file)
--- a/drivers/misc/mei/interface.h
+++ b/drivers/misc/mei/interface.h
@@ -56,7 +56,7 @@ int mei_flow_ctrl_creds(struct mei_device *dev, struct mei_cl *cl);
 
 
 int mei_wd_send(struct mei_device *dev);
-int mei_wd_stop(struct mei_device *dev, bool preserve);
+int mei_wd_stop(struct mei_device *dev);
 int mei_wd_host_init(struct mei_device *dev);
 /*
  * mei_watchdog_register  - Registering watchdog interface

diff --git a/drivers/misc/mei/interrupt.c b/drivers/misc/mei/interrupt.c
index 0f25cee6ab85ba34fb5ca93f9b17731f6d1117b0..0900a711badda0c28010278dc9c8adde3f50c075 100644 (file)
--- a/drivers/misc/mei/interrupt.c
+++ b/drivers/misc/mei/interrupt.c
@@ -1224,10 +1224,9 @@ static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
                }
        }
 
-       if (dev->stop && !dev->wd_pending) {
-               dev->wd_stopped = true;
+       if (dev->wd_state == MEI_WD_STOPPING) {
+               dev->wd_state = MEI_WD_IDLE;
                wake_up_interruptible(&dev->wait_stop_wd);
-               return 0;
        }
 
        if (dev->extra_write_index) {
@@ -1250,14 +1249,12 @@ static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
 
                        dev->wd_pending = false;
 
-                       if (dev->wd_timeout)
+                       if (dev->wd_state == MEI_WD_RUNNING)
                                *slots -= mei_data2slots(MEI_WD_START_MSG_SIZE);
                        else
                                *slots -= mei_data2slots(MEI_WD_STOP_MSG_SIZE);
                }
        }
-       if (dev->stop)
-               return -ENODEV;
 
        /* complete control write list CB */
        dev_dbg(&dev->pdev->dev, "complete control write list cb.\n");

diff --git a/drivers/misc/mei/main.c b/drivers/misc/mei/main.c
index 5c557dd129d6bd9b6876ad5889a21a5523639395..9a595338ae1555daa628152895b7910ac47c520b 100644 (file)
--- a/drivers/misc/mei/main.c
+++ b/drivers/misc/mei/main.c
@@ -1060,7 +1060,9 @@ static void __devexit mei_remove(struct pci_dev *pdev)
 
        mutex_lock(&dev->device_lock);
 
-       mei_wd_stop(dev, false);
+       cancel_delayed_work(&dev->timer_work);
+
+       mei_wd_stop(dev);
 
        mei_device = NULL;
 
@@ -1115,8 +1117,11 @@ static int mei_pci_suspend(struct device *device)
        if (!dev)
                return -ENODEV;
        mutex_lock(&dev->device_lock);
+
+       cancel_delayed_work(&dev->timer_work);
+
        /* Stop watchdog if exists */
-       err = mei_wd_stop(dev, true);
+       err = mei_wd_stop(dev);
        /* Set new mei state */
        if (dev->dev_state == MEI_DEV_ENABLED ||
            dev->dev_state == MEI_DEV_RECOVERING_FROM_RESET) {

diff --git a/drivers/misc/mei/mei_dev.h b/drivers/misc/mei/mei_dev.h
index 64a4f17893e503f9bd917ffd7ca146c1dbfb9b09..c8660c0eb1c7045d51e6552a88e5769cc4301216 100644 (file)
--- a/drivers/misc/mei/mei_dev.h
+++ b/drivers/misc/mei/mei_dev.h
@@ -33,6 +33,8 @@
 #define MEI_WD_MIN_TIMEOUT       120  /* seconds */
 #define MEI_WD_MAX_TIMEOUT     65535  /* seconds */
 
+#define MEI_WD_STOP_TIMEOUT      10 /* msecs */
+
 #define MEI_WD_STATE_INDEPENDENCE_MSG_SENT       (1 << 0)
 
 #define MEI_RD_MSG_BUF_SIZE           (128 * sizeof(u32))
@@ -120,6 +122,12 @@ enum mei_file_transaction_states {
        MEI_READ_COMPLETE
 };
 
+enum mei_wd_states {
+       MEI_WD_IDLE,
+       MEI_WD_RUNNING,
+       MEI_WD_STOPPING,
+};
+
 /* MEI CB */
 enum mei_cb_major_types {
        MEI_READ = 0,
@@ -228,7 +236,6 @@ struct mei_device {
        enum mei_dev_state dev_state;
        enum mei_init_clients_states init_clients_state;
        u16 init_clients_timer;
-       bool stop;
        bool need_reset;
 
        u32 extra_write_index;
@@ -248,11 +255,10 @@ struct mei_device {
        bool mei_host_buffer_is_empty;
 
        struct mei_cl wd_cl;
+       enum mei_wd_states wd_state;
        bool wd_interface_reg;
        bool wd_pending;
-       bool wd_stopped;
-       bool wd_bypass; /* if false, don't refresh watchdog ME client */
-       u16 wd_timeout; /* seconds ((wd_data[1] << 8) + wd_data[0]) */
+       u16 wd_timeout;
        unsigned char wd_data[MEI_WD_START_MSG_SIZE];
 
 

diff --git a/drivers/misc/mei/wd.c b/drivers/misc/mei/wd.c
index 755a58305a7e9817952dee50d1f58310c197bf19..0824166a7303156c6cb31cd79dff9ea9c816ae64 100644 (file)
--- a/drivers/misc/mei/wd.c
+++ b/drivers/misc/mei/wd.c
@@ -67,6 +67,7 @@ int mei_wd_host_init(struct mei_device *dev)
        /* look for WD client and connect to it */
        dev->wd_cl.state = MEI_FILE_DISCONNECTED;
        dev->wd_timeout = MEI_WD_DEFAULT_TIMEOUT;
+       dev->wd_state = MEI_WD_IDLE;
 
        /* find ME WD client */
        mei_me_cl_update_filext(dev, &dev->wd_cl,
@@ -128,18 +129,17 @@ int mei_wd_send(struct mei_device *dev)
  *     -EIO when message send fails
  *     -EINVAL when invalid message is to be sent
  */
-int mei_wd_stop(struct mei_device *dev, bool preserve)
+int mei_wd_stop(struct mei_device *dev)
 {
        int ret;
-       u16 wd_timeout = dev->wd_timeout;
 
-       cancel_delayed_work(&dev->timer_work);
-       if (dev->wd_cl.state != MEI_FILE_CONNECTED || !dev->wd_timeout)
+       if (dev->wd_cl.state != MEI_FILE_CONNECTED ||
+           dev->wd_state != MEI_WD_RUNNING)
                return 0;
 
-       dev->wd_timeout = 0;
        memcpy(dev->wd_data, mei_stop_wd_params, MEI_WD_STOP_MSG_SIZE);
-       dev->stop = true;
+
+       dev->wd_state = MEI_WD_STOPPING;
 
        ret = mei_flow_ctrl_creds(dev, &dev->wd_cl);
        if (ret < 0)
@@ -161,13 +161,14 @@ int mei_wd_stop(struct mei_device *dev, bool preserve)
        } else {
                dev->wd_pending = true;
        }
-       dev->wd_stopped = false;
+
        mutex_unlock(&dev->device_lock);
 
        ret = wait_event_interruptible_timeout(dev->wait_stop_wd,
-                                       dev->wd_stopped, 10 * HZ);
+                                       dev->wd_state == MEI_WD_IDLE,
+                                       msecs_to_jiffies(MEI_WD_STOP_TIMEOUT));
        mutex_lock(&dev->device_lock);
-       if (dev->wd_stopped) {
+       if (dev->wd_state == MEI_WD_IDLE) {
                dev_dbg(&dev->pdev->dev, "wd: stop completed ret=%d.\n", ret);
                ret = 0;
        } else {
@@ -177,9 +178,6 @@ int mei_wd_stop(struct mei_device *dev, bool preserve)
                        "wd: stop failed to complete ret=%d.\n", ret);
        }
 
-       if (preserve)
-               dev->wd_timeout = wd_timeout;
-
 out:
        return ret;
 }
@@ -239,7 +237,7 @@ static int mei_wd_ops_stop(struct watchdog_device *wd_dev)
                return -ENODEV;
 
        mutex_lock(&dev->device_lock);
-       mei_wd_stop(dev, false);
+       mei_wd_stop(dev);
        mutex_unlock(&dev->device_lock);
 
        return 0;
@@ -269,6 +267,8 @@ static int mei_wd_ops_ping(struct watchdog_device *wd_dev)
                goto end;
        }
 
+       dev->wd_state = MEI_WD_RUNNING;
+
        /* Check if we can send the ping to HW*/
        if (dev->mei_host_buffer_is_empty &&
                mei_flow_ctrl_creds(dev, &dev->wd_cl) > 0) {