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/aio.h>
23 #include <linux/pci.h>
24 #include <linux/init.h>
25 #include <linux/ioctl.h>
26 #include <linux/cdev.h>
27 #include <linux/list.h>
28 #include <linux/delay.h>
29 #include <linux/sched.h>
30 #include <linux/uuid.h>
31 #include <linux/jiffies.h>
32 #include <linux/uaccess.h>
34 #include <linux/mei.h>
41 const uuid_le mei_amthif_guid
= UUID_LE(0x12f80028, 0xb4b7, 0x4b2d,
42 0xac, 0xa8, 0x46, 0xe0,
43 0xff, 0x65, 0x81, 0x4c);
46 * mei_amthif_reset_params - initializes mei device iamthif
48 * @dev: the device structure
50 void mei_amthif_reset_params(struct mei_device
*dev
)
52 /* reset iamthif parameters. */
53 dev
->iamthif_current_cb
= NULL
;
54 dev
->iamthif_msg_buf_size
= 0;
55 dev
->iamthif_msg_buf_index
= 0;
56 dev
->iamthif_canceled
= false;
57 dev
->iamthif_ioctl
= false;
58 dev
->iamthif_state
= MEI_IAMTHIF_IDLE
;
59 dev
->iamthif_timer
= 0;
60 dev
->iamthif_stall_timer
= 0;
61 dev
->iamthif_open_count
= 0;
65 * mei_amthif_host_init - mei initialization amthif client.
67 * @dev: the device structure
70 int mei_amthif_host_init(struct mei_device
*dev
)
72 struct mei_cl
*cl
= &dev
->iamthif_cl
;
73 unsigned char *msg_buf
;
76 dev
->iamthif_state
= MEI_IAMTHIF_IDLE
;
80 i
= mei_me_cl_by_uuid(dev
, &mei_amthif_guid
);
83 dev_info(&dev
->pdev
->dev
,
84 "amthif: failed to find the client %d\n", ret
);
88 cl
->me_client_id
= dev
->me_clients
[i
].client_id
;
90 /* Assign iamthif_mtu to the value received from ME */
92 dev
->iamthif_mtu
= dev
->me_clients
[i
].props
.max_msg_length
;
93 dev_dbg(&dev
->pdev
->dev
, "IAMTHIF_MTU = %d\n",
94 dev
->me_clients
[i
].props
.max_msg_length
);
96 kfree(dev
->iamthif_msg_buf
);
97 dev
->iamthif_msg_buf
= NULL
;
99 /* allocate storage for ME message buffer */
100 msg_buf
= kcalloc(dev
->iamthif_mtu
,
101 sizeof(unsigned char), GFP_KERNEL
);
103 dev_err(&dev
->pdev
->dev
, "amthif: memory allocation for ME message buffer failed.\n");
107 dev
->iamthif_msg_buf
= msg_buf
;
109 ret
= mei_cl_link(cl
, MEI_IAMTHIF_HOST_CLIENT_ID
);
112 dev_err(&dev
->pdev
->dev
,
113 "amthif: failed link client %d\n", ret
);
117 cl
->state
= MEI_FILE_CONNECTING
;
119 if (mei_hbm_cl_connect_req(dev
, cl
)) {
120 dev_dbg(&dev
->pdev
->dev
, "amthif: Failed to connect to ME client\n");
121 cl
->state
= MEI_FILE_DISCONNECTED
;
122 cl
->host_client_id
= 0;
124 cl
->timer_count
= MEI_CONNECT_TIMEOUT
;
130 * mei_amthif_find_read_list_entry - finds a amthilist entry for current file
132 * @dev: the device structure
133 * @file: pointer to file object
135 * returns returned a list entry on success, NULL on failure.
137 struct mei_cl_cb
*mei_amthif_find_read_list_entry(struct mei_device
*dev
,
140 struct mei_cl_cb
*pos
= NULL
;
141 struct mei_cl_cb
*next
= NULL
;
143 list_for_each_entry_safe(pos
, next
,
144 &dev
->amthif_rd_complete_list
.list
, list
) {
145 if (pos
->cl
&& pos
->cl
== &dev
->iamthif_cl
&&
146 pos
->file_object
== file
)
154 * mei_amthif_read - read data from AMTHIF client
156 * @dev: the device structure
157 * @if_num: minor number
158 * @file: pointer to file object
159 * @*ubuf: pointer to user data in user space
160 * @length: data length to read
161 * @offset: data read offset
163 * Locking: called under "dev->device_lock" lock
166 * returned data length on success,
167 * zero if no data to read,
168 * negative on failure.
170 int mei_amthif_read(struct mei_device
*dev
, struct file
*file
,
171 char __user
*ubuf
, size_t length
, loff_t
*offset
)
175 struct mei_cl_cb
*cb
= NULL
;
176 struct mei_cl
*cl
= file
->private_data
;
177 unsigned long timeout
;
180 /* Only possible if we are in timeout */
181 if (!cl
|| cl
!= &dev
->iamthif_cl
) {
182 dev_dbg(&dev
->pdev
->dev
, "bad file ext.\n");
186 i
= mei_me_cl_by_id(dev
, dev
->iamthif_cl
.me_client_id
);
189 dev_dbg(&dev
->pdev
->dev
, "amthif client not found.\n");
192 dev_dbg(&dev
->pdev
->dev
, "checking amthif data\n");
193 cb
= mei_amthif_find_read_list_entry(dev
, file
);
195 /* Check for if we can block or not*/
196 if (cb
== NULL
&& file
->f_flags
& O_NONBLOCK
)
200 dev_dbg(&dev
->pdev
->dev
, "waiting for amthif data\n");
202 /* unlock the Mutex */
203 mutex_unlock(&dev
->device_lock
);
205 wait_ret
= wait_event_interruptible(dev
->iamthif_cl
.wait
,
206 (cb
= mei_amthif_find_read_list_entry(dev
, file
)));
208 /* Locking again the Mutex */
209 mutex_lock(&dev
->device_lock
);
214 dev_dbg(&dev
->pdev
->dev
, "woke up from sleep\n");
218 dev_dbg(&dev
->pdev
->dev
, "Got amthif data\n");
219 dev
->iamthif_timer
= 0;
222 timeout
= cb
->read_time
+
223 mei_secs_to_jiffies(MEI_IAMTHIF_READ_TIMER
);
224 dev_dbg(&dev
->pdev
->dev
, "amthif timeout = %lud\n",
227 if (time_after(jiffies
, timeout
)) {
228 dev_dbg(&dev
->pdev
->dev
, "amthif Time out\n");
229 /* 15 sec for the message has expired */
235 /* if the whole message will fit remove it from the list */
236 if (cb
->buf_idx
>= *offset
&& length
>= (cb
->buf_idx
- *offset
))
238 else if (cb
->buf_idx
> 0 && cb
->buf_idx
<= *offset
) {
239 /* end of the message has been reached */
244 /* else means that not full buffer will be read and do not
245 * remove message from deletion list
248 dev_dbg(&dev
->pdev
->dev
, "amthif cb->response_buffer size - %d\n",
249 cb
->response_buffer
.size
);
250 dev_dbg(&dev
->pdev
->dev
, "amthif cb->buf_idx - %lu\n", cb
->buf_idx
);
252 /* length is being truncated to PAGE_SIZE, however,
253 * the buf_idx may point beyond */
254 length
= min_t(size_t, length
, (cb
->buf_idx
- *offset
));
256 if (copy_to_user(ubuf
, cb
->response_buffer
.data
+ *offset
, length
))
260 if ((*offset
+ length
) < cb
->buf_idx
) {
266 dev_dbg(&dev
->pdev
->dev
, "free amthif cb memory.\n");
274 * mei_amthif_send_cmd - send amthif command to the ME
276 * @dev: the device structure
277 * @cb: mei call back struct
279 * returns 0 on success, <0 on failure.
282 static int mei_amthif_send_cmd(struct mei_device
*dev
, struct mei_cl_cb
*cb
)
284 struct mei_msg_hdr mei_hdr
;
290 dev_dbg(&dev
->pdev
->dev
, "write data to amthif client.\n");
292 dev
->iamthif_state
= MEI_IAMTHIF_WRITING
;
293 dev
->iamthif_current_cb
= cb
;
294 dev
->iamthif_file_object
= cb
->file_object
;
295 dev
->iamthif_canceled
= false;
296 dev
->iamthif_ioctl
= true;
297 dev
->iamthif_msg_buf_size
= cb
->request_buffer
.size
;
298 memcpy(dev
->iamthif_msg_buf
, cb
->request_buffer
.data
,
299 cb
->request_buffer
.size
);
301 ret
= mei_cl_flow_ctrl_creds(&dev
->iamthif_cl
);
305 if (ret
&& dev
->hbuf_is_ready
) {
307 dev
->hbuf_is_ready
= false;
308 if (cb
->request_buffer
.size
> mei_hbuf_max_len(dev
)) {
309 mei_hdr
.length
= mei_hbuf_max_len(dev
);
310 mei_hdr
.msg_complete
= 0;
312 mei_hdr
.length
= cb
->request_buffer
.size
;
313 mei_hdr
.msg_complete
= 1;
316 mei_hdr
.host_addr
= dev
->iamthif_cl
.host_client_id
;
317 mei_hdr
.me_addr
= dev
->iamthif_cl
.me_client_id
;
318 mei_hdr
.reserved
= 0;
319 mei_hdr
.internal
= 0;
320 dev
->iamthif_msg_buf_index
+= mei_hdr
.length
;
321 ret
= mei_write_message(dev
, &mei_hdr
, dev
->iamthif_msg_buf
);
325 if (mei_hdr
.msg_complete
) {
326 if (mei_cl_flow_ctrl_reduce(&dev
->iamthif_cl
))
328 dev
->iamthif_flow_control_pending
= true;
329 dev
->iamthif_state
= MEI_IAMTHIF_FLOW_CONTROL
;
330 dev_dbg(&dev
->pdev
->dev
, "add amthif cb to write waiting list\n");
331 dev
->iamthif_current_cb
= cb
;
332 dev
->iamthif_file_object
= cb
->file_object
;
333 list_add_tail(&cb
->list
, &dev
->write_waiting_list
.list
);
335 dev_dbg(&dev
->pdev
->dev
, "message does not complete, so add amthif cb to write list.\n");
336 list_add_tail(&cb
->list
, &dev
->write_list
.list
);
339 if (!dev
->hbuf_is_ready
)
340 dev_dbg(&dev
->pdev
->dev
, "host buffer is not empty");
342 dev_dbg(&dev
->pdev
->dev
, "No flow control credentials, so add iamthif cb to write list.\n");
343 list_add_tail(&cb
->list
, &dev
->write_list
.list
);
349 * mei_amthif_write - write amthif data to amthif client
351 * @dev: the device structure
352 * @cb: mei call back struct
354 * returns 0 on success, <0 on failure.
357 int mei_amthif_write(struct mei_device
*dev
, struct mei_cl_cb
*cb
)
364 ret
= mei_io_cb_alloc_resp_buf(cb
, dev
->iamthif_mtu
);
368 cb
->fop_type
= MEI_FOP_IOCTL
;
370 if (!list_empty(&dev
->amthif_cmd_list
.list
) ||
371 dev
->iamthif_state
!= MEI_IAMTHIF_IDLE
) {
372 dev_dbg(&dev
->pdev
->dev
,
373 "amthif state = %d\n", dev
->iamthif_state
);
374 dev_dbg(&dev
->pdev
->dev
, "AMTHIF: add cb to the wait list\n");
375 list_add_tail(&cb
->list
, &dev
->amthif_cmd_list
.list
);
378 return mei_amthif_send_cmd(dev
, cb
);
381 * mei_amthif_run_next_cmd
383 * @dev: the device structure
385 * returns 0 on success, <0 on failure.
387 void mei_amthif_run_next_cmd(struct mei_device
*dev
)
389 struct mei_cl_cb
*pos
= NULL
;
390 struct mei_cl_cb
*next
= NULL
;
396 dev
->iamthif_msg_buf_size
= 0;
397 dev
->iamthif_msg_buf_index
= 0;
398 dev
->iamthif_canceled
= false;
399 dev
->iamthif_ioctl
= true;
400 dev
->iamthif_state
= MEI_IAMTHIF_IDLE
;
401 dev
->iamthif_timer
= 0;
402 dev
->iamthif_file_object
= NULL
;
404 dev_dbg(&dev
->pdev
->dev
, "complete amthif cmd_list cb.\n");
406 list_for_each_entry_safe(pos
, next
, &dev
->amthif_cmd_list
.list
, list
) {
407 list_del(&pos
->list
);
409 if (pos
->cl
&& pos
->cl
== &dev
->iamthif_cl
) {
410 status
= mei_amthif_send_cmd(dev
, pos
);
412 dev_dbg(&dev
->pdev
->dev
,
413 "amthif write failed status = %d\n",
423 unsigned int mei_amthif_poll(struct mei_device
*dev
,
424 struct file
*file
, poll_table
*wait
)
426 unsigned int mask
= 0;
428 poll_wait(file
, &dev
->iamthif_cl
.wait
, wait
);
430 mutex_lock(&dev
->device_lock
);
431 if (!mei_cl_is_connected(&dev
->iamthif_cl
)) {
435 } else if (dev
->iamthif_state
== MEI_IAMTHIF_READ_COMPLETE
&&
436 dev
->iamthif_file_object
== file
) {
438 mask
|= (POLLIN
| POLLRDNORM
);
439 dev_dbg(&dev
->pdev
->dev
, "run next amthif cb\n");
440 mei_amthif_run_next_cmd(dev
);
442 mutex_unlock(&dev
->device_lock
);
450 * mei_amthif_irq_write_completed - processes completed iamthif operation.
452 * @dev: the device structure.
453 * @slots: free slots.
454 * @cb_pos: callback block.
455 * @cl: private data of the file object.
456 * @cmpl_list: complete list.
458 * returns 0, OK; otherwise, error.
460 int mei_amthif_irq_write_complete(struct mei_cl
*cl
, struct mei_cl_cb
*cb
,
461 s32
*slots
, struct mei_cl_cb
*cmpl_list
)
463 struct mei_device
*dev
= cl
->dev
;
464 struct mei_msg_hdr mei_hdr
;
465 size_t len
= dev
->iamthif_msg_buf_size
- dev
->iamthif_msg_buf_index
;
466 u32 msg_slots
= mei_data2slots(len
);
469 rets
= mei_cl_flow_ctrl_creds(cl
);
474 cl_dbg(dev
, cl
, "No flow control credentials: not sending.\n");
478 mei_hdr
.host_addr
= cl
->host_client_id
;
479 mei_hdr
.me_addr
= cl
->me_client_id
;
480 mei_hdr
.reserved
= 0;
481 mei_hdr
.internal
= 0;
483 if (*slots
>= msg_slots
) {
484 mei_hdr
.length
= len
;
485 mei_hdr
.msg_complete
= 1;
486 /* Split the message only if we can write the whole host buffer */
487 } else if (*slots
== dev
->hbuf_depth
) {
489 len
= (*slots
* sizeof(u32
)) - sizeof(struct mei_msg_hdr
);
490 mei_hdr
.length
= len
;
491 mei_hdr
.msg_complete
= 0;
493 /* wait for next time the host buffer is empty */
497 dev_dbg(&dev
->pdev
->dev
, MEI_HDR_FMT
, MEI_HDR_PRM(&mei_hdr
));
500 rets
= mei_write_message(dev
, &mei_hdr
,
501 dev
->iamthif_msg_buf
+ dev
->iamthif_msg_buf_index
);
503 dev
->iamthif_state
= MEI_IAMTHIF_IDLE
;
509 if (mei_cl_flow_ctrl_reduce(cl
))
512 dev
->iamthif_msg_buf_index
+= mei_hdr
.length
;
515 if (mei_hdr
.msg_complete
) {
516 dev
->iamthif_state
= MEI_IAMTHIF_FLOW_CONTROL
;
517 dev
->iamthif_flow_control_pending
= true;
519 /* save iamthif cb sent to amthif client */
520 cb
->buf_idx
= dev
->iamthif_msg_buf_index
;
521 dev
->iamthif_current_cb
= cb
;
523 list_move_tail(&cb
->list
, &dev
->write_waiting_list
.list
);
531 * mei_amthif_irq_read_message - read routine after ISR to
532 * handle the read amthif message
534 * @dev: the device structure
535 * @mei_hdr: header of amthif message
536 * @complete_list: An instance of our list structure
538 * returns 0 on success, <0 on failure.
540 int mei_amthif_irq_read_msg(struct mei_device
*dev
,
541 struct mei_msg_hdr
*mei_hdr
,
542 struct mei_cl_cb
*complete_list
)
544 struct mei_cl_cb
*cb
;
545 unsigned char *buffer
;
547 BUG_ON(mei_hdr
->me_addr
!= dev
->iamthif_cl
.me_client_id
);
548 BUG_ON(dev
->iamthif_state
!= MEI_IAMTHIF_READING
);
550 buffer
= dev
->iamthif_msg_buf
+ dev
->iamthif_msg_buf_index
;
551 BUG_ON(dev
->iamthif_mtu
< dev
->iamthif_msg_buf_index
+ mei_hdr
->length
);
553 mei_read_slots(dev
, buffer
, mei_hdr
->length
);
555 dev
->iamthif_msg_buf_index
+= mei_hdr
->length
;
557 if (!mei_hdr
->msg_complete
)
560 dev_dbg(&dev
->pdev
->dev
, "amthif_message_buffer_index =%d\n",
563 dev_dbg(&dev
->pdev
->dev
, "completed amthif read.\n ");
564 if (!dev
->iamthif_current_cb
)
567 cb
= dev
->iamthif_current_cb
;
568 dev
->iamthif_current_cb
= NULL
;
573 dev
->iamthif_stall_timer
= 0;
574 cb
->buf_idx
= dev
->iamthif_msg_buf_index
;
575 cb
->read_time
= jiffies
;
576 if (dev
->iamthif_ioctl
&& cb
->cl
== &dev
->iamthif_cl
) {
577 /* found the iamthif cb */
578 dev_dbg(&dev
->pdev
->dev
, "complete the amthif read cb.\n ");
579 dev_dbg(&dev
->pdev
->dev
, "add the amthif read cb to complete.\n ");
580 list_add_tail(&cb
->list
, &complete_list
->list
);
586 * mei_amthif_irq_read - prepares to read amthif data.
588 * @dev: the device structure.
589 * @slots: free slots.
591 * returns 0, OK; otherwise, error.
593 int mei_amthif_irq_read(struct mei_device
*dev
, s32
*slots
)
595 u32 msg_slots
= mei_data2slots(sizeof(struct hbm_flow_control
));
597 if (*slots
< msg_slots
)
602 if (mei_hbm_cl_flow_control_req(dev
, &dev
->iamthif_cl
)) {
603 dev_dbg(&dev
->pdev
->dev
, "iamthif flow control failed\n");
607 dev_dbg(&dev
->pdev
->dev
, "iamthif flow control success\n");
608 dev
->iamthif_state
= MEI_IAMTHIF_READING
;
609 dev
->iamthif_flow_control_pending
= false;
610 dev
->iamthif_msg_buf_index
= 0;
611 dev
->iamthif_msg_buf_size
= 0;
612 dev
->iamthif_stall_timer
= MEI_IAMTHIF_STALL_TIMER
;
613 dev
->hbuf_is_ready
= mei_hbuf_is_ready(dev
);
618 * mei_amthif_complete - complete amthif callback.
620 * @dev: the device structure.
621 * @cb_pos: callback block.
623 void mei_amthif_complete(struct mei_device
*dev
, struct mei_cl_cb
*cb
)
625 if (dev
->iamthif_canceled
!= 1) {
626 dev
->iamthif_state
= MEI_IAMTHIF_READ_COMPLETE
;
627 dev
->iamthif_stall_timer
= 0;
628 memcpy(cb
->response_buffer
.data
,
629 dev
->iamthif_msg_buf
,
630 dev
->iamthif_msg_buf_index
);
631 list_add_tail(&cb
->list
, &dev
->amthif_rd_complete_list
.list
);
632 dev_dbg(&dev
->pdev
->dev
, "amthif read completed\n");
633 dev
->iamthif_timer
= jiffies
;
634 dev_dbg(&dev
->pdev
->dev
, "dev->iamthif_timer = %ld\n",
637 mei_amthif_run_next_cmd(dev
);
640 dev_dbg(&dev
->pdev
->dev
, "completing amthif call back.\n");
641 wake_up_interruptible(&dev
->iamthif_cl
.wait
);
645 * mei_clear_list - removes all callbacks associated with file
648 * @dev: device structure.
649 * @file: file structure
650 * @mei_cb_list: callbacks list
652 * mei_clear_list is called to clear resources associated with file
653 * when application calls close function or Ctrl-C was pressed
655 * returns true if callback removed from the list, false otherwise
657 static bool mei_clear_list(struct mei_device
*dev
,
658 const struct file
*file
, struct list_head
*mei_cb_list
)
660 struct mei_cl_cb
*cb_pos
= NULL
;
661 struct mei_cl_cb
*cb_next
= NULL
;
662 bool removed
= false;
664 /* list all list member */
665 list_for_each_entry_safe(cb_pos
, cb_next
, mei_cb_list
, list
) {
666 /* check if list member associated with a file */
667 if (file
== cb_pos
->file_object
) {
668 /* remove member from the list */
669 list_del(&cb_pos
->list
);
670 /* check if cb equal to current iamthif cb */
671 if (dev
->iamthif_current_cb
== cb_pos
) {
672 dev
->iamthif_current_cb
= NULL
;
673 /* send flow control to iamthif client */
674 mei_hbm_cl_flow_control_req(dev
,
677 /* free all allocated buffers */
678 mei_io_cb_free(cb_pos
);
687 * mei_clear_lists - removes all callbacks associated with file
689 * @dev: device structure
690 * @file: file structure
692 * mei_clear_lists is called to clear resources associated with file
693 * when application calls close function or Ctrl-C was pressed
695 * returns true if callback removed from the list, false otherwise
697 static bool mei_clear_lists(struct mei_device
*dev
, struct file
*file
)
699 bool removed
= false;
701 /* remove callbacks associated with a file */
702 mei_clear_list(dev
, file
, &dev
->amthif_cmd_list
.list
);
703 if (mei_clear_list(dev
, file
, &dev
->amthif_rd_complete_list
.list
))
706 mei_clear_list(dev
, file
, &dev
->ctrl_rd_list
.list
);
708 if (mei_clear_list(dev
, file
, &dev
->ctrl_wr_list
.list
))
711 if (mei_clear_list(dev
, file
, &dev
->write_waiting_list
.list
))
714 if (mei_clear_list(dev
, file
, &dev
->write_list
.list
))
717 /* check if iamthif_current_cb not NULL */
718 if (dev
->iamthif_current_cb
&& !removed
) {
719 /* check file and iamthif current cb association */
720 if (dev
->iamthif_current_cb
->file_object
== file
) {
722 mei_io_cb_free(dev
->iamthif_current_cb
);
723 dev
->iamthif_current_cb
= NULL
;
731 * mei_amthif_release - the release function
733 * @dev: device structure
734 * @file: pointer to file structure
736 * returns 0 on success, <0 on error
738 int mei_amthif_release(struct mei_device
*dev
, struct file
*file
)
740 if (dev
->iamthif_open_count
> 0)
741 dev
->iamthif_open_count
--;
743 if (dev
->iamthif_file_object
== file
&&
744 dev
->iamthif_state
!= MEI_IAMTHIF_IDLE
) {
746 dev_dbg(&dev
->pdev
->dev
, "amthif canceled iamthif state %d\n",
748 dev
->iamthif_canceled
= true;
749 if (dev
->iamthif_state
== MEI_IAMTHIF_READ_COMPLETE
) {
750 dev_dbg(&dev
->pdev
->dev
, "run next amthif iamthif cb\n");
751 mei_amthif_run_next_cmd(dev
);
755 if (mei_clear_lists(dev
, file
))
756 dev
->iamthif_state
= MEI_IAMTHIF_IDLE
;