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/pci.h>
18 #include <linux/sched.h>
19 #include <linux/wait.h>
20 #include <linux/delay.h>
21 #include <linux/pm_runtime.h>
23 #include <linux/mei.h>
30 * mei_me_cl_by_uuid - locate index of me client
34 * Locking: called under "dev->device_lock" lock
36 * returns me client or NULL if not found
38 struct mei_me_client
*mei_me_cl_by_uuid(const struct mei_device
*dev
,
41 struct mei_me_client
*me_cl
;
43 list_for_each_entry(me_cl
, &dev
->me_clients
, list
)
44 if (uuid_le_cmp(*uuid
, me_cl
->props
.protocol_name
) == 0)
52 * mei_me_cl_by_id return index to me_clients for client_id
54 * @dev: the device structure
55 * @client_id: me client id
57 * Locking: called under "dev->device_lock" lock
59 * returns me client or NULL if not found
62 struct mei_me_client
*mei_me_cl_by_id(struct mei_device
*dev
, u8 client_id
)
65 struct mei_me_client
*me_cl
;
67 list_for_each_entry(me_cl
, &dev
->me_clients
, list
)
68 if (me_cl
->client_id
== client_id
)
75 * mei_cl_cmp_id - tells if the clients are the same
80 * returns true - if the clients has same host and me ids
83 static inline bool mei_cl_cmp_id(const struct mei_cl
*cl1
,
84 const struct mei_cl
*cl2
)
87 (cl1
->host_client_id
== cl2
->host_client_id
) &&
88 (cl1
->me_client_id
== cl2
->me_client_id
);
92 * mei_io_list_flush - removes cbs belonging to cl.
94 * @list: an instance of our list structure
95 * @cl: host client, can be NULL for flushing the whole list
96 * @free: whether to free the cbs
98 static void __mei_io_list_flush(struct mei_cl_cb
*list
,
99 struct mei_cl
*cl
, bool free
)
101 struct mei_cl_cb
*cb
;
102 struct mei_cl_cb
*next
;
104 /* enable removing everything if no cl is specified */
105 list_for_each_entry_safe(cb
, next
, &list
->list
, list
) {
106 if (!cl
|| (cb
->cl
&& mei_cl_cmp_id(cl
, cb
->cl
))) {
115 * mei_io_list_flush - removes list entry belonging to cl.
117 * @list: An instance of our list structure
120 void mei_io_list_flush(struct mei_cl_cb
*list
, struct mei_cl
*cl
)
122 __mei_io_list_flush(list
, cl
, false);
127 * mei_io_list_free - removes cb belonging to cl and free them
129 * @list: An instance of our list structure
132 static inline void mei_io_list_free(struct mei_cl_cb
*list
, struct mei_cl
*cl
)
134 __mei_io_list_flush(list
, cl
, true);
138 * mei_io_cb_free - free mei_cb_private related memory
140 * @cb: mei callback struct
142 void mei_io_cb_free(struct mei_cl_cb
*cb
)
147 kfree(cb
->request_buffer
.data
);
148 kfree(cb
->response_buffer
.data
);
153 * mei_io_cb_init - allocate and initialize io callback
156 * @fp: pointer to file structure
158 * returns mei_cl_cb pointer or NULL;
160 struct mei_cl_cb
*mei_io_cb_init(struct mei_cl
*cl
, struct file
*fp
)
162 struct mei_cl_cb
*cb
;
164 cb
= kzalloc(sizeof(struct mei_cl_cb
), GFP_KERNEL
);
168 mei_io_list_init(cb
);
170 cb
->file_object
= fp
;
177 * mei_io_cb_alloc_req_buf - allocate request buffer
179 * @cb: io callback structure
180 * @length: size of the buffer
182 * returns 0 on success
183 * -EINVAL if cb is NULL
184 * -ENOMEM if allocation failed
186 int mei_io_cb_alloc_req_buf(struct mei_cl_cb
*cb
, size_t length
)
194 cb
->request_buffer
.data
= kmalloc(length
, GFP_KERNEL
);
195 if (!cb
->request_buffer
.data
)
197 cb
->request_buffer
.size
= length
;
201 * mei_io_cb_alloc_resp_buf - allocate response buffer
203 * @cb: io callback structure
204 * @length: size of the buffer
206 * returns 0 on success
207 * -EINVAL if cb is NULL
208 * -ENOMEM if allocation failed
210 int mei_io_cb_alloc_resp_buf(struct mei_cl_cb
*cb
, size_t length
)
218 cb
->response_buffer
.data
= kmalloc(length
, GFP_KERNEL
);
219 if (!cb
->response_buffer
.data
)
221 cb
->response_buffer
.size
= length
;
228 * mei_cl_flush_queues - flushes queue lists belonging to cl.
232 int mei_cl_flush_queues(struct mei_cl
*cl
)
234 struct mei_device
*dev
;
236 if (WARN_ON(!cl
|| !cl
->dev
))
241 cl_dbg(dev
, cl
, "remove list entry belonging to cl\n");
242 mei_io_list_flush(&cl
->dev
->read_list
, cl
);
243 mei_io_list_free(&cl
->dev
->write_list
, cl
);
244 mei_io_list_free(&cl
->dev
->write_waiting_list
, cl
);
245 mei_io_list_flush(&cl
->dev
->ctrl_wr_list
, cl
);
246 mei_io_list_flush(&cl
->dev
->ctrl_rd_list
, cl
);
247 mei_io_list_flush(&cl
->dev
->amthif_cmd_list
, cl
);
248 mei_io_list_flush(&cl
->dev
->amthif_rd_complete_list
, cl
);
254 * mei_cl_init - initializes cl.
256 * @cl: host client to be initialized
259 void mei_cl_init(struct mei_cl
*cl
, struct mei_device
*dev
)
261 memset(cl
, 0, sizeof(struct mei_cl
));
262 init_waitqueue_head(&cl
->wait
);
263 init_waitqueue_head(&cl
->rx_wait
);
264 init_waitqueue_head(&cl
->tx_wait
);
265 INIT_LIST_HEAD(&cl
->link
);
266 INIT_LIST_HEAD(&cl
->device_link
);
267 cl
->reading_state
= MEI_IDLE
;
268 cl
->writing_state
= MEI_IDLE
;
273 * mei_cl_allocate - allocates cl structure and sets it up.
276 * returns The allocated file or NULL on failure
278 struct mei_cl
*mei_cl_allocate(struct mei_device
*dev
)
282 cl
= kmalloc(sizeof(struct mei_cl
), GFP_KERNEL
);
286 mei_cl_init(cl
, dev
);
292 * mei_cl_find_read_cb - find this cl's callback in the read list
296 * returns cb on success, NULL on error
298 struct mei_cl_cb
*mei_cl_find_read_cb(struct mei_cl
*cl
)
300 struct mei_device
*dev
= cl
->dev
;
301 struct mei_cl_cb
*cb
;
303 list_for_each_entry(cb
, &dev
->read_list
.list
, list
)
304 if (mei_cl_cmp_id(cl
, cb
->cl
))
309 /** mei_cl_link: allocate host id in the host map
312 * @id - fixed host id or -1 for generic one
314 * returns 0 on success
315 * -EINVAL on incorrect values
316 * -ENONET if client not found
318 int mei_cl_link(struct mei_cl
*cl
, int id
)
320 struct mei_device
*dev
;
321 long open_handle_count
;
323 if (WARN_ON(!cl
|| !cl
->dev
))
328 /* If Id is not assigned get one*/
329 if (id
== MEI_HOST_CLIENT_ID_ANY
)
330 id
= find_first_zero_bit(dev
->host_clients_map
,
333 if (id
>= MEI_CLIENTS_MAX
) {
334 dev_err(&dev
->pdev
->dev
, "id exceeded %d", MEI_CLIENTS_MAX
);
338 open_handle_count
= dev
->open_handle_count
+ dev
->iamthif_open_count
;
339 if (open_handle_count
>= MEI_MAX_OPEN_HANDLE_COUNT
) {
340 dev_err(&dev
->pdev
->dev
, "open_handle_count exceeded %d",
341 MEI_MAX_OPEN_HANDLE_COUNT
);
345 dev
->open_handle_count
++;
347 cl
->host_client_id
= id
;
348 list_add_tail(&cl
->link
, &dev
->file_list
);
350 set_bit(id
, dev
->host_clients_map
);
352 cl
->state
= MEI_FILE_INITIALIZING
;
354 cl_dbg(dev
, cl
, "link cl\n");
359 * mei_cl_unlink - remove me_cl from the list
363 int mei_cl_unlink(struct mei_cl
*cl
)
365 struct mei_device
*dev
;
367 /* don't shout on error exit path */
371 /* wd and amthif might not be initialized */
377 cl_dbg(dev
, cl
, "unlink client");
379 if (dev
->open_handle_count
> 0)
380 dev
->open_handle_count
--;
382 /* never clear the 0 bit */
383 if (cl
->host_client_id
)
384 clear_bit(cl
->host_client_id
, dev
->host_clients_map
);
386 list_del_init(&cl
->link
);
388 cl
->state
= MEI_FILE_INITIALIZING
;
394 void mei_host_client_init(struct work_struct
*work
)
396 struct mei_device
*dev
= container_of(work
,
397 struct mei_device
, init_work
);
398 struct mei_me_client
*me_cl
;
399 struct mei_client_properties
*props
;
401 mutex_lock(&dev
->device_lock
);
403 list_for_each_entry(me_cl
, &dev
->me_clients
, list
) {
404 props
= &me_cl
->props
;
406 if (!uuid_le_cmp(props
->protocol_name
, mei_amthif_guid
))
407 mei_amthif_host_init(dev
);
408 else if (!uuid_le_cmp(props
->protocol_name
, mei_wd_guid
))
409 mei_wd_host_init(dev
);
410 else if (!uuid_le_cmp(props
->protocol_name
, mei_nfc_guid
))
411 mei_nfc_host_init(dev
);
415 dev
->dev_state
= MEI_DEV_ENABLED
;
416 dev
->reset_count
= 0;
418 mutex_unlock(&dev
->device_lock
);
420 pm_runtime_mark_last_busy(&dev
->pdev
->dev
);
421 dev_dbg(&dev
->pdev
->dev
, "rpm: autosuspend\n");
422 pm_runtime_autosuspend(&dev
->pdev
->dev
);
426 * mei_hbuf_acquire: try to acquire host buffer
428 * @dev: the device structure
429 * returns true if host buffer was acquired
431 bool mei_hbuf_acquire(struct mei_device
*dev
)
433 if (mei_pg_state(dev
) == MEI_PG_ON
||
434 dev
->pg_event
== MEI_PG_EVENT_WAIT
) {
435 dev_dbg(&dev
->pdev
->dev
, "device is in pg\n");
439 if (!dev
->hbuf_is_ready
) {
440 dev_dbg(&dev
->pdev
->dev
, "hbuf is not ready\n");
444 dev
->hbuf_is_ready
= false;
450 * mei_cl_disconnect - disconnect host client from the me one
454 * Locking: called under "dev->device_lock" lock
456 * returns 0 on success, <0 on failure.
458 int mei_cl_disconnect(struct mei_cl
*cl
)
460 struct mei_device
*dev
;
461 struct mei_cl_cb
*cb
;
464 if (WARN_ON(!cl
|| !cl
->dev
))
469 cl_dbg(dev
, cl
, "disconnecting");
471 if (cl
->state
!= MEI_FILE_DISCONNECTING
)
474 rets
= pm_runtime_get(&dev
->pdev
->dev
);
475 if (rets
< 0 && rets
!= -EINPROGRESS
) {
476 pm_runtime_put_noidle(&dev
->pdev
->dev
);
477 cl_err(dev
, cl
, "rpm: get failed %d\n", rets
);
481 cb
= mei_io_cb_init(cl
, NULL
);
487 cb
->fop_type
= MEI_FOP_CLOSE
;
488 if (mei_hbuf_acquire(dev
)) {
489 if (mei_hbm_cl_disconnect_req(dev
, cl
)) {
491 cl_err(dev
, cl
, "failed to disconnect.\n");
494 cl
->timer_count
= MEI_CONNECT_TIMEOUT
;
495 mdelay(10); /* Wait for hardware disconnection ready */
496 list_add_tail(&cb
->list
, &dev
->ctrl_rd_list
.list
);
498 cl_dbg(dev
, cl
, "add disconnect cb to control write list\n");
499 list_add_tail(&cb
->list
, &dev
->ctrl_wr_list
.list
);
502 mutex_unlock(&dev
->device_lock
);
504 wait_event_timeout(dev
->wait_recvd_msg
,
505 MEI_FILE_DISCONNECTED
== cl
->state
,
506 mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT
));
508 mutex_lock(&dev
->device_lock
);
510 if (MEI_FILE_DISCONNECTED
== cl
->state
) {
512 cl_dbg(dev
, cl
, "successfully disconnected from FW client.\n");
514 cl_dbg(dev
, cl
, "timeout on disconnect from FW client.\n");
518 mei_io_list_flush(&dev
->ctrl_rd_list
, cl
);
519 mei_io_list_flush(&dev
->ctrl_wr_list
, cl
);
521 cl_dbg(dev
, cl
, "rpm: autosuspend\n");
522 pm_runtime_mark_last_busy(&dev
->pdev
->dev
);
523 pm_runtime_put_autosuspend(&dev
->pdev
->dev
);
531 * mei_cl_is_other_connecting - checks if other
532 * client with the same me client id is connecting
534 * @cl: private data of the file object
536 * returns true if other client is connected, false - otherwise.
538 bool mei_cl_is_other_connecting(struct mei_cl
*cl
)
540 struct mei_device
*dev
;
541 struct mei_cl
*ocl
; /* the other client */
543 if (WARN_ON(!cl
|| !cl
->dev
))
548 list_for_each_entry(ocl
, &dev
->file_list
, link
) {
549 if (ocl
->state
== MEI_FILE_CONNECTING
&&
551 cl
->me_client_id
== ocl
->me_client_id
)
560 * mei_cl_connect - connect host client to the me one
564 * Locking: called under "dev->device_lock" lock
566 * returns 0 on success, <0 on failure.
568 int mei_cl_connect(struct mei_cl
*cl
, struct file
*file
)
570 struct mei_device
*dev
;
571 struct mei_cl_cb
*cb
;
574 if (WARN_ON(!cl
|| !cl
->dev
))
579 rets
= pm_runtime_get(&dev
->pdev
->dev
);
580 if (rets
< 0 && rets
!= -EINPROGRESS
) {
581 pm_runtime_put_noidle(&dev
->pdev
->dev
);
582 cl_err(dev
, cl
, "rpm: get failed %d\n", rets
);
586 cb
= mei_io_cb_init(cl
, file
);
592 cb
->fop_type
= MEI_FOP_CONNECT
;
594 /* run hbuf acquire last so we don't have to undo */
595 if (!mei_cl_is_other_connecting(cl
) && mei_hbuf_acquire(dev
)) {
596 cl
->state
= MEI_FILE_CONNECTING
;
597 if (mei_hbm_cl_connect_req(dev
, cl
)) {
601 cl
->timer_count
= MEI_CONNECT_TIMEOUT
;
602 list_add_tail(&cb
->list
, &dev
->ctrl_rd_list
.list
);
604 cl
->state
= MEI_FILE_INITIALIZING
;
605 list_add_tail(&cb
->list
, &dev
->ctrl_wr_list
.list
);
608 mutex_unlock(&dev
->device_lock
);
609 wait_event_timeout(dev
->wait_recvd_msg
,
610 (cl
->state
== MEI_FILE_CONNECTED
||
611 cl
->state
== MEI_FILE_DISCONNECTED
),
612 mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT
));
613 mutex_lock(&dev
->device_lock
);
615 if (cl
->state
!= MEI_FILE_CONNECTED
) {
616 cl
->state
= MEI_FILE_DISCONNECTED
;
617 /* something went really wrong */
619 cl
->status
= -EFAULT
;
621 mei_io_list_flush(&dev
->ctrl_rd_list
, cl
);
622 mei_io_list_flush(&dev
->ctrl_wr_list
, cl
);
628 cl_dbg(dev
, cl
, "rpm: autosuspend\n");
629 pm_runtime_mark_last_busy(&dev
->pdev
->dev
);
630 pm_runtime_put_autosuspend(&dev
->pdev
->dev
);
637 * mei_cl_flow_ctrl_creds - checks flow_control credits for cl.
639 * @cl: private data of the file object
641 * returns 1 if mei_flow_ctrl_creds >0, 0 - otherwise.
642 * -ENOENT if mei_cl is not present
643 * -EINVAL if single_recv_buf == 0
645 int mei_cl_flow_ctrl_creds(struct mei_cl
*cl
)
647 struct mei_device
*dev
;
648 struct mei_me_client
*me_cl
;
650 if (WARN_ON(!cl
|| !cl
->dev
))
655 if (cl
->mei_flow_ctrl_creds
> 0)
658 me_cl
= mei_me_cl_by_id(dev
, cl
->me_client_id
);
660 cl_err(dev
, cl
, "no such me client %d\n", cl
->me_client_id
);
664 if (me_cl
->mei_flow_ctrl_creds
) {
665 if (WARN_ON(me_cl
->props
.single_recv_buf
== 0))
673 * mei_cl_flow_ctrl_reduce - reduces flow_control.
675 * @cl: private data of the file object
679 * -ENOENT when me client is not found
680 * -EINVAL when ctrl credits are <= 0
682 int mei_cl_flow_ctrl_reduce(struct mei_cl
*cl
)
684 struct mei_device
*dev
;
685 struct mei_me_client
*me_cl
;
687 if (WARN_ON(!cl
|| !cl
->dev
))
692 me_cl
= mei_me_cl_by_id(dev
, cl
->me_client_id
);
694 cl_err(dev
, cl
, "no such me client %d\n", cl
->me_client_id
);
698 if (me_cl
->props
.single_recv_buf
) {
699 if (WARN_ON(me_cl
->mei_flow_ctrl_creds
<= 0))
701 me_cl
->mei_flow_ctrl_creds
--;
703 if (WARN_ON(cl
->mei_flow_ctrl_creds
<= 0))
705 cl
->mei_flow_ctrl_creds
--;
711 * mei_cl_read_start - the start read client message function.
715 * returns 0 on success, <0 on failure.
717 int mei_cl_read_start(struct mei_cl
*cl
, size_t length
)
719 struct mei_device
*dev
;
720 struct mei_cl_cb
*cb
;
721 struct mei_me_client
*me_cl
;
724 if (WARN_ON(!cl
|| !cl
->dev
))
729 if (!mei_cl_is_connected(cl
))
733 cl_dbg(dev
, cl
, "read is pending.\n");
736 me_cl
= mei_me_cl_by_id(dev
, cl
->me_client_id
);
738 cl_err(dev
, cl
, "no such me client %d\n", cl
->me_client_id
);
742 rets
= pm_runtime_get(&dev
->pdev
->dev
);
743 if (rets
< 0 && rets
!= -EINPROGRESS
) {
744 pm_runtime_put_noidle(&dev
->pdev
->dev
);
745 cl_err(dev
, cl
, "rpm: get failed %d\n", rets
);
749 cb
= mei_io_cb_init(cl
, NULL
);
755 /* always allocate at least client max message */
756 length
= max_t(size_t, length
, me_cl
->props
.max_msg_length
);
757 rets
= mei_io_cb_alloc_resp_buf(cb
, length
);
761 cb
->fop_type
= MEI_FOP_READ
;
762 if (mei_hbuf_acquire(dev
)) {
763 rets
= mei_hbm_cl_flow_control_req(dev
, cl
);
767 list_add_tail(&cb
->list
, &dev
->read_list
.list
);
769 list_add_tail(&cb
->list
, &dev
->ctrl_wr_list
.list
);
775 cl_dbg(dev
, cl
, "rpm: autosuspend\n");
776 pm_runtime_mark_last_busy(&dev
->pdev
->dev
);
777 pm_runtime_put_autosuspend(&dev
->pdev
->dev
);
786 * mei_cl_irq_write - write a message to device
787 * from the interrupt thread context
790 * @cb: callback block.
791 * @cmpl_list: complete list.
793 * returns 0, OK; otherwise error.
795 int mei_cl_irq_write(struct mei_cl
*cl
, struct mei_cl_cb
*cb
,
796 struct mei_cl_cb
*cmpl_list
)
798 struct mei_device
*dev
;
799 struct mei_msg_data
*buf
;
800 struct mei_msg_hdr mei_hdr
;
806 if (WARN_ON(!cl
|| !cl
->dev
))
811 buf
= &cb
->request_buffer
;
813 rets
= mei_cl_flow_ctrl_creds(cl
);
818 cl_dbg(dev
, cl
, "No flow control credentials: not sending.\n");
822 slots
= mei_hbuf_empty_slots(dev
);
823 len
= buf
->size
- cb
->buf_idx
;
824 msg_slots
= mei_data2slots(len
);
826 mei_hdr
.host_addr
= cl
->host_client_id
;
827 mei_hdr
.me_addr
= cl
->me_client_id
;
828 mei_hdr
.reserved
= 0;
829 mei_hdr
.internal
= cb
->internal
;
831 if (slots
>= msg_slots
) {
832 mei_hdr
.length
= len
;
833 mei_hdr
.msg_complete
= 1;
834 /* Split the message only if we can write the whole host buffer */
835 } else if (slots
== dev
->hbuf_depth
) {
837 len
= (slots
* sizeof(u32
)) - sizeof(struct mei_msg_hdr
);
838 mei_hdr
.length
= len
;
839 mei_hdr
.msg_complete
= 0;
841 /* wait for next time the host buffer is empty */
845 cl_dbg(dev
, cl
, "buf: size = %d idx = %lu\n",
846 cb
->request_buffer
.size
, cb
->buf_idx
);
848 rets
= mei_write_message(dev
, &mei_hdr
, buf
->data
+ cb
->buf_idx
);
851 list_move_tail(&cb
->list
, &cmpl_list
->list
);
856 cl
->writing_state
= MEI_WRITING
;
857 cb
->buf_idx
+= mei_hdr
.length
;
859 if (mei_hdr
.msg_complete
) {
860 if (mei_cl_flow_ctrl_reduce(cl
))
862 list_move_tail(&cb
->list
, &dev
->write_waiting_list
.list
);
869 * mei_cl_write - submit a write cb to mei device
870 assumes device_lock is locked
873 * @cl: write callback with filled data
875 * returns number of bytes sent on success, <0 on failure.
877 int mei_cl_write(struct mei_cl
*cl
, struct mei_cl_cb
*cb
, bool blocking
)
879 struct mei_device
*dev
;
880 struct mei_msg_data
*buf
;
881 struct mei_msg_hdr mei_hdr
;
885 if (WARN_ON(!cl
|| !cl
->dev
))
894 buf
= &cb
->request_buffer
;
896 cl_dbg(dev
, cl
, "mei_cl_write %d\n", buf
->size
);
898 rets
= pm_runtime_get(&dev
->pdev
->dev
);
899 if (rets
< 0 && rets
!= -EINPROGRESS
) {
900 pm_runtime_put_noidle(&dev
->pdev
->dev
);
901 cl_err(dev
, cl
, "rpm: get failed %d\n", rets
);
905 cb
->fop_type
= MEI_FOP_WRITE
;
907 cl
->writing_state
= MEI_IDLE
;
909 mei_hdr
.host_addr
= cl
->host_client_id
;
910 mei_hdr
.me_addr
= cl
->me_client_id
;
911 mei_hdr
.reserved
= 0;
912 mei_hdr
.msg_complete
= 0;
913 mei_hdr
.internal
= cb
->internal
;
915 rets
= mei_cl_flow_ctrl_creds(cl
);
920 cl_dbg(dev
, cl
, "No flow control credentials: not sending.\n");
924 if (!mei_hbuf_acquire(dev
)) {
925 cl_dbg(dev
, cl
, "Cannot acquire the host buffer: not sending.\n");
930 /* Check for a maximum length */
931 if (buf
->size
> mei_hbuf_max_len(dev
)) {
932 mei_hdr
.length
= mei_hbuf_max_len(dev
);
933 mei_hdr
.msg_complete
= 0;
935 mei_hdr
.length
= buf
->size
;
936 mei_hdr
.msg_complete
= 1;
939 rets
= mei_write_message(dev
, &mei_hdr
, buf
->data
);
943 cl
->writing_state
= MEI_WRITING
;
944 cb
->buf_idx
= mei_hdr
.length
;
947 if (mei_hdr
.msg_complete
) {
948 rets
= mei_cl_flow_ctrl_reduce(cl
);
952 list_add_tail(&cb
->list
, &dev
->write_waiting_list
.list
);
954 list_add_tail(&cb
->list
, &dev
->write_list
.list
);
958 if (blocking
&& cl
->writing_state
!= MEI_WRITE_COMPLETE
) {
960 mutex_unlock(&dev
->device_lock
);
961 rets
= wait_event_interruptible(cl
->tx_wait
,
962 cl
->writing_state
== MEI_WRITE_COMPLETE
);
963 mutex_lock(&dev
->device_lock
);
964 /* wait_event_interruptible returns -ERESTARTSYS */
966 if (signal_pending(current
))
974 cl_dbg(dev
, cl
, "rpm: autosuspend\n");
975 pm_runtime_mark_last_busy(&dev
->pdev
->dev
);
976 pm_runtime_put_autosuspend(&dev
->pdev
->dev
);
983 * mei_cl_complete - processes completed operation for a client
985 * @cl: private data of the file object.
986 * @cb: callback block.
988 void mei_cl_complete(struct mei_cl
*cl
, struct mei_cl_cb
*cb
)
990 if (cb
->fop_type
== MEI_FOP_WRITE
) {
993 cl
->writing_state
= MEI_WRITE_COMPLETE
;
994 if (waitqueue_active(&cl
->tx_wait
))
995 wake_up_interruptible(&cl
->tx_wait
);
997 } else if (cb
->fop_type
== MEI_FOP_READ
&&
998 MEI_READING
== cl
->reading_state
) {
999 cl
->reading_state
= MEI_READ_COMPLETE
;
1000 if (waitqueue_active(&cl
->rx_wait
))
1001 wake_up_interruptible(&cl
->rx_wait
);
1003 mei_cl_bus_rx_event(cl
);
1010 * mei_cl_all_disconnect - disconnect forcefully all connected clients
1015 void mei_cl_all_disconnect(struct mei_device
*dev
)
1019 list_for_each_entry(cl
, &dev
->file_list
, link
) {
1020 cl
->state
= MEI_FILE_DISCONNECTED
;
1021 cl
->mei_flow_ctrl_creds
= 0;
1022 cl
->timer_count
= 0;
1028 * mei_cl_all_wakeup - wake up all readers and writers they can be interrupted
1032 void mei_cl_all_wakeup(struct mei_device
*dev
)
1035 list_for_each_entry(cl
, &dev
->file_list
, link
) {
1036 if (waitqueue_active(&cl
->rx_wait
)) {
1037 cl_dbg(dev
, cl
, "Waking up reading client!\n");
1038 wake_up_interruptible(&cl
->rx_wait
);
1040 if (waitqueue_active(&cl
->tx_wait
)) {
1041 cl_dbg(dev
, cl
, "Waking up writing client!\n");
1042 wake_up_interruptible(&cl
->tx_wait
);
1048 * mei_cl_all_write_clear - clear all pending writes
1052 void mei_cl_all_write_clear(struct mei_device
*dev
)
1054 mei_io_list_free(&dev
->write_list
, NULL
);
1055 mei_io_list_free(&dev
->write_waiting_list
, NULL
);