]>
git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - drivers/misc/mei/amthif.c
13d89043ad76d4309e81c6ef1bb38512bc0978af
3 * Intel Management Engine Interface (Intel MEI) Linux driver
4 * Copyright (c) 2003-2012, Intel Corporation.
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.
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
17 #include <linux/kernel.h>
19 #include <linux/errno.h>
20 #include <linux/types.h>
21 #include <linux/fcntl.h>
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>
30 #include <linux/slab.h>
32 #include <linux/mei.h>
38 const uuid_le mei_amthif_guid
= UUID_LE(0x12f80028, 0xb4b7, 0x4b2d,
39 0xac, 0xa8, 0x46, 0xe0,
40 0xff, 0x65, 0x81, 0x4c);
43 * mei_amthif_reset_params - initializes mei device iamthif
45 * @dev: the device structure
47 void mei_amthif_reset_params(struct mei_device
*dev
)
49 /* reset iamthif parameters. */
50 dev
->iamthif_current_cb
= NULL
;
51 dev
->iamthif_canceled
= false;
52 dev
->iamthif_state
= MEI_IAMTHIF_IDLE
;
53 dev
->iamthif_stall_timer
= 0;
54 dev
->iamthif_open_count
= 0;
58 * mei_amthif_host_init - mei initialization amthif client.
60 * @dev: the device structure
63 * Return: 0 on success, <0 on failure.
65 int mei_amthif_host_init(struct mei_device
*dev
, struct mei_me_client
*me_cl
)
67 struct mei_cl
*cl
= &dev
->iamthif_cl
;
70 if (mei_cl_is_connected(cl
))
73 dev
->iamthif_state
= MEI_IAMTHIF_IDLE
;
77 ret
= mei_cl_link(cl
);
79 dev_err(dev
->dev
, "amthif: failed cl_link %d\n", ret
);
83 ret
= mei_cl_connect(cl
, me_cl
, NULL
);
89 * mei_amthif_read - read data from AMTHIF client
91 * @dev: the device structure
92 * @file: pointer to file object
93 * @ubuf: pointer to user data in user space
94 * @length: data length to read
95 * @offset: data read offset
97 * Locking: called under "dev->device_lock" lock
100 * returned data length on success,
101 * zero if no data to read,
102 * negative on failure.
104 int mei_amthif_read(struct mei_device
*dev
, struct file
*file
,
105 char __user
*ubuf
, size_t length
, loff_t
*offset
)
107 struct mei_cl
*cl
= file
->private_data
;
108 struct mei_cl_cb
*cb
;
112 dev_dbg(dev
->dev
, "checking amthif data\n");
113 cb
= mei_cl_read_cb(cl
, file
);
115 /* Check for if we can block or not*/
116 if (cb
== NULL
&& file
->f_flags
& O_NONBLOCK
)
120 dev_dbg(dev
->dev
, "waiting for amthif data\n");
122 /* unlock the Mutex */
123 mutex_unlock(&dev
->device_lock
);
125 wait_ret
= wait_event_interruptible(cl
->rx_wait
,
126 !list_empty(&cl
->rd_completed
) ||
127 !mei_cl_is_connected(cl
));
129 /* Locking again the Mutex */
130 mutex_lock(&dev
->device_lock
);
135 if (!mei_cl_is_connected(cl
)) {
140 cb
= mei_cl_read_cb(cl
, file
);
145 dev_dbg(dev
->dev
, "read operation failed %d\n", rets
);
149 dev_dbg(dev
->dev
, "Got amthif data\n");
150 /* if the whole message will fit remove it from the list */
151 if (cb
->buf_idx
>= *offset
&& length
>= (cb
->buf_idx
- *offset
))
152 list_del_init(&cb
->list
);
153 else if (cb
->buf_idx
<= *offset
) {
154 /* end of the message has been reached */
155 list_del_init(&cb
->list
);
159 /* else means that not full buffer will be read and do not
160 * remove message from deletion list
163 dev_dbg(dev
->dev
, "amthif cb->buf.size - %zu cb->buf_idx - %zu\n",
164 cb
->buf
.size
, cb
->buf_idx
);
166 /* length is being truncated to PAGE_SIZE, however,
167 * the buf_idx may point beyond */
168 length
= min_t(size_t, length
, (cb
->buf_idx
- *offset
));
170 if (copy_to_user(ubuf
, cb
->buf
.data
+ *offset
, length
)) {
171 dev_dbg(dev
->dev
, "failed to copy data to userland\n");
175 if ((*offset
+ length
) < cb
->buf_idx
) {
181 dev_dbg(dev
->dev
, "free amthif cb memory.\n");
189 * mei_amthif_read_start - queue message for sending read credential
192 * @file: file pointer of message recipient
194 * Return: 0 on success, <0 on failure.
196 static int mei_amthif_read_start(struct mei_cl
*cl
, const struct file
*file
)
198 struct mei_device
*dev
= cl
->dev
;
199 struct mei_cl_cb
*cb
;
202 cb
= mei_io_cb_init(cl
, MEI_FOP_READ
, file
);
208 rets
= mei_io_cb_alloc_buf(cb
, mei_cl_mtu(cl
));
212 list_add_tail(&cb
->list
, &dev
->ctrl_wr_list
.list
);
214 dev
->iamthif_state
= MEI_IAMTHIF_READING
;
215 dev
->iamthif_fp
= cb
->fp
;
216 dev
->iamthif_current_cb
= cb
;
225 * mei_amthif_send_cmd - send amthif command to the ME
227 * @cl: the host client
228 * @cb: mei call back struct
230 * Return: 0 on success, <0 on failure.
232 static int mei_amthif_send_cmd(struct mei_cl
*cl
, struct mei_cl_cb
*cb
)
234 struct mei_device
*dev
;
242 dev
->iamthif_state
= MEI_IAMTHIF_WRITING
;
243 dev
->iamthif_current_cb
= cb
;
244 dev
->iamthif_fp
= cb
->fp
;
245 dev
->iamthif_canceled
= false;
247 ret
= mei_cl_write(cl
, cb
, false);
252 cb
->status
= mei_amthif_read_start(cl
, cb
->fp
);
258 * mei_amthif_run_next_cmd - send next amt command from queue
260 * @dev: the device structure
262 * Return: 0 on success, <0 on failure.
264 int mei_amthif_run_next_cmd(struct mei_device
*dev
)
266 struct mei_cl
*cl
= &dev
->iamthif_cl
;
267 struct mei_cl_cb
*cb
;
269 dev
->iamthif_canceled
= false;
270 dev
->iamthif_state
= MEI_IAMTHIF_IDLE
;
271 dev
->iamthif_fp
= NULL
;
273 dev_dbg(dev
->dev
, "complete amthif cmd_list cb.\n");
275 cb
= list_first_entry_or_null(&dev
->amthif_cmd_list
.list
,
280 list_del_init(&cb
->list
);
281 return mei_amthif_send_cmd(cl
, cb
);
285 * mei_amthif_write - write amthif data to amthif client
288 * @cb: mei call back struct
290 * Return: 0 on success, <0 on failure.
292 int mei_amthif_write(struct mei_cl
*cl
, struct mei_cl_cb
*cb
)
295 struct mei_device
*dev
= cl
->dev
;
297 list_add_tail(&cb
->list
, &dev
->amthif_cmd_list
.list
);
300 * The previous request is still in processing, queue this one.
302 if (dev
->iamthif_state
!= MEI_IAMTHIF_IDLE
)
305 return mei_amthif_run_next_cmd(dev
);
309 * mei_amthif_poll - the amthif poll function
311 * @file: pointer to file structure
312 * @wait: pointer to poll_table structure
316 * Locking: called under "dev->device_lock" lock
318 unsigned int mei_amthif_poll(struct file
*file
, poll_table
*wait
)
320 struct mei_cl
*cl
= file
->private_data
;
321 struct mei_cl_cb
*cb
= mei_cl_read_cb(cl
, file
);
322 unsigned int mask
= 0;
324 poll_wait(file
, &cl
->rx_wait
, wait
);
326 mask
|= POLLIN
| POLLRDNORM
;
332 * mei_amthif_irq_write - write iamthif command in irq thread context.
334 * @cl: private data of the file object.
335 * @cb: callback block.
336 * @cmpl_list: complete list.
338 * Return: 0, OK; otherwise, error.
340 int mei_amthif_irq_write(struct mei_cl
*cl
, struct mei_cl_cb
*cb
,
341 struct mei_cl_cb
*cmpl_list
)
345 ret
= mei_cl_irq_write(cl
, cb
, cmpl_list
);
350 cb
->status
= mei_amthif_read_start(cl
, cb
->fp
);
356 * mei_amthif_irq_read_msg - read routine after ISR to
357 * handle the read amthif message
360 * @mei_hdr: header of amthif message
361 * @cmpl_list: completed callbacks list
363 * Return: -ENODEV if cb is NULL 0 otherwise; error message is in cb->status
365 int mei_amthif_irq_read_msg(struct mei_cl
*cl
,
366 struct mei_msg_hdr
*mei_hdr
,
367 struct mei_cl_cb
*cmpl_list
)
369 struct mei_device
*dev
;
374 if (dev
->iamthif_state
!= MEI_IAMTHIF_READING
) {
375 mei_irq_discard_msg(dev
, mei_hdr
);
379 ret
= mei_cl_irq_read_msg(cl
, mei_hdr
, cmpl_list
);
383 if (!mei_hdr
->msg_complete
)
386 dev_dbg(dev
->dev
, "completed amthif read.\n ");
387 dev
->iamthif_stall_timer
= 0;
393 * mei_amthif_complete - complete amthif callback.
396 * @cb: callback block.
398 void mei_amthif_complete(struct mei_cl
*cl
, struct mei_cl_cb
*cb
)
400 struct mei_device
*dev
= cl
->dev
;
402 if (cb
->fop_type
== MEI_FOP_WRITE
) {
404 dev
->iamthif_stall_timer
= MEI_IAMTHIF_STALL_TIMER
;
409 * in case of error enqueue the write cb to complete read list
410 * so it can be propagated to the reader
412 list_add_tail(&cb
->list
, &cl
->rd_completed
);
413 wake_up_interruptible(&cl
->rx_wait
);
417 if (!dev
->iamthif_canceled
) {
418 list_add_tail(&cb
->list
, &cl
->rd_completed
);
419 dev_dbg(dev
->dev
, "amthif read completed\n");
424 dev
->iamthif_current_cb
= NULL
;
425 dev
->iamthif_stall_timer
= 0;
426 mei_amthif_run_next_cmd(dev
);
428 dev_dbg(dev
->dev
, "completing amthif call back.\n");
429 wake_up_interruptible(&cl
->rx_wait
);
433 * mei_clear_list - removes all callbacks associated with file
436 * @dev: device structure.
437 * @file: file structure
438 * @mei_cb_list: callbacks list
440 * mei_clear_list is called to clear resources associated with file
441 * when application calls close function or Ctrl-C was pressed
443 * Return: true if callback removed from the list, false otherwise
445 static bool mei_clear_list(struct mei_device
*dev
,
446 const struct file
*file
, struct list_head
*mei_cb_list
)
448 struct mei_cl
*cl
= &dev
->iamthif_cl
;
449 struct mei_cl_cb
*cb
, *next
;
450 bool removed
= false;
452 /* list all list member */
453 list_for_each_entry_safe(cb
, next
, mei_cb_list
, list
) {
454 /* check if list member associated with a file */
455 if (file
== cb
->fp
) {
456 /* check if cb equal to current iamthif cb */
457 if (dev
->iamthif_current_cb
== cb
) {
458 dev
->iamthif_current_cb
= NULL
;
459 /* send flow control to iamthif client */
460 mei_hbm_cl_flow_control_req(dev
, cl
);
462 /* free all allocated buffers */
471 * mei_clear_lists - removes all callbacks associated with file
473 * @dev: device structure
474 * @file: file structure
476 * mei_clear_lists is called to clear resources associated with file
477 * when application calls close function or Ctrl-C was pressed
479 * Return: true if callback removed from the list, false otherwise
481 static bool mei_clear_lists(struct mei_device
*dev
, const struct file
*file
)
483 bool removed
= false;
484 struct mei_cl
*cl
= &dev
->iamthif_cl
;
486 /* remove callbacks associated with a file */
487 mei_clear_list(dev
, file
, &dev
->amthif_cmd_list
.list
);
488 if (mei_clear_list(dev
, file
, &cl
->rd_completed
))
491 mei_clear_list(dev
, file
, &dev
->ctrl_rd_list
.list
);
493 if (mei_clear_list(dev
, file
, &dev
->ctrl_wr_list
.list
))
496 if (mei_clear_list(dev
, file
, &dev
->write_waiting_list
.list
))
499 if (mei_clear_list(dev
, file
, &dev
->write_list
.list
))
502 /* check if iamthif_current_cb not NULL */
503 if (dev
->iamthif_current_cb
&& !removed
) {
504 /* check file and iamthif current cb association */
505 if (dev
->iamthif_current_cb
->fp
== file
) {
507 mei_io_cb_free(dev
->iamthif_current_cb
);
508 dev
->iamthif_current_cb
= NULL
;
516 * mei_amthif_release - the release function
518 * @dev: device structure
519 * @file: pointer to file structure
521 * Return: 0 on success, <0 on error
523 int mei_amthif_release(struct mei_device
*dev
, struct file
*file
)
525 if (dev
->iamthif_open_count
> 0)
526 dev
->iamthif_open_count
--;
528 if (dev
->iamthif_fp
== file
&&
529 dev
->iamthif_state
!= MEI_IAMTHIF_IDLE
) {
531 dev_dbg(dev
->dev
, "amthif canceled iamthif state %d\n",
533 dev
->iamthif_canceled
= true;
536 if (mei_clear_lists(dev
, file
))
537 dev
->iamthif_state
= MEI_IAMTHIF_IDLE
;