Loading...
Note: File does not exist in v3.1.
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/sched.h>
18#include <linux/wait.h>
19#include <linux/delay.h>
20#include <linux/slab.h>
21#include <linux/pm_runtime.h>
22
23#include <linux/mei.h>
24
25#include "mei_dev.h"
26#include "hbm.h"
27#include "client.h"
28
29/**
30 * mei_me_cl_init - initialize me client
31 *
32 * @me_cl: me client
33 */
34void mei_me_cl_init(struct mei_me_client *me_cl)
35{
36 INIT_LIST_HEAD(&me_cl->list);
37 kref_init(&me_cl->refcnt);
38}
39
40/**
41 * mei_me_cl_get - increases me client refcount
42 *
43 * @me_cl: me client
44 *
45 * Locking: called under "dev->device_lock" lock
46 *
47 * Return: me client or NULL
48 */
49struct mei_me_client *mei_me_cl_get(struct mei_me_client *me_cl)
50{
51 if (me_cl && kref_get_unless_zero(&me_cl->refcnt))
52 return me_cl;
53
54 return NULL;
55}
56
57/**
58 * mei_me_cl_release - free me client
59 *
60 * Locking: called under "dev->device_lock" lock
61 *
62 * @ref: me_client refcount
63 */
64static void mei_me_cl_release(struct kref *ref)
65{
66 struct mei_me_client *me_cl =
67 container_of(ref, struct mei_me_client, refcnt);
68
69 kfree(me_cl);
70}
71
72/**
73 * mei_me_cl_put - decrease me client refcount and free client if necessary
74 *
75 * Locking: called under "dev->device_lock" lock
76 *
77 * @me_cl: me client
78 */
79void mei_me_cl_put(struct mei_me_client *me_cl)
80{
81 if (me_cl)
82 kref_put(&me_cl->refcnt, mei_me_cl_release);
83}
84
85/**
86 * __mei_me_cl_del - delete me client from the list and decrease
87 * reference counter
88 *
89 * @dev: mei device
90 * @me_cl: me client
91 *
92 * Locking: dev->me_clients_rwsem
93 */
94static void __mei_me_cl_del(struct mei_device *dev, struct mei_me_client *me_cl)
95{
96 if (!me_cl)
97 return;
98
99 list_del_init(&me_cl->list);
100 mei_me_cl_put(me_cl);
101}
102
103/**
104 * mei_me_cl_del - delete me client from the list and decrease
105 * reference counter
106 *
107 * @dev: mei device
108 * @me_cl: me client
109 */
110void mei_me_cl_del(struct mei_device *dev, struct mei_me_client *me_cl)
111{
112 down_write(&dev->me_clients_rwsem);
113 __mei_me_cl_del(dev, me_cl);
114 up_write(&dev->me_clients_rwsem);
115}
116
117/**
118 * mei_me_cl_add - add me client to the list
119 *
120 * @dev: mei device
121 * @me_cl: me client
122 */
123void mei_me_cl_add(struct mei_device *dev, struct mei_me_client *me_cl)
124{
125 down_write(&dev->me_clients_rwsem);
126 list_add(&me_cl->list, &dev->me_clients);
127 up_write(&dev->me_clients_rwsem);
128}
129
130/**
131 * __mei_me_cl_by_uuid - locate me client by uuid
132 * increases ref count
133 *
134 * @dev: mei device
135 * @uuid: me client uuid
136 *
137 * Return: me client or NULL if not found
138 *
139 * Locking: dev->me_clients_rwsem
140 */
141static struct mei_me_client *__mei_me_cl_by_uuid(struct mei_device *dev,
142 const uuid_le *uuid)
143{
144 struct mei_me_client *me_cl;
145 const uuid_le *pn;
146
147 WARN_ON(!rwsem_is_locked(&dev->me_clients_rwsem));
148
149 list_for_each_entry(me_cl, &dev->me_clients, list) {
150 pn = &me_cl->props.protocol_name;
151 if (uuid_le_cmp(*uuid, *pn) == 0)
152 return mei_me_cl_get(me_cl);
153 }
154
155 return NULL;
156}
157
158/**
159 * mei_me_cl_by_uuid - locate me client by uuid
160 * increases ref count
161 *
162 * @dev: mei device
163 * @uuid: me client uuid
164 *
165 * Return: me client or NULL if not found
166 *
167 * Locking: dev->me_clients_rwsem
168 */
169struct mei_me_client *mei_me_cl_by_uuid(struct mei_device *dev,
170 const uuid_le *uuid)
171{
172 struct mei_me_client *me_cl;
173
174 down_read(&dev->me_clients_rwsem);
175 me_cl = __mei_me_cl_by_uuid(dev, uuid);
176 up_read(&dev->me_clients_rwsem);
177
178 return me_cl;
179}
180
181/**
182 * mei_me_cl_by_id - locate me client by client id
183 * increases ref count
184 *
185 * @dev: the device structure
186 * @client_id: me client id
187 *
188 * Return: me client or NULL if not found
189 *
190 * Locking: dev->me_clients_rwsem
191 */
192struct mei_me_client *mei_me_cl_by_id(struct mei_device *dev, u8 client_id)
193{
194
195 struct mei_me_client *__me_cl, *me_cl = NULL;
196
197 down_read(&dev->me_clients_rwsem);
198 list_for_each_entry(__me_cl, &dev->me_clients, list) {
199 if (__me_cl->client_id == client_id) {
200 me_cl = mei_me_cl_get(__me_cl);
201 break;
202 }
203 }
204 up_read(&dev->me_clients_rwsem);
205
206 return me_cl;
207}
208
209/**
210 * __mei_me_cl_by_uuid_id - locate me client by client id and uuid
211 * increases ref count
212 *
213 * @dev: the device structure
214 * @uuid: me client uuid
215 * @client_id: me client id
216 *
217 * Return: me client or null if not found
218 *
219 * Locking: dev->me_clients_rwsem
220 */
221static struct mei_me_client *__mei_me_cl_by_uuid_id(struct mei_device *dev,
222 const uuid_le *uuid, u8 client_id)
223{
224 struct mei_me_client *me_cl;
225 const uuid_le *pn;
226
227 WARN_ON(!rwsem_is_locked(&dev->me_clients_rwsem));
228
229 list_for_each_entry(me_cl, &dev->me_clients, list) {
230 pn = &me_cl->props.protocol_name;
231 if (uuid_le_cmp(*uuid, *pn) == 0 &&
232 me_cl->client_id == client_id)
233 return mei_me_cl_get(me_cl);
234 }
235
236 return NULL;
237}
238
239
240/**
241 * mei_me_cl_by_uuid_id - locate me client by client id and uuid
242 * increases ref count
243 *
244 * @dev: the device structure
245 * @uuid: me client uuid
246 * @client_id: me client id
247 *
248 * Return: me client or null if not found
249 */
250struct mei_me_client *mei_me_cl_by_uuid_id(struct mei_device *dev,
251 const uuid_le *uuid, u8 client_id)
252{
253 struct mei_me_client *me_cl;
254
255 down_read(&dev->me_clients_rwsem);
256 me_cl = __mei_me_cl_by_uuid_id(dev, uuid, client_id);
257 up_read(&dev->me_clients_rwsem);
258
259 return me_cl;
260}
261
262/**
263 * mei_me_cl_rm_by_uuid - remove all me clients matching uuid
264 *
265 * @dev: the device structure
266 * @uuid: me client uuid
267 *
268 * Locking: called under "dev->device_lock" lock
269 */
270void mei_me_cl_rm_by_uuid(struct mei_device *dev, const uuid_le *uuid)
271{
272 struct mei_me_client *me_cl;
273
274 dev_dbg(dev->dev, "remove %pUl\n", uuid);
275
276 down_write(&dev->me_clients_rwsem);
277 me_cl = __mei_me_cl_by_uuid(dev, uuid);
278 __mei_me_cl_del(dev, me_cl);
279 up_write(&dev->me_clients_rwsem);
280}
281
282/**
283 * mei_me_cl_rm_by_uuid_id - remove all me clients matching client id
284 *
285 * @dev: the device structure
286 * @uuid: me client uuid
287 * @id: me client id
288 *
289 * Locking: called under "dev->device_lock" lock
290 */
291void mei_me_cl_rm_by_uuid_id(struct mei_device *dev, const uuid_le *uuid, u8 id)
292{
293 struct mei_me_client *me_cl;
294
295 dev_dbg(dev->dev, "remove %pUl %d\n", uuid, id);
296
297 down_write(&dev->me_clients_rwsem);
298 me_cl = __mei_me_cl_by_uuid_id(dev, uuid, id);
299 __mei_me_cl_del(dev, me_cl);
300 up_write(&dev->me_clients_rwsem);
301}
302
303/**
304 * mei_me_cl_rm_all - remove all me clients
305 *
306 * @dev: the device structure
307 *
308 * Locking: called under "dev->device_lock" lock
309 */
310void mei_me_cl_rm_all(struct mei_device *dev)
311{
312 struct mei_me_client *me_cl, *next;
313
314 down_write(&dev->me_clients_rwsem);
315 list_for_each_entry_safe(me_cl, next, &dev->me_clients, list)
316 __mei_me_cl_del(dev, me_cl);
317 up_write(&dev->me_clients_rwsem);
318}
319
320/**
321 * mei_cl_cmp_id - tells if the clients are the same
322 *
323 * @cl1: host client 1
324 * @cl2: host client 2
325 *
326 * Return: true - if the clients has same host and me ids
327 * false - otherwise
328 */
329static inline bool mei_cl_cmp_id(const struct mei_cl *cl1,
330 const struct mei_cl *cl2)
331{
332 return cl1 && cl2 &&
333 (cl1->host_client_id == cl2->host_client_id) &&
334 (mei_cl_me_id(cl1) == mei_cl_me_id(cl2));
335}
336
337/**
338 * mei_io_cb_free - free mei_cb_private related memory
339 *
340 * @cb: mei callback struct
341 */
342void mei_io_cb_free(struct mei_cl_cb *cb)
343{
344 if (cb == NULL)
345 return;
346
347 list_del(&cb->list);
348 kfree(cb->buf.data);
349 kfree(cb);
350}
351
352/**
353 * mei_io_cb_init - allocate and initialize io callback
354 *
355 * @cl: mei client
356 * @type: operation type
357 * @fp: pointer to file structure
358 *
359 * Return: mei_cl_cb pointer or NULL;
360 */
361static struct mei_cl_cb *mei_io_cb_init(struct mei_cl *cl,
362 enum mei_cb_file_ops type,
363 const struct file *fp)
364{
365 struct mei_cl_cb *cb;
366
367 cb = kzalloc(sizeof(struct mei_cl_cb), GFP_KERNEL);
368 if (!cb)
369 return NULL;
370
371 INIT_LIST_HEAD(&cb->list);
372 cb->fp = fp;
373 cb->cl = cl;
374 cb->buf_idx = 0;
375 cb->fop_type = type;
376 return cb;
377}
378
379/**
380 * __mei_io_list_flush - removes and frees cbs belonging to cl.
381 *
382 * @list: an instance of our list structure
383 * @cl: host client, can be NULL for flushing the whole list
384 * @free: whether to free the cbs
385 */
386static void __mei_io_list_flush(struct mei_cl_cb *list,
387 struct mei_cl *cl, bool free)
388{
389 struct mei_cl_cb *cb, *next;
390
391 /* enable removing everything if no cl is specified */
392 list_for_each_entry_safe(cb, next, &list->list, list) {
393 if (!cl || mei_cl_cmp_id(cl, cb->cl)) {
394 list_del_init(&cb->list);
395 if (free)
396 mei_io_cb_free(cb);
397 }
398 }
399}
400
401/**
402 * mei_io_list_flush - removes list entry belonging to cl.
403 *
404 * @list: An instance of our list structure
405 * @cl: host client
406 */
407void mei_io_list_flush(struct mei_cl_cb *list, struct mei_cl *cl)
408{
409 __mei_io_list_flush(list, cl, false);
410}
411
412/**
413 * mei_io_list_free - removes cb belonging to cl and free them
414 *
415 * @list: An instance of our list structure
416 * @cl: host client
417 */
418static inline void mei_io_list_free(struct mei_cl_cb *list, struct mei_cl *cl)
419{
420 __mei_io_list_flush(list, cl, true);
421}
422
423/**
424 * mei_cl_alloc_cb - a convenient wrapper for allocating read cb
425 *
426 * @cl: host client
427 * @length: size of the buffer
428 * @fop_type: operation type
429 * @fp: associated file pointer (might be NULL)
430 *
431 * Return: cb on success and NULL on failure
432 */
433struct mei_cl_cb *mei_cl_alloc_cb(struct mei_cl *cl, size_t length,
434 enum mei_cb_file_ops fop_type,
435 const struct file *fp)
436{
437 struct mei_cl_cb *cb;
438
439 cb = mei_io_cb_init(cl, fop_type, fp);
440 if (!cb)
441 return NULL;
442
443 if (length == 0)
444 return cb;
445
446 cb->buf.data = kmalloc(length, GFP_KERNEL);
447 if (!cb->buf.data) {
448 mei_io_cb_free(cb);
449 return NULL;
450 }
451 cb->buf.size = length;
452
453 return cb;
454}
455
456/**
457 * mei_cl_enqueue_ctrl_wr_cb - a convenient wrapper for allocating
458 * and enqueuing of the control commands cb
459 *
460 * @cl: host client
461 * @length: size of the buffer
462 * @fop_type: operation type
463 * @fp: associated file pointer (might be NULL)
464 *
465 * Return: cb on success and NULL on failure
466 * Locking: called under "dev->device_lock" lock
467 */
468struct mei_cl_cb *mei_cl_enqueue_ctrl_wr_cb(struct mei_cl *cl, size_t length,
469 enum mei_cb_file_ops fop_type,
470 const struct file *fp)
471{
472 struct mei_cl_cb *cb;
473
474 /* for RX always allocate at least client's mtu */
475 if (length)
476 length = max_t(size_t, length, mei_cl_mtu(cl));
477
478 cb = mei_cl_alloc_cb(cl, length, fop_type, fp);
479 if (!cb)
480 return NULL;
481
482 list_add_tail(&cb->list, &cl->dev->ctrl_wr_list.list);
483 return cb;
484}
485
486/**
487 * mei_cl_read_cb - find this cl's callback in the read list
488 * for a specific file
489 *
490 * @cl: host client
491 * @fp: file pointer (matching cb file object), may be NULL
492 *
493 * Return: cb on success, NULL if cb is not found
494 */
495struct mei_cl_cb *mei_cl_read_cb(const struct mei_cl *cl, const struct file *fp)
496{
497 struct mei_cl_cb *cb;
498
499 list_for_each_entry(cb, &cl->rd_completed, list)
500 if (!fp || fp == cb->fp)
501 return cb;
502
503 return NULL;
504}
505
506/**
507 * mei_cl_read_cb_flush - free client's read pending and completed cbs
508 * for a specific file
509 *
510 * @cl: host client
511 * @fp: file pointer (matching cb file object), may be NULL
512 */
513void mei_cl_read_cb_flush(const struct mei_cl *cl, const struct file *fp)
514{
515 struct mei_cl_cb *cb, *next;
516
517 list_for_each_entry_safe(cb, next, &cl->rd_completed, list)
518 if (!fp || fp == cb->fp)
519 mei_io_cb_free(cb);
520
521
522 list_for_each_entry_safe(cb, next, &cl->rd_pending, list)
523 if (!fp || fp == cb->fp)
524 mei_io_cb_free(cb);
525}
526
527/**
528 * mei_cl_flush_queues - flushes queue lists belonging to cl.
529 *
530 * @cl: host client
531 * @fp: file pointer (matching cb file object), may be NULL
532 *
533 * Return: 0 on success, -EINVAL if cl or cl->dev is NULL.
534 */
535int mei_cl_flush_queues(struct mei_cl *cl, const struct file *fp)
536{
537 struct mei_device *dev;
538
539 if (WARN_ON(!cl || !cl->dev))
540 return -EINVAL;
541
542 dev = cl->dev;
543
544 cl_dbg(dev, cl, "remove list entry belonging to cl\n");
545 mei_io_list_free(&cl->dev->write_list, cl);
546 mei_io_list_free(&cl->dev->write_waiting_list, cl);
547 mei_io_list_flush(&cl->dev->ctrl_wr_list, cl);
548 mei_io_list_flush(&cl->dev->ctrl_rd_list, cl);
549 mei_io_list_flush(&cl->dev->amthif_cmd_list, cl);
550
551 mei_cl_read_cb_flush(cl, fp);
552
553 return 0;
554}
555
556
557/**
558 * mei_cl_init - initializes cl.
559 *
560 * @cl: host client to be initialized
561 * @dev: mei device
562 */
563void mei_cl_init(struct mei_cl *cl, struct mei_device *dev)
564{
565 memset(cl, 0, sizeof(struct mei_cl));
566 init_waitqueue_head(&cl->wait);
567 init_waitqueue_head(&cl->rx_wait);
568 init_waitqueue_head(&cl->tx_wait);
569 init_waitqueue_head(&cl->ev_wait);
570 INIT_LIST_HEAD(&cl->rd_completed);
571 INIT_LIST_HEAD(&cl->rd_pending);
572 INIT_LIST_HEAD(&cl->link);
573 cl->writing_state = MEI_IDLE;
574 cl->state = MEI_FILE_UNINITIALIZED;
575 cl->dev = dev;
576}
577
578/**
579 * mei_cl_allocate - allocates cl structure and sets it up.
580 *
581 * @dev: mei device
582 * Return: The allocated file or NULL on failure
583 */
584struct mei_cl *mei_cl_allocate(struct mei_device *dev)
585{
586 struct mei_cl *cl;
587
588 cl = kmalloc(sizeof(struct mei_cl), GFP_KERNEL);
589 if (!cl)
590 return NULL;
591
592 mei_cl_init(cl, dev);
593
594 return cl;
595}
596
597/**
598 * mei_cl_link - allocate host id in the host map
599 *
600 * @cl: host client
601 *
602 * Return: 0 on success
603 * -EINVAL on incorrect values
604 * -EMFILE if open count exceeded.
605 */
606int mei_cl_link(struct mei_cl *cl)
607{
608 struct mei_device *dev;
609 long open_handle_count;
610 int id;
611
612 if (WARN_ON(!cl || !cl->dev))
613 return -EINVAL;
614
615 dev = cl->dev;
616
617 id = find_first_zero_bit(dev->host_clients_map, MEI_CLIENTS_MAX);
618 if (id >= MEI_CLIENTS_MAX) {
619 dev_err(dev->dev, "id exceeded %d", MEI_CLIENTS_MAX);
620 return -EMFILE;
621 }
622
623 open_handle_count = dev->open_handle_count + dev->iamthif_open_count;
624 if (open_handle_count >= MEI_MAX_OPEN_HANDLE_COUNT) {
625 dev_err(dev->dev, "open_handle_count exceeded %d",
626 MEI_MAX_OPEN_HANDLE_COUNT);
627 return -EMFILE;
628 }
629
630 dev->open_handle_count++;
631
632 cl->host_client_id = id;
633 list_add_tail(&cl->link, &dev->file_list);
634
635 set_bit(id, dev->host_clients_map);
636
637 cl->state = MEI_FILE_INITIALIZING;
638
639 cl_dbg(dev, cl, "link cl\n");
640 return 0;
641}
642
643/**
644 * mei_cl_unlink - remove host client from the list
645 *
646 * @cl: host client
647 *
648 * Return: always 0
649 */
650int mei_cl_unlink(struct mei_cl *cl)
651{
652 struct mei_device *dev;
653
654 /* don't shout on error exit path */
655 if (!cl)
656 return 0;
657
658 /* amthif might not be initialized */
659 if (!cl->dev)
660 return 0;
661
662 dev = cl->dev;
663
664 cl_dbg(dev, cl, "unlink client");
665
666 if (dev->open_handle_count > 0)
667 dev->open_handle_count--;
668
669 /* never clear the 0 bit */
670 if (cl->host_client_id)
671 clear_bit(cl->host_client_id, dev->host_clients_map);
672
673 list_del_init(&cl->link);
674
675 cl->state = MEI_FILE_UNINITIALIZED;
676 cl->writing_state = MEI_IDLE;
677
678 WARN_ON(!list_empty(&cl->rd_completed) ||
679 !list_empty(&cl->rd_pending) ||
680 !list_empty(&cl->link));
681
682 return 0;
683}
684
685void mei_host_client_init(struct mei_device *dev)
686{
687 dev->dev_state = MEI_DEV_ENABLED;
688 dev->reset_count = 0;
689
690 schedule_work(&dev->bus_rescan_work);
691
692 pm_runtime_mark_last_busy(dev->dev);
693 dev_dbg(dev->dev, "rpm: autosuspend\n");
694 pm_request_autosuspend(dev->dev);
695}
696
697/**
698 * mei_hbuf_acquire - try to acquire host buffer
699 *
700 * @dev: the device structure
701 * Return: true if host buffer was acquired
702 */
703bool mei_hbuf_acquire(struct mei_device *dev)
704{
705 if (mei_pg_state(dev) == MEI_PG_ON ||
706 mei_pg_in_transition(dev)) {
707 dev_dbg(dev->dev, "device is in pg\n");
708 return false;
709 }
710
711 if (!dev->hbuf_is_ready) {
712 dev_dbg(dev->dev, "hbuf is not ready\n");
713 return false;
714 }
715
716 dev->hbuf_is_ready = false;
717
718 return true;
719}
720
721/**
722 * mei_cl_wake_all - wake up readers, writers and event waiters so
723 * they can be interrupted
724 *
725 * @cl: host client
726 */
727static void mei_cl_wake_all(struct mei_cl *cl)
728{
729 struct mei_device *dev = cl->dev;
730
731 /* synchronized under device mutex */
732 if (waitqueue_active(&cl->rx_wait)) {
733 cl_dbg(dev, cl, "Waking up reading client!\n");
734 wake_up_interruptible(&cl->rx_wait);
735 }
736 /* synchronized under device mutex */
737 if (waitqueue_active(&cl->tx_wait)) {
738 cl_dbg(dev, cl, "Waking up writing client!\n");
739 wake_up_interruptible(&cl->tx_wait);
740 }
741 /* synchronized under device mutex */
742 if (waitqueue_active(&cl->ev_wait)) {
743 cl_dbg(dev, cl, "Waking up waiting for event clients!\n");
744 wake_up_interruptible(&cl->ev_wait);
745 }
746 /* synchronized under device mutex */
747 if (waitqueue_active(&cl->wait)) {
748 cl_dbg(dev, cl, "Waking up ctrl write clients!\n");
749 wake_up(&cl->wait);
750 }
751}
752
753/**
754 * mei_cl_set_disconnected - set disconnected state and clear
755 * associated states and resources
756 *
757 * @cl: host client
758 */
759void mei_cl_set_disconnected(struct mei_cl *cl)
760{
761 struct mei_device *dev = cl->dev;
762
763 if (cl->state == MEI_FILE_DISCONNECTED ||
764 cl->state <= MEI_FILE_INITIALIZING)
765 return;
766
767 cl->state = MEI_FILE_DISCONNECTED;
768 mei_io_list_free(&dev->write_list, cl);
769 mei_io_list_free(&dev->write_waiting_list, cl);
770 mei_io_list_flush(&dev->ctrl_rd_list, cl);
771 mei_io_list_flush(&dev->ctrl_wr_list, cl);
772 mei_cl_wake_all(cl);
773 cl->rx_flow_ctrl_creds = 0;
774 cl->tx_flow_ctrl_creds = 0;
775 cl->timer_count = 0;
776
777 if (!cl->me_cl)
778 return;
779
780 if (!WARN_ON(cl->me_cl->connect_count == 0))
781 cl->me_cl->connect_count--;
782
783 if (cl->me_cl->connect_count == 0)
784 cl->me_cl->tx_flow_ctrl_creds = 0;
785
786 mei_me_cl_put(cl->me_cl);
787 cl->me_cl = NULL;
788}
789
790static int mei_cl_set_connecting(struct mei_cl *cl, struct mei_me_client *me_cl)
791{
792 if (!mei_me_cl_get(me_cl))
793 return -ENOENT;
794
795 /* only one connection is allowed for fixed address clients */
796 if (me_cl->props.fixed_address) {
797 if (me_cl->connect_count) {
798 mei_me_cl_put(me_cl);
799 return -EBUSY;
800 }
801 }
802
803 cl->me_cl = me_cl;
804 cl->state = MEI_FILE_CONNECTING;
805 cl->me_cl->connect_count++;
806
807 return 0;
808}
809
810/*
811 * mei_cl_send_disconnect - send disconnect request
812 *
813 * @cl: host client
814 * @cb: callback block
815 *
816 * Return: 0, OK; otherwise, error.
817 */
818static int mei_cl_send_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb)
819{
820 struct mei_device *dev;
821 int ret;
822
823 dev = cl->dev;
824
825 ret = mei_hbm_cl_disconnect_req(dev, cl);
826 cl->status = ret;
827 if (ret) {
828 cl->state = MEI_FILE_DISCONNECT_REPLY;
829 return ret;
830 }
831
832 list_move_tail(&cb->list, &dev->ctrl_rd_list.list);
833 cl->timer_count = MEI_CONNECT_TIMEOUT;
834 mei_schedule_stall_timer(dev);
835
836 return 0;
837}
838
839/**
840 * mei_cl_irq_disconnect - processes close related operation from
841 * interrupt thread context - send disconnect request
842 *
843 * @cl: client
844 * @cb: callback block.
845 * @cmpl_list: complete list.
846 *
847 * Return: 0, OK; otherwise, error.
848 */
849int mei_cl_irq_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb,
850 struct mei_cl_cb *cmpl_list)
851{
852 struct mei_device *dev = cl->dev;
853 u32 msg_slots;
854 int slots;
855 int ret;
856
857 msg_slots = mei_data2slots(sizeof(struct hbm_client_connect_request));
858 slots = mei_hbuf_empty_slots(dev);
859
860 if (slots < msg_slots)
861 return -EMSGSIZE;
862
863 ret = mei_cl_send_disconnect(cl, cb);
864 if (ret)
865 list_move_tail(&cb->list, &cmpl_list->list);
866
867 return ret;
868}
869
870/**
871 * __mei_cl_disconnect - disconnect host client from the me one
872 * internal function runtime pm has to be already acquired
873 *
874 * @cl: host client
875 *
876 * Return: 0 on success, <0 on failure.
877 */
878static int __mei_cl_disconnect(struct mei_cl *cl)
879{
880 struct mei_device *dev;
881 struct mei_cl_cb *cb;
882 int rets;
883
884 dev = cl->dev;
885
886 cl->state = MEI_FILE_DISCONNECTING;
887
888 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DISCONNECT, NULL);
889 if (!cb) {
890 rets = -ENOMEM;
891 goto out;
892 }
893
894 if (mei_hbuf_acquire(dev)) {
895 rets = mei_cl_send_disconnect(cl, cb);
896 if (rets) {
897 cl_err(dev, cl, "failed to disconnect.\n");
898 goto out;
899 }
900 }
901
902 mutex_unlock(&dev->device_lock);
903 wait_event_timeout(cl->wait,
904 cl->state == MEI_FILE_DISCONNECT_REPLY ||
905 cl->state == MEI_FILE_DISCONNECTED,
906 mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
907 mutex_lock(&dev->device_lock);
908
909 rets = cl->status;
910 if (cl->state != MEI_FILE_DISCONNECT_REPLY &&
911 cl->state != MEI_FILE_DISCONNECTED) {
912 cl_dbg(dev, cl, "timeout on disconnect from FW client.\n");
913 rets = -ETIME;
914 }
915
916out:
917 /* we disconnect also on error */
918 mei_cl_set_disconnected(cl);
919 if (!rets)
920 cl_dbg(dev, cl, "successfully disconnected from FW client.\n");
921
922 mei_io_cb_free(cb);
923 return rets;
924}
925
926/**
927 * mei_cl_disconnect - disconnect host client from the me one
928 *
929 * @cl: host client
930 *
931 * Locking: called under "dev->device_lock" lock
932 *
933 * Return: 0 on success, <0 on failure.
934 */
935int mei_cl_disconnect(struct mei_cl *cl)
936{
937 struct mei_device *dev;
938 int rets;
939
940 if (WARN_ON(!cl || !cl->dev))
941 return -ENODEV;
942
943 dev = cl->dev;
944
945 cl_dbg(dev, cl, "disconnecting");
946
947 if (!mei_cl_is_connected(cl))
948 return 0;
949
950 if (mei_cl_is_fixed_address(cl)) {
951 mei_cl_set_disconnected(cl);
952 return 0;
953 }
954
955 rets = pm_runtime_get(dev->dev);
956 if (rets < 0 && rets != -EINPROGRESS) {
957 pm_runtime_put_noidle(dev->dev);
958 cl_err(dev, cl, "rpm: get failed %d\n", rets);
959 return rets;
960 }
961
962 rets = __mei_cl_disconnect(cl);
963
964 cl_dbg(dev, cl, "rpm: autosuspend\n");
965 pm_runtime_mark_last_busy(dev->dev);
966 pm_runtime_put_autosuspend(dev->dev);
967
968 return rets;
969}
970
971
972/**
973 * mei_cl_is_other_connecting - checks if other
974 * client with the same me client id is connecting
975 *
976 * @cl: private data of the file object
977 *
978 * Return: true if other client is connected, false - otherwise.
979 */
980static bool mei_cl_is_other_connecting(struct mei_cl *cl)
981{
982 struct mei_device *dev;
983 struct mei_cl_cb *cb;
984
985 dev = cl->dev;
986
987 list_for_each_entry(cb, &dev->ctrl_rd_list.list, list) {
988 if (cb->fop_type == MEI_FOP_CONNECT &&
989 mei_cl_me_id(cl) == mei_cl_me_id(cb->cl))
990 return true;
991 }
992
993 return false;
994}
995
996/**
997 * mei_cl_send_connect - send connect request
998 *
999 * @cl: host client
1000 * @cb: callback block
1001 *
1002 * Return: 0, OK; otherwise, error.
1003 */
1004static int mei_cl_send_connect(struct mei_cl *cl, struct mei_cl_cb *cb)
1005{
1006 struct mei_device *dev;
1007 int ret;
1008
1009 dev = cl->dev;
1010
1011 ret = mei_hbm_cl_connect_req(dev, cl);
1012 cl->status = ret;
1013 if (ret) {
1014 cl->state = MEI_FILE_DISCONNECT_REPLY;
1015 return ret;
1016 }
1017
1018 list_move_tail(&cb->list, &dev->ctrl_rd_list.list);
1019 cl->timer_count = MEI_CONNECT_TIMEOUT;
1020 mei_schedule_stall_timer(dev);
1021 return 0;
1022}
1023
1024/**
1025 * mei_cl_irq_connect - send connect request in irq_thread context
1026 *
1027 * @cl: host client
1028 * @cb: callback block
1029 * @cmpl_list: complete list
1030 *
1031 * Return: 0, OK; otherwise, error.
1032 */
1033int mei_cl_irq_connect(struct mei_cl *cl, struct mei_cl_cb *cb,
1034 struct mei_cl_cb *cmpl_list)
1035{
1036 struct mei_device *dev = cl->dev;
1037 u32 msg_slots;
1038 int slots;
1039 int rets;
1040
1041 msg_slots = mei_data2slots(sizeof(struct hbm_client_connect_request));
1042 slots = mei_hbuf_empty_slots(dev);
1043
1044 if (mei_cl_is_other_connecting(cl))
1045 return 0;
1046
1047 if (slots < msg_slots)
1048 return -EMSGSIZE;
1049
1050 rets = mei_cl_send_connect(cl, cb);
1051 if (rets)
1052 list_move_tail(&cb->list, &cmpl_list->list);
1053
1054 return rets;
1055}
1056
1057/**
1058 * mei_cl_connect - connect host client to the me one
1059 *
1060 * @cl: host client
1061 * @me_cl: me client
1062 * @fp: pointer to file structure
1063 *
1064 * Locking: called under "dev->device_lock" lock
1065 *
1066 * Return: 0 on success, <0 on failure.
1067 */
1068int mei_cl_connect(struct mei_cl *cl, struct mei_me_client *me_cl,
1069 const struct file *fp)
1070{
1071 struct mei_device *dev;
1072 struct mei_cl_cb *cb;
1073 int rets;
1074
1075 if (WARN_ON(!cl || !cl->dev || !me_cl))
1076 return -ENODEV;
1077
1078 dev = cl->dev;
1079
1080 rets = mei_cl_set_connecting(cl, me_cl);
1081 if (rets)
1082 return rets;
1083
1084 if (mei_cl_is_fixed_address(cl)) {
1085 cl->state = MEI_FILE_CONNECTED;
1086 return 0;
1087 }
1088
1089 rets = pm_runtime_get(dev->dev);
1090 if (rets < 0 && rets != -EINPROGRESS) {
1091 pm_runtime_put_noidle(dev->dev);
1092 cl_err(dev, cl, "rpm: get failed %d\n", rets);
1093 goto nortpm;
1094 }
1095
1096 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_CONNECT, fp);
1097 if (!cb) {
1098 rets = -ENOMEM;
1099 goto out;
1100 }
1101
1102 /* run hbuf acquire last so we don't have to undo */
1103 if (!mei_cl_is_other_connecting(cl) && mei_hbuf_acquire(dev)) {
1104 rets = mei_cl_send_connect(cl, cb);
1105 if (rets)
1106 goto out;
1107 }
1108
1109 mutex_unlock(&dev->device_lock);
1110 wait_event_timeout(cl->wait,
1111 (cl->state == MEI_FILE_CONNECTED ||
1112 cl->state == MEI_FILE_DISCONNECTED ||
1113 cl->state == MEI_FILE_DISCONNECT_REQUIRED ||
1114 cl->state == MEI_FILE_DISCONNECT_REPLY),
1115 mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
1116 mutex_lock(&dev->device_lock);
1117
1118 if (!mei_cl_is_connected(cl)) {
1119 if (cl->state == MEI_FILE_DISCONNECT_REQUIRED) {
1120 mei_io_list_flush(&dev->ctrl_rd_list, cl);
1121 mei_io_list_flush(&dev->ctrl_wr_list, cl);
1122 /* ignore disconnect return valuue;
1123 * in case of failure reset will be invoked
1124 */
1125 __mei_cl_disconnect(cl);
1126 rets = -EFAULT;
1127 goto out;
1128 }
1129
1130 /* timeout or something went really wrong */
1131 if (!cl->status)
1132 cl->status = -EFAULT;
1133 }
1134
1135 rets = cl->status;
1136out:
1137 cl_dbg(dev, cl, "rpm: autosuspend\n");
1138 pm_runtime_mark_last_busy(dev->dev);
1139 pm_runtime_put_autosuspend(dev->dev);
1140
1141 mei_io_cb_free(cb);
1142
1143nortpm:
1144 if (!mei_cl_is_connected(cl))
1145 mei_cl_set_disconnected(cl);
1146
1147 return rets;
1148}
1149
1150/**
1151 * mei_cl_alloc_linked - allocate and link host client
1152 *
1153 * @dev: the device structure
1154 *
1155 * Return: cl on success ERR_PTR on failure
1156 */
1157struct mei_cl *mei_cl_alloc_linked(struct mei_device *dev)
1158{
1159 struct mei_cl *cl;
1160 int ret;
1161
1162 cl = mei_cl_allocate(dev);
1163 if (!cl) {
1164 ret = -ENOMEM;
1165 goto err;
1166 }
1167
1168 ret = mei_cl_link(cl);
1169 if (ret)
1170 goto err;
1171
1172 return cl;
1173err:
1174 kfree(cl);
1175 return ERR_PTR(ret);
1176}
1177
1178/**
1179 * mei_cl_tx_flow_ctrl_creds - checks flow_control credits for cl.
1180 *
1181 * @cl: host client
1182 *
1183 * Return: 1 if tx_flow_ctrl_creds >0, 0 - otherwise.
1184 */
1185static int mei_cl_tx_flow_ctrl_creds(struct mei_cl *cl)
1186{
1187 if (WARN_ON(!cl || !cl->me_cl))
1188 return -EINVAL;
1189
1190 if (cl->tx_flow_ctrl_creds > 0)
1191 return 1;
1192
1193 if (mei_cl_is_fixed_address(cl))
1194 return 1;
1195
1196 if (mei_cl_is_single_recv_buf(cl)) {
1197 if (cl->me_cl->tx_flow_ctrl_creds > 0)
1198 return 1;
1199 }
1200 return 0;
1201}
1202
1203/**
1204 * mei_cl_tx_flow_ctrl_creds_reduce - reduces transmit flow control credits
1205 * for a client
1206 *
1207 * @cl: host client
1208 *
1209 * Return:
1210 * 0 on success
1211 * -EINVAL when ctrl credits are <= 0
1212 */
1213static int mei_cl_tx_flow_ctrl_creds_reduce(struct mei_cl *cl)
1214{
1215 if (WARN_ON(!cl || !cl->me_cl))
1216 return -EINVAL;
1217
1218 if (mei_cl_is_fixed_address(cl))
1219 return 0;
1220
1221 if (mei_cl_is_single_recv_buf(cl)) {
1222 if (WARN_ON(cl->me_cl->tx_flow_ctrl_creds <= 0))
1223 return -EINVAL;
1224 cl->me_cl->tx_flow_ctrl_creds--;
1225 } else {
1226 if (WARN_ON(cl->tx_flow_ctrl_creds <= 0))
1227 return -EINVAL;
1228 cl->tx_flow_ctrl_creds--;
1229 }
1230 return 0;
1231}
1232
1233/**
1234 * mei_cl_notify_fop2req - convert fop to proper request
1235 *
1236 * @fop: client notification start response command
1237 *
1238 * Return: MEI_HBM_NOTIFICATION_START/STOP
1239 */
1240u8 mei_cl_notify_fop2req(enum mei_cb_file_ops fop)
1241{
1242 if (fop == MEI_FOP_NOTIFY_START)
1243 return MEI_HBM_NOTIFICATION_START;
1244 else
1245 return MEI_HBM_NOTIFICATION_STOP;
1246}
1247
1248/**
1249 * mei_cl_notify_req2fop - convert notification request top file operation type
1250 *
1251 * @req: hbm notification request type
1252 *
1253 * Return: MEI_FOP_NOTIFY_START/STOP
1254 */
1255enum mei_cb_file_ops mei_cl_notify_req2fop(u8 req)
1256{
1257 if (req == MEI_HBM_NOTIFICATION_START)
1258 return MEI_FOP_NOTIFY_START;
1259 else
1260 return MEI_FOP_NOTIFY_STOP;
1261}
1262
1263/**
1264 * mei_cl_irq_notify - send notification request in irq_thread context
1265 *
1266 * @cl: client
1267 * @cb: callback block.
1268 * @cmpl_list: complete list.
1269 *
1270 * Return: 0 on such and error otherwise.
1271 */
1272int mei_cl_irq_notify(struct mei_cl *cl, struct mei_cl_cb *cb,
1273 struct mei_cl_cb *cmpl_list)
1274{
1275 struct mei_device *dev = cl->dev;
1276 u32 msg_slots;
1277 int slots;
1278 int ret;
1279 bool request;
1280
1281 msg_slots = mei_data2slots(sizeof(struct hbm_client_connect_request));
1282 slots = mei_hbuf_empty_slots(dev);
1283
1284 if (slots < msg_slots)
1285 return -EMSGSIZE;
1286
1287 request = mei_cl_notify_fop2req(cb->fop_type);
1288 ret = mei_hbm_cl_notify_req(dev, cl, request);
1289 if (ret) {
1290 cl->status = ret;
1291 list_move_tail(&cb->list, &cmpl_list->list);
1292 return ret;
1293 }
1294
1295 list_move_tail(&cb->list, &dev->ctrl_rd_list.list);
1296 return 0;
1297}
1298
1299/**
1300 * mei_cl_notify_request - send notification stop/start request
1301 *
1302 * @cl: host client
1303 * @fp: associate request with file
1304 * @request: 1 for start or 0 for stop
1305 *
1306 * Locking: called under "dev->device_lock" lock
1307 *
1308 * Return: 0 on such and error otherwise.
1309 */
1310int mei_cl_notify_request(struct mei_cl *cl,
1311 const struct file *fp, u8 request)
1312{
1313 struct mei_device *dev;
1314 struct mei_cl_cb *cb;
1315 enum mei_cb_file_ops fop_type;
1316 int rets;
1317
1318 if (WARN_ON(!cl || !cl->dev))
1319 return -ENODEV;
1320
1321 dev = cl->dev;
1322
1323 if (!dev->hbm_f_ev_supported) {
1324 cl_dbg(dev, cl, "notifications not supported\n");
1325 return -EOPNOTSUPP;
1326 }
1327
1328 rets = pm_runtime_get(dev->dev);
1329 if (rets < 0 && rets != -EINPROGRESS) {
1330 pm_runtime_put_noidle(dev->dev);
1331 cl_err(dev, cl, "rpm: get failed %d\n", rets);
1332 return rets;
1333 }
1334
1335 fop_type = mei_cl_notify_req2fop(request);
1336 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, fop_type, fp);
1337 if (!cb) {
1338 rets = -ENOMEM;
1339 goto out;
1340 }
1341
1342 if (mei_hbuf_acquire(dev)) {
1343 if (mei_hbm_cl_notify_req(dev, cl, request)) {
1344 rets = -ENODEV;
1345 goto out;
1346 }
1347 list_move_tail(&cb->list, &dev->ctrl_rd_list.list);
1348 }
1349
1350 mutex_unlock(&dev->device_lock);
1351 wait_event_timeout(cl->wait,
1352 cl->notify_en == request || !mei_cl_is_connected(cl),
1353 mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
1354 mutex_lock(&dev->device_lock);
1355
1356 if (cl->notify_en != request && !cl->status)
1357 cl->status = -EFAULT;
1358
1359 rets = cl->status;
1360
1361out:
1362 cl_dbg(dev, cl, "rpm: autosuspend\n");
1363 pm_runtime_mark_last_busy(dev->dev);
1364 pm_runtime_put_autosuspend(dev->dev);
1365
1366 mei_io_cb_free(cb);
1367 return rets;
1368}
1369
1370/**
1371 * mei_cl_notify - raise notification
1372 *
1373 * @cl: host client
1374 *
1375 * Locking: called under "dev->device_lock" lock
1376 */
1377void mei_cl_notify(struct mei_cl *cl)
1378{
1379 struct mei_device *dev;
1380
1381 if (!cl || !cl->dev)
1382 return;
1383
1384 dev = cl->dev;
1385
1386 if (!cl->notify_en)
1387 return;
1388
1389 cl_dbg(dev, cl, "notify event");
1390 cl->notify_ev = true;
1391 if (!mei_cl_bus_notify_event(cl))
1392 wake_up_interruptible(&cl->ev_wait);
1393
1394 if (cl->ev_async)
1395 kill_fasync(&cl->ev_async, SIGIO, POLL_PRI);
1396
1397}
1398
1399/**
1400 * mei_cl_notify_get - get or wait for notification event
1401 *
1402 * @cl: host client
1403 * @block: this request is blocking
1404 * @notify_ev: true if notification event was received
1405 *
1406 * Locking: called under "dev->device_lock" lock
1407 *
1408 * Return: 0 on such and error otherwise.
1409 */
1410int mei_cl_notify_get(struct mei_cl *cl, bool block, bool *notify_ev)
1411{
1412 struct mei_device *dev;
1413 int rets;
1414
1415 *notify_ev = false;
1416
1417 if (WARN_ON(!cl || !cl->dev))
1418 return -ENODEV;
1419
1420 dev = cl->dev;
1421
1422 if (!mei_cl_is_connected(cl))
1423 return -ENODEV;
1424
1425 if (cl->notify_ev)
1426 goto out;
1427
1428 if (!block)
1429 return -EAGAIN;
1430
1431 mutex_unlock(&dev->device_lock);
1432 rets = wait_event_interruptible(cl->ev_wait, cl->notify_ev);
1433 mutex_lock(&dev->device_lock);
1434
1435 if (rets < 0)
1436 return rets;
1437
1438out:
1439 *notify_ev = cl->notify_ev;
1440 cl->notify_ev = false;
1441 return 0;
1442}
1443
1444/**
1445 * mei_cl_read_start - the start read client message function.
1446 *
1447 * @cl: host client
1448 * @length: number of bytes to read
1449 * @fp: pointer to file structure
1450 *
1451 * Return: 0 on success, <0 on failure.
1452 */
1453int mei_cl_read_start(struct mei_cl *cl, size_t length, const struct file *fp)
1454{
1455 struct mei_device *dev;
1456 struct mei_cl_cb *cb;
1457 int rets;
1458
1459 if (WARN_ON(!cl || !cl->dev))
1460 return -ENODEV;
1461
1462 dev = cl->dev;
1463
1464 if (!mei_cl_is_connected(cl))
1465 return -ENODEV;
1466
1467 if (!mei_me_cl_is_active(cl->me_cl)) {
1468 cl_err(dev, cl, "no such me client\n");
1469 return -ENOTTY;
1470 }
1471
1472 if (mei_cl_is_fixed_address(cl) || cl == &dev->iamthif_cl)
1473 return 0;
1474
1475 /* HW currently supports only one pending read */
1476 if (cl->rx_flow_ctrl_creds)
1477 return -EBUSY;
1478
1479 cb = mei_cl_enqueue_ctrl_wr_cb(cl, length, MEI_FOP_READ, fp);
1480 if (!cb)
1481 return -ENOMEM;
1482
1483 rets = pm_runtime_get(dev->dev);
1484 if (rets < 0 && rets != -EINPROGRESS) {
1485 pm_runtime_put_noidle(dev->dev);
1486 cl_err(dev, cl, "rpm: get failed %d\n", rets);
1487 goto nortpm;
1488 }
1489
1490 rets = 0;
1491 if (mei_hbuf_acquire(dev)) {
1492 rets = mei_hbm_cl_flow_control_req(dev, cl);
1493 if (rets < 0)
1494 goto out;
1495
1496 list_move_tail(&cb->list, &cl->rd_pending);
1497 }
1498 cl->rx_flow_ctrl_creds++;
1499
1500out:
1501 cl_dbg(dev, cl, "rpm: autosuspend\n");
1502 pm_runtime_mark_last_busy(dev->dev);
1503 pm_runtime_put_autosuspend(dev->dev);
1504nortpm:
1505 if (rets)
1506 mei_io_cb_free(cb);
1507
1508 return rets;
1509}
1510
1511/**
1512 * mei_cl_irq_write - write a message to device
1513 * from the interrupt thread context
1514 *
1515 * @cl: client
1516 * @cb: callback block.
1517 * @cmpl_list: complete list.
1518 *
1519 * Return: 0, OK; otherwise error.
1520 */
1521int mei_cl_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,
1522 struct mei_cl_cb *cmpl_list)
1523{
1524 struct mei_device *dev;
1525 struct mei_msg_data *buf;
1526 struct mei_msg_hdr mei_hdr;
1527 size_t len;
1528 u32 msg_slots;
1529 int slots;
1530 int rets;
1531 bool first_chunk;
1532
1533 if (WARN_ON(!cl || !cl->dev))
1534 return -ENODEV;
1535
1536 dev = cl->dev;
1537
1538 buf = &cb->buf;
1539
1540 first_chunk = cb->buf_idx == 0;
1541
1542 rets = first_chunk ? mei_cl_tx_flow_ctrl_creds(cl) : 1;
1543 if (rets < 0)
1544 goto err;
1545
1546 if (rets == 0) {
1547 cl_dbg(dev, cl, "No flow control credentials: not sending.\n");
1548 return 0;
1549 }
1550
1551 slots = mei_hbuf_empty_slots(dev);
1552 len = buf->size - cb->buf_idx;
1553 msg_slots = mei_data2slots(len);
1554
1555 mei_hdr.host_addr = mei_cl_host_addr(cl);
1556 mei_hdr.me_addr = mei_cl_me_id(cl);
1557 mei_hdr.reserved = 0;
1558 mei_hdr.internal = cb->internal;
1559
1560 if (slots >= msg_slots) {
1561 mei_hdr.length = len;
1562 mei_hdr.msg_complete = 1;
1563 /* Split the message only if we can write the whole host buffer */
1564 } else if (slots == dev->hbuf_depth) {
1565 msg_slots = slots;
1566 len = (slots * sizeof(u32)) - sizeof(struct mei_msg_hdr);
1567 mei_hdr.length = len;
1568 mei_hdr.msg_complete = 0;
1569 } else {
1570 /* wait for next time the host buffer is empty */
1571 return 0;
1572 }
1573
1574 cl_dbg(dev, cl, "buf: size = %zu idx = %zu\n",
1575 cb->buf.size, cb->buf_idx);
1576
1577 rets = mei_write_message(dev, &mei_hdr, buf->data + cb->buf_idx);
1578 if (rets)
1579 goto err;
1580
1581 cl->status = 0;
1582 cl->writing_state = MEI_WRITING;
1583 cb->buf_idx += mei_hdr.length;
1584 cb->completed = mei_hdr.msg_complete == 1;
1585
1586 if (first_chunk) {
1587 if (mei_cl_tx_flow_ctrl_creds_reduce(cl)) {
1588 rets = -EIO;
1589 goto err;
1590 }
1591 }
1592
1593 if (mei_hdr.msg_complete)
1594 list_move_tail(&cb->list, &dev->write_waiting_list.list);
1595
1596 return 0;
1597
1598err:
1599 cl->status = rets;
1600 list_move_tail(&cb->list, &cmpl_list->list);
1601 return rets;
1602}
1603
1604/**
1605 * mei_cl_write - submit a write cb to mei device
1606 * assumes device_lock is locked
1607 *
1608 * @cl: host client
1609 * @cb: write callback with filled data
1610 *
1611 * Return: number of bytes sent on success, <0 on failure.
1612 */
1613int mei_cl_write(struct mei_cl *cl, struct mei_cl_cb *cb)
1614{
1615 struct mei_device *dev;
1616 struct mei_msg_data *buf;
1617 struct mei_msg_hdr mei_hdr;
1618 int size;
1619 int rets;
1620 bool blocking;
1621
1622 if (WARN_ON(!cl || !cl->dev))
1623 return -ENODEV;
1624
1625 if (WARN_ON(!cb))
1626 return -EINVAL;
1627
1628 dev = cl->dev;
1629
1630 buf = &cb->buf;
1631 size = buf->size;
1632 blocking = cb->blocking;
1633
1634 cl_dbg(dev, cl, "size=%d\n", size);
1635
1636 rets = pm_runtime_get(dev->dev);
1637 if (rets < 0 && rets != -EINPROGRESS) {
1638 pm_runtime_put_noidle(dev->dev);
1639 cl_err(dev, cl, "rpm: get failed %d\n", rets);
1640 goto free;
1641 }
1642
1643 cb->buf_idx = 0;
1644 cl->writing_state = MEI_IDLE;
1645
1646 mei_hdr.host_addr = mei_cl_host_addr(cl);
1647 mei_hdr.me_addr = mei_cl_me_id(cl);
1648 mei_hdr.reserved = 0;
1649 mei_hdr.msg_complete = 0;
1650 mei_hdr.internal = cb->internal;
1651
1652 rets = mei_cl_tx_flow_ctrl_creds(cl);
1653 if (rets < 0)
1654 goto err;
1655
1656 if (rets == 0) {
1657 cl_dbg(dev, cl, "No flow control credentials: not sending.\n");
1658 rets = size;
1659 goto out;
1660 }
1661 if (!mei_hbuf_acquire(dev)) {
1662 cl_dbg(dev, cl, "Cannot acquire the host buffer: not sending.\n");
1663 rets = size;
1664 goto out;
1665 }
1666
1667 /* Check for a maximum length */
1668 if (size > mei_hbuf_max_len(dev)) {
1669 mei_hdr.length = mei_hbuf_max_len(dev);
1670 mei_hdr.msg_complete = 0;
1671 } else {
1672 mei_hdr.length = size;
1673 mei_hdr.msg_complete = 1;
1674 }
1675
1676 rets = mei_write_message(dev, &mei_hdr, buf->data);
1677 if (rets)
1678 goto err;
1679
1680 rets = mei_cl_tx_flow_ctrl_creds_reduce(cl);
1681 if (rets)
1682 goto err;
1683
1684 cl->writing_state = MEI_WRITING;
1685 cb->buf_idx = mei_hdr.length;
1686 cb->completed = mei_hdr.msg_complete == 1;
1687
1688out:
1689 if (mei_hdr.msg_complete)
1690 list_add_tail(&cb->list, &dev->write_waiting_list.list);
1691 else
1692 list_add_tail(&cb->list, &dev->write_list.list);
1693
1694 cb = NULL;
1695 if (blocking && cl->writing_state != MEI_WRITE_COMPLETE) {
1696
1697 mutex_unlock(&dev->device_lock);
1698 rets = wait_event_interruptible(cl->tx_wait,
1699 cl->writing_state == MEI_WRITE_COMPLETE ||
1700 (!mei_cl_is_connected(cl)));
1701 mutex_lock(&dev->device_lock);
1702 /* wait_event_interruptible returns -ERESTARTSYS */
1703 if (rets) {
1704 if (signal_pending(current))
1705 rets = -EINTR;
1706 goto err;
1707 }
1708 if (cl->writing_state != MEI_WRITE_COMPLETE) {
1709 rets = -EFAULT;
1710 goto err;
1711 }
1712 }
1713
1714 rets = size;
1715err:
1716 cl_dbg(dev, cl, "rpm: autosuspend\n");
1717 pm_runtime_mark_last_busy(dev->dev);
1718 pm_runtime_put_autosuspend(dev->dev);
1719free:
1720 mei_io_cb_free(cb);
1721
1722 return rets;
1723}
1724
1725
1726/**
1727 * mei_cl_complete - processes completed operation for a client
1728 *
1729 * @cl: private data of the file object.
1730 * @cb: callback block.
1731 */
1732void mei_cl_complete(struct mei_cl *cl, struct mei_cl_cb *cb)
1733{
1734 struct mei_device *dev = cl->dev;
1735
1736 switch (cb->fop_type) {
1737 case MEI_FOP_WRITE:
1738 mei_io_cb_free(cb);
1739 cl->writing_state = MEI_WRITE_COMPLETE;
1740 if (waitqueue_active(&cl->tx_wait)) {
1741 wake_up_interruptible(&cl->tx_wait);
1742 } else {
1743 pm_runtime_mark_last_busy(dev->dev);
1744 pm_request_autosuspend(dev->dev);
1745 }
1746 break;
1747
1748 case MEI_FOP_READ:
1749 list_add_tail(&cb->list, &cl->rd_completed);
1750 if (!mei_cl_is_fixed_address(cl) &&
1751 !WARN_ON(!cl->rx_flow_ctrl_creds))
1752 cl->rx_flow_ctrl_creds--;
1753 if (!mei_cl_bus_rx_event(cl))
1754 wake_up_interruptible(&cl->rx_wait);
1755 break;
1756
1757 case MEI_FOP_CONNECT:
1758 case MEI_FOP_DISCONNECT:
1759 case MEI_FOP_NOTIFY_STOP:
1760 case MEI_FOP_NOTIFY_START:
1761 if (waitqueue_active(&cl->wait))
1762 wake_up(&cl->wait);
1763
1764 break;
1765 case MEI_FOP_DISCONNECT_RSP:
1766 mei_io_cb_free(cb);
1767 mei_cl_set_disconnected(cl);
1768 break;
1769 default:
1770 BUG_ON(0);
1771 }
1772}
1773
1774
1775/**
1776 * mei_cl_all_disconnect - disconnect forcefully all connected clients
1777 *
1778 * @dev: mei device
1779 */
1780void mei_cl_all_disconnect(struct mei_device *dev)
1781{
1782 struct mei_cl *cl;
1783
1784 list_for_each_entry(cl, &dev->file_list, link)
1785 mei_cl_set_disconnected(cl);
1786}