x86/xen: resume timer irqs early
[linux/fpc-iii.git] / drivers / misc / mei / bus.c
blobcd2033cd7120d7631fa8d345409ed9ea86259799
1 /*
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
12 * more details.
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/pci.h>
26 #include <linux/mei_cl_bus.h>
28 #include "mei_dev.h"
29 #include "hw-me.h"
30 #include "client.h"
32 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver)
33 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev)
35 static int mei_cl_device_match(struct device *dev, struct device_driver *drv)
37 struct mei_cl_device *device = to_mei_cl_device(dev);
38 struct mei_cl_driver *driver = to_mei_cl_driver(drv);
39 const struct mei_cl_device_id *id;
41 if (!device)
42 return 0;
44 if (!driver || !driver->id_table)
45 return 0;
47 id = driver->id_table;
49 while (id->name[0]) {
50 if (!strncmp(dev_name(dev), id->name, sizeof(id->name)))
51 return 1;
53 id++;
56 return 0;
59 static int mei_cl_device_probe(struct device *dev)
61 struct mei_cl_device *device = to_mei_cl_device(dev);
62 struct mei_cl_driver *driver;
63 struct mei_cl_device_id id;
65 if (!device)
66 return 0;
68 driver = to_mei_cl_driver(dev->driver);
69 if (!driver || !driver->probe)
70 return -ENODEV;
72 dev_dbg(dev, "Device probe\n");
74 strncpy(id.name, dev_name(dev), sizeof(id.name));
76 return driver->probe(device, &id);
79 static int mei_cl_device_remove(struct device *dev)
81 struct mei_cl_device *device = to_mei_cl_device(dev);
82 struct mei_cl_driver *driver;
84 if (!device || !dev->driver)
85 return 0;
87 if (device->event_cb) {
88 device->event_cb = NULL;
89 cancel_work_sync(&device->event_work);
92 driver = to_mei_cl_driver(dev->driver);
93 if (!driver->remove) {
94 dev->driver = NULL;
96 return 0;
99 return driver->remove(device);
102 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
103 char *buf)
105 int len;
107 len = snprintf(buf, PAGE_SIZE, "mei:%s\n", dev_name(dev));
109 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
111 static DEVICE_ATTR_RO(modalias);
113 static struct attribute *mei_cl_dev_attrs[] = {
114 &dev_attr_modalias.attr,
115 NULL,
117 ATTRIBUTE_GROUPS(mei_cl_dev);
119 static int mei_cl_uevent(struct device *dev, struct kobj_uevent_env *env)
121 if (add_uevent_var(env, "MODALIAS=mei:%s", dev_name(dev)))
122 return -ENOMEM;
124 return 0;
127 static struct bus_type mei_cl_bus_type = {
128 .name = "mei",
129 .dev_groups = mei_cl_dev_groups,
130 .match = mei_cl_device_match,
131 .probe = mei_cl_device_probe,
132 .remove = mei_cl_device_remove,
133 .uevent = mei_cl_uevent,
136 static void mei_cl_dev_release(struct device *dev)
138 kfree(to_mei_cl_device(dev));
141 static struct device_type mei_cl_device_type = {
142 .release = mei_cl_dev_release,
145 static struct mei_cl *mei_bus_find_mei_cl_by_uuid(struct mei_device *dev,
146 uuid_le uuid)
148 struct mei_cl *cl, *next;
150 list_for_each_entry_safe(cl, next, &dev->device_list, device_link) {
151 if (!uuid_le_cmp(uuid, cl->device_uuid))
152 return cl;
155 return NULL;
157 struct mei_cl_device *mei_cl_add_device(struct mei_device *dev,
158 uuid_le uuid, char *name,
159 struct mei_cl_ops *ops)
161 struct mei_cl_device *device;
162 struct mei_cl *cl;
163 int status;
165 cl = mei_bus_find_mei_cl_by_uuid(dev, uuid);
166 if (cl == NULL)
167 return NULL;
169 device = kzalloc(sizeof(struct mei_cl_device), GFP_KERNEL);
170 if (!device)
171 return NULL;
173 device->cl = cl;
174 device->ops = ops;
176 device->dev.parent = &dev->pdev->dev;
177 device->dev.bus = &mei_cl_bus_type;
178 device->dev.type = &mei_cl_device_type;
180 dev_set_name(&device->dev, "%s", name);
182 status = device_register(&device->dev);
183 if (status) {
184 dev_err(&dev->pdev->dev, "Failed to register MEI device\n");
185 kfree(device);
186 return NULL;
189 cl->device = device;
191 dev_dbg(&device->dev, "client %s registered\n", name);
193 return device;
195 EXPORT_SYMBOL_GPL(mei_cl_add_device);
197 void mei_cl_remove_device(struct mei_cl_device *device)
199 device_unregister(&device->dev);
201 EXPORT_SYMBOL_GPL(mei_cl_remove_device);
203 int __mei_cl_driver_register(struct mei_cl_driver *driver, struct module *owner)
205 int err;
207 driver->driver.name = driver->name;
208 driver->driver.owner = owner;
209 driver->driver.bus = &mei_cl_bus_type;
211 err = driver_register(&driver->driver);
212 if (err)
213 return err;
215 pr_debug("mei: driver [%s] registered\n", driver->driver.name);
217 return 0;
219 EXPORT_SYMBOL_GPL(__mei_cl_driver_register);
221 void mei_cl_driver_unregister(struct mei_cl_driver *driver)
223 driver_unregister(&driver->driver);
225 pr_debug("mei: driver [%s] unregistered\n", driver->driver.name);
227 EXPORT_SYMBOL_GPL(mei_cl_driver_unregister);
229 static int ___mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length,
230 bool blocking)
232 struct mei_device *dev;
233 struct mei_cl_cb *cb;
234 int id;
235 int rets;
237 if (WARN_ON(!cl || !cl->dev))
238 return -ENODEV;
240 dev = cl->dev;
242 if (cl->state != MEI_FILE_CONNECTED)
243 return -ENODEV;
245 /* Check if we have an ME client device */
246 id = mei_me_cl_by_id(dev, cl->me_client_id);
247 if (id < 0)
248 return -ENODEV;
250 if (length > dev->me_clients[id].props.max_msg_length)
251 return -EINVAL;
253 cb = mei_io_cb_init(cl, NULL);
254 if (!cb)
255 return -ENOMEM;
257 rets = mei_io_cb_alloc_req_buf(cb, length);
258 if (rets < 0) {
259 mei_io_cb_free(cb);
260 return rets;
263 memcpy(cb->request_buffer.data, buf, length);
265 mutex_lock(&dev->device_lock);
267 rets = mei_cl_write(cl, cb, blocking);
269 mutex_unlock(&dev->device_lock);
270 if (rets < 0)
271 mei_io_cb_free(cb);
273 return rets;
276 int __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length)
278 struct mei_device *dev;
279 struct mei_cl_cb *cb;
280 size_t r_length;
281 int err;
283 if (WARN_ON(!cl || !cl->dev))
284 return -ENODEV;
286 dev = cl->dev;
288 mutex_lock(&dev->device_lock);
290 if (!cl->read_cb) {
291 err = mei_cl_read_start(cl, length);
292 if (err < 0) {
293 mutex_unlock(&dev->device_lock);
294 return err;
298 if (cl->reading_state != MEI_READ_COMPLETE &&
299 !waitqueue_active(&cl->rx_wait)) {
301 mutex_unlock(&dev->device_lock);
303 if (wait_event_interruptible(cl->rx_wait,
304 cl->reading_state == MEI_READ_COMPLETE ||
305 mei_cl_is_transitioning(cl))) {
307 if (signal_pending(current))
308 return -EINTR;
309 return -ERESTARTSYS;
312 mutex_lock(&dev->device_lock);
315 cb = cl->read_cb;
317 if (cl->reading_state != MEI_READ_COMPLETE) {
318 r_length = 0;
319 goto out;
322 r_length = min_t(size_t, length, cb->buf_idx);
324 memcpy(buf, cb->response_buffer.data, r_length);
326 mei_io_cb_free(cb);
327 cl->reading_state = MEI_IDLE;
328 cl->read_cb = NULL;
330 out:
331 mutex_unlock(&dev->device_lock);
333 return r_length;
336 inline int __mei_cl_async_send(struct mei_cl *cl, u8 *buf, size_t length)
338 return ___mei_cl_send(cl, buf, length, 0);
341 inline int __mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length)
343 return ___mei_cl_send(cl, buf, length, 1);
346 int mei_cl_send(struct mei_cl_device *device, u8 *buf, size_t length)
348 struct mei_cl *cl = device->cl;
350 if (cl == NULL)
351 return -ENODEV;
353 if (device->ops && device->ops->send)
354 return device->ops->send(device, buf, length);
356 return __mei_cl_send(cl, buf, length);
358 EXPORT_SYMBOL_GPL(mei_cl_send);
360 int mei_cl_recv(struct mei_cl_device *device, u8 *buf, size_t length)
362 struct mei_cl *cl = device->cl;
364 if (cl == NULL)
365 return -ENODEV;
367 if (device->ops && device->ops->recv)
368 return device->ops->recv(device, buf, length);
370 return __mei_cl_recv(cl, buf, length);
372 EXPORT_SYMBOL_GPL(mei_cl_recv);
374 static void mei_bus_event_work(struct work_struct *work)
376 struct mei_cl_device *device;
378 device = container_of(work, struct mei_cl_device, event_work);
380 if (device->event_cb)
381 device->event_cb(device, device->events, device->event_context);
383 device->events = 0;
385 /* Prepare for the next read */
386 mei_cl_read_start(device->cl, 0);
389 int mei_cl_register_event_cb(struct mei_cl_device *device,
390 mei_cl_event_cb_t event_cb, void *context)
392 if (device->event_cb)
393 return -EALREADY;
395 device->events = 0;
396 device->event_cb = event_cb;
397 device->event_context = context;
398 INIT_WORK(&device->event_work, mei_bus_event_work);
400 mei_cl_read_start(device->cl, 0);
402 return 0;
404 EXPORT_SYMBOL_GPL(mei_cl_register_event_cb);
406 void *mei_cl_get_drvdata(const struct mei_cl_device *device)
408 return dev_get_drvdata(&device->dev);
410 EXPORT_SYMBOL_GPL(mei_cl_get_drvdata);
412 void mei_cl_set_drvdata(struct mei_cl_device *device, void *data)
414 dev_set_drvdata(&device->dev, data);
416 EXPORT_SYMBOL_GPL(mei_cl_set_drvdata);
418 int mei_cl_enable_device(struct mei_cl_device *device)
420 int err;
421 struct mei_device *dev;
422 struct mei_cl *cl = device->cl;
424 if (cl == NULL)
425 return -ENODEV;
427 dev = cl->dev;
429 mutex_lock(&dev->device_lock);
431 cl->state = MEI_FILE_CONNECTING;
433 err = mei_cl_connect(cl, NULL);
434 if (err < 0) {
435 mutex_unlock(&dev->device_lock);
436 dev_err(&dev->pdev->dev, "Could not connect to the ME client");
438 return err;
441 mutex_unlock(&dev->device_lock);
443 if (device->event_cb && !cl->read_cb)
444 mei_cl_read_start(device->cl, 0);
446 if (!device->ops || !device->ops->enable)
447 return 0;
449 return device->ops->enable(device);
451 EXPORT_SYMBOL_GPL(mei_cl_enable_device);
453 int mei_cl_disable_device(struct mei_cl_device *device)
455 int err;
456 struct mei_device *dev;
457 struct mei_cl *cl = device->cl;
459 if (cl == NULL)
460 return -ENODEV;
462 dev = cl->dev;
464 mutex_lock(&dev->device_lock);
466 if (cl->state != MEI_FILE_CONNECTED) {
467 mutex_unlock(&dev->device_lock);
468 dev_err(&dev->pdev->dev, "Already disconnected");
470 return 0;
473 cl->state = MEI_FILE_DISCONNECTING;
475 err = mei_cl_disconnect(cl);
476 if (err < 0) {
477 mutex_unlock(&dev->device_lock);
478 dev_err(&dev->pdev->dev,
479 "Could not disconnect from the ME client");
481 return err;
484 /* Flush queues and remove any pending read */
485 mei_cl_flush_queues(cl);
487 if (cl->read_cb) {
488 struct mei_cl_cb *cb = NULL;
490 cb = mei_cl_find_read_cb(cl);
491 /* Remove entry from read list */
492 if (cb)
493 list_del(&cb->list);
495 cb = cl->read_cb;
496 cl->read_cb = NULL;
498 if (cb) {
499 mei_io_cb_free(cb);
500 cb = NULL;
504 device->event_cb = NULL;
506 mutex_unlock(&dev->device_lock);
508 if (!device->ops || !device->ops->disable)
509 return 0;
511 return device->ops->disable(device);
513 EXPORT_SYMBOL_GPL(mei_cl_disable_device);
515 void mei_cl_bus_rx_event(struct mei_cl *cl)
517 struct mei_cl_device *device = cl->device;
519 if (!device || !device->event_cb)
520 return;
522 set_bit(MEI_CL_EVENT_RX, &device->events);
524 schedule_work(&device->event_work);
527 int __init mei_cl_bus_init(void)
529 return bus_register(&mei_cl_bus_type);
532 void __exit mei_cl_bus_exit(void)
534 bus_unregister(&mei_cl_bus_type);