Skip to content

L
linux
Commit 62382997 authored by Tomas Winkler's avatar Tomas Winkler Committed by Greg Kroah-Hartman
Browse files
Options

mei: bus: move driver api functions at the start of the file 

To make the file more organize move mei client driver api
to the start of the file and add Kdoc.

There are no functional changes in this patch.
Signed-off-by: default avatarTomas Winkler <tomas.winkler@intel.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent a0a785c4
Hide whitespace changes
Inline Side-by-side
Showing with 444 additions and 355 deletions
drivers/misc/mei/bus.c
View file @ 62382997
...@@ -30,527 +30,616 @@ ...@@ -30,527 +30,616 @@
#define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver)
#define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev)
static int mei_cl_device_match(struct device *dev, struct device_driver *drv) /**
* __mei_cl_send - internal client send (write)
*
* @cl: host client
* @buf: buffer to send
* @length: buffer length
* @blocking: wait for write completion
*
* Return: written size bytes or < 0 on error
*/
ssize_t __mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length,
bool blocking)
{ {
struct mei_cl_device *cldev = to_mei_cl_device(dev); struct mei_device *bus;
struct mei_cl_driver *cldrv = to_mei_cl_driver(drv); struct mei_cl_cb *cb = NULL;
const struct mei_cl_device_id *id; ssize_t rets;
const uuid_le *uuid;
const char *name;
if (!cldev)
return 0;
uuid = mei_me_cl_uuid(cldev->me_cl); if (WARN_ON(!cl || !cl->dev))
name = cldev->name; return -ENODEV;
if (!cldrv || !cldrv->id_table) bus = cl->dev;
return 0;
id = cldrv->id_table; mutex_lock(&bus->device_lock);
if (!mei_cl_is_connected(cl)) {
rets = -ENODEV;
goto out;
}
while (uuid_le_cmp(NULL_UUID_LE, id->uuid)) { /* Check if we have an ME client device */
if (!mei_me_cl_is_active(cl->me_cl)) {
rets = -ENOTTY;
goto out;
}
if (!uuid_le_cmp(*uuid, id->uuid)) { if (length > mei_cl_mtu(cl)) {
if (id->name[0]) { rets = -EFBIG;
if (!strncmp(name, id->name, sizeof(id->name))) goto out;
return 1; }
} else {
return 1;
}
}
id++; cb = mei_cl_alloc_cb(cl, length, MEI_FOP_WRITE, NULL);
if (!cb) {
rets = -ENOMEM;
goto out;
} }
return 0; memcpy(cb->buf.data, buf, length);
rets = mei_cl_write(cl, cb, blocking);
out:
mutex_unlock(&bus->device_lock);
if (rets < 0)
mei_io_cb_free(cb);
return rets;
} }
static int mei_cl_device_probe(struct device *dev) /**
* __mei_cl_recv - internal client receive (read)
*
* @cl: host client
* @buf: buffer to send
* @length: buffer length
*
* Return: read size in bytes of < 0 on error
*/
ssize_t __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length)
{ {
struct mei_cl_device *cldev = to_mei_cl_device(dev); struct mei_device *bus;
struct mei_cl_driver *cldrv; struct mei_cl_cb *cb;
struct mei_cl_device_id id; size_t r_length;
ssize_t rets;
if (!cldev)
return 0;
cldrv = to_mei_cl_driver(dev->driver); if (WARN_ON(!cl || !cl->dev))
if (!cldrv || !cldrv->probe)
return -ENODEV; return -ENODEV;
dev_dbg(dev, "Device probe\n"); bus = cl->dev;
strlcpy(id.name, cldev->name, sizeof(id.name)); mutex_lock(&bus->device_lock);
return cldrv->probe(cldev, &id); cb = mei_cl_read_cb(cl, NULL);
} if (cb)
goto copy;
static int mei_cl_device_remove(struct device *dev) rets = mei_cl_read_start(cl, length, NULL);
{ if (rets && rets != -EBUSY)
struct mei_cl_device *cldev = to_mei_cl_device(dev); goto out;
struct mei_cl_driver *cldrv;
if (!cldev || !dev->driver) /* wait on event only if there is no other waiter */
return 0; if (list_empty(&cl->rd_completed) && !waitqueue_active(&cl->rx_wait)) {
if (cldev->event_cb) { mutex_unlock(&bus->device_lock);
cldev->event_cb = NULL;
cancel_work_sync(&cldev->event_work);
}
cldrv = to_mei_cl_driver(dev->driver); if (wait_event_interruptible(cl->rx_wait,
if (!cldrv->remove) { (!list_empty(&cl->rd_completed)) ||
dev->driver = NULL; (!mei_cl_is_connected(cl)))) {
return 0; if (signal_pending(current))
return -EINTR;
return -ERESTARTSYS;
}
mutex_lock(&bus->device_lock);
if (!mei_cl_is_connected(cl)) {
rets = -EBUSY;
goto out;
}
} }
return cldrv->remove(cldev); cb = mei_cl_read_cb(cl, NULL);
} if (!cb) {
rets = 0;
goto out;
}
static ssize_t name_show(struct device *dev, struct device_attribute *a, copy:
char *buf) if (cb->status) {
{ rets = cb->status;
struct mei_cl_device *cldev = to_mei_cl_device(dev); goto free;
size_t len; }
len = snprintf(buf, PAGE_SIZE, "%s", cldev->name); r_length = min_t(size_t, length, cb->buf_idx);
memcpy(buf, cb->buf.data, r_length);
rets = r_length;
return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len; free:
mei_io_cb_free(cb);
out:
mutex_unlock(&bus->device_lock);
return rets;
} }
static DEVICE_ATTR_RO(name);
static ssize_t uuid_show(struct device *dev, struct device_attribute *a, /**
char *buf) * mei_cl_send - me device send (write)
*
* @cldev: me client device
* @buf: buffer to send
* @length: buffer length
*
* Return: written size in bytes or < 0 on error
*/
ssize_t mei_cl_send(struct mei_cl_device *cldev, u8 *buf, size_t length)
{ {
struct mei_cl_device *cldev = to_mei_cl_device(dev); struct mei_cl *cl = cldev->cl;
const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl);
size_t len;
len = snprintf(buf, PAGE_SIZE, "%pUl", uuid); if (cl == NULL)
return -ENODEV;
return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len; return __mei_cl_send(cl, buf, length, 1);
} }
static DEVICE_ATTR_RO(uuid); EXPORT_SYMBOL_GPL(mei_cl_send);
static ssize_t modalias_show(struct device *dev, struct device_attribute *a, /**
char *buf) * mei_cl_recv - client receive (read)
*
* @cldev: me client device
* @buf: buffer to send
* @length: buffer length
*
* Return: read size in bytes of < 0 on error
*/
ssize_t mei_cl_recv(struct mei_cl_device *cldev, u8 *buf, size_t length)
{ {
struct mei_cl_device *cldev = to_mei_cl_device(dev); struct mei_cl *cl = cldev->cl;
const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl);
size_t len;
len = snprintf(buf, PAGE_SIZE, "mei:%s:" MEI_CL_UUID_FMT ":", if (cl == NULL)
cldev->name, MEI_CL_UUID_ARGS(uuid->b)); return -ENODEV;
return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len; return __mei_cl_recv(cl, buf, length);
} }
static DEVICE_ATTR_RO(modalias); EXPORT_SYMBOL_GPL(mei_cl_recv);
static struct attribute *mei_cl_dev_attrs[] = {
&dev_attr_name.attr,
&dev_attr_uuid.attr,
&dev_attr_modalias.attr,
NULL,
};
ATTRIBUTE_GROUPS(mei_cl_dev);
static int mei_cl_uevent(struct device *dev, struct kobj_uevent_env *env) /**
* mei_bus_event_work - dispatch rx event for a bus device
* and schedule new work
*
* @work: work
*/
static void mei_bus_event_work(struct work_struct *work)
{ {
struct mei_cl_device *cldev = to_mei_cl_device(dev); struct mei_cl_device *cldev;
const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl);
if (add_uevent_var(env, "MEI_CL_UUID=%pUl", uuid)) cldev = container_of(work, struct mei_cl_device, event_work);
return -ENOMEM;
if (add_uevent_var(env, "MEI_CL_NAME=%s", cldev->name)) if (cldev->event_cb)
return -ENOMEM; cldev->event_cb(cldev, cldev->events, cldev->event_context);
if (add_uevent_var(env, "MODALIAS=mei:%s:" MEI_CL_UUID_FMT ":", cldev->events = 0;
cldev->name, MEI_CL_UUID_ARGS(uuid->b)))
return -ENOMEM;
return 0; /* Prepare for the next read */
mei_cl_read_start(cldev->cl, 0, NULL);
} }
static struct bus_type mei_cl_bus_type = { /**
.name = "mei", * mei_cl_bus_rx_event - schedule rx evenet
.dev_groups = mei_cl_dev_groups, *
.match = mei_cl_device_match, * @cl: host client
.probe = mei_cl_device_probe, */
.remove = mei_cl_device_remove, void mei_cl_bus_rx_event(struct mei_cl *cl)
.uevent = mei_cl_uevent,
};
static void mei_cl_dev_release(struct device *dev)
{ {
struct mei_cl_device *cldev = to_mei_cl_device(dev); struct mei_cl_device *cldev = cl->cldev;
if (!cldev) if (!cldev || !cldev->event_cb)
return; return;
mei_me_cl_put(cldev->me_cl); set_bit(MEI_CL_EVENT_RX, &cldev->events);
kfree(cldev);
}
static struct device_type mei_cl_device_type = {
.release = mei_cl_dev_release,
};
struct mei_cl *mei_cl_bus_find_cl_by_uuid(struct mei_device *bus,
uuid_le uuid)
{
struct mei_cl *cl;
list_for_each_entry(cl, &bus->device_list, device_link) {
if (cl->cldev && cl->cldev->me_cl &&
!uuid_le_cmp(uuid, *mei_me_cl_uuid(cl->cldev->me_cl)))
return cl;
}
return NULL; schedule_work(&cldev->event_work);
} }
struct mei_cl_device *mei_cl_add_device(struct mei_device *bus, /**
struct mei_me_client *me_cl, * mei_cl_register_event_cb - register event callback
struct mei_cl *cl, *
char *name) * @cldev: me client devices
* @event_cb: callback function
* @context: driver context data
*
* Return: 0 on success
* -EALREADY if an callback is already registered
* <0 on other errors
*/
int mei_cl_register_event_cb(struct mei_cl_device *cldev,
mei_cl_event_cb_t event_cb, void *context)
{ {
struct mei_cl_device *cldev; if (cldev->event_cb)
int status; return -EALREADY;
cldev = kzalloc(sizeof(struct mei_cl_device), GFP_KERNEL);
if (!cldev)
return NULL;
cldev->me_cl = mei_me_cl_get(me_cl);
if (!cldev->me_cl) {
kfree(cldev);
return NULL;
}
cldev->cl = cl;
cldev->dev.parent = bus->dev;
cldev->dev.bus = &mei_cl_bus_type;
cldev->dev.type = &mei_cl_device_type;
strlcpy(cldev->name, name, sizeof(cldev->name));
dev_set_name(&cldev->dev, "mei:%s:%pUl", name, mei_me_cl_uuid(me_cl));
status = device_register(&cldev->dev); cldev->events = 0;
if (status) { cldev->event_cb = event_cb;
dev_err(bus->dev, "Failed to register MEI device\n"); cldev->event_context = context;
mei_me_cl_put(cldev->me_cl); INIT_WORK(&cldev->event_work, mei_bus_event_work);
kfree(cldev);
return NULL;
}
cl->cldev = cldev; mei_cl_read_start(cldev->cl, 0, NULL);
dev_dbg(&cldev->dev, "client %s registered\n", name); return 0;
}
EXPORT_SYMBOL_GPL(mei_cl_register_event_cb);
return cldev; /**
* mei_cl_get_drvdata - driver data getter
*
* @cldev: mei client device
*
* Return: driver private data
*/
void *mei_cl_get_drvdata(const struct mei_cl_device *cldev)
{
return dev_get_drvdata(&cldev->dev);
} }
EXPORT_SYMBOL_GPL(mei_cl_add_device); EXPORT_SYMBOL_GPL(mei_cl_get_drvdata);
void mei_cl_remove_device(struct mei_cl_device *cldev) /**
* mei_cl_set_drvdata - driver data setter
*
* @cldev: mei client device
* @data: data to store
*/
void mei_cl_set_drvdata(struct mei_cl_device *cldev, void *data)
{ {
device_unregister(&cldev->dev); dev_set_drvdata(&cldev->dev, data);
} }
EXPORT_SYMBOL_GPL(mei_cl_remove_device); EXPORT_SYMBOL_GPL(mei_cl_set_drvdata);
int __mei_cl_driver_register(struct mei_cl_driver *cldrv, struct module *owner) /**
* mei_cl_enable_device - enable me client device
* create connection with me client
*
* @cldev: me client device
*
* Return: 0 on success and < 0 on error
*/
int mei_cl_enable_device(struct mei_cl_device *cldev)
{ {
int err; int err;
struct mei_device *bus;
struct mei_cl *cl = cldev->cl;
cldrv->driver.name = cldrv->name; if (cl == NULL)
cldrv->driver.owner = owner; return -ENODEV;
cldrv->driver.bus = &mei_cl_bus_type;
err = driver_register(&cldrv->driver); bus = cl->dev;
if (err)
return err;
pr_debug("mei: driver [%s] registered\n", cldrv->driver.name); mutex_lock(&bus->device_lock);
return 0; if (mei_cl_is_connected(cl)) {
} mutex_unlock(&bus->device_lock);
EXPORT_SYMBOL_GPL(__mei_cl_driver_register); dev_warn(bus->dev, "Already connected");
return -EBUSY;
}
void mei_cl_driver_unregister(struct mei_cl_driver *cldrv) err = mei_cl_connect(cl, cldev->me_cl, NULL);
{ if (err < 0) {
driver_unregister(&cldrv->driver); mutex_unlock(&bus->device_lock);
dev_err(bus->dev, "Could not connect to the ME client");
pr_debug("mei: driver [%s] unregistered\n", cldrv->driver.name); return err;
}
mutex_unlock(&bus->device_lock);
if (cldev->event_cb)
mei_cl_read_start(cldev->cl, 0, NULL);
return 0;
} }
EXPORT_SYMBOL_GPL(mei_cl_driver_unregister); EXPORT_SYMBOL_GPL(mei_cl_enable_device);
ssize_t __mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length, /**
bool blocking) * mei_cl_disable_device - disable me client device
* disconnect form the me client
*
* @cldev: me client device
*
* Return: 0 on success and < 0 on error
*/
int mei_cl_disable_device(struct mei_cl_device *cldev)
{ {
int err;
struct mei_device *bus; struct mei_device *bus;
struct mei_cl_cb *cb = NULL; struct mei_cl *cl = cldev->cl;
ssize_t rets;
if (WARN_ON(!cl || !cl->dev)) if (cl == NULL)
return -ENODEV; return -ENODEV;
bus = cl->dev; bus = cl->dev;
mutex_lock(&bus->device_lock); cldev->event_cb = NULL;
if (!mei_cl_is_connected(cl)) {
rets = -ENODEV;
goto out;
}
/* Check if we have an ME client device */ mutex_lock(&bus->device_lock);
if (!mei_me_cl_is_active(cl->me_cl)) {
rets = -ENOTTY;
goto out;
}
if (length > mei_cl_mtu(cl)) { if (!mei_cl_is_connected(cl)) {
rets = -EFBIG; dev_err(bus->dev, "Already disconnected");
err = 0;
goto out; goto out;
} }
cb = mei_cl_alloc_cb(cl, length, MEI_FOP_WRITE, NULL); err = mei_cl_disconnect(cl);
if (!cb) { if (err < 0) {
rets = -ENOMEM; dev_err(bus->dev, "Could not disconnect from the ME client");
goto out; goto out;
} }
memcpy(cb->buf.data, buf, length); /* Flush queues and remove any pending read */
mei_cl_flush_queues(cl, NULL);
rets = mei_cl_write(cl, cb, blocking);
out: out:
mutex_unlock(&bus->device_lock); mutex_unlock(&bus->device_lock);
if (rets < 0) return err;
mei_io_cb_free(cb);
return rets;
} }
EXPORT_SYMBOL_GPL(mei_cl_disable_device);
ssize_t __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length) static int mei_cl_device_match(struct device *dev, struct device_driver *drv)
{ {
struct mei_device *bus; struct mei_cl_device *cldev = to_mei_cl_device(dev);
struct mei_cl_cb *cb; struct mei_cl_driver *cldrv = to_mei_cl_driver(drv);
size_t r_length; const struct mei_cl_device_id *id;
ssize_t rets; const uuid_le *uuid;
const char *name;
if (WARN_ON(!cl || !cl->dev)) if (!cldev)
return -ENODEV; return 0;
bus = cl->dev; uuid = mei_me_cl_uuid(cldev->me_cl);
name = cldev->name;
mutex_lock(&bus->device_lock); if (!cldrv || !cldrv->id_table)
return 0;
cb = mei_cl_read_cb(cl, NULL); id = cldrv->id_table;
if (cb)
goto copy;
rets = mei_cl_read_start(cl, length, NULL); while (uuid_le_cmp(NULL_UUID_LE, id->uuid)) {
if (rets && rets != -EBUSY)
goto out;
if (list_empty(&cl->rd_completed) && !waitqueue_active(&cl->rx_wait)) { if (!uuid_le_cmp(*uuid, id->uuid)) {
if (id->name[0]) {
if (!strncmp(name, id->name, sizeof(id->name)))
return 1;
} else {
return 1;
}
}
mutex_unlock(&bus->device_lock); id++;
}
if (wait_event_interruptible(cl->rx_wait, return 0;
(!list_empty(&cl->rd_completed)) || }
(!mei_cl_is_connected(cl)))) {
if (signal_pending(current)) static int mei_cl_device_probe(struct device *dev)
return -EINTR; {
return -ERESTARTSYS; struct mei_cl_device *cldev = to_mei_cl_device(dev);
} struct mei_cl_driver *cldrv;
struct mei_cl_device_id id;
mutex_lock(&bus->device_lock); if (!cldev)
return 0;
if (!mei_cl_is_connected(cl)) { cldrv = to_mei_cl_driver(dev->driver);
rets = -EBUSY; if (!cldrv || !cldrv->probe)
goto out; return -ENODEV;
}
} dev_dbg(dev, "Device probe\n");
strlcpy(id.name, cldev->name, sizeof(id.name));
return cldrv->probe(cldev, &id);
}
cb = mei_cl_read_cb(cl, NULL); static int mei_cl_device_remove(struct device *dev)
if (!cb) { {
rets = 0; struct mei_cl_device *cldev = to_mei_cl_device(dev);
goto out; struct mei_cl_driver *cldrv;
}
copy: if (!cldev || !dev->driver)
if (cb->status) { return 0;
rets = cb->status;
goto free; if (cldev->event_cb) {
cldev->event_cb = NULL;
cancel_work_sync(&cldev->event_work);
} }
r_length = min_t(size_t, length, cb->buf_idx); cldrv = to_mei_cl_driver(dev->driver);
memcpy(buf, cb->buf.data, r_length); if (!cldrv->remove) {
rets = r_length; dev->driver = NULL;
free: return 0;
mei_io_cb_free(cb); }
out:
mutex_unlock(&bus->device_lock);
return rets; return cldrv->remove(cldev);
} }
ssize_t mei_cl_send(struct mei_cl_device *cldev, u8 *buf, size_t length) static ssize_t name_show(struct device *dev, struct device_attribute *a,
char *buf)
{ {
struct mei_cl *cl = cldev->cl; struct mei_cl_device *cldev = to_mei_cl_device(dev);
size_t len;
if (cl == NULL) len = snprintf(buf, PAGE_SIZE, "%s", cldev->name);
return -ENODEV;
return __mei_cl_send(cl, buf, length, 1); return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
} }
EXPORT_SYMBOL_GPL(mei_cl_send); static DEVICE_ATTR_RO(name);
ssize_t mei_cl_recv(struct mei_cl_device *cldev, u8 *buf, size_t length) static ssize_t uuid_show(struct device *dev, struct device_attribute *a,
char *buf)
{ {
struct mei_cl *cl = cldev->cl; struct mei_cl_device *cldev = to_mei_cl_device(dev);
const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl);
size_t len;
if (cl == NULL) len = snprintf(buf, PAGE_SIZE, "%pUl", uuid);
return -ENODEV;
return __mei_cl_recv(cl, buf, length); return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
} }
EXPORT_SYMBOL_GPL(mei_cl_recv); static DEVICE_ATTR_RO(uuid);
static void mei_bus_event_work(struct work_struct *work) static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
char *buf)
{ {
struct mei_cl_device *cldev; struct mei_cl_device *cldev = to_mei_cl_device(dev);
const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl);
cldev = container_of(work, struct mei_cl_device, event_work); size_t len;
if (cldev->event_cb)
cldev->event_cb(cldev, cldev->events, cldev->event_context);
cldev->events = 0; len = snprintf(buf, PAGE_SIZE, "mei:%s:" MEI_CL_UUID_FMT ":",
cldev->name, MEI_CL_UUID_ARGS(uuid->b));
/* Prepare for the next read */ return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
mei_cl_read_start(cldev->cl, 0, NULL);
} }
static DEVICE_ATTR_RO(modalias);
int mei_cl_register_event_cb(struct mei_cl_device *cldev, static struct attribute *mei_cl_dev_attrs[] = {
mei_cl_event_cb_t event_cb, void *context) &dev_attr_name.attr,
&dev_attr_uuid.attr,
&dev_attr_modalias.attr,
NULL,
};
ATTRIBUTE_GROUPS(mei_cl_dev);
static int mei_cl_uevent(struct device *dev, struct kobj_uevent_env *env)
{ {
if (cldev->event_cb) struct mei_cl_device *cldev = to_mei_cl_device(dev);
return -EALREADY; const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl);
cldev->events = 0; if (add_uevent_var(env, "MEI_CL_UUID=%pUl", uuid))
cldev->event_cb = event_cb; return -ENOMEM;
cldev->event_context = context;
INIT_WORK(&cldev->event_work, mei_bus_event_work);
mei_cl_read_start(cldev->cl, 0, NULL); if (add_uevent_var(env, "MEI_CL_NAME=%s", cldev->name))
return -ENOMEM;
if (add_uevent_var(env, "MODALIAS=mei:%s:" MEI_CL_UUID_FMT ":",
cldev->name, MEI_CL_UUID_ARGS(uuid->b)))
return -ENOMEM;
return 0; return 0;
} }
EXPORT_SYMBOL_GPL(mei_cl_register_event_cb);
void *mei_cl_get_drvdata(const struct mei_cl_device *cldev) static struct bus_type mei_cl_bus_type = {
.name = "mei",
.dev_groups = mei_cl_dev_groups,
.match = mei_cl_device_match,
.probe = mei_cl_device_probe,
.remove = mei_cl_device_remove,
.uevent = mei_cl_uevent,
};
static void mei_cl_dev_release(struct device *dev)
{ {
return dev_get_drvdata(&cldev->dev); struct mei_cl_device *cldev = to_mei_cl_device(dev);
if (!cldev)
return;
mei_me_cl_put(cldev->me_cl);
kfree(cldev);
} }
EXPORT_SYMBOL_GPL(mei_cl_get_drvdata);
void mei_cl_set_drvdata(struct mei_cl_device *cldev, void *data) static struct device_type mei_cl_device_type = {
.release = mei_cl_dev_release,
};
struct mei_cl *mei_cl_bus_find_cl_by_uuid(struct mei_device *bus,
uuid_le uuid)
{ {
dev_set_drvdata(&cldev->dev, data); struct mei_cl *cl;
list_for_each_entry(cl, &bus->device_list, device_link) {
if (cl->cldev && cl->cldev->me_cl &&
!uuid_le_cmp(uuid, *mei_me_cl_uuid(cl->cldev->me_cl)))
return cl;
}
return NULL;
} }
EXPORT_SYMBOL_GPL(mei_cl_set_drvdata);
int mei_cl_enable_device(struct mei_cl_device *cldev) struct mei_cl_device *mei_cl_add_device(struct mei_device *bus,
struct mei_me_client *me_cl,
struct mei_cl *cl,
char *name)
{ {
int err; struct mei_cl_device *cldev;
struct mei_device *bus; int status;
struct mei_cl *cl = cldev->cl;
if (cl == NULL) cldev = kzalloc(sizeof(struct mei_cl_device), GFP_KERNEL);
return -ENODEV; if (!cldev)
return NULL;
bus = cl->dev; cldev->me_cl = mei_me_cl_get(me_cl);
if (!cldev->me_cl) {
kfree(cldev);
return NULL;
}
mutex_lock(&bus->device_lock); cldev->cl = cl;
cldev->dev.parent = bus->dev;
cldev->dev.bus = &mei_cl_bus_type;
cldev->dev.type = &mei_cl_device_type;
if (mei_cl_is_connected(cl)) { strlcpy(cldev->name, name, sizeof(cldev->name));
mutex_unlock(&bus->device_lock);
dev_warn(bus->dev, "Already connected");
return -EBUSY;
}
err = mei_cl_connect(cl, cldev->me_cl, NULL); dev_set_name(&cldev->dev, "mei:%s:%pUl", name, mei_me_cl_uuid(me_cl));
if (err < 0) {
mutex_unlock(&bus->device_lock);
dev_err(bus->dev, "Could not connect to the ME client");
return err; status = device_register(&cldev->dev);
if (status) {
dev_err(bus->dev, "Failed to register MEI device\n");
mei_me_cl_put(cldev->me_cl);
kfree(cldev);
return NULL;
} }
mutex_unlock(&bus->device_lock); cl->cldev = cldev;
if (cldev->event_cb) dev_dbg(&cldev->dev, "client %s registered\n", name);
mei_cl_read_start(cldev->cl, 0, NULL);
return 0; return cldev;
} }
EXPORT_SYMBOL_GPL(mei_cl_enable_device); EXPORT_SYMBOL_GPL(mei_cl_add_device);
int mei_cl_disable_device(struct mei_cl_device *cldev) void mei_cl_remove_device(struct mei_cl_device *cldev)
{ {
int err; device_unregister(&cldev->dev);
struct mei_device *bus; }
struct mei_cl *cl = cldev->cl; EXPORT_SYMBOL_GPL(mei_cl_remove_device);
if (cl == NULL)
return -ENODEV;
bus = cl->dev;
cldev->event_cb = NULL;
mutex_lock(&bus->device_lock);
if (!mei_cl_is_connected(cl)) { int __mei_cl_driver_register(struct mei_cl_driver *cldrv, struct module *owner)
dev_err(bus->dev, "Already disconnected"); {
err = 0; int err;
goto out;
}
err = mei_cl_disconnect(cl); cldrv->driver.name = cldrv->name;
if (err < 0) { cldrv->driver.owner = owner;
dev_err(bus->dev, "Could not disconnect from the ME client"); cldrv->driver.bus = &mei_cl_bus_type;
goto out;
}
/* Flush queues and remove any pending read */ err = driver_register(&cldrv->driver);
mei_cl_flush_queues(cl, NULL); if (err)
return err;
out: pr_debug("mei: driver [%s] registered\n", cldrv->driver.name);
mutex_unlock(&bus->device_lock);
return err;
return 0;
} }
EXPORT_SYMBOL_GPL(mei_cl_disable_device); EXPORT_SYMBOL_GPL(__mei_cl_driver_register);
void mei_cl_bus_rx_event(struct mei_cl *cl) void mei_cl_driver_unregister(struct mei_cl_driver *cldrv)
{ {
struct mei_cl_device *cldev = cl->cldev; driver_unregister(&cldrv->driver);
if (!cldev || !cldev->event_cb)
return;
set_bit(MEI_CL_EVENT_RX, &cldev->events);
schedule_work(&cldev->event_work); pr_debug("mei: driver [%s] unregistered\n", cldrv->driver.name);
} }
EXPORT_SYMBOL_GPL(mei_cl_driver_unregister);
int __init mei_cl_bus_init(void) int __init mei_cl_bus_init(void)
{ {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7