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

/*
 * Copyright (C) 1999-2002 Vojtech Pavlik
*
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */
#ifndef _SERIO_H
#define _SERIO_H


#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/spinlock.h>
#include <linux/mutex.h>
#include <linux/device.h>
#include <linux/mod_devicetable.h>
#include <uapi/linux/serio.h>

extern struct bus_type serio_bus;

struct serio {
	void *port_data;

	char name[32];
	char phys[32];
	char firmware_id[128];

	bool manual_bind;

	struct serio_device_id id;

	spinlock_t lock;		/* protects critical sections from port's interrupt handler */

	int (*write)(struct serio *, unsigned char);
	int (*open)(struct serio *);
	void (*close)(struct serio *);
	int (*start)(struct serio *);
	void (*stop)(struct serio *);

	struct serio *parent;
	struct list_head child_node;	/* Entry in parent->children list */
	struct list_head children;
	unsigned int depth;		/* level of nesting in serio hierarchy */

	struct serio_driver *drv;	/* accessed from interrupt, must be protected by serio->lock and serio->sem */
	struct mutex drv_mutex;		/* protects serio->drv so attributes can pin driver */

	struct device dev;

	struct list_head node;
};
#define to_serio_port(d)	container_of(d, struct serio, dev)

struct serio_driver {
	const char *description;

	const struct serio_device_id *id_table;
	bool manual_bind;

	void (*write_wakeup)(struct serio *);
	irqreturn_t (*interrupt)(struct serio *, unsigned char, unsigned int);
	int  (*connect)(struct serio *, struct serio_driver *drv);
	int  (*reconnect)(struct serio *);
	void (*disconnect)(struct serio *);
	void (*cleanup)(struct serio *);

	struct device_driver driver;
};
#define to_serio_driver(d)	container_of(d, struct serio_driver, driver)

int serio_open(struct serio *serio, struct serio_driver *drv);
void serio_close(struct serio *serio);
void serio_rescan(struct serio *serio);
void serio_reconnect(struct serio *serio);
irqreturn_t serio_interrupt(struct serio *serio, unsigned char data, unsigned int flags);

void __serio_register_port(struct serio *serio, struct module *owner);

/* use a define to avoid include chaining to get THIS_MODULE */
#define serio_register_port(serio) \
	__serio_register_port(serio, THIS_MODULE)

void serio_unregister_port(struct serio *serio);
void serio_unregister_child_port(struct serio *serio);

int __must_check __serio_register_driver(struct serio_driver *drv,
				struct module *owner, const char *mod_name);

/* use a define to avoid include chaining to get THIS_MODULE & friends */
#define serio_register_driver(drv) \
	__serio_register_driver(drv, THIS_MODULE, KBUILD_MODNAME)

void serio_unregister_driver(struct serio_driver *drv);

/**
 * module_serio_driver() - Helper macro for registering a serio driver
 * @__serio_driver: serio_driver struct
 *
 * Helper macro for serio drivers which do not do anything special in
 * module init/exit. This eliminates a lot of boilerplate. Each module
 * may only use this macro once, and calling it replaces module_init()
 * and module_exit().
 */
#define module_serio_driver(__serio_driver) \
	module_driver(__serio_driver, serio_register_driver, \
		       serio_unregister_driver)

static inline int serio_write(struct serio *serio, unsigned char data)
{
	if (serio->write)
		return serio->write(serio, data);
	else
		return -1;
}

static inline void serio_drv_write_wakeup(struct serio *serio)
{
	if (serio->drv && serio->drv->write_wakeup)
		serio->drv->write_wakeup(serio);
}

/*
 * Use the following functions to manipulate serio's per-port
 * driver-specific data.
 */
static inline void *serio_get_drvdata(struct serio *serio)
{
	return dev_get_drvdata(&serio->dev);
}

static inline void serio_set_drvdata(struct serio *serio, void *data)
{
	dev_set_drvdata(&serio->dev, data);
}

/*
 * Use the following functions to protect critical sections in
 * driver code from port's interrupt handler
 */
static inline void serio_pause_rx(struct serio *serio)
{
	spin_lock_irq(&serio->lock);
}

static inline void serio_continue_rx(struct serio *serio)
{
	spin_unlock_irq(&serio->lock);
}

#endif
Commit	Line	Data
	1	/*
	2	* Copyright (C) 1999-2002 Vojtech Pavlik
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU General Public License version 2 as published by
	6	* the Free Software Foundation.
	7	*/
	8	#ifndef _SERIO_H
	9	#define _SERIO_H
	10
	11
	12	#include <linux/types.h>
	13	#include <linux/interrupt.h>
	14	#include <linux/list.h>
	15	#include <linux/spinlock.h>
	16	#include <linux/mutex.h>
	17	#include <linux/device.h>
	18	#include <linux/mod_devicetable.h>
	19	#include <uapi/linux/serio.h>
	20
	21	extern struct bus_type serio_bus;
	22
	23	struct serio {
	24	void *port_data;
	25
	26	char name[32];
	27	char phys[32];
	28	char firmware_id[128];
	29
	30	bool manual_bind;
	31
	32	struct serio_device_id id;
	33
	34	spinlock_t lock; /* protects critical sections from port's interrupt handler */
	35
	36	int (write)(struct serio , unsigned char);
	37	int (open)(struct serio );
	38	void (close)(struct serio );
	39	int (start)(struct serio );
	40	void (stop)(struct serio );
	41
	42	struct serio *parent;
	43	struct list_head child_node; /* Entry in parent->children list */
	44	struct list_head children;
	45	unsigned int depth; /* level of nesting in serio hierarchy */
	46
	47	struct serio_driver drv; / accessed from interrupt, must be protected by serio->lock and serio->sem */
	48	struct mutex drv_mutex; /* protects serio->drv so attributes can pin driver */
	49
	50	struct device dev;
	51
	52	struct list_head node;
	53	};
	54	#define to_serio_port(d) container_of(d, struct serio, dev)
	55
	56	struct serio_driver {
	57	const char *description;
	58
	59	const struct serio_device_id *id_table;
	60	bool manual_bind;
	61
	62	void (write_wakeup)(struct serio );
	63	irqreturn_t (interrupt)(struct serio , unsigned char, unsigned int);
	64	int (connect)(struct serio , struct serio_driver *drv);
	65	int (reconnect)(struct serio );
	66	void (disconnect)(struct serio );
	67	void (cleanup)(struct serio );
	68
	69	struct device_driver driver;
	70	};
	71	#define to_serio_driver(d) container_of(d, struct serio_driver, driver)
	72
	73	int serio_open(struct serio serio, struct serio_driver drv);
	74	void serio_close(struct serio *serio);
	75	void serio_rescan(struct serio *serio);
	76	void serio_reconnect(struct serio *serio);
	77	irqreturn_t serio_interrupt(struct serio *serio, unsigned char data, unsigned int flags);
	78
	79	void __serio_register_port(struct serio serio, struct module owner);
	80
	81	/* use a define to avoid include chaining to get THIS_MODULE */
	82	#define serio_register_port(serio) \
	83	__serio_register_port(serio, THIS_MODULE)
	84
	85	void serio_unregister_port(struct serio *serio);
	86	void serio_unregister_child_port(struct serio *serio);
	87
	88	int __must_check __serio_register_driver(struct serio_driver *drv,
	89	struct module owner, const char mod_name);
	90
	91	/* use a define to avoid include chaining to get THIS_MODULE & friends */
	92	#define serio_register_driver(drv) \
	93	__serio_register_driver(drv, THIS_MODULE, KBUILD_MODNAME)
	94
	95	void serio_unregister_driver(struct serio_driver *drv);
	96
	97	/**
	98	* module_serio_driver() - Helper macro for registering a serio driver
	99	* @__serio_driver: serio_driver struct
	100	*
	101	* Helper macro for serio drivers which do not do anything special in
	102	* module init/exit. This eliminates a lot of boilerplate. Each module
	103	* may only use this macro once, and calling it replaces module_init()
	104	* and module_exit().
	105	*/
	106	#define module_serio_driver(__serio_driver) \
	107	module_driver(__serio_driver, serio_register_driver, \
	108	serio_unregister_driver)
	109
	110	static inline int serio_write(struct serio *serio, unsigned char data)
	111	{
	112	if (serio->write)
	113	return serio->write(serio, data);
	114	else
	115	return -1;
	116	}
	117
	118	static inline void serio_drv_write_wakeup(struct serio *serio)
	119	{
	120	if (serio->drv && serio->drv->write_wakeup)
	121	serio->drv->write_wakeup(serio);
	122	}
	123
	124	/*
	125	* Use the following functions to manipulate serio's per-port
	126	* driver-specific data.
	127	*/
	128	static inline void serio_get_drvdata(struct serio serio)
	129	{
	130	return dev_get_drvdata(&serio->dev);
	131	}
	132
	133	static inline void serio_set_drvdata(struct serio serio, void data)
	134	{
	135	dev_set_drvdata(&serio->dev, data);
	136	}
	137
	138	/*
	139	* Use the following functions to protect critical sections in
	140	* driver code from port's interrupt handler
	141	*/
	142	static inline void serio_pause_rx(struct serio *serio)
	143	{
	144	spin_lock_irq(&serio->lock);
	145	}
	146
	147	static inline void serio_continue_rx(struct serio *serio)
	148	{
	149	spin_unlock_irq(&serio->lock);
	150	}
	151
	152	#endif