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