mei: do not run reset flow from the interrupt thread

This fixes a potential deadlock in case of a firmware
initiated reset

mei_reset has a dialog with the interrupt thread hence
it has to be run from an another work item

Most of the mei_resets were called from mei_hbm_dispatch
which is called in interrupt thread context so this
function underwent major revamp. The error code is
propagated to the interrupt thread and if needed
the reset is scheduled from there.

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

1 files changed, 124 insertions, 76 deletions

diff --git a/drivers/misc/mei/hbm.c b/drivers/misc/mei/hbm.c
index 9b3a0fb7f265..8109b9a98cc3 100644
--- a/drivers/misc/mei/hbm.c
+++ b/drivers/misc/mei/hbm.c
@@ -28,9 +28,9 @@
  *
  * @dev: the device structure
  *
- * returns none.
+ * returns 0 on success -ENOMEM on allocation failure
  */
-static void mei_hbm_me_cl_allocate(struct mei_device *dev)
+static int mei_hbm_me_cl_allocate(struct mei_device *dev)
 {
         struct mei_me_client *clients;
         int b;
@@ -44,7 +44,7 @@ static void mei_hbm_me_cl_allocate(struct mei_device *dev)
                 dev->me_clients_num++;
 
         if (dev->me_clients_num == 0)
-                return;
+                return 0;
 
         kfree(dev->me_clients);
         dev->me_clients = NULL;
@@ -56,12 +56,10 @@ static void mei_hbm_me_cl_allocate(struct mei_device *dev)
                         sizeof(struct mei_me_client), GFP_KERNEL);
         if (!clients) {
                 dev_err(&dev->pdev->dev, "memory allocation for ME clients failed.\n");
-                dev->dev_state = MEI_DEV_RESETTING;
-                mei_reset(dev, 1);
-                return;
+                return -ENOMEM;
         }
         dev->me_clients = clients;
-        return;
+        return 0;
 }
 
 /**
@@ -137,7 +135,7 @@ int mei_hbm_start_wait(struct mei_device *dev)
         mutex_unlock(&dev->device_lock);
         ret = wait_event_interruptible_timeout(dev->wait_recvd_msg,
                         dev->hbm_state == MEI_HBM_IDLE ||
-                        dev->hbm_state > MEI_HBM_START,
+                        dev->hbm_state >= MEI_HBM_STARTED,
                         mei_secs_to_jiffies(MEI_INTEROP_TIMEOUT));
         mutex_lock(&dev->device_lock);
 
@@ -153,12 +151,15 @@ int mei_hbm_start_wait(struct mei_device *dev)
  * mei_hbm_start_req - sends start request message.
  *
  * @dev: the device structure
+ *
+ * returns 0 on success and < 0 on failure
  */
 int mei_hbm_start_req(struct mei_device *dev)
 {
         struct mei_msg_hdr *mei_hdr = &dev->wr_msg.hdr;
         struct hbm_host_version_request *start_req;
         const size_t len = sizeof(struct hbm_host_version_request);
+        int ret;
 
         mei_hbm_hdr(mei_hdr, len);
 
@@ -170,12 +171,13 @@ int mei_hbm_start_req(struct mei_device *dev)
         start_req->host_version.minor_version = HBM_MINOR_VERSION;
 
         dev->hbm_state = MEI_HBM_IDLE;
-        if (mei_write_message(dev, mei_hdr, dev->wr_msg.data)) {
-                dev_err(&dev->pdev->dev, "version message write failed\n");
-                dev->dev_state = MEI_DEV_RESETTING;
-                mei_reset(dev, 1);
-                return -EIO;
+        ret = mei_write_message(dev, mei_hdr, dev->wr_msg.data);
+        if (ret) {
+                dev_err(&dev->pdev->dev, "version message write failed: ret = %d\n",
+                        ret);
+                return ret;
         }
+
         dev->hbm_state = MEI_HBM_START;
         dev->init_clients_timer = MEI_CLIENTS_INIT_TIMEOUT;
         return 0;
@@ -186,13 +188,15 @@ int mei_hbm_start_req(struct mei_device *dev)
  *
  * @dev: the device structure
  *
- * returns none.
+ * returns 0 on success and < 0 on failure
  */
-static void mei_hbm_enum_clients_req(struct mei_device *dev)
+static int mei_hbm_enum_clients_req(struct mei_device *dev)
 {
         struct mei_msg_hdr *mei_hdr = &dev->wr_msg.hdr;
         struct hbm_host_enum_request *enum_req;
         const size_t len = sizeof(struct hbm_host_enum_request);
+        int ret;
+
         /* enumerate clients */
         mei_hbm_hdr(mei_hdr, len);
 
@@ -200,14 +204,15 @@ static void mei_hbm_enum_clients_req(struct mei_device *dev)
         memset(enum_req, 0, len);
         enum_req->hbm_cmd = HOST_ENUM_REQ_CMD;
 
-        if (mei_write_message(dev, mei_hdr, dev->wr_msg.data)) {
-                dev->dev_state = MEI_DEV_RESETTING;
-                dev_err(&dev->pdev->dev, "enumeration request write failed.\n");
-                mei_reset(dev, 1);
+        ret = mei_write_message(dev, mei_hdr, dev->wr_msg.data);
+        if (ret) {
+                dev_err(&dev->pdev->dev, "enumeration request write failed: ret = %d.\n",
+                        ret);
+                return ret;
         }
         dev->hbm_state = MEI_HBM_ENUM_CLIENTS;
         dev->init_clients_timer = MEI_CLIENTS_INIT_TIMEOUT;
-        return;
+        return 0;
 }
 
 /**
@@ -215,7 +220,7 @@ static void mei_hbm_enum_clients_req(struct mei_device *dev)
  *
  * @dev: the device structure
  *
- * returns none.
+ * returns 0 on success and < 0 on failure
  */
 
 static int mei_hbm_prop_req(struct mei_device *dev)
@@ -226,7 +231,7 @@ static int mei_hbm_prop_req(struct mei_device *dev)
         const size_t len = sizeof(struct hbm_props_request);
         unsigned long next_client_index;
         unsigned long client_num;
-
+        int ret;
 
         client_num = dev->me_client_presentation_num;
 
@@ -253,12 +258,11 @@ static int mei_hbm_prop_req(struct mei_device *dev)
         prop_req->hbm_cmd = HOST_CLIENT_PROPERTIES_REQ_CMD;
         prop_req->address = next_client_index;
 
-        if (mei_write_message(dev, mei_hdr, dev->wr_msg.data)) {
-                dev->dev_state = MEI_DEV_RESETTING;
-                dev_err(&dev->pdev->dev, "properties request write failed\n");
-                mei_reset(dev, 1);
-
-                return -EIO;
+        ret = mei_write_message(dev, mei_hdr, dev->wr_msg.data);
+        if (ret) {
+                dev_err(&dev->pdev->dev, "properties request write failed: ret = %d\n",
+                        ret);
+                return ret;
         }
 
         dev->init_clients_timer = MEI_CLIENTS_INIT_TIMEOUT;
@@ -559,8 +563,10 @@ bool mei_hbm_version_is_supported(struct mei_device *dev)
  *
  * @dev: the device structure
  * @mei_hdr: header of bus message
+ *
+ * returns 0 on success and < 0 on failure
  */
-void mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr)
+int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr)
 {
         struct mei_bus_message *mei_msg;
         struct mei_me_client *me_client;
@@ -579,6 +585,10 @@ void mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr)
 
         switch (mei_msg->hbm_cmd) {
         case HOST_START_RES_CMD:
+                dev_dbg(&dev->pdev->dev, "hbm: start: response message received.\n");
+
+                dev->init_clients_timer = 0;
+
                 version_res = (struct hbm_host_version_response *)mei_msg;
 
                 dev_dbg(&dev->pdev->dev, "HBM VERSION: DRIVER=%02d:%02d DEVICE=%02d:%02d\n",
@@ -597,73 +607,89 @@ void mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr)
                 }
 
                 if (!mei_hbm_version_is_supported(dev)) {
-                        dev_warn(&dev->pdev->dev, "hbm version mismatch: stopping the driver.\n");
+                        dev_warn(&dev->pdev->dev, "hbm: start: version mismatch - stopping the driver.\n");
 
-                        dev->hbm_state = MEI_HBM_STOP;
+                        dev->hbm_state = MEI_HBM_STOPPED;
                         mei_hbm_stop_req_prepare(dev, &dev->wr_msg.hdr,
                                                 dev->wr_msg.data);
-                        mei_write_message(dev, &dev->wr_msg.hdr,
-                                        dev->wr_msg.data);
+                        if (mei_write_message(dev, &dev->wr_msg.hdr,
+                                        dev->wr_msg.data)) {
+                                dev_err(&dev->pdev->dev, "hbm: start: failed to send stop request\n");
+                                return -EIO;
+                        }
+                        break;
+                }
 
-                        return;
+                if (dev->dev_state != MEI_DEV_INIT_CLIENTS ||
+                    dev->hbm_state != MEI_HBM_START) {
+                        dev_err(&dev->pdev->dev, "hbm: start: state mismatch, [%d, %d]\n",
+                                dev->dev_state, dev->hbm_state);
+                        return -EPROTO;
                 }
 
-                if (dev->dev_state == MEI_DEV_INIT_CLIENTS &&
-                    dev->hbm_state == MEI_HBM_START) {
-                        dev->init_clients_timer = 0;
-                        mei_hbm_enum_clients_req(dev);
-                } else {
-                        dev_err(&dev->pdev->dev, "reset: wrong host start response\n");
-                        mei_reset(dev, 1);
-                        return;
+                dev->hbm_state = MEI_HBM_STARTED;
+
+                if (mei_hbm_enum_clients_req(dev)) {
+                        dev_err(&dev->pdev->dev, "hbm: start: failed to send enumeration request\n");
+                        return -EIO;
                 }
 
                 wake_up_interruptible(&dev->wait_recvd_msg);
-                dev_dbg(&dev->pdev->dev, "host start response message received.\n");
                 break;
 
         case CLIENT_CONNECT_RES_CMD:
+                dev_dbg(&dev->pdev->dev, "hbm: client connect response: message received.\n");
+
                 connect_res = (struct hbm_client_connect_response *) mei_msg;
                 mei_hbm_cl_connect_res(dev, connect_res);
-                dev_dbg(&dev->pdev->dev, "client connect response message received.\n");
                 wake_up(&dev->wait_recvd_msg);
                 break;
 
         case CLIENT_DISCONNECT_RES_CMD:
+                dev_dbg(&dev->pdev->dev, "hbm: client disconnect response: message received.\n");
+
                 disconnect_res = (struct hbm_client_connect_response *) mei_msg;
                 mei_hbm_cl_disconnect_res(dev, disconnect_res);
-                dev_dbg(&dev->pdev->dev, "client disconnect response message received.\n");
                 wake_up(&dev->wait_recvd_msg);
                 break;
 
         case MEI_FLOW_CONTROL_CMD:
+                dev_dbg(&dev->pdev->dev, "hbm: client flow control response: message received.\n");
+
                 flow_control = (struct hbm_flow_control *) mei_msg;
                 mei_hbm_cl_flow_control_res(dev, flow_control);
-                dev_dbg(&dev->pdev->dev, "client flow control response message received.\n");
                 break;
 
         case HOST_CLIENT_PROPERTIES_RES_CMD:
+                dev_dbg(&dev->pdev->dev, "hbm: properties response: message received.\n");
+
+                dev->init_clients_timer = 0;
+
+                if (dev->me_clients == NULL) {
+                        dev_err(&dev->pdev->dev, "hbm: properties response: mei_clients not allocated\n");
+                        return -EPROTO;
+                }
+
                 props_res = (struct hbm_props_response *)mei_msg;
                 me_client = &dev->me_clients[dev->me_client_presentation_num];
 
-                if (props_res->status || !dev->me_clients) {
-                        dev_err(&dev->pdev->dev, "reset: properties response hbm wrong status.\n");
-                        mei_reset(dev, 1);
-                        return;
+                if (props_res->status) {
+                        dev_err(&dev->pdev->dev, "hbm: properties response: wrong status = %d\n",
+                                props_res->status);
+                        return -EPROTO;
                 }
 
                 if (me_client->client_id != props_res->address) {
-                        dev_err(&dev->pdev->dev, "reset: host properties response address mismatch\n");
-                        mei_reset(dev, 1);
-                        return;
+                        dev_err(&dev->pdev->dev, "hbm: properties response: address mismatch %d ?= %d\n",
+                                me_client->client_id, props_res->address);
+                        return -EPROTO;
                 }
 
                 if (dev->dev_state != MEI_DEV_INIT_CLIENTS ||
                     dev->hbm_state != MEI_HBM_CLIENT_PROPERTIES) {
-                        dev_err(&dev->pdev->dev, "reset: unexpected properties response\n");
-                        mei_reset(dev, 1);
-
-                        return;
+                        dev_err(&dev->pdev->dev, "hbm: properties response: state mismatch, [%d, %d]\n",
+                                dev->dev_state, dev->hbm_state);
+                        return -EPROTO;
                 }
 
                 me_client->props = props_res->client_properties;
@@ -671,49 +697,70 @@ void mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr)
                 dev->me_client_presentation_num++;
 
                 /* request property for the next client */
-                mei_hbm_prop_req(dev);
+                if (mei_hbm_prop_req(dev))
+                        return -EIO;
 
                 break;
 
         case HOST_ENUM_RES_CMD:
+                dev_dbg(&dev->pdev->dev, "hbm: enumeration response: message received\n");
+
+                dev->init_clients_timer = 0;
+
                 enum_res = (struct hbm_host_enum_response *) mei_msg;
                 BUILD_BUG_ON(sizeof(dev->me_clients_map)
                                 < sizeof(enum_res->valid_addresses));
                 memcpy(dev->me_clients_map, enum_res->valid_addresses,
                         sizeof(enum_res->valid_addresses));
-                if (dev->dev_state == MEI_DEV_INIT_CLIENTS &&
-                    dev->hbm_state == MEI_HBM_ENUM_CLIENTS) {
-                                dev->init_clients_timer = 0;
-                                mei_hbm_me_cl_allocate(dev);
-                                dev->hbm_state = MEI_HBM_CLIENT_PROPERTIES;
-
-                                /* first property reqeust */
-                                mei_hbm_prop_req(dev);
-                } else {
-                        dev_err(&dev->pdev->dev, "reset: unexpected enumeration response hbm.\n");
-                        mei_reset(dev, 1);
-                        return;
+
+                if (dev->dev_state != MEI_DEV_INIT_CLIENTS ||
+                    dev->hbm_state != MEI_HBM_ENUM_CLIENTS) {
+                        dev_err(&dev->pdev->dev, "hbm: enumeration response: state mismatch, [%d, %d]\n",
+                                dev->dev_state, dev->hbm_state);
+                        return -EPROTO;
                 }
+
+                if (mei_hbm_me_cl_allocate(dev)) {
+                        dev_err(&dev->pdev->dev, "hbm: enumeration response: cannot allocate clients array\n");
+                        return -ENOMEM;
+                }
+
+                dev->hbm_state = MEI_HBM_CLIENT_PROPERTIES;
+
+                /* first property request */
+                if (mei_hbm_prop_req(dev))
+                        return -EIO;
+
                 break;
 
         case HOST_STOP_RES_CMD:
+                dev_dbg(&dev->pdev->dev, "hbm: stop response: message received\n");
+
+                dev->init_clients_timer = 0;
+
+                if (dev->hbm_state != MEI_HBM_STOPPED) {
+                        dev_err(&dev->pdev->dev, "hbm: stop response: state mismatch, [%d, %d]\n",
+                                dev->dev_state, dev->hbm_state);
+                        return -EPROTO;
+                }
 
-                if (dev->hbm_state != MEI_HBM_STOP)
-                        dev_err(&dev->pdev->dev, "unexpected stop response hbm.\n");
                 dev->dev_state = MEI_DEV_DISABLED;
-                dev_info(&dev->pdev->dev, "reset: FW stop response.\n");
-                mei_reset(dev, 1);
+                dev_info(&dev->pdev->dev, "hbm: stop response: resetting.\n");
+                /* force the reset */
+                return -EPROTO;
                 break;
 
         case CLIENT_DISCONNECT_REQ_CMD:
-                /* search for client */
+                dev_dbg(&dev->pdev->dev, "hbm: disconnect request: message received\n");
+
                 disconnect_req = (struct hbm_client_connect_request *)mei_msg;
                 mei_hbm_fw_disconnect_req(dev, disconnect_req);
                 break;
 
         case ME_STOP_REQ_CMD:
+                dev_dbg(&dev->pdev->dev, "hbm: stop request: message received\n");
 
-                dev->hbm_state = MEI_HBM_STOP;
+                dev->hbm_state = MEI_HBM_STOPPED;
                 mei_hbm_stop_req_prepare(dev, &dev->wr_ext_msg.hdr,
                                         dev->wr_ext_msg.data);
                 break;
@@ -722,5 +769,6 @@ void mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr)
                 break;
 
         }
+        return 0;
 }