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

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

drivers/misc/mei/bus.c

+444 −355
Original line number Original line Diff line number Diff line
@@ -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);

	name = cldev->name;





	if (!cldrv || !cldrv->id_table)

	if (WARN_ON(!cl || !cl->dev))

		return 0;

		return -ENODEV;





	id = cldrv->id_table;

	bus = cl->dev;





	while (uuid_le_cmp(NULL_UUID_LE, id->uuid)) {

	mutex_lock(&bus->device_lock);

	if (!mei_cl_is_connected(cl)) {

		rets = -ENODEV;

		goto out;

	}





		if (!uuid_le_cmp(*uuid, id->uuid)) {

	/* Check if we have an ME client device */

			if (id->name[0]) {

	if (!mei_me_cl_is_active(cl->me_cl)) {

				if (!strncmp(name, id->name, sizeof(id->name)))

		rets = -ENOTTY;

					return 1;

		goto out;

			} else {

				return 1;

	}

	}



	if (length > mei_cl_mtu(cl)) {

		rets = -EFBIG;

		goto out;

	}

	}





		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);

		if (wait_event_interruptible(cl->rx_wait,

				(!list_empty(&cl->rd_completed)) ||

				(!mei_cl_is_connected(cl)))) {



			if (signal_pending(current))

				return -EINTR;

			return -ERESTARTSYS;

		}

		}





	cldrv = to_mei_cl_driver(dev->driver);

		mutex_lock(&bus->device_lock);

	if (!cldrv->remove) {

		dev->driver = NULL;





		return 0;

		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));

	cldev->events = 0;

	cldev->event_cb = event_cb;

	cldev->event_context = context;

	INIT_WORK(&cldev->event_work, mei_bus_event_work);





	dev_set_name(&cldev->dev, "mei:%s:%pUl", name, mei_me_cl_uuid(me_cl));

	mei_cl_read_start(cldev->cl, 0, NULL);





	status = device_register(&cldev->dev);

	return 0;

	if (status) {

		dev_err(bus->dev, "Failed to register MEI device\n");

		mei_me_cl_put(cldev->me_cl);

		kfree(cldev);

		return NULL;

}

}

EXPORT_SYMBOL_GPL(mei_cl_register_event_cb);





	cl->cldev = cldev;

/**



 * mei_cl_get_drvdata - driver data getter

	dev_dbg(&cldev->dev, "client %s registered\n", name);

 *



 * @cldev: mei client device

	return cldev;

 *

 * 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);

		dev_warn(bus->dev, "Already connected");

		return -EBUSY;

	}

	}

EXPORT_SYMBOL_GPL(__mei_cl_driver_register);





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;

	}

	}

EXPORT_SYMBOL_GPL(mei_cl_driver_unregister);





ssize_t __mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length,

	mutex_unlock(&bus->device_lock);

			bool blocking)



	if (cldev->event_cb)

		mei_cl_read_start(cldev->cl, 0, NULL);



	return 0;

}

EXPORT_SYMBOL_GPL(mei_cl_enable_device);



/**

 * 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;



	if (!cldev)

		return 0;



	cldrv = to_mei_cl_driver(dev->driver);

	if (!cldrv || !cldrv->probe)

		return -ENODEV;



	dev_dbg(dev, "Device probe\n");



	strlcpy(id.name, cldev->name, sizeof(id.name));



	return cldrv->probe(cldev, &id);

}

}





		mutex_lock(&bus->device_lock);

static int mei_cl_device_remove(struct device *dev)

{

	struct mei_cl_device *cldev = to_mei_cl_device(dev);

	struct mei_cl_driver *cldrv;





		if (!mei_cl_is_connected(cl)) {

	if (!cldev || !dev->driver)

			rets = -EBUSY;

		return 0;

			goto out;



		}

	if (cldev->event_cb) {

		cldev->event_cb = NULL;

		cancel_work_sync(&cldev->event_work);

	}

	}





	cb = mei_cl_read_cb(cl, NULL);

	cldrv = to_mei_cl_driver(dev->driver);

	if (!cb) {

	if (!cldrv->remove) {

		rets = 0;

		dev->driver = NULL;

		goto out;



		return 0;

	}

	}





copy:

	return cldrv->remove(cldev);

	if (cb->status) {

		rets = cb->status;

		goto free;

}

}





	r_length = min_t(size_t, length, cb->buf_idx);

static ssize_t name_show(struct device *dev, struct device_attribute *a,

	memcpy(buf, cb->buf.data, r_length);

			     char *buf)

	rets = r_length;

{

	struct mei_cl_device *cldev = to_mei_cl_device(dev);

	size_t len;





free:

	len = snprintf(buf, PAGE_SIZE, "%s", cldev->name);

	mei_io_cb_free(cb);

out:

	mutex_unlock(&bus->device_lock);





	return rets;

	return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;

}

}

static DEVICE_ATTR_RO(name);





ssize_t mei_cl_send(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_send(cl, buf, length, 1);

	return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;

}

}

EXPORT_SYMBOL_GPL(mei_cl_send);

static DEVICE_ATTR_RO(uuid);





ssize_t mei_cl_recv(struct mei_cl_device *cldev, u8 *buf, size_t length)

static ssize_t modalias_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, "mei:%s:" MEI_CL_UUID_FMT ":",

		return -ENODEV;

		cldev->name, MEI_CL_UUID_ARGS(uuid->b));





	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(modalias);





static void mei_bus_event_work(struct work_struct *work)

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)

{

{

	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);

	if (add_uevent_var(env, "MEI_CL_UUID=%pUl", uuid))

		return -ENOMEM;





	if (cldev->event_cb)

	if (add_uevent_var(env, "MEI_CL_NAME=%s", cldev->name))

		cldev->event_cb(cldev, cldev->events, cldev->event_context);

		return -ENOMEM;





	cldev->events = 0;

	if (add_uevent_var(env, "MODALIAS=mei:%s:" MEI_CL_UUID_FMT ":",

		cldev->name, MEI_CL_UUID_ARGS(uuid->b)))

		return -ENOMEM;





	/* Prepare for the next read */

	return 0;

	mei_cl_read_start(cldev->cl, 0, NULL);

}

}





int mei_cl_register_event_cb(struct mei_cl_device *cldev,

static struct bus_type mei_cl_bus_type = {

			  mei_cl_event_cb_t event_cb, void *context)

	.name		= "mei",

{

	.dev_groups	= mei_cl_dev_groups,

	if (cldev->event_cb)

	.match		= mei_cl_device_match,

		return -EALREADY;

	.probe		= mei_cl_device_probe,

	.remove		= mei_cl_device_remove,

	.uevent		= mei_cl_uevent,

};





	cldev->events = 0;

static void mei_cl_dev_release(struct device *dev)

	cldev->event_cb = event_cb;

{

	cldev->event_context = context;

	struct mei_cl_device *cldev = to_mei_cl_device(dev);

	INIT_WORK(&cldev->event_work, mei_bus_event_work);





	mei_cl_read_start(cldev->cl, 0, NULL);

	if (!cldev)

		return;





	return 0;

	mei_me_cl_put(cldev->me_cl);

	kfree(cldev);

}

}

EXPORT_SYMBOL_GPL(mei_cl_register_event_cb);





void *mei_cl_get_drvdata(const struct mei_cl_device *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)

{

{

	return dev_get_drvdata(&cldev->dev);

	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;

	}

	}

EXPORT_SYMBOL_GPL(mei_cl_get_drvdata);





void mei_cl_set_drvdata(struct mei_cl_device *cldev, void *data)

	return NULL;

{

	dev_set_drvdata(&cldev->dev, data);

}

}

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;



	if (cl == NULL)

		return -ENODEV;



	bus = cl->dev;



	cldev->event_cb = NULL;



	mutex_lock(&bus->device_lock);



	if (!mei_cl_is_connected(cl)) {

		dev_err(bus->dev, "Already disconnected");

		err = 0;

		goto out;

}

}

EXPORT_SYMBOL_GPL(mei_cl_remove_device);





	err = mei_cl_disconnect(cl);

int __mei_cl_driver_register(struct mei_cl_driver *cldrv, struct module *owner)

	if (err < 0) {

{

		dev_err(bus->dev, "Could not disconnect from the ME client");

	int err;

		goto out;

	}





	/* Flush queues and remove any pending read */

	cldrv->driver.name = cldrv->name;

	mei_cl_flush_queues(cl, NULL);

	cldrv->driver.owner = owner;

	cldrv->driver.bus = &mei_cl_bus_type;





out:

	err = driver_register(&cldrv->driver);

	mutex_unlock(&bus->device_lock);

	if (err)

		return err;

		return err;





	pr_debug("mei: driver [%s] registered\n", cldrv->driver.name);



	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)

{

{