Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 1 | /* |
| 2 | * |
| 3 | * Intel Management Engine Interface (Intel MEI) Linux driver |
Tomas Winkler | 733ba91 | 2012-02-09 19:25:53 +0200 | [diff] [blame] | 4 | * Copyright (c) 2003-2012, Intel Corporation. |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify it |
| 7 | * under the terms and conditions of the GNU General Public License, |
| 8 | * version 2, as published by the Free Software Foundation. |
| 9 | * |
| 10 | * This program is distributed in the hope it will be useful, but WITHOUT |
| 11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| 13 | * more details. |
| 14 | * |
| 15 | */ |
| 16 | |
| 17 | |
Tomas Winkler | 40e0b67 | 2013-03-27 16:58:30 +0200 | [diff] [blame] | 18 | #include <linux/export.h> |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 19 | #include <linux/pci.h> |
| 20 | #include <linux/kthread.h> |
| 21 | #include <linux/interrupt.h> |
| 22 | #include <linux/fs.h> |
| 23 | #include <linux/jiffies.h> |
| 24 | |
Tomas Winkler | 4f3afe1 | 2012-05-09 16:38:59 +0300 | [diff] [blame] | 25 | #include <linux/mei.h> |
Tomas Winkler | 47a7380 | 2012-12-25 19:06:03 +0200 | [diff] [blame] | 26 | |
| 27 | #include "mei_dev.h" |
Tomas Winkler | 0edb23f | 2013-01-08 23:07:12 +0200 | [diff] [blame] | 28 | #include "hbm.h" |
Tomas Winkler | 9dc64d6 | 2013-01-08 23:07:17 +0200 | [diff] [blame] | 29 | #include "hw-me.h" |
Tomas Winkler | 90e0b5f | 2013-01-08 23:07:14 +0200 | [diff] [blame] | 30 | #include "client.h" |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 31 | |
| 32 | |
| 33 | /** |
Tomas Winkler | 4c6e22b | 2013-03-17 11:41:20 +0200 | [diff] [blame] | 34 | * mei_irq_compl_handler - dispatch complete handelers |
| 35 | * for the completed callbacks |
| 36 | * |
| 37 | * @dev - mei device |
| 38 | * @compl_list - list of completed cbs |
| 39 | */ |
| 40 | void mei_irq_compl_handler(struct mei_device *dev, struct mei_cl_cb *compl_list) |
| 41 | { |
| 42 | struct mei_cl_cb *cb, *next; |
| 43 | struct mei_cl *cl; |
| 44 | |
| 45 | list_for_each_entry_safe(cb, next, &compl_list->list, list) { |
| 46 | cl = cb->cl; |
| 47 | list_del(&cb->list); |
| 48 | if (!cl) |
| 49 | continue; |
| 50 | |
| 51 | dev_dbg(&dev->pdev->dev, "completing call back.\n"); |
| 52 | if (cl == &dev->iamthif_cl) |
| 53 | mei_amthif_complete(dev, cb); |
| 54 | else |
Tomas Winkler | db086fa | 2013-05-12 15:34:45 +0300 | [diff] [blame] | 55 | mei_cl_complete(cl, cb); |
Tomas Winkler | 4c6e22b | 2013-03-17 11:41:20 +0200 | [diff] [blame] | 56 | } |
| 57 | } |
Tomas Winkler | 40e0b67 | 2013-03-27 16:58:30 +0200 | [diff] [blame] | 58 | EXPORT_SYMBOL_GPL(mei_irq_compl_handler); |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 59 | |
Tomas Winkler | 4c6e22b | 2013-03-17 11:41:20 +0200 | [diff] [blame] | 60 | /** |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 61 | * mei_cl_hbm_equal - check if hbm is addressed to the client |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 62 | * |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 63 | * @cl: host client |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 64 | * @mei_hdr: header of mei client message |
| 65 | * |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 66 | * returns true if matches, false otherwise |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 67 | */ |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 68 | static inline int mei_cl_hbm_equal(struct mei_cl *cl, |
| 69 | struct mei_msg_hdr *mei_hdr) |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 70 | { |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 71 | return cl->host_client_id == mei_hdr->host_addr && |
| 72 | cl->me_client_id == mei_hdr->me_addr; |
| 73 | } |
| 74 | /** |
| 75 | * mei_cl_is_reading - checks if the client |
| 76 | is the one to read this message |
| 77 | * |
| 78 | * @cl: mei client |
| 79 | * @mei_hdr: header of mei message |
| 80 | * |
| 81 | * returns true on match and false otherwise |
| 82 | */ |
| 83 | static bool mei_cl_is_reading(struct mei_cl *cl, struct mei_msg_hdr *mei_hdr) |
| 84 | { |
| 85 | return mei_cl_hbm_equal(cl, mei_hdr) && |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 86 | cl->state == MEI_FILE_CONNECTED && |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 87 | cl->reading_state != MEI_READ_COMPLETE; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 88 | } |
| 89 | |
| 90 | /** |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 91 | * mei_irq_read_client_message - process client message |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 92 | * |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 93 | * @dev: the device structure |
| 94 | * @mei_hdr: header of mei client message |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 95 | * @complete_list: An instance of our list structure |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 96 | * |
| 97 | * returns 0 on success, <0 on failure. |
| 98 | */ |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 99 | static int mei_cl_irq_read_msg(struct mei_device *dev, |
| 100 | struct mei_msg_hdr *mei_hdr, |
| 101 | struct mei_cl_cb *complete_list) |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 102 | { |
| 103 | struct mei_cl *cl; |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 104 | struct mei_cl_cb *cb, *next; |
Tomas Winkler | 479bc59 | 2011-06-16 00:46:03 +0300 | [diff] [blame] | 105 | unsigned char *buffer = NULL; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 106 | |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 107 | list_for_each_entry_safe(cb, next, &dev->read_list.list, list) { |
| 108 | cl = cb->cl; |
| 109 | if (!cl || !mei_cl_is_reading(cl, mei_hdr)) |
| 110 | continue; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 111 | |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 112 | cl->reading_state = MEI_READING; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 113 | |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 114 | if (cb->response_buffer.size == 0 || |
| 115 | cb->response_buffer.data == NULL) { |
Alexander Usyskin | c0abffb | 2013-09-15 18:11:07 +0300 | [diff] [blame] | 116 | cl_err(dev, cl, "response buffer is not allocated.\n"); |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 117 | list_del(&cb->list); |
| 118 | return -ENOMEM; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 119 | } |
| 120 | |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 121 | if (cb->response_buffer.size < mei_hdr->length + cb->buf_idx) { |
Alexander Usyskin | c0abffb | 2013-09-15 18:11:07 +0300 | [diff] [blame] | 122 | cl_dbg(dev, cl, "message overflow. size %d len %d idx %ld\n", |
Tomas Winkler | fcb136e | 2013-04-19 22:01:35 +0300 | [diff] [blame] | 123 | cb->response_buffer.size, |
| 124 | mei_hdr->length, cb->buf_idx); |
Wei Yongjun | 46e407d | 2013-04-23 10:44:35 +0800 | [diff] [blame] | 125 | buffer = krealloc(cb->response_buffer.data, |
| 126 | mei_hdr->length + cb->buf_idx, |
| 127 | GFP_KERNEL); |
Tomas Winkler | fcb136e | 2013-04-19 22:01:35 +0300 | [diff] [blame] | 128 | |
Wei Yongjun | 46e407d | 2013-04-23 10:44:35 +0800 | [diff] [blame] | 129 | if (!buffer) { |
Alexander Usyskin | c0abffb | 2013-09-15 18:11:07 +0300 | [diff] [blame] | 130 | cl_err(dev, cl, "allocation failed.\n"); |
Tomas Winkler | fcb136e | 2013-04-19 22:01:35 +0300 | [diff] [blame] | 131 | list_del(&cb->list); |
| 132 | return -ENOMEM; |
| 133 | } |
Wei Yongjun | 46e407d | 2013-04-23 10:44:35 +0800 | [diff] [blame] | 134 | cb->response_buffer.data = buffer; |
Tomas Winkler | fcb136e | 2013-04-19 22:01:35 +0300 | [diff] [blame] | 135 | cb->response_buffer.size = |
| 136 | mei_hdr->length + cb->buf_idx; |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 137 | } |
| 138 | |
| 139 | buffer = cb->response_buffer.data + cb->buf_idx; |
| 140 | mei_read_slots(dev, buffer, mei_hdr->length); |
| 141 | |
| 142 | cb->buf_idx += mei_hdr->length; |
| 143 | if (mei_hdr->msg_complete) { |
| 144 | cl->status = 0; |
| 145 | list_del(&cb->list); |
Alexander Usyskin | c0abffb | 2013-09-15 18:11:07 +0300 | [diff] [blame] | 146 | cl_dbg(dev, cl, "completed read length = %lu\n", |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 147 | cb->buf_idx); |
| 148 | list_add_tail(&cb->list, &complete_list->list); |
| 149 | } |
| 150 | break; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 151 | } |
| 152 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 153 | dev_dbg(&dev->pdev->dev, "message read\n"); |
| 154 | if (!buffer) { |
Tomas Winkler | edf1eed | 2012-02-09 19:25:54 +0200 | [diff] [blame] | 155 | mei_read_slots(dev, dev->rd_msg_buf, mei_hdr->length); |
Tomas Winkler | 15d4acc | 2012-12-25 19:06:00 +0200 | [diff] [blame] | 156 | dev_dbg(&dev->pdev->dev, "discarding message " MEI_HDR_FMT "\n", |
| 157 | MEI_HDR_PRM(mei_hdr)); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 158 | } |
| 159 | |
| 160 | return 0; |
| 161 | } |
| 162 | |
| 163 | /** |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 164 | * mei_cl_irq_close - processes close related operation from |
| 165 | * interrupt thread context - send disconnect request |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 166 | * |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 167 | * @cl: client |
| 168 | * @cb: callback block. |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 169 | * @slots: free slots. |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 170 | * @cmpl_list: complete list. |
| 171 | * |
| 172 | * returns 0, OK; otherwise, error. |
| 173 | */ |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 174 | static int mei_cl_irq_close(struct mei_cl *cl, struct mei_cl_cb *cb, |
| 175 | s32 *slots, struct mei_cl_cb *cmpl_list) |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 176 | { |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 177 | struct mei_device *dev = cl->dev; |
| 178 | |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 179 | u32 msg_slots = |
| 180 | mei_data2slots(sizeof(struct hbm_client_connect_request)); |
Tomas Winkler | b45f3cc | 2012-07-04 19:24:53 +0300 | [diff] [blame] | 181 | |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 182 | if (*slots < msg_slots) |
| 183 | return -EMSGSIZE; |
| 184 | |
| 185 | *slots -= msg_slots; |
Tomas Winkler | b45f3cc | 2012-07-04 19:24:53 +0300 | [diff] [blame] | 186 | |
Tomas Winkler | 8120e72 | 2012-12-25 19:06:11 +0200 | [diff] [blame] | 187 | if (mei_hbm_cl_disconnect_req(dev, cl)) { |
Tomas Winkler | b45f3cc | 2012-07-04 19:24:53 +0300 | [diff] [blame] | 188 | cl->status = 0; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 189 | cb->buf_idx = 0; |
| 190 | list_move_tail(&cb->list, &cmpl_list->list); |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 191 | return -EIO; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 192 | } |
| 193 | |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 194 | cl->state = MEI_FILE_DISCONNECTING; |
| 195 | cl->status = 0; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 196 | cb->buf_idx = 0; |
| 197 | list_move_tail(&cb->list, &dev->ctrl_rd_list.list); |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 198 | cl->timer_count = MEI_CONNECT_TIMEOUT; |
| 199 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 200 | return 0; |
| 201 | } |
| 202 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 203 | |
| 204 | /** |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 205 | * mei_cl_irq_close - processes client read related operation from the |
| 206 | * interrupt thread context - request for flow control credits |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 207 | * |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 208 | * @cl: client |
| 209 | * @cb: callback block. |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 210 | * @slots: free slots. |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 211 | * @cmpl_list: complete list. |
| 212 | * |
| 213 | * returns 0, OK; otherwise, error. |
| 214 | */ |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 215 | static int mei_cl_irq_read(struct mei_cl *cl, struct mei_cl_cb *cb, |
| 216 | s32 *slots, struct mei_cl_cb *cmpl_list) |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 217 | { |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 218 | struct mei_device *dev = cl->dev; |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 219 | u32 msg_slots = mei_data2slots(sizeof(struct hbm_flow_control)); |
| 220 | |
Tomas Winkler | 2ebf8c9 | 2013-09-16 23:44:43 +0300 | [diff] [blame] | 221 | int ret; |
| 222 | |
| 223 | |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 224 | if (*slots < msg_slots) { |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 225 | /* return the cancel routine */ |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 226 | list_del(&cb->list); |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 227 | return -EMSGSIZE; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 228 | } |
| 229 | |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 230 | *slots -= msg_slots; |
Tomas Winkler | 7bdf72d | 2012-07-04 19:24:52 +0300 | [diff] [blame] | 231 | |
Tomas Winkler | 2ebf8c9 | 2013-09-16 23:44:43 +0300 | [diff] [blame] | 232 | ret = mei_hbm_cl_flow_control_req(dev, cl); |
| 233 | if (ret) { |
| 234 | cl->status = ret; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 235 | cb->buf_idx = 0; |
| 236 | list_move_tail(&cb->list, &cmpl_list->list); |
Tomas Winkler | 2ebf8c9 | 2013-09-16 23:44:43 +0300 | [diff] [blame] | 237 | return ret; |
Tomas Winkler | 1ccb7b6 | 2012-03-14 14:39:42 +0200 | [diff] [blame] | 238 | } |
Tomas Winkler | 2ebf8c9 | 2013-09-16 23:44:43 +0300 | [diff] [blame] | 239 | |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 240 | list_move_tail(&cb->list, &dev->read_list.list); |
Tomas Winkler | 1ccb7b6 | 2012-03-14 14:39:42 +0200 | [diff] [blame] | 241 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 242 | return 0; |
| 243 | } |
| 244 | |
| 245 | |
| 246 | /** |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 247 | * mei_cl_irq_ioctl - processes client ioctl related operation from the |
| 248 | * interrupt thread context - send connection request |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 249 | * |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 250 | * @cl: client |
| 251 | * @cb: callback block. |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 252 | * @slots: free slots. |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 253 | * @cmpl_list: complete list. |
| 254 | * |
| 255 | * returns 0, OK; otherwise, error. |
| 256 | */ |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 257 | static int mei_cl_irq_ioctl(struct mei_cl *cl, struct mei_cl_cb *cb, |
| 258 | s32 *slots, struct mei_cl_cb *cmpl_list) |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 259 | { |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 260 | struct mei_device *dev = cl->dev; |
Tomas Winkler | 2ebf8c9 | 2013-09-16 23:44:43 +0300 | [diff] [blame] | 261 | int ret; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 262 | |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 263 | u32 msg_slots = |
| 264 | mei_data2slots(sizeof(struct hbm_client_connect_request)); |
| 265 | |
| 266 | if (*slots < msg_slots) { |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 267 | /* return the cancel routine */ |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 268 | list_del(&cb->list); |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 269 | return -EMSGSIZE; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 270 | } |
| 271 | |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 272 | *slots -= msg_slots; |
| 273 | |
Tomas Winkler | b45f3cc | 2012-07-04 19:24:53 +0300 | [diff] [blame] | 274 | cl->state = MEI_FILE_CONNECTING; |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 275 | |
Tomas Winkler | 2ebf8c9 | 2013-09-16 23:44:43 +0300 | [diff] [blame] | 276 | ret = mei_hbm_cl_connect_req(dev, cl); |
| 277 | if (ret) { |
| 278 | cl->status = ret; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 279 | cb->buf_idx = 0; |
| 280 | list_del(&cb->list); |
Tomas Winkler | 2ebf8c9 | 2013-09-16 23:44:43 +0300 | [diff] [blame] | 281 | return ret; |
Tomas Winkler | b45f3cc | 2012-07-04 19:24:53 +0300 | [diff] [blame] | 282 | } |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 283 | |
| 284 | list_move_tail(&cb->list, &dev->ctrl_rd_list.list); |
| 285 | cl->timer_count = MEI_CONNECT_TIMEOUT; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 286 | return 0; |
| 287 | } |
| 288 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 289 | |
| 290 | /** |
Masanari Iida | 393b148 | 2013-04-05 01:05:05 +0900 | [diff] [blame] | 291 | * mei_irq_read_handler - bottom half read routine after ISR to |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 292 | * handle the read processing. |
| 293 | * |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 294 | * @dev: the device structure |
Tomas Winkler | 06ecd64 | 2013-02-06 14:06:42 +0200 | [diff] [blame] | 295 | * @cmpl_list: An instance of our list structure |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 296 | * @slots: slots to read. |
| 297 | * |
| 298 | * returns 0 on success, <0 on failure. |
| 299 | */ |
Tomas Winkler | 06ecd64 | 2013-02-06 14:06:42 +0200 | [diff] [blame] | 300 | int mei_irq_read_handler(struct mei_device *dev, |
| 301 | struct mei_cl_cb *cmpl_list, s32 *slots) |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 302 | { |
| 303 | struct mei_msg_hdr *mei_hdr; |
Tomas Winkler | 10ee907 | 2013-11-11 13:26:08 +0200 | [diff] [blame^] | 304 | struct mei_cl *cl; |
| 305 | int ret; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 306 | |
| 307 | if (!dev->rd_msg_hdr) { |
Tomas Winkler | 827eef5 | 2013-02-06 14:06:41 +0200 | [diff] [blame] | 308 | dev->rd_msg_hdr = mei_read_hdr(dev); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 309 | (*slots)--; |
| 310 | dev_dbg(&dev->pdev->dev, "slots =%08x.\n", *slots); |
| 311 | } |
| 312 | mei_hdr = (struct mei_msg_hdr *) &dev->rd_msg_hdr; |
Tomas Winkler | 15d4acc | 2012-12-25 19:06:00 +0200 | [diff] [blame] | 313 | dev_dbg(&dev->pdev->dev, MEI_HDR_FMT, MEI_HDR_PRM(mei_hdr)); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 314 | |
| 315 | if (mei_hdr->reserved || !dev->rd_msg_hdr) { |
Tomas Winkler | 10ee907 | 2013-11-11 13:26:08 +0200 | [diff] [blame^] | 316 | dev_err(&dev->pdev->dev, "corrupted message header 0x%08X\n", |
| 317 | dev->rd_msg_hdr); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 318 | ret = -EBADMSG; |
| 319 | goto end; |
| 320 | } |
| 321 | |
Tomas Winkler | 10ee907 | 2013-11-11 13:26:08 +0200 | [diff] [blame^] | 322 | if (mei_slots2data(*slots) < mei_hdr->length) { |
| 323 | dev_err(&dev->pdev->dev, "less data available than length=%08x.\n", |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 324 | *slots); |
| 325 | /* we can't read the message */ |
| 326 | ret = -ERANGE; |
| 327 | goto end; |
| 328 | } |
| 329 | |
Tomas Winkler | 10ee907 | 2013-11-11 13:26:08 +0200 | [diff] [blame^] | 330 | /* HBM message */ |
| 331 | if (mei_hdr->host_addr == 0 && mei_hdr->me_addr == 0) { |
Tomas Winkler | bb1b013 | 2012-12-25 19:06:07 +0200 | [diff] [blame] | 332 | mei_hbm_dispatch(dev, mei_hdr); |
Tomas Winkler | 10ee907 | 2013-11-11 13:26:08 +0200 | [diff] [blame^] | 333 | ret = 0; |
| 334 | dev_dbg(&dev->pdev->dev, "mei_hbm_dispatch.\n"); |
| 335 | goto reset_slots; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 336 | } |
| 337 | |
Tomas Winkler | 10ee907 | 2013-11-11 13:26:08 +0200 | [diff] [blame^] | 338 | /* find recepient cl */ |
| 339 | list_for_each_entry(cl, &dev->file_list, link) { |
| 340 | if (mei_cl_hbm_equal(cl, mei_hdr)) { |
| 341 | cl_dbg(dev, cl, "got a message\n"); |
| 342 | break; |
| 343 | } |
| 344 | } |
| 345 | |
| 346 | /* if no recepient cl was found we assume corrupted header\n */ |
| 347 | if (&cl->link == &dev->file_list) { |
| 348 | dev_err(&dev->pdev->dev, "no destination client found 0x%08X\n", |
| 349 | dev->rd_msg_hdr); |
| 350 | ret = -EBADMSG; |
| 351 | goto end; |
| 352 | } |
| 353 | |
| 354 | if (mei_hdr->host_addr == dev->iamthif_cl.host_client_id && |
| 355 | MEI_FILE_CONNECTED == dev->iamthif_cl.state && |
| 356 | dev->iamthif_state == MEI_IAMTHIF_READING) { |
| 357 | |
| 358 | ret = mei_amthif_irq_read_msg(dev, mei_hdr, cmpl_list); |
| 359 | if (ret) { |
| 360 | dev_err(&dev->pdev->dev, "mei_amthif_irq_read_msg failed = %d\n", |
| 361 | ret); |
| 362 | goto end; |
| 363 | } |
| 364 | } else { |
| 365 | ret = mei_cl_irq_read_msg(dev, mei_hdr, cmpl_list); |
| 366 | if (ret) { |
| 367 | dev_err(&dev->pdev->dev, "mei_cl_irq_read_msg failed = %d\n", |
| 368 | ret); |
| 369 | goto end; |
| 370 | } |
| 371 | } |
| 372 | |
| 373 | reset_slots: |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 374 | /* reset the number of slots and header */ |
| 375 | *slots = mei_count_full_read_slots(dev); |
| 376 | dev->rd_msg_hdr = 0; |
| 377 | |
| 378 | if (*slots == -EOVERFLOW) { |
| 379 | /* overflow - reset */ |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 380 | dev_err(&dev->pdev->dev, "resetting due to slots overflow.\n"); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 381 | /* set the event since message has been read */ |
| 382 | ret = -ERANGE; |
| 383 | goto end; |
| 384 | } |
| 385 | end: |
| 386 | return ret; |
| 387 | } |
Tomas Winkler | 40e0b67 | 2013-03-27 16:58:30 +0200 | [diff] [blame] | 388 | EXPORT_SYMBOL_GPL(mei_irq_read_handler); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 389 | |
| 390 | |
| 391 | /** |
Tomas Winkler | 06ecd64 | 2013-02-06 14:06:42 +0200 | [diff] [blame] | 392 | * mei_irq_write_handler - dispatch write requests |
| 393 | * after irq received |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 394 | * |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 395 | * @dev: the device structure |
Tomas Winkler | 9a84d61 | 2012-11-18 15:13:18 +0200 | [diff] [blame] | 396 | * @cmpl_list: An instance of our list structure |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 397 | * |
| 398 | * returns 0 on success, <0 on failure. |
| 399 | */ |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 400 | int mei_irq_write_handler(struct mei_device *dev, struct mei_cl_cb *cmpl_list) |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 401 | { |
| 402 | |
| 403 | struct mei_cl *cl; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 404 | struct mei_cl_cb *cb, *next; |
Tomas Winkler | fb601ad | 2012-10-15 12:06:48 +0200 | [diff] [blame] | 405 | struct mei_cl_cb *list; |
Tomas Winkler | 9a84d61 | 2012-11-18 15:13:18 +0200 | [diff] [blame] | 406 | s32 slots; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 407 | int ret; |
| 408 | |
Tomas Winkler | 827eef5 | 2013-02-06 14:06:41 +0200 | [diff] [blame] | 409 | if (!mei_hbuf_is_ready(dev)) { |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 410 | dev_dbg(&dev->pdev->dev, "host buffer is not empty.\n"); |
| 411 | return 0; |
| 412 | } |
Tomas Winkler | 9a84d61 | 2012-11-18 15:13:18 +0200 | [diff] [blame] | 413 | slots = mei_hbuf_empty_slots(dev); |
| 414 | if (slots <= 0) |
Tomas Winkler | 7d5e0e5 | 2012-06-19 09:13:36 +0300 | [diff] [blame] | 415 | return -EMSGSIZE; |
| 416 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 417 | /* complete all waiting for write CB */ |
| 418 | dev_dbg(&dev->pdev->dev, "complete all waiting for write cb.\n"); |
| 419 | |
| 420 | list = &dev->write_waiting_list; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 421 | list_for_each_entry_safe(cb, next, &list->list, list) { |
| 422 | cl = cb->cl; |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 423 | if (cl == NULL) |
| 424 | continue; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 425 | |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 426 | cl->status = 0; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 427 | list_del(&cb->list); |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 428 | if (MEI_WRITING == cl->writing_state && |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 429 | cb->fop_type == MEI_FOP_WRITE && |
Tomas Winkler | 4b8960b | 2012-11-11 17:38:00 +0200 | [diff] [blame] | 430 | cl != &dev->iamthif_cl) { |
Alexander Usyskin | c0abffb | 2013-09-15 18:11:07 +0300 | [diff] [blame] | 431 | cl_dbg(dev, cl, "MEI WRITE COMPLETE\n"); |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 432 | cl->writing_state = MEI_WRITE_COMPLETE; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 433 | list_add_tail(&cb->list, &cmpl_list->list); |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 434 | } |
| 435 | if (cl == &dev->iamthif_cl) { |
Alexander Usyskin | c0abffb | 2013-09-15 18:11:07 +0300 | [diff] [blame] | 436 | cl_dbg(dev, cl, "check iamthif flow control.\n"); |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 437 | if (dev->iamthif_flow_control_pending) { |
Tomas Winkler | 9a84d61 | 2012-11-18 15:13:18 +0200 | [diff] [blame] | 438 | ret = mei_amthif_irq_read(dev, &slots); |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 439 | if (ret) |
| 440 | return ret; |
| 441 | } |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 442 | } |
| 443 | } |
| 444 | |
Tomas Winkler | c216fde | 2012-08-16 19:39:43 +0300 | [diff] [blame] | 445 | if (dev->wd_state == MEI_WD_STOPPING) { |
| 446 | dev->wd_state = MEI_WD_IDLE; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 447 | wake_up_interruptible(&dev->wait_stop_wd); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 448 | } |
| 449 | |
Tomas Winkler | 5fb54fb | 2012-11-18 15:13:15 +0200 | [diff] [blame] | 450 | if (dev->wr_ext_msg.hdr.length) { |
| 451 | mei_write_message(dev, &dev->wr_ext_msg.hdr, |
Tomas Winkler | 438763f | 2012-12-25 19:05:59 +0200 | [diff] [blame] | 452 | dev->wr_ext_msg.data); |
Tomas Winkler | 9a84d61 | 2012-11-18 15:13:18 +0200 | [diff] [blame] | 453 | slots -= mei_data2slots(dev->wr_ext_msg.hdr.length); |
Tomas Winkler | 5fb54fb | 2012-11-18 15:13:15 +0200 | [diff] [blame] | 454 | dev->wr_ext_msg.hdr.length = 0; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 455 | } |
Tomas Winkler | b210d75 | 2012-08-07 00:03:56 +0300 | [diff] [blame] | 456 | if (dev->dev_state == MEI_DEV_ENABLED) { |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 457 | if (dev->wd_pending && |
Tomas Winkler | 90e0b5f | 2013-01-08 23:07:14 +0200 | [diff] [blame] | 458 | mei_cl_flow_ctrl_creds(&dev->wd_cl) > 0) { |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 459 | if (mei_wd_send(dev)) |
| 460 | dev_dbg(&dev->pdev->dev, "wd send failed.\n"); |
Tomas Winkler | 90e0b5f | 2013-01-08 23:07:14 +0200 | [diff] [blame] | 461 | else if (mei_cl_flow_ctrl_reduce(&dev->wd_cl)) |
Tomas Winkler | 483136e | 2012-07-04 19:24:54 +0300 | [diff] [blame] | 462 | return -ENODEV; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 463 | |
Tomas Winkler | eb9af0a | 2011-05-25 17:28:22 +0300 | [diff] [blame] | 464 | dev->wd_pending = false; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 465 | |
Tomas Winkler | c216fde | 2012-08-16 19:39:43 +0300 | [diff] [blame] | 466 | if (dev->wd_state == MEI_WD_RUNNING) |
Tomas Winkler | 9a84d61 | 2012-11-18 15:13:18 +0200 | [diff] [blame] | 467 | slots -= mei_data2slots(MEI_WD_START_MSG_SIZE); |
Tomas Winkler | d242a0a | 2012-07-04 19:24:50 +0300 | [diff] [blame] | 468 | else |
Tomas Winkler | 9a84d61 | 2012-11-18 15:13:18 +0200 | [diff] [blame] | 469 | slots -= mei_data2slots(MEI_WD_STOP_MSG_SIZE); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 470 | } |
| 471 | } |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 472 | |
| 473 | /* complete control write list CB */ |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 474 | dev_dbg(&dev->pdev->dev, "complete control write list cb.\n"); |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 475 | list_for_each_entry_safe(cb, next, &dev->ctrl_wr_list.list, list) { |
| 476 | cl = cb->cl; |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 477 | if (!cl) { |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 478 | list_del(&cb->list); |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 479 | return -ENODEV; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 480 | } |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 481 | switch (cb->fop_type) { |
Tomas Winkler | 4b8960b | 2012-11-11 17:38:00 +0200 | [diff] [blame] | 482 | case MEI_FOP_CLOSE: |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 483 | /* send disconnect message */ |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 484 | ret = mei_cl_irq_close(cl, cb, &slots, cmpl_list); |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 485 | if (ret) |
| 486 | return ret; |
| 487 | |
| 488 | break; |
Tomas Winkler | 4b8960b | 2012-11-11 17:38:00 +0200 | [diff] [blame] | 489 | case MEI_FOP_READ: |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 490 | /* send flow control message */ |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 491 | ret = mei_cl_irq_read(cl, cb, &slots, cmpl_list); |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 492 | if (ret) |
| 493 | return ret; |
| 494 | |
| 495 | break; |
Tomas Winkler | 4b8960b | 2012-11-11 17:38:00 +0200 | [diff] [blame] | 496 | case MEI_FOP_IOCTL: |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 497 | /* connect message */ |
Tomas Winkler | 90e0b5f | 2013-01-08 23:07:14 +0200 | [diff] [blame] | 498 | if (mei_cl_is_other_connecting(cl)) |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 499 | continue; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 500 | ret = mei_cl_irq_ioctl(cl, cb, &slots, cmpl_list); |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 501 | if (ret) |
| 502 | return ret; |
| 503 | |
| 504 | break; |
| 505 | |
| 506 | default: |
| 507 | BUG(); |
| 508 | } |
| 509 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 510 | } |
| 511 | /* complete write list CB */ |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 512 | dev_dbg(&dev->pdev->dev, "complete write list cb.\n"); |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 513 | list_for_each_entry_safe(cb, next, &dev->write_list.list, list) { |
| 514 | cl = cb->cl; |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 515 | if (cl == NULL) |
| 516 | continue; |
Tomas Winkler | be9d87a | 2012-11-18 15:13:19 +0200 | [diff] [blame] | 517 | if (cl == &dev->iamthif_cl) |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 518 | ret = mei_amthif_irq_write_complete(cl, cb, |
| 519 | &slots, cmpl_list); |
Tomas Winkler | be9d87a | 2012-11-18 15:13:19 +0200 | [diff] [blame] | 520 | else |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 521 | ret = mei_cl_irq_write_complete(cl, cb, |
| 522 | &slots, cmpl_list); |
Tomas Winkler | be9d87a | 2012-11-18 15:13:19 +0200 | [diff] [blame] | 523 | if (ret) |
| 524 | return ret; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 525 | } |
| 526 | return 0; |
| 527 | } |
Tomas Winkler | 40e0b67 | 2013-03-27 16:58:30 +0200 | [diff] [blame] | 528 | EXPORT_SYMBOL_GPL(mei_irq_write_handler); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 529 | |
| 530 | |
| 531 | |
| 532 | /** |
| 533 | * mei_timer - timer function. |
| 534 | * |
| 535 | * @work: pointer to the work_struct structure |
| 536 | * |
| 537 | * NOTE: This function is called by timer interrupt work |
| 538 | */ |
Oren Weil | a61c653 | 2011-09-07 09:03:13 +0300 | [diff] [blame] | 539 | void mei_timer(struct work_struct *work) |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 540 | { |
| 541 | unsigned long timeout; |
| 542 | struct mei_cl *cl_pos = NULL; |
| 543 | struct mei_cl *cl_next = NULL; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 544 | struct mei_cl_cb *cb_pos = NULL; |
| 545 | struct mei_cl_cb *cb_next = NULL; |
| 546 | |
| 547 | struct mei_device *dev = container_of(work, |
Oren Weil | a61c653 | 2011-09-07 09:03:13 +0300 | [diff] [blame] | 548 | struct mei_device, timer_work.work); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 549 | |
| 550 | |
| 551 | mutex_lock(&dev->device_lock); |
Tomas Winkler | b210d75 | 2012-08-07 00:03:56 +0300 | [diff] [blame] | 552 | if (dev->dev_state != MEI_DEV_ENABLED) { |
| 553 | if (dev->dev_state == MEI_DEV_INIT_CLIENTS) { |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 554 | if (dev->init_clients_timer) { |
| 555 | if (--dev->init_clients_timer == 0) { |
Tomas Winkler | 9b0d5ef | 2013-04-18 23:03:48 +0300 | [diff] [blame] | 556 | dev_err(&dev->pdev->dev, "reset: init clients timeout hbm_state = %d.\n", |
| 557 | dev->hbm_state); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 558 | mei_reset(dev, 1); |
| 559 | } |
| 560 | } |
| 561 | } |
| 562 | goto out; |
| 563 | } |
| 564 | /*** connect/disconnect timeouts ***/ |
| 565 | list_for_each_entry_safe(cl_pos, cl_next, &dev->file_list, link) { |
| 566 | if (cl_pos->timer_count) { |
| 567 | if (--cl_pos->timer_count == 0) { |
Tomas Winkler | d6c36a4 | 2013-04-08 21:56:38 +0300 | [diff] [blame] | 568 | dev_err(&dev->pdev->dev, "reset: connect/disconnect timeout.\n"); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 569 | mei_reset(dev, 1); |
| 570 | goto out; |
| 571 | } |
| 572 | } |
| 573 | } |
| 574 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 575 | if (dev->iamthif_stall_timer) { |
| 576 | if (--dev->iamthif_stall_timer == 0) { |
Tomas Winkler | d6c36a4 | 2013-04-08 21:56:38 +0300 | [diff] [blame] | 577 | dev_err(&dev->pdev->dev, "reset: amthif hanged.\n"); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 578 | mei_reset(dev, 1); |
| 579 | dev->iamthif_msg_buf_size = 0; |
| 580 | dev->iamthif_msg_buf_index = 0; |
Tomas Winkler | eb9af0a | 2011-05-25 17:28:22 +0300 | [diff] [blame] | 581 | dev->iamthif_canceled = false; |
| 582 | dev->iamthif_ioctl = true; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 583 | dev->iamthif_state = MEI_IAMTHIF_IDLE; |
| 584 | dev->iamthif_timer = 0; |
| 585 | |
Tomas Winkler | 601a1ef | 2012-10-09 16:50:20 +0200 | [diff] [blame] | 586 | mei_io_cb_free(dev->iamthif_current_cb); |
| 587 | dev->iamthif_current_cb = NULL; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 588 | |
| 589 | dev->iamthif_file_object = NULL; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 590 | mei_amthif_run_next_cmd(dev); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 591 | } |
| 592 | } |
| 593 | |
| 594 | if (dev->iamthif_timer) { |
| 595 | |
| 596 | timeout = dev->iamthif_timer + |
Tomas Winkler | 3870c32 | 2012-11-01 21:17:14 +0200 | [diff] [blame] | 597 | mei_secs_to_jiffies(MEI_IAMTHIF_READ_TIMER); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 598 | |
| 599 | dev_dbg(&dev->pdev->dev, "dev->iamthif_timer = %ld\n", |
| 600 | dev->iamthif_timer); |
| 601 | dev_dbg(&dev->pdev->dev, "timeout = %ld\n", timeout); |
| 602 | dev_dbg(&dev->pdev->dev, "jiffies = %ld\n", jiffies); |
| 603 | if (time_after(jiffies, timeout)) { |
| 604 | /* |
| 605 | * User didn't read the AMTHI data on time (15sec) |
| 606 | * freeing AMTHI for other requests |
| 607 | */ |
| 608 | |
| 609 | dev_dbg(&dev->pdev->dev, "freeing AMTHI for other requests\n"); |
| 610 | |
Tomas Winkler | e773efc | 2012-11-11 17:37:58 +0200 | [diff] [blame] | 611 | list_for_each_entry_safe(cb_pos, cb_next, |
| 612 | &dev->amthif_rd_complete_list.list, list) { |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 613 | |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 614 | cl_pos = cb_pos->file_object->private_data; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 615 | |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 616 | /* Finding the AMTHI entry. */ |
| 617 | if (cl_pos == &dev->iamthif_cl) |
Tomas Winkler | fb601ad | 2012-10-15 12:06:48 +0200 | [diff] [blame] | 618 | list_del(&cb_pos->list); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 619 | } |
Tomas Winkler | 601a1ef | 2012-10-09 16:50:20 +0200 | [diff] [blame] | 620 | mei_io_cb_free(dev->iamthif_current_cb); |
| 621 | dev->iamthif_current_cb = NULL; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 622 | |
| 623 | dev->iamthif_file_object->private_data = NULL; |
| 624 | dev->iamthif_file_object = NULL; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 625 | dev->iamthif_timer = 0; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 626 | mei_amthif_run_next_cmd(dev); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 627 | |
| 628 | } |
| 629 | } |
| 630 | out: |
Tomas Winkler | 441ab50 | 2011-12-13 23:39:34 +0200 | [diff] [blame] | 631 | schedule_delayed_work(&dev->timer_work, 2 * HZ); |
| 632 | mutex_unlock(&dev->device_lock); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 633 | } |
| 634 | |