[deliverable/linux.git] / include / linux / mei_cl_bus.h

#ifndef _LINUX_MEI_CL_BUS_H
#define _LINUX_MEI_CL_BUS_H

#include <linux/device.h>
#include <linux/uuid.h>
#include <linux/mod_devicetable.h>

struct mei_cl_device;

typedef void (*mei_cl_event_cb_t)(struct mei_cl_device *device,
			       u32 events, void *context);

/**
 * struct mei_cl_device - MEI device handle
 * An mei_cl_device pointer is returned from mei_add_device()
 * and links MEI bus clients to their actual ME host client pointer.
 * Drivers for MEI devices will get an mei_cl_device pointer
 * when being probed and shall use it for doing ME bus I/O.
 *
 * @dev: linux driver model device pointer
 * @me_cl: me client
 * @cl: mei client
 * @name: device name
 * @event_work: async work to execute event callback
 * @event_cb: Drivers register this callback to get asynchronous ME
 *	events (e.g. Rx buffer pending) notifications.
 * @event_context: event callback run context
 * @events: Events bitmask sent to the driver.
 * @priv_data: client private data
 */
struct mei_cl_device {
	struct device dev;

	struct mei_me_client *me_cl;
	struct mei_cl *cl;
	char name[MEI_CL_NAME_SIZE];

	struct work_struct event_work;
	mei_cl_event_cb_t event_cb;
	void *event_context;
	unsigned long events;

	void *priv_data;
};

struct mei_cl_driver {
	struct device_driver driver;
	const char *name;

	const struct mei_cl_device_id *id_table;

	int (*probe)(struct mei_cl_device *dev,
		     const struct mei_cl_device_id *id);
	int (*remove)(struct mei_cl_device *dev);
};

int __mei_cl_driver_register(struct mei_cl_driver *driver,
				struct module *owner);
#define mei_cl_driver_register(driver)             \
	__mei_cl_driver_register(driver, THIS_MODULE)

void mei_cl_driver_unregister(struct mei_cl_driver *driver);

ssize_t mei_cl_send(struct mei_cl_device *device, u8 *buf, size_t length);
ssize_t  mei_cl_recv(struct mei_cl_device *device, u8 *buf, size_t length);

int mei_cl_register_event_cb(struct mei_cl_device *device,
			  mei_cl_event_cb_t read_cb, void *context);

#define MEI_CL_EVENT_RX 0
#define MEI_CL_EVENT_TX 1

void *mei_cl_get_drvdata(const struct mei_cl_device *device);
void mei_cl_set_drvdata(struct mei_cl_device *device, void *data);

int mei_cl_enable_device(struct mei_cl_device *device);
int mei_cl_disable_device(struct mei_cl_device *device);

#endif /* _LINUX_MEI_CL_BUS_H */
Commit	Line	Data
e5354107 SO	1	#ifndef _LINUX_MEI_CL_BUS_H
	2	#define _LINUX_MEI_CL_BUS_H
	3
	4	#include <linux/device.h>
	5	#include <linux/uuid.h>
1f180359	6	#include <linux/mod_devicetable.h>
e5354107 SO	7
	8	struct mei_cl_device;
	9
dbac993f TW	10	typedef void (mei_cl_event_cb_t)(struct mei_cl_device device,
	11	u32 events, void *context);
	12
	13	/**
	14	* struct mei_cl_device - MEI device handle
	15	* An mei_cl_device pointer is returned from mei_add_device()
	16	* and links MEI bus clients to their actual ME host client pointer.
	17	* Drivers for MEI devices will get an mei_cl_device pointer
	18	* when being probed and shall use it for doing ME bus I/O.
	19	*
	20	* @dev: linux driver model device pointer
	21	* @me_cl: me client
	22	* @cl: mei client
	23	* @name: device name
	24	* @event_work: async work to execute event callback
	25	* @event_cb: Drivers register this callback to get asynchronous ME
	26	* events (e.g. Rx buffer pending) notifications.
	27	* @event_context: event callback run context
	28	* @events: Events bitmask sent to the driver.
	29	* @priv_data: client private data
	30	*/
	31	struct mei_cl_device {
	32	struct device dev;
	33
	34	struct mei_me_client *me_cl;
	35	struct mei_cl *cl;
	36	char name[MEI_CL_NAME_SIZE];
	37
	38	struct work_struct event_work;
	39	mei_cl_event_cb_t event_cb;
	40	void *event_context;
	41	unsigned long events;
	42
	43	void *priv_data;
	44	};
	45
e5354107 SO	46	struct mei_cl_driver {
	47	struct device_driver driver;
	48	const char *name;
	49
	50	const struct mei_cl_device_id *id_table;
	51
	52	int (probe)(struct mei_cl_device dev,
	53	const struct mei_cl_device_id *id);
	54	int (remove)(struct mei_cl_device dev);
	55	};
	56
333e4ee0 SO	57	int __mei_cl_driver_register(struct mei_cl_driver *driver,
	58	struct module *owner);
	59	#define mei_cl_driver_register(driver) \
	60	__mei_cl_driver_register(driver, THIS_MODULE)
	61
	62	void mei_cl_driver_unregister(struct mei_cl_driver *driver);
	63
39db74ce TW	64	ssize_t mei_cl_send(struct mei_cl_device device, u8 buf, size_t length);
39db74ce TW	65	ssize_t mei_cl_recv(struct mei_cl_device device, u8 buf, size_t length);
3e833295	66
3e833295 SO	67	int mei_cl_register_event_cb(struct mei_cl_device *device,
	68	mei_cl_event_cb_t read_cb, void *context);
	69
	70	#define MEI_CL_EVENT_RX 0
	71	#define MEI_CL_EVENT_TX 1
	72
aa6aef21 SO	73	void mei_cl_get_drvdata(const struct mei_cl_device device);
	74	void mei_cl_set_drvdata(struct mei_cl_device device, void data);
	75
e46980a1 SO	76	int mei_cl_enable_device(struct mei_cl_device *device);
	77	int mei_cl_disable_device(struct mei_cl_device *device);
	78
e5354107	79	#endif /* _LINUX_MEI_CL_BUS_H */