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) { |
| 116 | dev_err(&dev->pdev->dev, "response buffer is not allocated.\n"); |
| 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) { |
Tomas Winkler | fcb136e | 2013-04-19 22:01:35 +0300 | [diff] [blame] | 122 | dev_dbg(&dev->pdev->dev, "message overflow. size %d len %d idx %ld\n", |
| 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) { |
Tomas Winkler | fcb136e | 2013-04-19 22:01:35 +0300 | [diff] [blame] | 130 | dev_err(&dev->pdev->dev, "allocation failed.\n"); |
| 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); |
| 146 | dev_dbg(&dev->pdev->dev, "completed read H cl = %d, ME cl = %d, length = %lu\n", |
| 147 | cl->host_client_id, |
| 148 | cl->me_client_id, |
| 149 | cb->buf_idx); |
| 150 | list_add_tail(&cb->list, &complete_list->list); |
| 151 | } |
| 152 | break; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 153 | } |
| 154 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 155 | dev_dbg(&dev->pdev->dev, "message read\n"); |
| 156 | if (!buffer) { |
Tomas Winkler | edf1eed | 2012-02-09 19:25:54 +0200 | [diff] [blame] | 157 | mei_read_slots(dev, dev->rd_msg_buf, mei_hdr->length); |
Tomas Winkler | 15d4acc | 2012-12-25 19:06:00 +0200 | [diff] [blame] | 158 | dev_dbg(&dev->pdev->dev, "discarding message " MEI_HDR_FMT "\n", |
| 159 | MEI_HDR_PRM(mei_hdr)); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 160 | } |
| 161 | |
| 162 | return 0; |
| 163 | } |
| 164 | |
| 165 | /** |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 166 | * mei_cl_irq_close - processes close related operation from |
| 167 | * interrupt thread context - send disconnect request |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 168 | * |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 169 | * @cl: client |
| 170 | * @cb: callback block. |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 171 | * @slots: free slots. |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 172 | * @cmpl_list: complete list. |
| 173 | * |
| 174 | * returns 0, OK; otherwise, error. |
| 175 | */ |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 176 | static int mei_cl_irq_close(struct mei_cl *cl, struct mei_cl_cb *cb, |
| 177 | s32 *slots, struct mei_cl_cb *cmpl_list) |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 178 | { |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 179 | struct mei_device *dev = cl->dev; |
| 180 | |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 181 | u32 msg_slots = |
| 182 | mei_data2slots(sizeof(struct hbm_client_connect_request)); |
Tomas Winkler | b45f3cc | 2012-07-04 19:24:53 +0300 | [diff] [blame] | 183 | |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 184 | if (*slots < msg_slots) |
| 185 | return -EMSGSIZE; |
| 186 | |
| 187 | *slots -= msg_slots; |
Tomas Winkler | b45f3cc | 2012-07-04 19:24:53 +0300 | [diff] [blame] | 188 | |
Tomas Winkler | 8120e72 | 2012-12-25 19:06:11 +0200 | [diff] [blame] | 189 | if (mei_hbm_cl_disconnect_req(dev, cl)) { |
Tomas Winkler | b45f3cc | 2012-07-04 19:24:53 +0300 | [diff] [blame] | 190 | cl->status = 0; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 191 | cb->buf_idx = 0; |
| 192 | list_move_tail(&cb->list, &cmpl_list->list); |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 193 | return -EIO; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 194 | } |
| 195 | |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 196 | cl->state = MEI_FILE_DISCONNECTING; |
| 197 | cl->status = 0; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 198 | cb->buf_idx = 0; |
| 199 | list_move_tail(&cb->list, &dev->ctrl_rd_list.list); |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 200 | cl->timer_count = MEI_CONNECT_TIMEOUT; |
| 201 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 202 | return 0; |
| 203 | } |
| 204 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 205 | |
| 206 | /** |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 207 | * mei_cl_irq_close - processes client read related operation from the |
| 208 | * interrupt thread context - request for flow control credits |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 209 | * |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 210 | * @cl: client |
| 211 | * @cb: callback block. |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 212 | * @slots: free slots. |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 213 | * @cmpl_list: complete list. |
| 214 | * |
| 215 | * returns 0, OK; otherwise, error. |
| 216 | */ |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 217 | static int mei_cl_irq_read(struct mei_cl *cl, struct mei_cl_cb *cb, |
| 218 | s32 *slots, struct mei_cl_cb *cmpl_list) |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 219 | { |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 220 | struct mei_device *dev = cl->dev; |
| 221 | |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 222 | u32 msg_slots = mei_data2slots(sizeof(struct hbm_flow_control)); |
| 223 | |
| 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 | 8120e72 | 2012-12-25 19:06:11 +0200 | [diff] [blame] | 232 | if (mei_hbm_cl_flow_control_req(dev, cl)) { |
Tomas Winkler | 1ccb7b6 | 2012-03-14 14:39:42 +0200 | [diff] [blame] | 233 | cl->status = -ENODEV; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 234 | cb->buf_idx = 0; |
| 235 | list_move_tail(&cb->list, &cmpl_list->list); |
Tomas Winkler | 1ccb7b6 | 2012-03-14 14:39:42 +0200 | [diff] [blame] | 236 | return -ENODEV; |
| 237 | } |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 238 | list_move_tail(&cb->list, &dev->read_list.list); |
Tomas Winkler | 1ccb7b6 | 2012-03-14 14:39:42 +0200 | [diff] [blame] | 239 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 240 | return 0; |
| 241 | } |
| 242 | |
| 243 | |
| 244 | /** |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 245 | * mei_cl_irq_ioctl - processes client ioctl related operation from the |
| 246 | * interrupt thread context - send connection request |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 247 | * |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 248 | * @cl: client |
| 249 | * @cb: callback block. |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 250 | * @slots: free slots. |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 251 | * @cmpl_list: complete list. |
| 252 | * |
| 253 | * returns 0, OK; otherwise, error. |
| 254 | */ |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 255 | static int mei_cl_irq_ioctl(struct mei_cl *cl, struct mei_cl_cb *cb, |
| 256 | s32 *slots, struct mei_cl_cb *cmpl_list) |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 257 | { |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 258 | struct mei_device *dev = cl->dev; |
| 259 | |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 260 | u32 msg_slots = |
| 261 | mei_data2slots(sizeof(struct hbm_client_connect_request)); |
| 262 | |
| 263 | if (*slots < msg_slots) { |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 264 | /* return the cancel routine */ |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 265 | list_del(&cb->list); |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 266 | return -EMSGSIZE; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 267 | } |
| 268 | |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 269 | *slots -= msg_slots; |
| 270 | |
Tomas Winkler | b45f3cc | 2012-07-04 19:24:53 +0300 | [diff] [blame] | 271 | cl->state = MEI_FILE_CONNECTING; |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 272 | |
Tomas Winkler | 8120e72 | 2012-12-25 19:06:11 +0200 | [diff] [blame] | 273 | if (mei_hbm_cl_connect_req(dev, cl)) { |
Tomas Winkler | b45f3cc | 2012-07-04 19:24:53 +0300 | [diff] [blame] | 274 | cl->status = -ENODEV; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 275 | cb->buf_idx = 0; |
| 276 | list_del(&cb->list); |
Tomas Winkler | b45f3cc | 2012-07-04 19:24:53 +0300 | [diff] [blame] | 277 | return -ENODEV; |
Tomas Winkler | b45f3cc | 2012-07-04 19:24:53 +0300 | [diff] [blame] | 278 | } |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 279 | |
| 280 | list_move_tail(&cb->list, &dev->ctrl_rd_list.list); |
| 281 | cl->timer_count = MEI_CONNECT_TIMEOUT; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 282 | return 0; |
| 283 | } |
| 284 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 285 | |
| 286 | /** |
Masanari Iida | 393b148 | 2013-04-05 01:05:05 +0900 | [diff] [blame] | 287 | * mei_irq_read_handler - bottom half read routine after ISR to |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 288 | * handle the read processing. |
| 289 | * |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 290 | * @dev: the device structure |
Tomas Winkler | 06ecd64 | 2013-02-06 14:06:42 +0200 | [diff] [blame] | 291 | * @cmpl_list: An instance of our list structure |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 292 | * @slots: slots to read. |
| 293 | * |
| 294 | * returns 0 on success, <0 on failure. |
| 295 | */ |
Tomas Winkler | 06ecd64 | 2013-02-06 14:06:42 +0200 | [diff] [blame] | 296 | int mei_irq_read_handler(struct mei_device *dev, |
| 297 | struct mei_cl_cb *cmpl_list, s32 *slots) |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 298 | { |
| 299 | struct mei_msg_hdr *mei_hdr; |
| 300 | struct mei_cl *cl_pos = NULL; |
| 301 | struct mei_cl *cl_next = NULL; |
| 302 | int ret = 0; |
| 303 | |
| 304 | if (!dev->rd_msg_hdr) { |
Tomas Winkler | 827eef5 | 2013-02-06 14:06:41 +0200 | [diff] [blame] | 305 | dev->rd_msg_hdr = mei_read_hdr(dev); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 306 | dev_dbg(&dev->pdev->dev, "slots =%08x.\n", *slots); |
| 307 | (*slots)--; |
| 308 | dev_dbg(&dev->pdev->dev, "slots =%08x.\n", *slots); |
| 309 | } |
| 310 | mei_hdr = (struct mei_msg_hdr *) &dev->rd_msg_hdr; |
Tomas Winkler | 15d4acc | 2012-12-25 19:06:00 +0200 | [diff] [blame] | 311 | 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] | 312 | |
| 313 | if (mei_hdr->reserved || !dev->rd_msg_hdr) { |
| 314 | dev_dbg(&dev->pdev->dev, "corrupted message header.\n"); |
| 315 | ret = -EBADMSG; |
| 316 | goto end; |
| 317 | } |
| 318 | |
| 319 | if (mei_hdr->host_addr || mei_hdr->me_addr) { |
| 320 | list_for_each_entry_safe(cl_pos, cl_next, |
| 321 | &dev->file_list, link) { |
| 322 | dev_dbg(&dev->pdev->dev, |
| 323 | "list_for_each_entry_safe read host" |
| 324 | " client = %d, ME client = %d\n", |
| 325 | cl_pos->host_client_id, |
| 326 | cl_pos->me_client_id); |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 327 | if (mei_cl_hbm_equal(cl_pos, mei_hdr)) |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 328 | break; |
| 329 | } |
| 330 | |
| 331 | if (&cl_pos->link == &dev->file_list) { |
| 332 | dev_dbg(&dev->pdev->dev, "corrupted message header\n"); |
| 333 | ret = -EBADMSG; |
| 334 | goto end; |
| 335 | } |
| 336 | } |
| 337 | if (((*slots) * sizeof(u32)) < mei_hdr->length) { |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 338 | dev_err(&dev->pdev->dev, |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 339 | "we can't read the message slots =%08x.\n", |
| 340 | *slots); |
| 341 | /* we can't read the message */ |
| 342 | ret = -ERANGE; |
| 343 | goto end; |
| 344 | } |
| 345 | |
| 346 | /* decide where to read the message too */ |
| 347 | if (!mei_hdr->host_addr) { |
| 348 | dev_dbg(&dev->pdev->dev, "call mei_irq_thread_read_bus_message.\n"); |
Tomas Winkler | bb1b013 | 2012-12-25 19:06:07 +0200 | [diff] [blame] | 349 | mei_hbm_dispatch(dev, mei_hdr); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 350 | dev_dbg(&dev->pdev->dev, "end mei_irq_thread_read_bus_message.\n"); |
| 351 | } else if (mei_hdr->host_addr == dev->iamthif_cl.host_client_id && |
| 352 | (MEI_FILE_CONNECTED == dev->iamthif_cl.state) && |
| 353 | (dev->iamthif_state == MEI_IAMTHIF_READING)) { |
Tomas Winkler | 15d4acc | 2012-12-25 19:06:00 +0200 | [diff] [blame] | 354 | |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 355 | dev_dbg(&dev->pdev->dev, "call mei_irq_thread_read_iamthif_message.\n"); |
Tomas Winkler | 15d4acc | 2012-12-25 19:06:00 +0200 | [diff] [blame] | 356 | dev_dbg(&dev->pdev->dev, MEI_HDR_FMT, MEI_HDR_PRM(mei_hdr)); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 357 | |
Tomas Winkler | 5ceb46e | 2013-04-19 21:16:53 +0300 | [diff] [blame] | 358 | ret = mei_amthif_irq_read_msg(dev, mei_hdr, cmpl_list); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 359 | if (ret) |
| 360 | goto end; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 361 | } else { |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 362 | dev_dbg(&dev->pdev->dev, "call mei_cl_irq_read_msg.\n"); |
| 363 | dev_dbg(&dev->pdev->dev, MEI_HDR_FMT, MEI_HDR_PRM(mei_hdr)); |
| 364 | ret = mei_cl_irq_read_msg(dev, mei_hdr, cmpl_list); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 365 | if (ret) |
| 366 | goto end; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 367 | } |
| 368 | |
| 369 | /* reset the number of slots and header */ |
| 370 | *slots = mei_count_full_read_slots(dev); |
| 371 | dev->rd_msg_hdr = 0; |
| 372 | |
| 373 | if (*slots == -EOVERFLOW) { |
| 374 | /* overflow - reset */ |
Tomas Winkler | 6e0f180 | 2013-04-19 22:01:34 +0300 | [diff] [blame] | 375 | dev_err(&dev->pdev->dev, "resetting due to slots overflow.\n"); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 376 | /* set the event since message has been read */ |
| 377 | ret = -ERANGE; |
| 378 | goto end; |
| 379 | } |
| 380 | end: |
| 381 | return ret; |
| 382 | } |
Tomas Winkler | 40e0b67 | 2013-03-27 16:58:30 +0200 | [diff] [blame] | 383 | EXPORT_SYMBOL_GPL(mei_irq_read_handler); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 384 | |
| 385 | |
| 386 | /** |
Tomas Winkler | 06ecd64 | 2013-02-06 14:06:42 +0200 | [diff] [blame] | 387 | * mei_irq_write_handler - dispatch write requests |
| 388 | * after irq received |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 389 | * |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 390 | * @dev: the device structure |
Tomas Winkler | 9a84d61 | 2012-11-18 15:13:18 +0200 | [diff] [blame] | 391 | * @cmpl_list: An instance of our list structure |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 392 | * |
| 393 | * returns 0 on success, <0 on failure. |
| 394 | */ |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 395 | 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] | 396 | { |
| 397 | |
| 398 | struct mei_cl *cl; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 399 | struct mei_cl_cb *cb, *next; |
Tomas Winkler | fb601ad | 2012-10-15 12:06:48 +0200 | [diff] [blame] | 400 | struct mei_cl_cb *list; |
Tomas Winkler | 9a84d61 | 2012-11-18 15:13:18 +0200 | [diff] [blame] | 401 | s32 slots; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 402 | int ret; |
| 403 | |
Tomas Winkler | 827eef5 | 2013-02-06 14:06:41 +0200 | [diff] [blame] | 404 | if (!mei_hbuf_is_ready(dev)) { |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 405 | dev_dbg(&dev->pdev->dev, "host buffer is not empty.\n"); |
| 406 | return 0; |
| 407 | } |
Tomas Winkler | 9a84d61 | 2012-11-18 15:13:18 +0200 | [diff] [blame] | 408 | slots = mei_hbuf_empty_slots(dev); |
| 409 | if (slots <= 0) |
Tomas Winkler | 7d5e0e5 | 2012-06-19 09:13:36 +0300 | [diff] [blame] | 410 | return -EMSGSIZE; |
| 411 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 412 | /* complete all waiting for write CB */ |
| 413 | dev_dbg(&dev->pdev->dev, "complete all waiting for write cb.\n"); |
| 414 | |
| 415 | list = &dev->write_waiting_list; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 416 | list_for_each_entry_safe(cb, next, &list->list, list) { |
| 417 | cl = cb->cl; |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 418 | if (cl == NULL) |
| 419 | continue; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 420 | |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 421 | cl->status = 0; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 422 | list_del(&cb->list); |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 423 | if (MEI_WRITING == cl->writing_state && |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 424 | cb->fop_type == MEI_FOP_WRITE && |
Tomas Winkler | 4b8960b | 2012-11-11 17:38:00 +0200 | [diff] [blame] | 425 | cl != &dev->iamthif_cl) { |
Tomas Winkler | 483136e | 2012-07-04 19:24:54 +0300 | [diff] [blame] | 426 | dev_dbg(&dev->pdev->dev, "MEI WRITE COMPLETE\n"); |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 427 | cl->writing_state = MEI_WRITE_COMPLETE; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 428 | list_add_tail(&cb->list, &cmpl_list->list); |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 429 | } |
| 430 | if (cl == &dev->iamthif_cl) { |
| 431 | dev_dbg(&dev->pdev->dev, "check iamthif flow control.\n"); |
| 432 | if (dev->iamthif_flow_control_pending) { |
Tomas Winkler | 9a84d61 | 2012-11-18 15:13:18 +0200 | [diff] [blame] | 433 | ret = mei_amthif_irq_read(dev, &slots); |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 434 | if (ret) |
| 435 | return ret; |
| 436 | } |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 437 | } |
| 438 | } |
| 439 | |
Tomas Winkler | c216fde | 2012-08-16 19:39:43 +0300 | [diff] [blame] | 440 | if (dev->wd_state == MEI_WD_STOPPING) { |
| 441 | dev->wd_state = MEI_WD_IDLE; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 442 | wake_up_interruptible(&dev->wait_stop_wd); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 443 | } |
| 444 | |
Tomas Winkler | 5fb54fb | 2012-11-18 15:13:15 +0200 | [diff] [blame] | 445 | if (dev->wr_ext_msg.hdr.length) { |
| 446 | mei_write_message(dev, &dev->wr_ext_msg.hdr, |
Tomas Winkler | 438763f | 2012-12-25 19:05:59 +0200 | [diff] [blame] | 447 | dev->wr_ext_msg.data); |
Tomas Winkler | 9a84d61 | 2012-11-18 15:13:18 +0200 | [diff] [blame] | 448 | slots -= mei_data2slots(dev->wr_ext_msg.hdr.length); |
Tomas Winkler | 5fb54fb | 2012-11-18 15:13:15 +0200 | [diff] [blame] | 449 | dev->wr_ext_msg.hdr.length = 0; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 450 | } |
Tomas Winkler | b210d75 | 2012-08-07 00:03:56 +0300 | [diff] [blame] | 451 | if (dev->dev_state == MEI_DEV_ENABLED) { |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 452 | if (dev->wd_pending && |
Tomas Winkler | 90e0b5f | 2013-01-08 23:07:14 +0200 | [diff] [blame] | 453 | mei_cl_flow_ctrl_creds(&dev->wd_cl) > 0) { |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 454 | if (mei_wd_send(dev)) |
| 455 | dev_dbg(&dev->pdev->dev, "wd send failed.\n"); |
Tomas Winkler | 90e0b5f | 2013-01-08 23:07:14 +0200 | [diff] [blame] | 456 | else if (mei_cl_flow_ctrl_reduce(&dev->wd_cl)) |
Tomas Winkler | 483136e | 2012-07-04 19:24:54 +0300 | [diff] [blame] | 457 | return -ENODEV; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 458 | |
Tomas Winkler | eb9af0a | 2011-05-25 17:28:22 +0300 | [diff] [blame] | 459 | dev->wd_pending = false; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 460 | |
Tomas Winkler | c216fde | 2012-08-16 19:39:43 +0300 | [diff] [blame] | 461 | if (dev->wd_state == MEI_WD_RUNNING) |
Tomas Winkler | 9a84d61 | 2012-11-18 15:13:18 +0200 | [diff] [blame] | 462 | slots -= mei_data2slots(MEI_WD_START_MSG_SIZE); |
Tomas Winkler | d242a0a | 2012-07-04 19:24:50 +0300 | [diff] [blame] | 463 | else |
Tomas Winkler | 9a84d61 | 2012-11-18 15:13:18 +0200 | [diff] [blame] | 464 | slots -= mei_data2slots(MEI_WD_STOP_MSG_SIZE); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 465 | } |
| 466 | } |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 467 | |
| 468 | /* complete control write list CB */ |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 469 | dev_dbg(&dev->pdev->dev, "complete control write list cb.\n"); |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 470 | list_for_each_entry_safe(cb, next, &dev->ctrl_wr_list.list, list) { |
| 471 | cl = cb->cl; |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 472 | if (!cl) { |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 473 | list_del(&cb->list); |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 474 | return -ENODEV; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 475 | } |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 476 | switch (cb->fop_type) { |
Tomas Winkler | 4b8960b | 2012-11-11 17:38:00 +0200 | [diff] [blame] | 477 | case MEI_FOP_CLOSE: |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 478 | /* send disconnect message */ |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 479 | ret = mei_cl_irq_close(cl, cb, &slots, cmpl_list); |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 480 | if (ret) |
| 481 | return ret; |
| 482 | |
| 483 | break; |
Tomas Winkler | 4b8960b | 2012-11-11 17:38:00 +0200 | [diff] [blame] | 484 | case MEI_FOP_READ: |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 485 | /* send flow control message */ |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 486 | ret = mei_cl_irq_read(cl, cb, &slots, cmpl_list); |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 487 | if (ret) |
| 488 | return ret; |
| 489 | |
| 490 | break; |
Tomas Winkler | 4b8960b | 2012-11-11 17:38:00 +0200 | [diff] [blame] | 491 | case MEI_FOP_IOCTL: |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 492 | /* connect message */ |
Tomas Winkler | 90e0b5f | 2013-01-08 23:07:14 +0200 | [diff] [blame] | 493 | if (mei_cl_is_other_connecting(cl)) |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 494 | continue; |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 495 | ret = mei_cl_irq_ioctl(cl, cb, &slots, cmpl_list); |
Tomas Winkler | c837209 | 2011-11-27 21:43:33 +0200 | [diff] [blame] | 496 | if (ret) |
| 497 | return ret; |
| 498 | |
| 499 | break; |
| 500 | |
| 501 | default: |
| 502 | BUG(); |
| 503 | } |
| 504 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 505 | } |
| 506 | /* complete write list CB */ |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 507 | dev_dbg(&dev->pdev->dev, "complete write list cb.\n"); |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 508 | list_for_each_entry_safe(cb, next, &dev->write_list.list, list) { |
| 509 | cl = cb->cl; |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 510 | if (cl == NULL) |
| 511 | continue; |
Tomas Winkler | 90e0b5f | 2013-01-08 23:07:14 +0200 | [diff] [blame] | 512 | if (mei_cl_flow_ctrl_creds(cl) <= 0) { |
Tomas Winkler | be9d87a | 2012-11-18 15:13:19 +0200 | [diff] [blame] | 513 | dev_dbg(&dev->pdev->dev, |
| 514 | "No flow control credentials for client %d, not sending.\n", |
| 515 | cl->host_client_id); |
| 516 | continue; |
| 517 | } |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 518 | |
Tomas Winkler | be9d87a | 2012-11-18 15:13:19 +0200 | [diff] [blame] | 519 | if (cl == &dev->iamthif_cl) |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 520 | ret = mei_amthif_irq_write_complete(cl, cb, |
| 521 | &slots, cmpl_list); |
Tomas Winkler | be9d87a | 2012-11-18 15:13:19 +0200 | [diff] [blame] | 522 | else |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 523 | ret = mei_cl_irq_write_complete(cl, cb, |
| 524 | &slots, cmpl_list); |
Tomas Winkler | be9d87a | 2012-11-18 15:13:19 +0200 | [diff] [blame] | 525 | if (ret) |
| 526 | return ret; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 527 | } |
| 528 | return 0; |
| 529 | } |
Tomas Winkler | 40e0b67 | 2013-03-27 16:58:30 +0200 | [diff] [blame] | 530 | EXPORT_SYMBOL_GPL(mei_irq_write_handler); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 531 | |
| 532 | |
| 533 | |
| 534 | /** |
| 535 | * mei_timer - timer function. |
| 536 | * |
| 537 | * @work: pointer to the work_struct structure |
| 538 | * |
| 539 | * NOTE: This function is called by timer interrupt work |
| 540 | */ |
Oren Weil | a61c653 | 2011-09-07 09:03:13 +0300 | [diff] [blame] | 541 | void mei_timer(struct work_struct *work) |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 542 | { |
| 543 | unsigned long timeout; |
| 544 | struct mei_cl *cl_pos = NULL; |
| 545 | struct mei_cl *cl_next = NULL; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 546 | struct mei_cl_cb *cb_pos = NULL; |
| 547 | struct mei_cl_cb *cb_next = NULL; |
| 548 | |
| 549 | struct mei_device *dev = container_of(work, |
Oren Weil | a61c653 | 2011-09-07 09:03:13 +0300 | [diff] [blame] | 550 | struct mei_device, timer_work.work); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 551 | |
| 552 | |
| 553 | mutex_lock(&dev->device_lock); |
Tomas Winkler | b210d75 | 2012-08-07 00:03:56 +0300 | [diff] [blame] | 554 | if (dev->dev_state != MEI_DEV_ENABLED) { |
| 555 | if (dev->dev_state == MEI_DEV_INIT_CLIENTS) { |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 556 | if (dev->init_clients_timer) { |
| 557 | if (--dev->init_clients_timer == 0) { |
Tomas Winkler | 9b0d5ef | 2013-04-18 23:03:48 +0300 | [diff] [blame] | 558 | dev_err(&dev->pdev->dev, "reset: init clients timeout hbm_state = %d.\n", |
| 559 | dev->hbm_state); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 560 | mei_reset(dev, 1); |
| 561 | } |
| 562 | } |
| 563 | } |
| 564 | goto out; |
| 565 | } |
| 566 | /*** connect/disconnect timeouts ***/ |
| 567 | list_for_each_entry_safe(cl_pos, cl_next, &dev->file_list, link) { |
| 568 | if (cl_pos->timer_count) { |
| 569 | if (--cl_pos->timer_count == 0) { |
Tomas Winkler | d6c36a4 | 2013-04-08 21:56:38 +0300 | [diff] [blame] | 570 | dev_err(&dev->pdev->dev, "reset: connect/disconnect timeout.\n"); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 571 | mei_reset(dev, 1); |
| 572 | goto out; |
| 573 | } |
| 574 | } |
| 575 | } |
| 576 | |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 577 | if (dev->iamthif_stall_timer) { |
| 578 | if (--dev->iamthif_stall_timer == 0) { |
Tomas Winkler | d6c36a4 | 2013-04-08 21:56:38 +0300 | [diff] [blame] | 579 | dev_err(&dev->pdev->dev, "reset: amthif hanged.\n"); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 580 | mei_reset(dev, 1); |
| 581 | dev->iamthif_msg_buf_size = 0; |
| 582 | dev->iamthif_msg_buf_index = 0; |
Tomas Winkler | eb9af0a | 2011-05-25 17:28:22 +0300 | [diff] [blame] | 583 | dev->iamthif_canceled = false; |
| 584 | dev->iamthif_ioctl = true; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 585 | dev->iamthif_state = MEI_IAMTHIF_IDLE; |
| 586 | dev->iamthif_timer = 0; |
| 587 | |
Tomas Winkler | 601a1ef | 2012-10-09 16:50:20 +0200 | [diff] [blame] | 588 | mei_io_cb_free(dev->iamthif_current_cb); |
| 589 | dev->iamthif_current_cb = NULL; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 590 | |
| 591 | dev->iamthif_file_object = NULL; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 592 | mei_amthif_run_next_cmd(dev); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 593 | } |
| 594 | } |
| 595 | |
| 596 | if (dev->iamthif_timer) { |
| 597 | |
| 598 | timeout = dev->iamthif_timer + |
Tomas Winkler | 3870c32 | 2012-11-01 21:17:14 +0200 | [diff] [blame] | 599 | mei_secs_to_jiffies(MEI_IAMTHIF_READ_TIMER); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 600 | |
| 601 | dev_dbg(&dev->pdev->dev, "dev->iamthif_timer = %ld\n", |
| 602 | dev->iamthif_timer); |
| 603 | dev_dbg(&dev->pdev->dev, "timeout = %ld\n", timeout); |
| 604 | dev_dbg(&dev->pdev->dev, "jiffies = %ld\n", jiffies); |
| 605 | if (time_after(jiffies, timeout)) { |
| 606 | /* |
| 607 | * User didn't read the AMTHI data on time (15sec) |
| 608 | * freeing AMTHI for other requests |
| 609 | */ |
| 610 | |
| 611 | dev_dbg(&dev->pdev->dev, "freeing AMTHI for other requests\n"); |
| 612 | |
Tomas Winkler | e773efc | 2012-11-11 17:37:58 +0200 | [diff] [blame] | 613 | list_for_each_entry_safe(cb_pos, cb_next, |
| 614 | &dev->amthif_rd_complete_list.list, list) { |
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 | cl_pos = cb_pos->file_object->private_data; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 617 | |
Tomas Winkler | b7cd2d9 | 2011-11-27 21:43:34 +0200 | [diff] [blame] | 618 | /* Finding the AMTHI entry. */ |
| 619 | if (cl_pos == &dev->iamthif_cl) |
Tomas Winkler | fb601ad | 2012-10-15 12:06:48 +0200 | [diff] [blame] | 620 | list_del(&cb_pos->list); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 621 | } |
Tomas Winkler | 601a1ef | 2012-10-09 16:50:20 +0200 | [diff] [blame] | 622 | mei_io_cb_free(dev->iamthif_current_cb); |
| 623 | dev->iamthif_current_cb = NULL; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 624 | |
| 625 | dev->iamthif_file_object->private_data = NULL; |
| 626 | dev->iamthif_file_object = NULL; |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 627 | dev->iamthif_timer = 0; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 628 | mei_amthif_run_next_cmd(dev); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 629 | |
| 630 | } |
| 631 | } |
| 632 | out: |
Tomas Winkler | 441ab50 | 2011-12-13 23:39:34 +0200 | [diff] [blame] | 633 | schedule_delayed_work(&dev->timer_work, 2 * HZ); |
| 634 | mutex_unlock(&dev->device_lock); |
Oren Weil | fb7d879 | 2011-05-15 13:43:42 +0300 | [diff] [blame] | 635 | } |
| 636 | |