mei: kill usless struct mei_io_list

kill useless mei_io_list list wrapper and use directly
struct mei_cl_cb mei_cb which was its only member for managing io queues

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

1 files changed, 58 insertions, 76 deletions

diff --git a/drivers/misc/mei/interrupt.c b/drivers/misc/mei/interrupt.c
index 320ebd2f06ce..54d6f1a1dbc9 100644
--- a/drivers/misc/mei/interrupt.c
+++ b/drivers/misc/mei/interrupt.c
@@ -87,9 +87,8 @@ static void _mei_cmpl_iamthif(struct mei_device *dev, struct mei_cl_cb *cb_pos)
                 memcpy(cb_pos->response_buffer.data,
                                 dev->iamthif_msg_buf,
                                 dev->iamthif_msg_buf_index);
-                list_add_tail(&cb_pos->cb_list,
-                                &dev->amthi_read_complete_list.mei_cb.cb_list);
-                dev_dbg(&dev->pdev->dev, "amthi read completed.\n");
+                list_add_tail(&cb_pos->list, &dev->amthi_read_complete_list.list);
+                dev_dbg(&dev->pdev->dev, "amthi read completed\n");
                 dev->iamthif_timer = jiffies;
                 dev_dbg(&dev->pdev->dev, "dev->iamthif_timer = %ld\n",
                                 dev->iamthif_timer);
@@ -112,7 +111,7 @@ static void _mei_cmpl_iamthif(struct mei_device *dev, struct mei_cl_cb *cb_pos)
  *
  * returns 0 on success, <0 on failure.
  */
-static int mei_irq_thread_read_amthi_message(struct mei_io_list *complete_list,
+static int mei_irq_thread_read_amthi_message(struct mei_cl_cb *complete_list,
                 struct mei_device *dev,
                 struct mei_msg_hdr *mei_hdr)
 {
@@ -155,8 +154,7 @@ static int mei_irq_thread_read_amthi_message(struct mei_io_list *complete_list,
                 /* found the iamthif cb */
                 dev_dbg(&dev->pdev->dev, "complete the amthi read cb.\n ");
                 dev_dbg(&dev->pdev->dev, "add the amthi read cb to complete.\n ");
-                list_add_tail(&cb->cb_list,
-                                                &complete_list->mei_cb.cb_list);
+                list_add_tail(&cb->list, &complete_list->list);
         }
         return 0;
 }
@@ -188,7 +186,7 @@ static int _mei_irq_thread_state_ok(struct mei_cl *cl,
  *
  * returns 0 on success, <0 on failure.
  */
-static int mei_irq_thread_read_client_message(struct mei_io_list *complete_list,
+static int mei_irq_thread_read_client_message(struct mei_cl_cb *complete_list,
                 struct mei_device *dev,
                 struct mei_msg_hdr *mei_hdr)
 {
@@ -197,11 +195,10 @@ static int mei_irq_thread_read_client_message(struct mei_io_list *complete_list,
         unsigned char *buffer = NULL;
 
         dev_dbg(&dev->pdev->dev, "start client msg\n");
-        if (list_empty(&dev->read_list.mei_cb.cb_list))
+        if (list_empty(&dev->read_list.list))
                 goto quit;
 
-        list_for_each_entry_safe(cb_pos, cb_next,
-                        &dev->read_list.mei_cb.cb_list, cb_list) {
+        list_for_each_entry_safe(cb_pos, cb_next, &dev->read_list.list, list) {
                 cl = (struct mei_cl *)cb_pos->file_private;
                 if (cl && _mei_irq_thread_state_ok(cl, mei_hdr)) {
                         cl->reading_state = MEI_READING;
@@ -210,7 +207,7 @@ static int mei_irq_thread_read_client_message(struct mei_io_list *complete_list,
                         if (cb_pos->response_buffer.size <
                                         mei_hdr->length + cb_pos->buf_idx) {
                                 dev_dbg(&dev->pdev->dev, "message overflow.\n");
-                                list_del(&cb_pos->cb_list);
+                                list_del(&cb_pos->list);
                                 return -ENOMEM;
                         }
                         if (buffer)
@@ -219,15 +216,15 @@ static int mei_irq_thread_read_client_message(struct mei_io_list *complete_list,
                         cb_pos->buf_idx += mei_hdr->length;
                         if (mei_hdr->msg_complete) {
                                 cl->status = 0;
-                                list_del(&cb_pos->cb_list);
+                                list_del(&cb_pos->list);
                                 dev_dbg(&dev->pdev->dev,
                                         "completed read H cl = %d, ME cl = %d, length = %lu\n",
                                         cl->host_client_id,
                                         cl->me_client_id,
                                         cb_pos->buf_idx);
 
-                                list_add_tail(&cb_pos->cb_list,
-                                        &complete_list->mei_cb.cb_list);
+                                list_add_tail(&cb_pos->list,
+                                                &complete_list->list);
                         }
 
                         break;
@@ -291,7 +288,7 @@ static int _mei_irq_thread_iamthif_read(struct mei_device *dev, s32 *slots)
 static int _mei_irq_thread_close(struct mei_device *dev, s32 *slots,
                                 struct mei_cl_cb *cb_pos,
                                 struct mei_cl *cl,
-                                struct mei_io_list *cmpl_list)
+                                struct mei_cl_cb *cmpl_list)
 {
         if ((*slots * sizeof(u32)) < (sizeof(struct mei_msg_hdr) +
                         sizeof(struct hbm_client_disconnect_request)))
@@ -302,15 +299,13 @@ static int _mei_irq_thread_close(struct mei_device *dev, s32 *slots,
         if (mei_disconnect(dev, cl)) {
                 cl->status = 0;
                 cb_pos->buf_idx = 0;
-                list_move_tail(&cb_pos->cb_list,
-                                &cmpl_list->mei_cb.cb_list);
+                list_move_tail(&cb_pos->list, &cmpl_list->list);
                 return -EMSGSIZE;
         } else {
                 cl->state = MEI_FILE_DISCONNECTING;
                 cl->status = 0;
                 cb_pos->buf_idx = 0;
-                list_move_tail(&cb_pos->cb_list,
-                                &dev->ctrl_rd_list.mei_cb.cb_list);
+                list_move_tail(&cb_pos->list, &dev->ctrl_rd_list.list);
                 cl->timer_count = MEI_CONNECT_TIMEOUT;
         }
 
@@ -357,7 +352,7 @@ static void mei_client_connect_response(struct mei_device *dev,
 {
 
         struct mei_cl *cl;
-        struct mei_cl_cb *cb_pos = NULL, *cb_next = NULL;
+        struct mei_cl_cb *pos = NULL, *next = NULL;
 
         dev_dbg(&dev->pdev->dev,
                         "connect_response:\n"
@@ -383,17 +378,16 @@ static void mei_client_connect_response(struct mei_device *dev,
                 dev->iamthif_state = MEI_IAMTHIF_IDLE;
                 return;
         }
-        list_for_each_entry_safe(cb_pos, cb_next,
-                                &dev->ctrl_rd_list.mei_cb.cb_list, cb_list) {
+        list_for_each_entry_safe(pos, next, &dev->ctrl_rd_list.list, list) {
 
-                cl = (struct mei_cl *)cb_pos->file_private;
+                cl = (struct mei_cl *)pos->file_private;
                 if (!cl) {
-                        list_del(&cb_pos->cb_list);
+                        list_del(&pos->list);
                         return;
                 }
-                if (MEI_IOCTL == cb_pos->major_file_operations) {
+                if (MEI_IOCTL == pos->major_file_operations) {
                         if (is_treat_specially_client(cl, rs)) {
-                                list_del(&cb_pos->cb_list);
+                                list_del(&pos->list);
                                 cl->status = 0;
                                 cl->timer_count = 0;
                                 break;
@@ -412,7 +406,7 @@ static void mei_client_disconnect_response(struct mei_device *dev,
                                         struct hbm_client_connect_response *rs)
 {
         struct mei_cl *cl;
-        struct mei_cl_cb *cb_pos = NULL, *cb_next = NULL;
+        struct mei_cl_cb *pos = NULL, *next = NULL;
 
         dev_dbg(&dev->pdev->dev,
                         "disconnect_response:\n"
@@ -423,12 +417,11 @@ static void mei_client_disconnect_response(struct mei_device *dev,
                         rs->host_addr,
                         rs->status);
 
-        list_for_each_entry_safe(cb_pos, cb_next,
-                        &dev->ctrl_rd_list.mei_cb.cb_list, cb_list) {
-                cl = (struct mei_cl *)cb_pos->file_private;
+        list_for_each_entry_safe(pos, next, &dev->ctrl_rd_list.list, list) {
+                cl = (struct mei_cl *)pos->file_private;
 
                 if (!cl) {
-                        list_del(&cb_pos->cb_list);
+                        list_del(&pos->list);
                         return;
                 }
 
@@ -436,7 +429,7 @@ static void mei_client_disconnect_response(struct mei_device *dev,
                 if (cl->host_client_id == rs->host_addr &&
                     cl->me_client_id == rs->me_addr) {
 
-                        list_del(&cb_pos->cb_list);
+                        list_del(&pos->list);
                         if (!rs->status)
                                 cl->state = MEI_FILE_DISCONNECTED;
 
@@ -822,12 +815,12 @@ static void mei_irq_thread_read_bus_message(struct mei_device *dev,
 static int _mei_irq_thread_read(struct mei_device *dev, s32 *slots,
                         struct mei_cl_cb *cb_pos,
                         struct mei_cl *cl,
-                        struct mei_io_list *cmpl_list)
+                        struct mei_cl_cb *cmpl_list)
 {
         if ((*slots * sizeof(u32)) < (sizeof(struct mei_msg_hdr) +
                         sizeof(struct hbm_flow_control))) {
                 /* return the cancel routine */
-                list_del(&cb_pos->cb_list);
+                list_del(&cb_pos->list);
                 return -EBADMSG;
         }
 
@@ -836,10 +829,10 @@ static int _mei_irq_thread_read(struct mei_device *dev,	s32 *slots,
         if (mei_send_flow_control(dev, cl)) {
                 cl->status = -ENODEV;
                 cb_pos->buf_idx = 0;
-                list_move_tail(&cb_pos->cb_list, &cmpl_list->mei_cb.cb_list);
+                list_move_tail(&cb_pos->list, &cmpl_list->list);
                 return -ENODEV;
         }
-        list_move_tail(&cb_pos->cb_list, &dev->read_list.mei_cb.cb_list);
+        list_move_tail(&cb_pos->list, &dev->read_list.list);
 
         return 0;
 }
@@ -859,12 +852,12 @@ static int _mei_irq_thread_read(struct mei_device *dev,	s32 *slots,
 static int _mei_irq_thread_ioctl(struct mei_device *dev, s32 *slots,
                         struct mei_cl_cb *cb_pos,
                         struct mei_cl *cl,
-                        struct mei_io_list *cmpl_list)
+                        struct mei_cl_cb *cmpl_list)
 {
         if ((*slots * sizeof(u32)) < (sizeof(struct mei_msg_hdr) +
                         sizeof(struct hbm_client_connect_request))) {
                 /* return the cancel routine */
-                list_del(&cb_pos->cb_list);
+                list_del(&cb_pos->list);
                 return -EBADMSG;
         }
 
@@ -873,11 +866,10 @@ static int _mei_irq_thread_ioctl(struct mei_device *dev, s32 *slots,
         if (mei_connect(dev, cl)) {
                 cl->status = -ENODEV;
                 cb_pos->buf_idx = 0;
-                list_del(&cb_pos->cb_list);
+                list_del(&cb_pos->list);
                 return -ENODEV;
         } else {
-                list_move_tail(&cb_pos->cb_list,
-                        &dev->ctrl_rd_list.mei_cb.cb_list);
+                list_move_tail(&cb_pos->list, &dev->ctrl_rd_list.list);
                 cl->timer_count = MEI_CONNECT_TIMEOUT;
         }
         return 0;
@@ -897,7 +889,7 @@ static int _mei_irq_thread_ioctl(struct mei_device *dev, s32 *slots,
 static int _mei_irq_thread_cmpl(struct mei_device *dev, s32 *slots,
                         struct mei_cl_cb *cb_pos,
                         struct mei_cl *cl,
-                        struct mei_io_list *cmpl_list)
+                        struct mei_cl_cb *cmpl_list)
 {
         struct mei_msg_hdr *mei_hdr;
 
@@ -924,16 +916,14 @@ static int _mei_irq_thread_cmpl(struct mei_device *dev,	s32 *slots,
                                 cb_pos->buf_idx),
                                 mei_hdr->length)) {
                         cl->status = -ENODEV;
-                        list_move_tail(&cb_pos->cb_list,
-                                &cmpl_list->mei_cb.cb_list);
+                        list_move_tail(&cb_pos->list, &cmpl_list->list);
                         return -ENODEV;
                 } else {
                         if (mei_flow_ctrl_reduce(dev, cl))
                                 return -ENODEV;
                         cl->status = 0;
                         cb_pos->buf_idx += mei_hdr->length;
-                        list_move_tail(&cb_pos->cb_list,
-                                &dev->write_waiting_list.mei_cb.cb_list);
+                        list_move_tail(&cb_pos->list, &dev->write_waiting_list.list);
                 }
         } else if (*slots == dev->hbuf_depth) {
                 /* buffer is still empty */
@@ -951,8 +941,7 @@ static int _mei_irq_thread_cmpl(struct mei_device *dev,	s32 *slots,
                                         cb_pos->buf_idx),
                                         mei_hdr->length)) {
                         cl->status = -ENODEV;
-                        list_move_tail(&cb_pos->cb_list,
-                                &cmpl_list->mei_cb.cb_list);
+                        list_move_tail(&cb_pos->list, &cmpl_list->list);
                         return -ENODEV;
                 } else {
                         cb_pos->buf_idx += mei_hdr->length;
@@ -988,7 +977,7 @@ static int _mei_irq_thread_cmpl(struct mei_device *dev,	s32 *slots,
 static int _mei_irq_thread_cmpl_iamthif(struct mei_device *dev, s32 *slots,
                         struct mei_cl_cb *cb_pos,
                         struct mei_cl *cl,
-                        struct mei_io_list *cmpl_list)
+                        struct mei_cl_cb *cmpl_list)
 {
         struct mei_msg_hdr *mei_hdr;
 
@@ -1011,7 +1000,7 @@ static int _mei_irq_thread_cmpl_iamthif(struct mei_device *dev, s32 *slots,
                                         mei_hdr->length)) {
                         dev->iamthif_state = MEI_IAMTHIF_IDLE;
                         cl->status = -ENODEV;
-                        list_del(&cb_pos->cb_list);
+                        list_del(&cb_pos->list);
                         return -ENODEV;
                 } else {
                         if (mei_flow_ctrl_reduce(dev, cl))
@@ -1023,8 +1012,7 @@ static int _mei_irq_thread_cmpl_iamthif(struct mei_device *dev, s32 *slots,
                         dev->iamthif_flow_control_pending = true;
                         /* save iamthif cb sent to amthi client */
                         dev->iamthif_current_cb = cb_pos;
-                        list_move_tail(&cb_pos->cb_list,
-                                &dev->write_waiting_list.mei_cb.cb_list);
+                        list_move_tail(&cb_pos->list, &dev->write_waiting_list.list);
 
                 }
         } else if (*slots == dev->hbuf_depth) {
@@ -1044,7 +1032,7 @@ static int _mei_irq_thread_cmpl_iamthif(struct mei_device *dev, s32 *slots,
                                         dev->iamthif_msg_buf_index),
                                         mei_hdr->length)) {
                         cl->status = -ENODEV;
-                        list_del(&cb_pos->cb_list);
+                        list_del(&cb_pos->list);
                 } else {
                         dev->iamthif_msg_buf_index += mei_hdr->length;
                 }
@@ -1066,7 +1054,7 @@ static int _mei_irq_thread_cmpl_iamthif(struct mei_device *dev, s32 *slots,
  *
  * returns 0 on success, <0 on failure.
  */
-static int mei_irq_thread_read_handler(struct mei_io_list *cmpl_list,
+static int mei_irq_thread_read_handler(struct mei_cl_cb *cmpl_list,
                 struct mei_device *dev,
                 s32 *slots)
 {
@@ -1169,14 +1157,13 @@ end:
  *
  * returns 0 on success, <0 on failure.
  */
-static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
-                struct mei_device *dev,
-                s32 *slots)
+static int mei_irq_thread_write_handler(struct mei_cl_cb *cmpl_list,
+                struct mei_device *dev, s32 *slots)
 {
 
         struct mei_cl *cl;
         struct mei_cl_cb *pos = NULL, *next = NULL;
-        struct mei_io_list *list;
+        struct mei_cl_cb *list;
         int ret;
 
         if (!mei_hbuf_is_empty(dev)) {
@@ -1191,20 +1178,19 @@ static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
         dev_dbg(&dev->pdev->dev, "complete all waiting for write cb.\n");
 
         list = &dev->write_waiting_list;
-        list_for_each_entry_safe(pos, next, &list->mei_cb.cb_list, cb_list) {
+        list_for_each_entry_safe(pos, next, &list->list, list) {
                 cl = (struct mei_cl *)pos->file_private;
                 if (cl == NULL)
                         continue;
 
                 cl->status = 0;
-                list_del(&pos->cb_list);
+                list_del(&pos->list);
                 if (MEI_WRITING == cl->writing_state &&
                    (pos->major_file_operations == MEI_WRITE) &&
                    (cl != &dev->iamthif_cl)) {
                         dev_dbg(&dev->pdev->dev, "MEI WRITE COMPLETE\n");
                         cl->writing_state = MEI_WRITE_COMPLETE;
-                        list_add_tail(&pos->cb_list,
-                                      &cmpl_list->mei_cb.cb_list);
+                        list_add_tail(&pos->list, &cmpl_list->list);
                 }
                 if (cl == &dev->iamthif_cl) {
                         dev_dbg(&dev->pdev->dev, "check iamthif flow control.\n");
@@ -1250,11 +1236,10 @@ static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
 
         /* complete control write list CB */
         dev_dbg(&dev->pdev->dev, "complete control write list cb.\n");
-        list_for_each_entry_safe(pos, next,
-                                &dev->ctrl_wr_list.mei_cb.cb_list, cb_list) {
+        list_for_each_entry_safe(pos, next, &dev->ctrl_wr_list.list, list) {
                 cl = (struct mei_cl *) pos->file_private;
                 if (!cl) {
-                        list_del(&pos->cb_list);
+                        list_del(&pos->list);
                         return -ENODEV;
                 }
                 switch (pos->major_file_operations) {
@@ -1289,8 +1274,7 @@ static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
         }
         /* complete  write list CB */
         dev_dbg(&dev->pdev->dev, "complete write list cb.\n");
-        list_for_each_entry_safe(pos, next,
-                                &dev->write_list.mei_cb.cb_list, cb_list) {
+        list_for_each_entry_safe(pos, next, &dev->write_list.list, list) {
                 cl = (struct mei_cl *)pos->file_private;
                 if (cl == NULL)
                         continue;
@@ -1410,16 +1394,15 @@ void mei_timer(struct work_struct *work)
 
                         dev_dbg(&dev->pdev->dev, "freeing AMTHI for other requests\n");
 
-                        amthi_complete_list = &dev->amthi_read_complete_list.
-                                        mei_cb.cb_list;
+                        amthi_complete_list = &dev->amthi_read_complete_list.list;
 
-                        list_for_each_entry_safe(cb_pos, cb_next, amthi_complete_list, cb_list) {
+                        list_for_each_entry_safe(cb_pos, cb_next, amthi_complete_list, list) {
 
                                 cl_pos = cb_pos->file_object->private_data;
 
                                 /* Finding the AMTHI entry. */
                                 if (cl_pos == &dev->iamthif_cl)
-                                        list_del(&cb_pos->cb_list);
+                                        list_del(&cb_pos->list);
                         }
                         if (dev->iamthif_current_cb)
                                 mei_free_cb_private(dev->iamthif_current_cb);
@@ -1450,7 +1433,7 @@ out:
 irqreturn_t mei_interrupt_thread_handler(int irq, void *dev_id)
 {
         struct mei_device *dev = (struct mei_device *) dev_id;
-        struct mei_io_list complete_list;
+        struct mei_cl_cb complete_list;
         struct mei_cl_cb *cb_pos = NULL, *cb_next = NULL;
         struct mei_cl *cl;
         s32 slots;
@@ -1530,14 +1513,13 @@ end:
                 wake_up_interruptible(&dev->wait_recvd_msg);
                 bus_message_received = false;
         }
-        if (list_empty(&complete_list.mei_cb.cb_list))
+        if (list_empty(&complete_list.list))
                 return IRQ_HANDLED;
 
 
-        list_for_each_entry_safe(cb_pos, cb_next,
-                        &complete_list.mei_cb.cb_list, cb_list) {
+        list_for_each_entry_safe(cb_pos, cb_next, &complete_list.list, list) {
                 cl = (struct mei_cl *)cb_pos->file_private;
-                list_del(&cb_pos->cb_list);
+                list_del(&cb_pos->list);
                 if (cl) {
                         if (cl != &dev->iamthif_cl) {
                                 dev_dbg(&dev->pdev->dev, "completing call back.\n");