Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 1 | /* |
| 2 | * |
| 3 | * Intel Management Engine Interface (Intel MEI) Linux driver |
| 4 | * Copyright (c) 2003-2012, Intel Corporation. |
| 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 | #include <linux/kernel.h> |
| 18 | #include <linux/fs.h> |
| 19 | #include <linux/errno.h> |
| 20 | #include <linux/types.h> |
| 21 | #include <linux/fcntl.h> |
| 22 | #include <linux/aio.h> |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 23 | #include <linux/ioctl.h> |
| 24 | #include <linux/cdev.h> |
| 25 | #include <linux/list.h> |
| 26 | #include <linux/delay.h> |
| 27 | #include <linux/sched.h> |
| 28 | #include <linux/uuid.h> |
| 29 | #include <linux/jiffies.h> |
| 30 | #include <linux/uaccess.h> |
Tomas Winkler | 1f18035 | 2014-09-29 16:31:46 +0300 | [diff] [blame] | 31 | #include <linux/slab.h> |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 32 | |
Tomas Winkler | 47a7380 | 2012-12-25 19:06:03 +0200 | [diff] [blame] | 33 | #include <linux/mei.h> |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 34 | |
| 35 | #include "mei_dev.h" |
Tomas Winkler | 0edb23f | 2013-01-08 23:07:12 +0200 | [diff] [blame] | 36 | #include "hbm.h" |
Tomas Winkler | 90e0b5f | 2013-01-08 23:07:14 +0200 | [diff] [blame] | 37 | #include "client.h" |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 38 | |
Tomas Winkler | 1a1aca4 | 2013-01-08 23:07:21 +0200 | [diff] [blame] | 39 | const uuid_le mei_amthif_guid = UUID_LE(0x12f80028, 0xb4b7, 0x4b2d, |
| 40 | 0xac, 0xa8, 0x46, 0xe0, |
| 41 | 0xff, 0x65, 0x81, 0x4c); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 42 | |
| 43 | /** |
| 44 | * mei_amthif_reset_params - initializes mei device iamthif |
| 45 | * |
| 46 | * @dev: the device structure |
| 47 | */ |
| 48 | void mei_amthif_reset_params(struct mei_device *dev) |
| 49 | { |
| 50 | /* reset iamthif parameters. */ |
| 51 | dev->iamthif_current_cb = NULL; |
| 52 | dev->iamthif_msg_buf_size = 0; |
| 53 | dev->iamthif_msg_buf_index = 0; |
| 54 | dev->iamthif_canceled = false; |
| 55 | dev->iamthif_ioctl = false; |
| 56 | dev->iamthif_state = MEI_IAMTHIF_IDLE; |
| 57 | dev->iamthif_timer = 0; |
Alexander Usyskin | 4a70457 | 2013-09-02 13:29:47 +0300 | [diff] [blame] | 58 | dev->iamthif_stall_timer = 0; |
Tomas Winkler | 22f96a0 | 2013-09-16 23:44:47 +0300 | [diff] [blame] | 59 | dev->iamthif_open_count = 0; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 60 | } |
| 61 | |
| 62 | /** |
Masanari Iida | 393b148 | 2013-04-05 01:05:05 +0900 | [diff] [blame] | 63 | * mei_amthif_host_init - mei initialization amthif client. |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 64 | * |
| 65 | * @dev: the device structure |
| 66 | * |
Alexander Usyskin | ce23139 | 2014-09-29 16:31:50 +0300 | [diff] [blame] | 67 | * Return: 0 on success, <0 on failure. |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 68 | */ |
Tomas Winkler | 781d0d8 | 2013-01-08 23:07:22 +0200 | [diff] [blame] | 69 | int mei_amthif_host_init(struct mei_device *dev) |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 70 | { |
Tomas Winkler | 781d0d8 | 2013-01-08 23:07:22 +0200 | [diff] [blame] | 71 | struct mei_cl *cl = &dev->iamthif_cl; |
Tomas Winkler | d320832 | 2014-08-24 12:08:55 +0300 | [diff] [blame] | 72 | struct mei_me_client *me_cl; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 73 | unsigned char *msg_buf; |
Tomas Winkler | d320832 | 2014-08-24 12:08:55 +0300 | [diff] [blame] | 74 | int ret; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 75 | |
Tomas Winkler | 6222f7b | 2013-01-08 23:07:23 +0200 | [diff] [blame] | 76 | dev->iamthif_state = MEI_IAMTHIF_IDLE; |
| 77 | |
Tomas Winkler | 781d0d8 | 2013-01-08 23:07:22 +0200 | [diff] [blame] | 78 | mei_cl_init(cl, dev); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 79 | |
Tomas Winkler | d320832 | 2014-08-24 12:08:55 +0300 | [diff] [blame] | 80 | me_cl = mei_me_cl_by_uuid(dev, &mei_amthif_guid); |
| 81 | if (!me_cl) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 82 | dev_info(dev->dev, "amthif: failed to find the client"); |
Alexander Usyskin | 7ca96aa | 2014-02-19 17:35:49 +0200 | [diff] [blame] | 83 | return -ENOTTY; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 84 | } |
| 85 | |
Tomas Winkler | d320832 | 2014-08-24 12:08:55 +0300 | [diff] [blame] | 86 | cl->me_client_id = me_cl->client_id; |
Tomas Winkler | d880f32 | 2014-08-21 14:29:15 +0300 | [diff] [blame] | 87 | cl->cl_uuid = me_cl->props.protocol_name; |
Tomas Winkler | 781d0d8 | 2013-01-08 23:07:22 +0200 | [diff] [blame] | 88 | |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 89 | /* Assign iamthif_mtu to the value received from ME */ |
| 90 | |
Tomas Winkler | d320832 | 2014-08-24 12:08:55 +0300 | [diff] [blame] | 91 | dev->iamthif_mtu = me_cl->props.max_msg_length; |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 92 | dev_dbg(dev->dev, "IAMTHIF_MTU = %d\n", dev->iamthif_mtu); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 93 | |
| 94 | kfree(dev->iamthif_msg_buf); |
| 95 | dev->iamthif_msg_buf = NULL; |
| 96 | |
| 97 | /* allocate storage for ME message buffer */ |
| 98 | msg_buf = kcalloc(dev->iamthif_mtu, |
| 99 | sizeof(unsigned char), GFP_KERNEL); |
Tomas Winkler | 79563db | 2015-01-11 00:07:16 +0200 | [diff] [blame] | 100 | if (!msg_buf) { |
| 101 | ret = -ENOMEM; |
| 102 | goto out; |
| 103 | } |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 104 | |
| 105 | dev->iamthif_msg_buf = msg_buf; |
| 106 | |
Tomas Winkler | 781d0d8 | 2013-01-08 23:07:22 +0200 | [diff] [blame] | 107 | ret = mei_cl_link(cl, MEI_IAMTHIF_HOST_CLIENT_ID); |
Tomas Winkler | 781d0d8 | 2013-01-08 23:07:22 +0200 | [diff] [blame] | 108 | if (ret < 0) { |
Tomas Winkler | 79563db | 2015-01-11 00:07:16 +0200 | [diff] [blame] | 109 | dev_err(dev->dev, "amthif: failed cl_link %d\n", ret); |
| 110 | goto out; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 111 | } |
Tomas Winkler | 781d0d8 | 2013-01-08 23:07:22 +0200 | [diff] [blame] | 112 | |
Tomas Winkler | 6409285 | 2014-02-17 15:13:21 +0200 | [diff] [blame] | 113 | ret = mei_cl_connect(cl, NULL); |
| 114 | |
| 115 | dev->iamthif_state = MEI_IAMTHIF_IDLE; |
| 116 | |
Tomas Winkler | 79563db | 2015-01-11 00:07:16 +0200 | [diff] [blame] | 117 | out: |
| 118 | mei_me_cl_put(me_cl); |
Tomas Winkler | 6409285 | 2014-02-17 15:13:21 +0200 | [diff] [blame] | 119 | return ret; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 120 | } |
| 121 | |
| 122 | /** |
| 123 | * mei_amthif_find_read_list_entry - finds a amthilist entry for current file |
| 124 | * |
| 125 | * @dev: the device structure |
| 126 | * @file: pointer to file object |
| 127 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 128 | * Return: returned a list entry on success, NULL on failure. |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 129 | */ |
| 130 | struct mei_cl_cb *mei_amthif_find_read_list_entry(struct mei_device *dev, |
| 131 | struct file *file) |
| 132 | { |
Tomas Winkler | 31f88f5 | 2014-02-17 15:13:25 +0200 | [diff] [blame] | 133 | struct mei_cl_cb *cb; |
Tomas Winkler | 92db155 | 2014-09-29 16:31:37 +0300 | [diff] [blame] | 134 | |
Alexander Usyskin | 05e314e | 2014-08-14 17:22:21 +0300 | [diff] [blame] | 135 | list_for_each_entry(cb, &dev->amthif_rd_complete_list.list, list) |
| 136 | if (cb->file_object == file) |
Tomas Winkler | 31f88f5 | 2014-02-17 15:13:25 +0200 | [diff] [blame] | 137 | return cb; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 138 | return NULL; |
| 139 | } |
| 140 | |
| 141 | |
| 142 | /** |
| 143 | * mei_amthif_read - read data from AMTHIF client |
| 144 | * |
| 145 | * @dev: the device structure |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 146 | * @file: pointer to file object |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 147 | * @ubuf: pointer to user data in user space |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 148 | * @length: data length to read |
| 149 | * @offset: data read offset |
| 150 | * |
| 151 | * Locking: called under "dev->device_lock" lock |
| 152 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 153 | * Return: |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 154 | * returned data length on success, |
| 155 | * zero if no data to read, |
| 156 | * negative on failure. |
| 157 | */ |
| 158 | int mei_amthif_read(struct mei_device *dev, struct file *file, |
| 159 | char __user *ubuf, size_t length, loff_t *offset) |
| 160 | { |
Tomas Winkler | d320832 | 2014-08-24 12:08:55 +0300 | [diff] [blame] | 161 | struct mei_cl *cl = file->private_data; |
| 162 | struct mei_cl_cb *cb; |
| 163 | unsigned long timeout; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 164 | int rets; |
| 165 | int wait_ret; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 166 | |
Alexander Usyskin | 83ce074 | 2014-01-08 22:31:46 +0200 | [diff] [blame] | 167 | /* Only possible if we are in timeout */ |
Alexander Usyskin | 05e314e | 2014-08-14 17:22:21 +0300 | [diff] [blame] | 168 | if (!cl) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 169 | dev_err(dev->dev, "bad file ext.\n"); |
Alexander Usyskin | 7ca96aa | 2014-02-19 17:35:49 +0200 | [diff] [blame] | 170 | return -ETIME; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 171 | } |
| 172 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 173 | dev_dbg(dev->dev, "checking amthif data\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 174 | cb = mei_amthif_find_read_list_entry(dev, file); |
| 175 | |
| 176 | /* Check for if we can block or not*/ |
| 177 | if (cb == NULL && file->f_flags & O_NONBLOCK) |
| 178 | return -EAGAIN; |
| 179 | |
| 180 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 181 | dev_dbg(dev->dev, "waiting for amthif data\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 182 | while (cb == NULL) { |
| 183 | /* unlock the Mutex */ |
| 184 | mutex_unlock(&dev->device_lock); |
| 185 | |
| 186 | wait_ret = wait_event_interruptible(dev->iamthif_cl.wait, |
| 187 | (cb = mei_amthif_find_read_list_entry(dev, file))); |
| 188 | |
Alexey Khoroshilov | e6028db | 2012-12-22 01:44:16 +0400 | [diff] [blame] | 189 | /* Locking again the Mutex */ |
| 190 | mutex_lock(&dev->device_lock); |
| 191 | |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 192 | if (wait_ret) |
| 193 | return -ERESTARTSYS; |
| 194 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 195 | dev_dbg(dev->dev, "woke up from sleep\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 196 | } |
| 197 | |
| 198 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 199 | dev_dbg(dev->dev, "Got amthif data\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 200 | dev->iamthif_timer = 0; |
| 201 | |
| 202 | if (cb) { |
| 203 | timeout = cb->read_time + |
| 204 | mei_secs_to_jiffies(MEI_IAMTHIF_READ_TIMER); |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 205 | dev_dbg(dev->dev, "amthif timeout = %lud\n", |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 206 | timeout); |
| 207 | |
| 208 | if (time_after(jiffies, timeout)) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 209 | dev_dbg(dev->dev, "amthif Time out\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 210 | /* 15 sec for the message has expired */ |
| 211 | list_del(&cb->list); |
Alexander Usyskin | 7ca96aa | 2014-02-19 17:35:49 +0200 | [diff] [blame] | 212 | rets = -ETIME; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 213 | goto free; |
| 214 | } |
| 215 | } |
| 216 | /* if the whole message will fit remove it from the list */ |
| 217 | if (cb->buf_idx >= *offset && length >= (cb->buf_idx - *offset)) |
| 218 | list_del(&cb->list); |
| 219 | else if (cb->buf_idx > 0 && cb->buf_idx <= *offset) { |
| 220 | /* end of the message has been reached */ |
| 221 | list_del(&cb->list); |
| 222 | rets = 0; |
| 223 | goto free; |
| 224 | } |
| 225 | /* else means that not full buffer will be read and do not |
| 226 | * remove message from deletion list |
| 227 | */ |
| 228 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 229 | dev_dbg(dev->dev, "amthif cb->response_buffer size - %d\n", |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 230 | cb->response_buffer.size); |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 231 | dev_dbg(dev->dev, "amthif cb->buf_idx - %lu\n", cb->buf_idx); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 232 | |
Alexander Usyskin | 83ce074 | 2014-01-08 22:31:46 +0200 | [diff] [blame] | 233 | /* length is being truncated to PAGE_SIZE, however, |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 234 | * the buf_idx may point beyond */ |
| 235 | length = min_t(size_t, length, (cb->buf_idx - *offset)); |
| 236 | |
Alexander Usyskin | dbac474 | 2014-03-12 13:19:13 +0200 | [diff] [blame] | 237 | if (copy_to_user(ubuf, cb->response_buffer.data + *offset, length)) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 238 | dev_dbg(dev->dev, "failed to copy data to userland\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 239 | rets = -EFAULT; |
Tomas Winkler | 34e267d | 2014-03-16 14:35:57 +0200 | [diff] [blame] | 240 | } else { |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 241 | rets = length; |
| 242 | if ((*offset + length) < cb->buf_idx) { |
| 243 | *offset += length; |
| 244 | goto out; |
| 245 | } |
| 246 | } |
| 247 | free: |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 248 | dev_dbg(dev->dev, "free amthif cb memory.\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 249 | *offset = 0; |
| 250 | mei_io_cb_free(cb); |
| 251 | out: |
| 252 | return rets; |
| 253 | } |
| 254 | |
| 255 | /** |
Tomas Winkler | ab5c4a5 | 2012-11-01 21:17:18 +0200 | [diff] [blame] | 256 | * mei_amthif_send_cmd - send amthif command to the ME |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 257 | * |
| 258 | * @dev: the device structure |
| 259 | * @cb: mei call back struct |
| 260 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 261 | * Return: 0 on success, <0 on failure. |
Tomas Winkler | ab5c4a5 | 2012-11-01 21:17:18 +0200 | [diff] [blame] | 262 | * |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 263 | */ |
Tomas Winkler | ab5c4a5 | 2012-11-01 21:17:18 +0200 | [diff] [blame] | 264 | static int mei_amthif_send_cmd(struct mei_device *dev, struct mei_cl_cb *cb) |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 265 | { |
| 266 | struct mei_msg_hdr mei_hdr; |
Tomas Winkler | 3d32cf0 | 2014-10-02 13:39:32 +0300 | [diff] [blame] | 267 | struct mei_cl *cl; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 268 | int ret; |
| 269 | |
| 270 | if (!dev || !cb) |
| 271 | return -ENODEV; |
| 272 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 273 | dev_dbg(dev->dev, "write data to amthif client.\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 274 | |
| 275 | dev->iamthif_state = MEI_IAMTHIF_WRITING; |
| 276 | dev->iamthif_current_cb = cb; |
| 277 | dev->iamthif_file_object = cb->file_object; |
| 278 | dev->iamthif_canceled = false; |
| 279 | dev->iamthif_ioctl = true; |
| 280 | dev->iamthif_msg_buf_size = cb->request_buffer.size; |
| 281 | memcpy(dev->iamthif_msg_buf, cb->request_buffer.data, |
| 282 | cb->request_buffer.size); |
Tomas Winkler | 3d32cf0 | 2014-10-02 13:39:32 +0300 | [diff] [blame] | 283 | cl = &dev->iamthif_cl; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 284 | |
Tomas Winkler | 3d32cf0 | 2014-10-02 13:39:32 +0300 | [diff] [blame] | 285 | ret = mei_cl_flow_ctrl_creds(cl); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 286 | if (ret < 0) |
| 287 | return ret; |
| 288 | |
Tomas Winkler | 6aae48f | 2014-02-19 17:35:47 +0200 | [diff] [blame] | 289 | if (ret && mei_hbuf_acquire(dev)) { |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 290 | ret = 0; |
Tomas Winkler | 827eef5 | 2013-02-06 14:06:41 +0200 | [diff] [blame] | 291 | if (cb->request_buffer.size > mei_hbuf_max_len(dev)) { |
| 292 | mei_hdr.length = mei_hbuf_max_len(dev); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 293 | mei_hdr.msg_complete = 0; |
| 294 | } else { |
| 295 | mei_hdr.length = cb->request_buffer.size; |
| 296 | mei_hdr.msg_complete = 1; |
| 297 | } |
| 298 | |
Tomas Winkler | 3d32cf0 | 2014-10-02 13:39:32 +0300 | [diff] [blame] | 299 | mei_hdr.host_addr = cl->host_client_id; |
| 300 | mei_hdr.me_addr = cl->me_client_id; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 301 | mei_hdr.reserved = 0; |
Tomas Winkler | 479327f | 2013-12-17 15:56:56 +0200 | [diff] [blame] | 302 | mei_hdr.internal = 0; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 303 | dev->iamthif_msg_buf_index += mei_hdr.length; |
Tomas Winkler | 2ebf8c9 | 2013-09-16 23:44:43 +0300 | [diff] [blame] | 304 | ret = mei_write_message(dev, &mei_hdr, dev->iamthif_msg_buf); |
| 305 | if (ret) |
| 306 | return ret; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 307 | |
| 308 | if (mei_hdr.msg_complete) { |
Tomas Winkler | 3d32cf0 | 2014-10-02 13:39:32 +0300 | [diff] [blame] | 309 | if (mei_cl_flow_ctrl_reduce(cl)) |
Tomas Winkler | 2ebf8c9 | 2013-09-16 23:44:43 +0300 | [diff] [blame] | 310 | return -EIO; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 311 | dev->iamthif_flow_control_pending = true; |
| 312 | dev->iamthif_state = MEI_IAMTHIF_FLOW_CONTROL; |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 313 | dev_dbg(dev->dev, "add amthif cb to write waiting list\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 314 | dev->iamthif_current_cb = cb; |
| 315 | dev->iamthif_file_object = cb->file_object; |
| 316 | list_add_tail(&cb->list, &dev->write_waiting_list.list); |
| 317 | } else { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 318 | dev_dbg(dev->dev, "message does not complete, so add amthif cb to write list.\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 319 | list_add_tail(&cb->list, &dev->write_list.list); |
| 320 | } |
| 321 | } else { |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 322 | list_add_tail(&cb->list, &dev->write_list.list); |
| 323 | } |
| 324 | return 0; |
| 325 | } |
| 326 | |
| 327 | /** |
Tomas Winkler | ab5c4a5 | 2012-11-01 21:17:18 +0200 | [diff] [blame] | 328 | * mei_amthif_write - write amthif data to amthif client |
| 329 | * |
| 330 | * @dev: the device structure |
| 331 | * @cb: mei call back struct |
| 332 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 333 | * Return: 0 on success, <0 on failure. |
Tomas Winkler | ab5c4a5 | 2012-11-01 21:17:18 +0200 | [diff] [blame] | 334 | * |
| 335 | */ |
| 336 | int mei_amthif_write(struct mei_device *dev, struct mei_cl_cb *cb) |
| 337 | { |
| 338 | int ret; |
| 339 | |
| 340 | if (!dev || !cb) |
| 341 | return -ENODEV; |
| 342 | |
| 343 | ret = mei_io_cb_alloc_resp_buf(cb, dev->iamthif_mtu); |
| 344 | if (ret) |
| 345 | return ret; |
| 346 | |
Tomas Winkler | 02a7eec | 2014-02-12 21:41:51 +0200 | [diff] [blame] | 347 | cb->fop_type = MEI_FOP_WRITE; |
Tomas Winkler | ab5c4a5 | 2012-11-01 21:17:18 +0200 | [diff] [blame] | 348 | |
Tomas Winkler | e773efc | 2012-11-11 17:37:58 +0200 | [diff] [blame] | 349 | if (!list_empty(&dev->amthif_cmd_list.list) || |
Tomas Winkler | ab5c4a5 | 2012-11-01 21:17:18 +0200 | [diff] [blame] | 350 | dev->iamthif_state != MEI_IAMTHIF_IDLE) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 351 | dev_dbg(dev->dev, |
Tomas Winkler | ab5c4a5 | 2012-11-01 21:17:18 +0200 | [diff] [blame] | 352 | "amthif state = %d\n", dev->iamthif_state); |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 353 | dev_dbg(dev->dev, "AMTHIF: add cb to the wait list\n"); |
Tomas Winkler | e773efc | 2012-11-11 17:37:58 +0200 | [diff] [blame] | 354 | list_add_tail(&cb->list, &dev->amthif_cmd_list.list); |
Tomas Winkler | ab5c4a5 | 2012-11-01 21:17:18 +0200 | [diff] [blame] | 355 | return 0; |
| 356 | } |
| 357 | return mei_amthif_send_cmd(dev, cb); |
| 358 | } |
| 359 | /** |
Alexander Usyskin | ce23139 | 2014-09-29 16:31:50 +0300 | [diff] [blame] | 360 | * mei_amthif_run_next_cmd - send next amt command from queue |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 361 | * |
| 362 | * @dev: the device structure |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 363 | */ |
| 364 | void mei_amthif_run_next_cmd(struct mei_device *dev) |
| 365 | { |
Alexander Usyskin | 05e314e | 2014-08-14 17:22:21 +0300 | [diff] [blame] | 366 | struct mei_cl_cb *cb; |
Alexander Usyskin | 140c755 | 2014-10-02 13:39:31 +0300 | [diff] [blame] | 367 | int ret; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 368 | |
| 369 | if (!dev) |
| 370 | return; |
| 371 | |
| 372 | dev->iamthif_msg_buf_size = 0; |
| 373 | dev->iamthif_msg_buf_index = 0; |
| 374 | dev->iamthif_canceled = false; |
| 375 | dev->iamthif_ioctl = true; |
| 376 | dev->iamthif_state = MEI_IAMTHIF_IDLE; |
| 377 | dev->iamthif_timer = 0; |
| 378 | dev->iamthif_file_object = NULL; |
| 379 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 380 | dev_dbg(dev->dev, "complete amthif cmd_list cb.\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 381 | |
Alexander Usyskin | 140c755 | 2014-10-02 13:39:31 +0300 | [diff] [blame] | 382 | cb = list_first_entry_or_null(&dev->amthif_cmd_list.list, |
| 383 | typeof(*cb), list); |
| 384 | if (!cb) |
| 385 | return; |
| 386 | list_del(&cb->list); |
| 387 | ret = mei_amthif_send_cmd(dev, cb); |
| 388 | if (ret) |
| 389 | dev_warn(dev->dev, "amthif write failed status = %d\n", ret); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 390 | } |
| 391 | |
Tomas Winkler | 744f0f2 | 2012-11-11 17:38:02 +0200 | [diff] [blame] | 392 | |
| 393 | unsigned int mei_amthif_poll(struct mei_device *dev, |
| 394 | struct file *file, poll_table *wait) |
| 395 | { |
| 396 | unsigned int mask = 0; |
Tomas Winkler | b950ac1 | 2013-07-25 20:15:53 +0300 | [diff] [blame] | 397 | |
Tomas Winkler | 744f0f2 | 2012-11-11 17:38:02 +0200 | [diff] [blame] | 398 | poll_wait(file, &dev->iamthif_cl.wait, wait); |
Tomas Winkler | b950ac1 | 2013-07-25 20:15:53 +0300 | [diff] [blame] | 399 | |
Tomas Winkler | 744f0f2 | 2012-11-11 17:38:02 +0200 | [diff] [blame] | 400 | mutex_lock(&dev->device_lock); |
Tomas Winkler | b950ac1 | 2013-07-25 20:15:53 +0300 | [diff] [blame] | 401 | if (!mei_cl_is_connected(&dev->iamthif_cl)) { |
| 402 | |
| 403 | mask = POLLERR; |
| 404 | |
| 405 | } else if (dev->iamthif_state == MEI_IAMTHIF_READ_COMPLETE && |
| 406 | dev->iamthif_file_object == file) { |
| 407 | |
Tomas Winkler | 744f0f2 | 2012-11-11 17:38:02 +0200 | [diff] [blame] | 408 | mask |= (POLLIN | POLLRDNORM); |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 409 | dev_dbg(dev->dev, "run next amthif cb\n"); |
Tomas Winkler | 744f0f2 | 2012-11-11 17:38:02 +0200 | [diff] [blame] | 410 | mei_amthif_run_next_cmd(dev); |
| 411 | } |
Tomas Winkler | b950ac1 | 2013-07-25 20:15:53 +0300 | [diff] [blame] | 412 | mutex_unlock(&dev->device_lock); |
| 413 | |
Tomas Winkler | 744f0f2 | 2012-11-11 17:38:02 +0200 | [diff] [blame] | 414 | return mask; |
| 415 | } |
| 416 | |
| 417 | |
| 418 | |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 419 | /** |
Tomas Winkler | 9d09819 | 2014-02-19 17:35:48 +0200 | [diff] [blame] | 420 | * mei_amthif_irq_write - write iamthif command in irq thread context. |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 421 | * |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 422 | * @cl: private data of the file object. |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 423 | * @cb: callback block. |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 424 | * @cmpl_list: complete list. |
| 425 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 426 | * Return: 0, OK; otherwise, error. |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 427 | */ |
Tomas Winkler | 9d09819 | 2014-02-19 17:35:48 +0200 | [diff] [blame] | 428 | int mei_amthif_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb, |
| 429 | struct mei_cl_cb *cmpl_list) |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 430 | { |
Tomas Winkler | 6220d6a | 2013-05-12 15:34:46 +0300 | [diff] [blame] | 431 | struct mei_device *dev = cl->dev; |
Tomas Winkler | e46f187 | 2012-12-25 19:06:10 +0200 | [diff] [blame] | 432 | struct mei_msg_hdr mei_hdr; |
Tomas Winkler | 24c656e | 2012-11-18 15:13:17 +0200 | [diff] [blame] | 433 | size_t len = dev->iamthif_msg_buf_size - dev->iamthif_msg_buf_index; |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 434 | u32 msg_slots = mei_data2slots(len); |
Tomas Winkler | 9d09819 | 2014-02-19 17:35:48 +0200 | [diff] [blame] | 435 | int slots; |
Tomas Winkler | 2ebf8c9 | 2013-09-16 23:44:43 +0300 | [diff] [blame] | 436 | int rets; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 437 | |
Tomas Winkler | 136698e | 2013-09-16 23:44:44 +0300 | [diff] [blame] | 438 | rets = mei_cl_flow_ctrl_creds(cl); |
| 439 | if (rets < 0) |
| 440 | return rets; |
| 441 | |
| 442 | if (rets == 0) { |
| 443 | cl_dbg(dev, cl, "No flow control credentials: not sending.\n"); |
| 444 | return 0; |
| 445 | } |
| 446 | |
Tomas Winkler | e46f187 | 2012-12-25 19:06:10 +0200 | [diff] [blame] | 447 | mei_hdr.host_addr = cl->host_client_id; |
| 448 | mei_hdr.me_addr = cl->me_client_id; |
| 449 | mei_hdr.reserved = 0; |
Tomas Winkler | 479327f | 2013-12-17 15:56:56 +0200 | [diff] [blame] | 450 | mei_hdr.internal = 0; |
Tomas Winkler | 24c656e | 2012-11-18 15:13:17 +0200 | [diff] [blame] | 451 | |
Tomas Winkler | 9d09819 | 2014-02-19 17:35:48 +0200 | [diff] [blame] | 452 | slots = mei_hbuf_empty_slots(dev); |
| 453 | |
| 454 | if (slots >= msg_slots) { |
Tomas Winkler | e46f187 | 2012-12-25 19:06:10 +0200 | [diff] [blame] | 455 | mei_hdr.length = len; |
| 456 | mei_hdr.msg_complete = 1; |
Tomas Winkler | 24c656e | 2012-11-18 15:13:17 +0200 | [diff] [blame] | 457 | /* Split the message only if we can write the whole host buffer */ |
Tomas Winkler | 9d09819 | 2014-02-19 17:35:48 +0200 | [diff] [blame] | 458 | } else if (slots == dev->hbuf_depth) { |
| 459 | msg_slots = slots; |
| 460 | len = (slots * sizeof(u32)) - sizeof(struct mei_msg_hdr); |
Tomas Winkler | e46f187 | 2012-12-25 19:06:10 +0200 | [diff] [blame] | 461 | mei_hdr.length = len; |
| 462 | mei_hdr.msg_complete = 0; |
Tomas Winkler | 24c656e | 2012-11-18 15:13:17 +0200 | [diff] [blame] | 463 | } else { |
| 464 | /* wait for next time the host buffer is empty */ |
| 465 | return 0; |
| 466 | } |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 467 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 468 | dev_dbg(dev->dev, MEI_HDR_FMT, MEI_HDR_PRM(&mei_hdr)); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 469 | |
Tomas Winkler | 2ebf8c9 | 2013-09-16 23:44:43 +0300 | [diff] [blame] | 470 | rets = mei_write_message(dev, &mei_hdr, |
| 471 | dev->iamthif_msg_buf + dev->iamthif_msg_buf_index); |
| 472 | if (rets) { |
| 473 | dev->iamthif_state = MEI_IAMTHIF_IDLE; |
| 474 | cl->status = rets; |
| 475 | list_del(&cb->list); |
| 476 | return rets; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 477 | } |
| 478 | |
Tomas Winkler | 90e0b5f | 2013-01-08 23:07:14 +0200 | [diff] [blame] | 479 | if (mei_cl_flow_ctrl_reduce(cl)) |
Tomas Winkler | 2ebf8c9 | 2013-09-16 23:44:43 +0300 | [diff] [blame] | 480 | return -EIO; |
Tomas Winkler | 24c656e | 2012-11-18 15:13:17 +0200 | [diff] [blame] | 481 | |
Tomas Winkler | e46f187 | 2012-12-25 19:06:10 +0200 | [diff] [blame] | 482 | dev->iamthif_msg_buf_index += mei_hdr.length; |
Tomas Winkler | 24c656e | 2012-11-18 15:13:17 +0200 | [diff] [blame] | 483 | cl->status = 0; |
| 484 | |
Tomas Winkler | e46f187 | 2012-12-25 19:06:10 +0200 | [diff] [blame] | 485 | if (mei_hdr.msg_complete) { |
Tomas Winkler | 24c656e | 2012-11-18 15:13:17 +0200 | [diff] [blame] | 486 | dev->iamthif_state = MEI_IAMTHIF_FLOW_CONTROL; |
| 487 | dev->iamthif_flow_control_pending = true; |
| 488 | |
Tomas Winkler | 1a1aca4 | 2013-01-08 23:07:21 +0200 | [diff] [blame] | 489 | /* save iamthif cb sent to amthif client */ |
Tomas Winkler | 24c656e | 2012-11-18 15:13:17 +0200 | [diff] [blame] | 490 | cb->buf_idx = dev->iamthif_msg_buf_index; |
| 491 | dev->iamthif_current_cb = cb; |
| 492 | |
| 493 | list_move_tail(&cb->list, &dev->write_waiting_list.list); |
| 494 | } |
| 495 | |
| 496 | |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 497 | return 0; |
| 498 | } |
| 499 | |
| 500 | /** |
Alexander Usyskin | ce23139 | 2014-09-29 16:31:50 +0300 | [diff] [blame] | 501 | * mei_amthif_irq_read_msg - read routine after ISR to |
Tomas Winkler | 1a1aca4 | 2013-01-08 23:07:21 +0200 | [diff] [blame] | 502 | * handle the read amthif message |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 503 | * |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 504 | * @dev: the device structure |
Tomas Winkler | 1a1aca4 | 2013-01-08 23:07:21 +0200 | [diff] [blame] | 505 | * @mei_hdr: header of amthif message |
Tomas Winkler | 5ceb46e | 2013-04-19 21:16:53 +0300 | [diff] [blame] | 506 | * @complete_list: An instance of our list structure |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 507 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 508 | * Return: 0 on success, <0 on failure. |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 509 | */ |
Tomas Winkler | 5ceb46e | 2013-04-19 21:16:53 +0300 | [diff] [blame] | 510 | int mei_amthif_irq_read_msg(struct mei_device *dev, |
| 511 | struct mei_msg_hdr *mei_hdr, |
| 512 | struct mei_cl_cb *complete_list) |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 513 | { |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 514 | struct mei_cl_cb *cb; |
| 515 | unsigned char *buffer; |
| 516 | |
| 517 | BUG_ON(mei_hdr->me_addr != dev->iamthif_cl.me_client_id); |
| 518 | BUG_ON(dev->iamthif_state != MEI_IAMTHIF_READING); |
| 519 | |
| 520 | buffer = dev->iamthif_msg_buf + dev->iamthif_msg_buf_index; |
| 521 | BUG_ON(dev->iamthif_mtu < dev->iamthif_msg_buf_index + mei_hdr->length); |
| 522 | |
| 523 | mei_read_slots(dev, buffer, mei_hdr->length); |
| 524 | |
| 525 | dev->iamthif_msg_buf_index += mei_hdr->length; |
| 526 | |
| 527 | if (!mei_hdr->msg_complete) |
| 528 | return 0; |
| 529 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 530 | dev_dbg(dev->dev, "amthif_message_buffer_index =%d\n", |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 531 | mei_hdr->length); |
| 532 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 533 | dev_dbg(dev->dev, "completed amthif read.\n "); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 534 | if (!dev->iamthif_current_cb) |
| 535 | return -ENODEV; |
| 536 | |
| 537 | cb = dev->iamthif_current_cb; |
| 538 | dev->iamthif_current_cb = NULL; |
| 539 | |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 540 | dev->iamthif_stall_timer = 0; |
| 541 | cb->buf_idx = dev->iamthif_msg_buf_index; |
| 542 | cb->read_time = jiffies; |
Alexander Usyskin | 05e314e | 2014-08-14 17:22:21 +0300 | [diff] [blame] | 543 | if (dev->iamthif_ioctl) { |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 544 | /* found the iamthif cb */ |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 545 | dev_dbg(dev->dev, "complete the amthif read cb.\n "); |
| 546 | dev_dbg(dev->dev, "add the amthif read cb to complete.\n "); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 547 | list_add_tail(&cb->list, &complete_list->list); |
| 548 | } |
| 549 | return 0; |
| 550 | } |
| 551 | |
| 552 | /** |
| 553 | * mei_amthif_irq_read - prepares to read amthif data. |
| 554 | * |
| 555 | * @dev: the device structure. |
| 556 | * @slots: free slots. |
| 557 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 558 | * Return: 0, OK; otherwise, error. |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 559 | */ |
| 560 | int mei_amthif_irq_read(struct mei_device *dev, s32 *slots) |
| 561 | { |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 562 | u32 msg_slots = mei_data2slots(sizeof(struct hbm_flow_control)); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 563 | |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 564 | if (*slots < msg_slots) |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 565 | return -EMSGSIZE; |
Tomas Winkler | c8c8d08 | 2013-03-11 18:27:02 +0200 | [diff] [blame] | 566 | |
| 567 | *slots -= msg_slots; |
| 568 | |
Tomas Winkler | 8120e72 | 2012-12-25 19:06:11 +0200 | [diff] [blame] | 569 | if (mei_hbm_cl_flow_control_req(dev, &dev->iamthif_cl)) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 570 | dev_dbg(dev->dev, "iamthif flow control failed\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 571 | return -EIO; |
| 572 | } |
| 573 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 574 | dev_dbg(dev->dev, "iamthif flow control success\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 575 | dev->iamthif_state = MEI_IAMTHIF_READING; |
| 576 | dev->iamthif_flow_control_pending = false; |
| 577 | dev->iamthif_msg_buf_index = 0; |
| 578 | dev->iamthif_msg_buf_size = 0; |
| 579 | dev->iamthif_stall_timer = MEI_IAMTHIF_STALL_TIMER; |
Tomas Winkler | 330dd7d | 2013-02-06 14:06:43 +0200 | [diff] [blame] | 580 | dev->hbuf_is_ready = mei_hbuf_is_ready(dev); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 581 | return 0; |
| 582 | } |
| 583 | |
| 584 | /** |
| 585 | * mei_amthif_complete - complete amthif callback. |
| 586 | * |
| 587 | * @dev: the device structure. |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 588 | * @cb: callback block. |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 589 | */ |
| 590 | void mei_amthif_complete(struct mei_device *dev, struct mei_cl_cb *cb) |
| 591 | { |
| 592 | if (dev->iamthif_canceled != 1) { |
| 593 | dev->iamthif_state = MEI_IAMTHIF_READ_COMPLETE; |
| 594 | dev->iamthif_stall_timer = 0; |
| 595 | memcpy(cb->response_buffer.data, |
| 596 | dev->iamthif_msg_buf, |
| 597 | dev->iamthif_msg_buf_index); |
Tomas Winkler | e773efc | 2012-11-11 17:37:58 +0200 | [diff] [blame] | 598 | list_add_tail(&cb->list, &dev->amthif_rd_complete_list.list); |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 599 | dev_dbg(dev->dev, "amthif read completed\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 600 | dev->iamthif_timer = jiffies; |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 601 | dev_dbg(dev->dev, "dev->iamthif_timer = %ld\n", |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 602 | dev->iamthif_timer); |
| 603 | } else { |
| 604 | mei_amthif_run_next_cmd(dev); |
| 605 | } |
| 606 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 607 | dev_dbg(dev->dev, "completing amthif call back.\n"); |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 608 | wake_up_interruptible(&dev->iamthif_cl.wait); |
| 609 | } |
| 610 | |
Tomas Winkler | a562d5c | 2012-11-11 17:38:01 +0200 | [diff] [blame] | 611 | /** |
| 612 | * mei_clear_list - removes all callbacks associated with file |
| 613 | * from mei_cb_list |
| 614 | * |
| 615 | * @dev: device structure. |
| 616 | * @file: file structure |
| 617 | * @mei_cb_list: callbacks list |
| 618 | * |
| 619 | * mei_clear_list is called to clear resources associated with file |
| 620 | * when application calls close function or Ctrl-C was pressed |
| 621 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 622 | * Return: true if callback removed from the list, false otherwise |
Tomas Winkler | a562d5c | 2012-11-11 17:38:01 +0200 | [diff] [blame] | 623 | */ |
| 624 | static bool mei_clear_list(struct mei_device *dev, |
| 625 | const struct file *file, struct list_head *mei_cb_list) |
| 626 | { |
| 627 | struct mei_cl_cb *cb_pos = NULL; |
| 628 | struct mei_cl_cb *cb_next = NULL; |
| 629 | bool removed = false; |
Tomas Winkler | 19838fb | 2012-11-01 21:17:15 +0200 | [diff] [blame] | 630 | |
Tomas Winkler | a562d5c | 2012-11-11 17:38:01 +0200 | [diff] [blame] | 631 | /* list all list member */ |
| 632 | list_for_each_entry_safe(cb_pos, cb_next, mei_cb_list, list) { |
| 633 | /* check if list member associated with a file */ |
| 634 | if (file == cb_pos->file_object) { |
| 635 | /* remove member from the list */ |
| 636 | list_del(&cb_pos->list); |
| 637 | /* check if cb equal to current iamthif cb */ |
| 638 | if (dev->iamthif_current_cb == cb_pos) { |
| 639 | dev->iamthif_current_cb = NULL; |
| 640 | /* send flow control to iamthif client */ |
Tomas Winkler | 8120e72 | 2012-12-25 19:06:11 +0200 | [diff] [blame] | 641 | mei_hbm_cl_flow_control_req(dev, |
| 642 | &dev->iamthif_cl); |
Tomas Winkler | a562d5c | 2012-11-11 17:38:01 +0200 | [diff] [blame] | 643 | } |
| 644 | /* free all allocated buffers */ |
| 645 | mei_io_cb_free(cb_pos); |
| 646 | cb_pos = NULL; |
| 647 | removed = true; |
| 648 | } |
| 649 | } |
| 650 | return removed; |
| 651 | } |
| 652 | |
| 653 | /** |
| 654 | * mei_clear_lists - removes all callbacks associated with file |
| 655 | * |
| 656 | * @dev: device structure |
| 657 | * @file: file structure |
| 658 | * |
| 659 | * mei_clear_lists is called to clear resources associated with file |
| 660 | * when application calls close function or Ctrl-C was pressed |
| 661 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 662 | * Return: true if callback removed from the list, false otherwise |
Tomas Winkler | a562d5c | 2012-11-11 17:38:01 +0200 | [diff] [blame] | 663 | */ |
| 664 | static bool mei_clear_lists(struct mei_device *dev, struct file *file) |
| 665 | { |
| 666 | bool removed = false; |
| 667 | |
| 668 | /* remove callbacks associated with a file */ |
| 669 | mei_clear_list(dev, file, &dev->amthif_cmd_list.list); |
| 670 | if (mei_clear_list(dev, file, &dev->amthif_rd_complete_list.list)) |
| 671 | removed = true; |
| 672 | |
| 673 | mei_clear_list(dev, file, &dev->ctrl_rd_list.list); |
| 674 | |
| 675 | if (mei_clear_list(dev, file, &dev->ctrl_wr_list.list)) |
| 676 | removed = true; |
| 677 | |
| 678 | if (mei_clear_list(dev, file, &dev->write_waiting_list.list)) |
| 679 | removed = true; |
| 680 | |
| 681 | if (mei_clear_list(dev, file, &dev->write_list.list)) |
| 682 | removed = true; |
| 683 | |
| 684 | /* check if iamthif_current_cb not NULL */ |
| 685 | if (dev->iamthif_current_cb && !removed) { |
| 686 | /* check file and iamthif current cb association */ |
| 687 | if (dev->iamthif_current_cb->file_object == file) { |
| 688 | /* remove cb */ |
| 689 | mei_io_cb_free(dev->iamthif_current_cb); |
| 690 | dev->iamthif_current_cb = NULL; |
| 691 | removed = true; |
| 692 | } |
| 693 | } |
| 694 | return removed; |
| 695 | } |
| 696 | |
| 697 | /** |
| 698 | * mei_amthif_release - the release function |
| 699 | * |
Masanari Iida | 393b148 | 2013-04-05 01:05:05 +0900 | [diff] [blame] | 700 | * @dev: device structure |
Tomas Winkler | a562d5c | 2012-11-11 17:38:01 +0200 | [diff] [blame] | 701 | * @file: pointer to file structure |
| 702 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 703 | * Return: 0 on success, <0 on error |
Tomas Winkler | a562d5c | 2012-11-11 17:38:01 +0200 | [diff] [blame] | 704 | */ |
| 705 | int mei_amthif_release(struct mei_device *dev, struct file *file) |
| 706 | { |
Tomas Winkler | 22f96a0 | 2013-09-16 23:44:47 +0300 | [diff] [blame] | 707 | if (dev->iamthif_open_count > 0) |
| 708 | dev->iamthif_open_count--; |
Tomas Winkler | a562d5c | 2012-11-11 17:38:01 +0200 | [diff] [blame] | 709 | |
| 710 | if (dev->iamthif_file_object == file && |
| 711 | dev->iamthif_state != MEI_IAMTHIF_IDLE) { |
| 712 | |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 713 | dev_dbg(dev->dev, "amthif canceled iamthif state %d\n", |
Tomas Winkler | a562d5c | 2012-11-11 17:38:01 +0200 | [diff] [blame] | 714 | dev->iamthif_state); |
| 715 | dev->iamthif_canceled = true; |
| 716 | if (dev->iamthif_state == MEI_IAMTHIF_READ_COMPLETE) { |
Tomas Winkler | 2bf94cab | 2014-09-29 16:31:42 +0300 | [diff] [blame] | 717 | dev_dbg(dev->dev, "run next amthif iamthif cb\n"); |
Tomas Winkler | a562d5c | 2012-11-11 17:38:01 +0200 | [diff] [blame] | 718 | mei_amthif_run_next_cmd(dev); |
| 719 | } |
| 720 | } |
| 721 | |
| 722 | if (mei_clear_lists(dev, file)) |
| 723 | dev->iamthif_state = MEI_IAMTHIF_IDLE; |
| 724 | |
| 725 | return 0; |
| 726 | } |