1 files changed, 152 insertions, 129 deletions

diff --git a/drivers/misc/mei/hbm.c b/drivers/misc/mei/hbm.c
index 28cd74c073b9..4960288e543a 100644
--- a/drivers/misc/mei/hbm.c
+++ b/drivers/misc/mei/hbm.c
@@ -21,7 +21,41 @@
 
 #include "mei_dev.h"
 #include "hbm.h"
-#include "hw-me.h"
+#include "client.h"
+
+static const char *mei_cl_conn_status_str(enum mei_cl_connect_status status)
+{
+#define MEI_CL_CS(status) case MEI_CL_CONN_##status: return #status
+        switch (status) {
+        MEI_CL_CS(SUCCESS);
+        MEI_CL_CS(NOT_FOUND);
+        MEI_CL_CS(ALREADY_STARTED);
+        MEI_CL_CS(OUT_OF_RESOURCES);
+        MEI_CL_CS(MESSAGE_SMALL);
+        default: return "unknown";
+        }
+#undef MEI_CL_CCS
+}
+
+/**
+ * mei_cl_conn_status_to_errno - convert client connect response
+ * status to error code
+ *
+ * @status: client connect response status
+ *
+ * returns corresponding error code
+ */
+static int mei_cl_conn_status_to_errno(enum mei_cl_connect_status status)
+{
+        switch (status) {
+        case MEI_CL_CONN_SUCCESS:          return 0;
+        case MEI_CL_CONN_NOT_FOUND:        return -ENOTTY;
+        case MEI_CL_CONN_ALREADY_STARTED:  return -EBUSY;
+        case MEI_CL_CONN_OUT_OF_RESOURCES: return -EBUSY;
+        case MEI_CL_CONN_MESSAGE_SMALL:    return -EINVAL;
+        default:                           return -EINVAL;
+        }
+}
 
 /**
  * mei_hbm_me_cl_allocate - allocates storage for me clients
@@ -100,33 +134,6 @@ bool mei_hbm_cl_addr_equal(struct mei_cl *cl, void *buf)
 
 
 /**
- * is_treat_specially_client - checks if the message belongs
- * to the file private data.
- *
- * @cl: private data of the file object
- * @rs: connect response bus message
- *
- */
-static bool is_treat_specially_client(struct mei_cl *cl,
-                struct hbm_client_connect_response *rs)
-{
-        if (mei_hbm_cl_addr_equal(cl, rs)) {
-                if (!rs->status) {
-                        cl->state = MEI_FILE_CONNECTED;
-                        cl->status = 0;
-
-                } else {
-                        cl->state = MEI_FILE_DISCONNECTED;
-                        cl->status = -ENODEV;
-                }
-                cl->timer_count = 0;
-
-                return true;
-        }
-        return false;
-}
-
-/**
  * mei_hbm_idle - set hbm to idle state
  *
  * @dev: the device structure
@@ -147,13 +154,13 @@ int mei_hbm_start_wait(struct mei_device *dev)
         ret = wait_event_interruptible_timeout(dev->wait_recvd_msg,
                         dev->hbm_state == MEI_HBM_IDLE ||
                         dev->hbm_state >= MEI_HBM_STARTED,
-                        mei_secs_to_jiffies(MEI_INTEROP_TIMEOUT));
+                        mei_secs_to_jiffies(MEI_HBM_TIMEOUT));
         mutex_lock(&dev->device_lock);
 
         if (ret <= 0 && (dev->hbm_state <= MEI_HBM_START)) {
                 dev->hbm_state = MEI_HBM_IDLE;
                 dev_err(&dev->pdev->dev, "waiting for mei start failed\n");
-                return -ETIMEDOUT;
+                return -ETIME;
         }
         return 0;
 }
@@ -283,17 +290,18 @@ static int mei_hbm_prop_req(struct mei_device *dev)
 }
 
 /**
- * mei_hbm_stop_req_prepare - prepare stop request message
+ * mei_hbm_stop_req - send stop request message
  *
  * @dev - mei device
- * @mei_hdr - mei message header
- * @data - hbm message body buffer
+ * @cl: client info
+ *
+ * This function returns -EIO on write failure
  */
-static void mei_hbm_stop_req_prepare(struct mei_device *dev,
-                struct mei_msg_hdr *mei_hdr, unsigned char *data)
+static int mei_hbm_stop_req(struct mei_device *dev)
 {
+        struct mei_msg_hdr *mei_hdr = &dev->wr_msg.hdr;
         struct hbm_host_stop_request *req =
-                        (struct hbm_host_stop_request *)data;
+                        (struct hbm_host_stop_request *)dev->wr_msg.data;
         const size_t len = sizeof(struct hbm_host_stop_request);
 
         mei_hbm_hdr(mei_hdr, len);
@@ -301,6 +309,8 @@ static void mei_hbm_stop_req_prepare(struct mei_device *dev,
         memset(req, 0, len);
         req->hbm_cmd = HOST_STOP_REQ_CMD;
         req->reason = DRIVER_STOP_REQUEST;
+
+        return mei_write_message(dev, mei_hdr, dev->wr_msg.data);
 }
 
 /**
@@ -319,8 +329,7 @@ int mei_hbm_cl_flow_control_req(struct mei_device *dev, struct mei_cl *cl)
         mei_hbm_hdr(mei_hdr, len);
         mei_hbm_cl_hdr(cl, MEI_FLOW_CONTROL_CMD, dev->wr_msg.data, len);
 
-        dev_dbg(&dev->pdev->dev, "sending flow control host client = %d, ME client = %d\n",
-                cl->host_client_id, cl->me_client_id);
+        cl_dbg(dev, cl, "sending flow control\n");
 
         return mei_write_message(dev, mei_hdr, dev->wr_msg.data);
 }
@@ -330,27 +339,34 @@ int mei_hbm_cl_flow_control_req(struct mei_device *dev, struct mei_cl *cl)
  *
  * @dev: the device structure
  * @flow: flow control.
+ *
+ * return 0 on success, < 0 otherwise
  */
-static void mei_hbm_add_single_flow_creds(struct mei_device *dev,
+static int mei_hbm_add_single_flow_creds(struct mei_device *dev,
                                   struct hbm_flow_control *flow)
 {
-        struct mei_me_client *client;
-        int i;
-
-        for (i = 0; i < dev->me_clients_num; i++) {
-                client = &dev->me_clients[i];
-                if (client && flow->me_addr == client->client_id) {
-                        if (client->props.single_recv_buf) {
-                                client->mei_flow_ctrl_creds++;
-                                dev_dbg(&dev->pdev->dev, "recv flow ctrl msg ME %d (single).\n",
-                                    flow->me_addr);
-                                dev_dbg(&dev->pdev->dev, "flow control credentials =%d.\n",
-                                    client->mei_flow_ctrl_creds);
-                        } else {
-                                BUG();  /* error in flow control */
-                        }
-                }
+        struct mei_me_client *me_cl;
+        int id;
+
+        id = mei_me_cl_by_id(dev, flow->me_addr);
+        if (id < 0) {
+                dev_err(&dev->pdev->dev, "no such me client %d\n",
+                        flow->me_addr);
+                return id;
         }
+
+        me_cl = &dev->me_clients[id];
+        if (me_cl->props.single_recv_buf) {
+                me_cl->mei_flow_ctrl_creds++;
+                dev_dbg(&dev->pdev->dev, "recv flow ctrl msg ME %d (single).\n",
+                    flow->me_addr);
+                dev_dbg(&dev->pdev->dev, "flow control credentials =%d.\n",
+                    me_cl->mei_flow_ctrl_creds);
+        } else {
+                BUG();  /* error in flow control */
+        }
+
+        return 0;
 }
 
 /**
@@ -362,8 +378,7 @@ static void mei_hbm_add_single_flow_creds(struct mei_device *dev,
 static void mei_hbm_cl_flow_control_res(struct mei_device *dev,
                 struct hbm_flow_control *flow_control)
 {
-        struct mei_cl *cl = NULL;
-        struct mei_cl *next = NULL;
+        struct mei_cl *cl;
 
         if (!flow_control->host_addr) {
                 /* single receive buffer */
@@ -372,7 +387,7 @@ static void mei_hbm_cl_flow_control_res(struct mei_device *dev,
         }
 
         /* normal connection */
-        list_for_each_entry_safe(cl, next, &dev->file_list, link) {
+        list_for_each_entry(cl, &dev->file_list, link) {
                 if (mei_hbm_cl_addr_equal(cl, flow_control)) {
                         cl->mei_flow_ctrl_creds++;
                         dev_dbg(&dev->pdev->dev, "flow ctrl msg for host %d ME %d.\n",
@@ -405,6 +420,25 @@ int mei_hbm_cl_disconnect_req(struct mei_device *dev, struct mei_cl *cl)
 }
 
 /**
+ * mei_hbm_cl_disconnect_rsp - sends disconnect respose to the FW
+ *
+ * @dev: the device structure
+ * @cl: a client to disconnect from
+ *
+ * This function returns -EIO on write failure
+ */
+int mei_hbm_cl_disconnect_rsp(struct mei_device *dev, struct mei_cl *cl)
+{
+        struct mei_msg_hdr *mei_hdr = &dev->wr_msg.hdr;
+        const size_t len = sizeof(struct hbm_client_connect_response);
+
+        mei_hbm_hdr(mei_hdr, len);
+        mei_hbm_cl_hdr(cl, CLIENT_DISCONNECT_RES_CMD, dev->wr_msg.data, len);
+
+        return mei_write_message(dev, mei_hdr, dev->wr_msg.data);
+}
+
+/**
  * mei_hbm_cl_disconnect_res - disconnect response from ME
  *
  * @dev: the device structure
@@ -414,29 +448,23 @@ static void mei_hbm_cl_disconnect_res(struct mei_device *dev,
                 struct hbm_client_connect_response *rs)
 {
         struct mei_cl *cl;
-        struct mei_cl_cb *pos = NULL, *next = NULL;
-
-        dev_dbg(&dev->pdev->dev,
-                        "disconnect_response:\n"
-                        "ME Client = %d\n"
-                        "Host Client = %d\n"
-                        "Status = %d\n",
-                        rs->me_addr,
-                        rs->host_addr,
-                        rs->status);
-
-        list_for_each_entry_safe(pos, next, &dev->ctrl_rd_list.list, list) {
-                cl = pos->cl;
-
-                if (!cl) {
-                        list_del(&pos->list);
+        struct mei_cl_cb *cb, *next;
+
+        dev_dbg(&dev->pdev->dev, "hbm: disconnect response cl:host=%02d me=%02d status=%d\n",
+                        rs->me_addr, rs->host_addr, rs->status);
+
+        list_for_each_entry_safe(cb, next, &dev->ctrl_rd_list.list, list) {
+                cl = cb->cl;
+
+                /* this should not happen */
+                if (WARN_ON(!cl)) {
+                        list_del(&cb->list);
                         return;
                 }
 
-                dev_dbg(&dev->pdev->dev, "list_for_each_entry_safe in ctrl_rd_list.\n");
                 if (mei_hbm_cl_addr_equal(cl, rs)) {
-                        list_del(&pos->list);
-                        if (!rs->status)
+                        list_del(&cb->list);
+                        if (rs->status == MEI_CL_DISCONN_SUCCESS)
                                 cl->state = MEI_FILE_DISCONNECTED;
 
                         cl->status = 0;
@@ -476,46 +504,41 @@ static void mei_hbm_cl_connect_res(struct mei_device *dev,
 {
 
         struct mei_cl *cl;
-        struct mei_cl_cb *pos = NULL, *next = NULL;
+        struct mei_cl_cb *cb, *next;
 
-        dev_dbg(&dev->pdev->dev,
-                        "connect_response:\n"
-                        "ME Client = %d\n"
-                        "Host Client = %d\n"
-                        "Status = %d\n",
-                        rs->me_addr,
-                        rs->host_addr,
-                        rs->status);
+        dev_dbg(&dev->pdev->dev, "hbm: connect response cl:host=%02d me=%02d status=%s\n",
+                        rs->me_addr, rs->host_addr,
+                        mei_cl_conn_status_str(rs->status));
 
-        /* if WD or iamthif client treat specially */
+        cl = NULL;
 
-        if (is_treat_specially_client(&dev->wd_cl, rs)) {
-                dev_dbg(&dev->pdev->dev, "successfully connected to WD client.\n");
-                mei_watchdog_register(dev);
+        list_for_each_entry_safe(cb, next, &dev->ctrl_rd_list.list, list) {
 
-                return;
-        }
+                cl = cb->cl;
+                /* this should not happen */
+                if (WARN_ON(!cl)) {
+                        list_del_init(&cb->list);
+                        continue;
+                }
 
-        if (is_treat_specially_client(&dev->iamthif_cl, rs)) {
-                dev->iamthif_state = MEI_IAMTHIF_IDLE;
-                return;
-        }
-        list_for_each_entry_safe(pos, next, &dev->ctrl_rd_list.list, list) {
+                if (cb->fop_type !=  MEI_FOP_CONNECT)
+                        continue;
 
-                cl = pos->cl;
-                if (!cl) {
-                        list_del(&pos->list);
-                        return;
-                }
-                if (pos->fop_type == MEI_FOP_IOCTL) {
-                        if (is_treat_specially_client(cl, rs)) {
-                                list_del(&pos->list);
-                                cl->status = 0;
-                                cl->timer_count = 0;
-                                break;
-                        }
+                if (mei_hbm_cl_addr_equal(cl, rs)) {
+                        list_del(&cb->list);
+                        break;
                 }
         }
+
+        if (!cl)
+                return;
+
+        cl->timer_count = 0;
+        if (rs->status == MEI_CL_CONN_SUCCESS)
+                cl->state = MEI_FILE_CONNECTED;
+        else
+                cl->state = MEI_FILE_DISCONNECTED;
+        cl->status = mei_cl_conn_status_to_errno(rs->status);
 }
 
 
@@ -525,32 +548,34 @@ static void mei_hbm_cl_connect_res(struct mei_device *dev,
  *
  * @dev: the device structure.
  * @disconnect_req: disconnect request bus message from the me
+ *
+ * returns -ENOMEM on allocation failure
  */
-static void mei_hbm_fw_disconnect_req(struct mei_device *dev,
+static int mei_hbm_fw_disconnect_req(struct mei_device *dev,
                 struct hbm_client_connect_request *disconnect_req)
 {
-        struct mei_cl *cl, *next;
-        const size_t len = sizeof(struct hbm_client_connect_response);
+        struct mei_cl *cl;
+        struct mei_cl_cb *cb;
 
-        list_for_each_entry_safe(cl, next, &dev->file_list, link) {
+        list_for_each_entry(cl, &dev->file_list, link) {
                 if (mei_hbm_cl_addr_equal(cl, disconnect_req)) {
                         dev_dbg(&dev->pdev->dev, "disconnect request host client %d ME client %d.\n",
                                         disconnect_req->host_addr,
                                         disconnect_req->me_addr);
                         cl->state = MEI_FILE_DISCONNECTED;
                         cl->timer_count = 0;
-                        if (cl == &dev->wd_cl)
-                                dev->wd_pending = false;
-                        else if (cl == &dev->iamthif_cl)
-                                dev->iamthif_timer = 0;
-
-                        /* prepare disconnect response */
-                        mei_hbm_hdr(&dev->wr_ext_msg.hdr, len);
-                        mei_hbm_cl_hdr(cl, CLIENT_DISCONNECT_RES_CMD,
-                                         dev->wr_ext_msg.data, len);
+
+                        cb = mei_io_cb_init(cl, NULL);
+                        if (!cb)
+                                return -ENOMEM;
+                        cb->fop_type = MEI_FOP_DISCONNECT_RSP;
+                        cl_dbg(dev, cl, "add disconnect response as first\n");
+                        list_add(&cb->list, &dev->ctrl_wr_list.list);
+
                         break;
                 }
         }
+        return 0;
 }
 
 
@@ -629,10 +654,7 @@ int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr)
                         dev_warn(&dev->pdev->dev, "hbm: start: version mismatch - stopping the driver.\n");
 
                         dev->hbm_state = MEI_HBM_STOPPED;
-                        mei_hbm_stop_req_prepare(dev, &dev->wr_msg.hdr,
-                                                dev->wr_msg.data);
-                        if (mei_write_message(dev, &dev->wr_msg.hdr,
-                                        dev->wr_msg.data)) {
+                        if (mei_hbm_stop_req(dev)) {
                                 dev_err(&dev->pdev->dev, "hbm: start: failed to send stop request\n");
                                 return -EIO;
                         }
@@ -778,10 +800,11 @@ int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr)
 
         case ME_STOP_REQ_CMD:
                 dev_dbg(&dev->pdev->dev, "hbm: stop request: message received\n");
-
                 dev->hbm_state = MEI_HBM_STOPPED;
-                mei_hbm_stop_req_prepare(dev, &dev->wr_ext_msg.hdr,
-                                        dev->wr_ext_msg.data);
+                if (mei_hbm_stop_req(dev)) {
+                        dev_err(&dev->pdev->dev, "hbm: start: failed to send stop request\n");
+                        return -EIO;
+                }
                 break;
         default:
                 BUG();