2 * Intel Management Engine Interface (Intel MEI) Linux driver
3 * Copyright (c) 2012-2013, Intel Corporation.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 #include <linux/module.h>
17 #include <linux/device.h>
18 #include <linux/kernel.h>
19 #include <linux/sched.h>
20 #include <linux/init.h>
21 #include <linux/errno.h>
22 #include <linux/slab.h>
23 #include <linux/mutex.h>
24 #include <linux/interrupt.h>
25 #include <linux/mei_cl_bus.h>
30 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver)
31 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev)
34 * __mei_cl_send - internal client send (write)
37 * @buf: buffer to send
38 * @length: buffer length
39 * @blocking: wait for write completion
41 * Return: written size bytes or < 0 on error
43 ssize_t
__mei_cl_send(struct mei_cl
*cl
, u8
*buf
, size_t length
,
46 struct mei_device
*bus
;
47 struct mei_cl_cb
*cb
= NULL
;
50 if (WARN_ON(!cl
|| !cl
->dev
))
55 mutex_lock(&bus
->device_lock
);
56 if (!mei_cl_is_connected(cl
)) {
61 /* Check if we have an ME client device */
62 if (!mei_me_cl_is_active(cl
->me_cl
)) {
67 if (length
> mei_cl_mtu(cl
)) {
72 cb
= mei_cl_alloc_cb(cl
, length
, MEI_FOP_WRITE
, NULL
);
78 memcpy(cb
->buf
.data
, buf
, length
);
80 rets
= mei_cl_write(cl
, cb
, blocking
);
83 mutex_unlock(&bus
->device_lock
);
91 * __mei_cl_recv - internal client receive (read)
94 * @buf: buffer to send
95 * @length: buffer length
97 * Return: read size in bytes of < 0 on error
99 ssize_t
__mei_cl_recv(struct mei_cl
*cl
, u8
*buf
, size_t length
)
101 struct mei_device
*bus
;
102 struct mei_cl_cb
*cb
;
106 if (WARN_ON(!cl
|| !cl
->dev
))
111 mutex_lock(&bus
->device_lock
);
113 cb
= mei_cl_read_cb(cl
, NULL
);
117 rets
= mei_cl_read_start(cl
, length
, NULL
);
118 if (rets
&& rets
!= -EBUSY
)
121 /* wait on event only if there is no other waiter */
122 if (list_empty(&cl
->rd_completed
) && !waitqueue_active(&cl
->rx_wait
)) {
124 mutex_unlock(&bus
->device_lock
);
126 if (wait_event_interruptible(cl
->rx_wait
,
127 (!list_empty(&cl
->rd_completed
)) ||
128 (!mei_cl_is_connected(cl
)))) {
130 if (signal_pending(current
))
135 mutex_lock(&bus
->device_lock
);
137 if (!mei_cl_is_connected(cl
)) {
143 cb
= mei_cl_read_cb(cl
, NULL
);
155 r_length
= min_t(size_t, length
, cb
->buf_idx
);
156 memcpy(buf
, cb
->buf
.data
, r_length
);
162 mutex_unlock(&bus
->device_lock
);
168 * mei_cl_send - me device send (write)
170 * @cldev: me client device
171 * @buf: buffer to send
172 * @length: buffer length
174 * Return: written size in bytes or < 0 on error
176 ssize_t
mei_cl_send(struct mei_cl_device
*cldev
, u8
*buf
, size_t length
)
178 struct mei_cl
*cl
= cldev
->cl
;
183 return __mei_cl_send(cl
, buf
, length
, 1);
185 EXPORT_SYMBOL_GPL(mei_cl_send
);
188 * mei_cl_recv - client receive (read)
190 * @cldev: me client device
191 * @buf: buffer to send
192 * @length: buffer length
194 * Return: read size in bytes of < 0 on error
196 ssize_t
mei_cl_recv(struct mei_cl_device
*cldev
, u8
*buf
, size_t length
)
198 struct mei_cl
*cl
= cldev
->cl
;
203 return __mei_cl_recv(cl
, buf
, length
);
205 EXPORT_SYMBOL_GPL(mei_cl_recv
);
208 * mei_bus_event_work - dispatch rx event for a bus device
209 * and schedule new work
213 static void mei_bus_event_work(struct work_struct
*work
)
215 struct mei_cl_device
*cldev
;
217 cldev
= container_of(work
, struct mei_cl_device
, event_work
);
220 cldev
->event_cb(cldev
, cldev
->events
, cldev
->event_context
);
224 /* Prepare for the next read */
225 if (cldev
->events_mask
& BIT(MEI_CL_EVENT_RX
))
226 mei_cl_read_start(cldev
->cl
, 0, NULL
);
230 * mei_cl_bus_notify_event - schedule notify cb on bus client
234 void mei_cl_bus_notify_event(struct mei_cl
*cl
)
236 struct mei_cl_device
*cldev
= cl
->cldev
;
238 if (!cldev
|| !cldev
->event_cb
)
241 if (!(cldev
->events_mask
& BIT(MEI_CL_EVENT_NOTIF
)))
247 set_bit(MEI_CL_EVENT_NOTIF
, &cldev
->events
);
249 schedule_work(&cldev
->event_work
);
251 cl
->notify_ev
= false;
255 * mei_cl_bus_rx_event - schedule rx evenet
259 void mei_cl_bus_rx_event(struct mei_cl
*cl
)
261 struct mei_cl_device
*cldev
= cl
->cldev
;
263 if (!cldev
|| !cldev
->event_cb
)
266 if (!(cldev
->events_mask
& BIT(MEI_CL_EVENT_RX
)))
269 set_bit(MEI_CL_EVENT_RX
, &cldev
->events
);
271 schedule_work(&cldev
->event_work
);
275 * mei_cl_register_event_cb - register event callback
277 * @cldev: me client devices
278 * @event_cb: callback function
279 * @events_mask: requested events bitmask
280 * @context: driver context data
282 * Return: 0 on success
283 * -EALREADY if an callback is already registered
286 int mei_cl_register_event_cb(struct mei_cl_device
*cldev
,
287 unsigned long events_mask
,
288 mei_cl_event_cb_t event_cb
, void *context
)
296 cldev
->events_mask
= events_mask
;
297 cldev
->event_cb
= event_cb
;
298 cldev
->event_context
= context
;
299 INIT_WORK(&cldev
->event_work
, mei_bus_event_work
);
301 if (cldev
->events_mask
& BIT(MEI_CL_EVENT_RX
)) {
302 ret
= mei_cl_read_start(cldev
->cl
, 0, NULL
);
303 if (ret
&& ret
!= -EBUSY
)
307 if (cldev
->events_mask
& BIT(MEI_CL_EVENT_NOTIF
)) {
308 mutex_lock(&cldev
->cl
->dev
->device_lock
);
309 ret
= mei_cl_notify_request(cldev
->cl
, NULL
, event_cb
? 1 : 0);
310 mutex_unlock(&cldev
->cl
->dev
->device_lock
);
317 EXPORT_SYMBOL_GPL(mei_cl_register_event_cb
);
320 * mei_cl_get_drvdata - driver data getter
322 * @cldev: mei client device
324 * Return: driver private data
326 void *mei_cl_get_drvdata(const struct mei_cl_device
*cldev
)
328 return dev_get_drvdata(&cldev
->dev
);
330 EXPORT_SYMBOL_GPL(mei_cl_get_drvdata
);
333 * mei_cl_set_drvdata - driver data setter
335 * @cldev: mei client device
336 * @data: data to store
338 void mei_cl_set_drvdata(struct mei_cl_device
*cldev
, void *data
)
340 dev_set_drvdata(&cldev
->dev
, data
);
342 EXPORT_SYMBOL_GPL(mei_cl_set_drvdata
);
345 * mei_cl_enable_device - enable me client device
346 * create connection with me client
348 * @cldev: me client device
350 * Return: 0 on success and < 0 on error
352 int mei_cl_enable_device(struct mei_cl_device
*cldev
)
354 struct mei_device
*bus
= cldev
->bus
;
361 mutex_lock(&bus
->device_lock
);
362 cl
= mei_cl_alloc_linked(bus
, MEI_HOST_CLIENT_ID_ANY
);
363 mutex_unlock(&bus
->device_lock
);
366 /* update pointers */
371 mutex_lock(&bus
->device_lock
);
372 if (mei_cl_is_connected(cl
)) {
377 if (!mei_me_cl_is_active(cldev
->me_cl
)) {
378 dev_err(&cldev
->dev
, "me client is not active\n");
383 ret
= mei_cl_connect(cl
, cldev
->me_cl
, NULL
);
385 dev_err(&cldev
->dev
, "cannot connect\n");
388 mutex_unlock(&bus
->device_lock
);
392 EXPORT_SYMBOL_GPL(mei_cl_enable_device
);
395 * mei_cl_disable_device - disable me client device
396 * disconnect form the me client
398 * @cldev: me client device
400 * Return: 0 on success and < 0 on error
402 int mei_cl_disable_device(struct mei_cl_device
*cldev
)
404 struct mei_device
*bus
;
408 if (!cldev
|| !cldev
->cl
)
415 cldev
->event_cb
= NULL
;
417 mutex_lock(&bus
->device_lock
);
419 if (!mei_cl_is_connected(cl
)) {
420 dev_err(bus
->dev
, "Already disconnected");
425 err
= mei_cl_disconnect(cl
);
427 dev_err(bus
->dev
, "Could not disconnect from the ME client");
430 /* Flush queues and remove any pending read */
431 mei_cl_flush_queues(cl
, NULL
);
437 mutex_unlock(&bus
->device_lock
);
440 EXPORT_SYMBOL_GPL(mei_cl_disable_device
);
443 * mei_cl_device_find - find matching entry in the driver id table
445 * @cldev: me client device
446 * @cldrv: me client driver
448 * Return: id on success; NULL if no id is matching
451 struct mei_cl_device_id
*mei_cl_device_find(struct mei_cl_device
*cldev
,
452 struct mei_cl_driver
*cldrv
)
454 const struct mei_cl_device_id
*id
;
457 uuid
= mei_me_cl_uuid(cldev
->me_cl
);
459 id
= cldrv
->id_table
;
460 while (uuid_le_cmp(NULL_UUID_LE
, id
->uuid
)) {
461 if (!uuid_le_cmp(*uuid
, id
->uuid
)) {
466 if (!strncmp(cldev
->name
, id
->name
, sizeof(id
->name
)))
477 * mei_cl_device_match - device match function
482 * Return: 1 if matching device was found 0 otherwise
484 static int mei_cl_device_match(struct device
*dev
, struct device_driver
*drv
)
486 struct mei_cl_device
*cldev
= to_mei_cl_device(dev
);
487 struct mei_cl_driver
*cldrv
= to_mei_cl_driver(drv
);
488 const struct mei_cl_device_id
*found_id
;
493 if (!cldev
->do_match
)
496 if (!cldrv
|| !cldrv
->id_table
)
499 found_id
= mei_cl_device_find(cldev
, cldrv
);
507 * mei_cl_device_probe - bus probe function
511 * Return: 0 on success; < 0 otherwise
513 static int mei_cl_device_probe(struct device
*dev
)
515 struct mei_cl_device
*cldev
;
516 struct mei_cl_driver
*cldrv
;
517 const struct mei_cl_device_id
*id
;
519 cldev
= to_mei_cl_device(dev
);
520 cldrv
= to_mei_cl_driver(dev
->driver
);
525 if (!cldrv
|| !cldrv
->probe
)
528 id
= mei_cl_device_find(cldev
, cldrv
);
532 __module_get(THIS_MODULE
);
534 return cldrv
->probe(cldev
, id
);
538 * mei_cl_device_remove - remove device from the bus
542 * Return: 0 on success; < 0 otherwise
544 static int mei_cl_device_remove(struct device
*dev
)
546 struct mei_cl_device
*cldev
= to_mei_cl_device(dev
);
547 struct mei_cl_driver
*cldrv
;
550 if (!cldev
|| !dev
->driver
)
553 if (cldev
->event_cb
) {
554 cldev
->event_cb
= NULL
;
555 cancel_work_sync(&cldev
->event_work
);
558 cldrv
= to_mei_cl_driver(dev
->driver
);
560 ret
= cldrv
->remove(cldev
);
562 module_put(THIS_MODULE
);
568 static ssize_t
name_show(struct device
*dev
, struct device_attribute
*a
,
571 struct mei_cl_device
*cldev
= to_mei_cl_device(dev
);
574 len
= snprintf(buf
, PAGE_SIZE
, "%s", cldev
->name
);
576 return (len
>= PAGE_SIZE
) ? (PAGE_SIZE
- 1) : len
;
578 static DEVICE_ATTR_RO(name
);
580 static ssize_t
uuid_show(struct device
*dev
, struct device_attribute
*a
,
583 struct mei_cl_device
*cldev
= to_mei_cl_device(dev
);
584 const uuid_le
*uuid
= mei_me_cl_uuid(cldev
->me_cl
);
587 len
= snprintf(buf
, PAGE_SIZE
, "%pUl", uuid
);
589 return (len
>= PAGE_SIZE
) ? (PAGE_SIZE
- 1) : len
;
591 static DEVICE_ATTR_RO(uuid
);
593 static ssize_t
modalias_show(struct device
*dev
, struct device_attribute
*a
,
596 struct mei_cl_device
*cldev
= to_mei_cl_device(dev
);
597 const uuid_le
*uuid
= mei_me_cl_uuid(cldev
->me_cl
);
600 len
= snprintf(buf
, PAGE_SIZE
, "mei:%s:" MEI_CL_UUID_FMT
":",
601 cldev
->name
, MEI_CL_UUID_ARGS(uuid
->b
));
603 return (len
>= PAGE_SIZE
) ? (PAGE_SIZE
- 1) : len
;
605 static DEVICE_ATTR_RO(modalias
);
607 static struct attribute
*mei_cl_dev_attrs
[] = {
610 &dev_attr_modalias
.attr
,
613 ATTRIBUTE_GROUPS(mei_cl_dev
);
616 * mei_cl_device_uevent - me client bus uevent handler
619 * @env: uevent kobject
621 * Return: 0 on success -ENOMEM on when add_uevent_var fails
623 static int mei_cl_device_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
625 struct mei_cl_device
*cldev
= to_mei_cl_device(dev
);
626 const uuid_le
*uuid
= mei_me_cl_uuid(cldev
->me_cl
);
628 if (add_uevent_var(env
, "MEI_CL_UUID=%pUl", uuid
))
631 if (add_uevent_var(env
, "MEI_CL_NAME=%s", cldev
->name
))
634 if (add_uevent_var(env
, "MODALIAS=mei:%s:" MEI_CL_UUID_FMT
":",
635 cldev
->name
, MEI_CL_UUID_ARGS(uuid
->b
)))
641 static struct bus_type mei_cl_bus_type
= {
643 .dev_groups
= mei_cl_dev_groups
,
644 .match
= mei_cl_device_match
,
645 .probe
= mei_cl_device_probe
,
646 .remove
= mei_cl_device_remove
,
647 .uevent
= mei_cl_device_uevent
,
650 static struct mei_device
*mei_dev_bus_get(struct mei_device
*bus
)
653 get_device(bus
->dev
);
658 static void mei_dev_bus_put(struct mei_device
*bus
)
661 put_device(bus
->dev
);
664 static void mei_cl_dev_release(struct device
*dev
)
666 struct mei_cl_device
*cldev
= to_mei_cl_device(dev
);
671 mei_me_cl_put(cldev
->me_cl
);
672 mei_dev_bus_put(cldev
->bus
);
676 static struct device_type mei_cl_device_type
= {
677 .release
= mei_cl_dev_release
,
681 * mei_cl_dev_alloc - initialize and allocate mei client device
686 * Return: allocated device structur or NULL on allocation failure
688 static struct mei_cl_device
*mei_cl_dev_alloc(struct mei_device
*bus
,
689 struct mei_me_client
*me_cl
)
691 struct mei_cl_device
*cldev
;
693 cldev
= kzalloc(sizeof(struct mei_cl_device
), GFP_KERNEL
);
697 device_initialize(&cldev
->dev
);
698 cldev
->dev
.parent
= bus
->dev
;
699 cldev
->dev
.bus
= &mei_cl_bus_type
;
700 cldev
->dev
.type
= &mei_cl_device_type
;
701 cldev
->bus
= mei_dev_bus_get(bus
);
702 cldev
->me_cl
= mei_me_cl_get(me_cl
);
704 INIT_LIST_HEAD(&cldev
->bus_list
);
710 * mei_cl_dev_setup - setup me client device
711 * run fix up routines and set the device name
714 * @cldev: me client device
716 * Return: true if the device is eligible for enumeration
718 static bool mei_cl_dev_setup(struct mei_device
*bus
,
719 struct mei_cl_device
*cldev
)
722 mei_cl_dev_fixup(cldev
);
725 dev_set_name(&cldev
->dev
, "mei:%s:%pUl",
726 cldev
->name
, mei_me_cl_uuid(cldev
->me_cl
));
728 return cldev
->do_match
== 1;
732 * mei_cl_bus_dev_add - add me client devices
734 * @cldev: me client device
736 * Return: 0 on success; < 0 on failre
738 static int mei_cl_bus_dev_add(struct mei_cl_device
*cldev
)
742 dev_dbg(cldev
->bus
->dev
, "adding %pUL\n", mei_me_cl_uuid(cldev
->me_cl
));
743 ret
= device_add(&cldev
->dev
);
751 * mei_cl_bus_dev_stop - stop the driver
753 * @cldev: me client device
755 static void mei_cl_bus_dev_stop(struct mei_cl_device
*cldev
)
758 device_release_driver(&cldev
->dev
);
762 * mei_cl_bus_dev_destroy - destroy me client devices object
764 * @cldev: me client device
766 static void mei_cl_bus_dev_destroy(struct mei_cl_device
*cldev
)
768 if (!cldev
->is_added
)
771 device_del(&cldev
->dev
);
773 mutex_lock(&cldev
->bus
->cl_bus_lock
);
774 list_del_init(&cldev
->bus_list
);
775 mutex_unlock(&cldev
->bus
->cl_bus_lock
);
778 put_device(&cldev
->dev
);
782 * mei_cl_bus_remove_device - remove a devices form the bus
784 * @cldev: me client device
786 static void mei_cl_bus_remove_device(struct mei_cl_device
*cldev
)
788 mei_cl_bus_dev_stop(cldev
);
789 mei_cl_bus_dev_destroy(cldev
);
793 * mei_cl_bus_remove_devices - remove all devices form the bus
797 void mei_cl_bus_remove_devices(struct mei_device
*bus
)
799 struct mei_cl_device
*cldev
, *next
;
801 list_for_each_entry_safe(cldev
, next
, &bus
->device_list
, bus_list
)
802 mei_cl_bus_remove_device(cldev
);
807 * mei_cl_dev_init - allocate and initializes an mei client devices
813 static void mei_cl_dev_init(struct mei_device
*bus
, struct mei_me_client
*me_cl
)
815 struct mei_cl_device
*cldev
;
817 dev_dbg(bus
->dev
, "initializing %pUl", mei_me_cl_uuid(me_cl
));
819 if (me_cl
->bus_added
)
822 cldev
= mei_cl_dev_alloc(bus
, me_cl
);
826 mutex_lock(&cldev
->bus
->cl_bus_lock
);
827 me_cl
->bus_added
= true;
828 list_add_tail(&cldev
->bus_list
, &bus
->device_list
);
829 mutex_unlock(&cldev
->bus
->cl_bus_lock
);
834 * mei_cl_bus_rescan - scan me clients list and add create
835 * devices for eligible clients
839 void mei_cl_bus_rescan(struct mei_device
*bus
)
841 struct mei_cl_device
*cldev
, *n
;
842 struct mei_me_client
*me_cl
;
844 down_read(&bus
->me_clients_rwsem
);
845 list_for_each_entry(me_cl
, &bus
->me_clients
, list
)
846 mei_cl_dev_init(bus
, me_cl
);
847 up_read(&bus
->me_clients_rwsem
);
849 mutex_lock(&bus
->cl_bus_lock
);
850 list_for_each_entry_safe(cldev
, n
, &bus
->device_list
, bus_list
) {
852 if (!mei_me_cl_is_active(cldev
->me_cl
)) {
853 mei_cl_bus_remove_device(cldev
);
860 if (mei_cl_dev_setup(bus
, cldev
))
861 mei_cl_bus_dev_add(cldev
);
863 list_del_init(&cldev
->bus_list
);
864 put_device(&cldev
->dev
);
867 mutex_unlock(&bus
->cl_bus_lock
);
869 dev_dbg(bus
->dev
, "rescan end");
872 int __mei_cl_driver_register(struct mei_cl_driver
*cldrv
, struct module
*owner
)
876 cldrv
->driver
.name
= cldrv
->name
;
877 cldrv
->driver
.owner
= owner
;
878 cldrv
->driver
.bus
= &mei_cl_bus_type
;
880 err
= driver_register(&cldrv
->driver
);
884 pr_debug("mei: driver [%s] registered\n", cldrv
->driver
.name
);
888 EXPORT_SYMBOL_GPL(__mei_cl_driver_register
);
890 void mei_cl_driver_unregister(struct mei_cl_driver
*cldrv
)
892 driver_unregister(&cldrv
->driver
);
894 pr_debug("mei: driver [%s] unregistered\n", cldrv
->driver
.name
);
896 EXPORT_SYMBOL_GPL(mei_cl_driver_unregister
);
899 int __init
mei_cl_bus_init(void)
901 return bus_register(&mei_cl_bus_type
);
904 void __exit
mei_cl_bus_exit(void)
906 bus_unregister(&mei_cl_bus_type
);