[mirror_ubuntu-bionic-kernel.git] / include / linux / gameport.h

#ifndef _GAMEPORT_H
#define _GAMEPORT_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.
 */

#ifdef __KERNEL__
#include <asm/io.h>
#include <linux/types.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/device.h>
#include <linux/timer.h>
#include <linux/slab.h>

struct gameport {

	void *port_data;	/* Private pointer for gameport drivers */
	char name[32];
	char phys[32];

	int io;
	int speed;
	int fuzz;

	void (*trigger)(struct gameport *);
	unsigned char (*read)(struct gameport *);
	int (*cooked_read)(struct gameport *, int *, int *);
	int (*calibrate)(struct gameport *, int *, int *);
	int (*open)(struct gameport *, int);
	void (*close)(struct gameport *);

	struct timer_list poll_timer;
	unsigned int poll_interval;	/* in msecs */
	spinlock_t timer_lock;
	unsigned int poll_cnt;
	void (*poll_handler)(struct gameport *);

	struct gameport *parent, *child;

	struct gameport_driver *drv;
	struct mutex drv_mutex;		/* protects serio->drv so attributes can pin driver */

	struct device dev;

	struct list_head node;
};
#define to_gameport_port(d)	container_of(d, struct gameport, dev)

struct gameport_driver {
	const char *description;

	int (*connect)(struct gameport *, struct gameport_driver *drv);
	int (*reconnect)(struct gameport *);
	void (*disconnect)(struct gameport *);

	struct device_driver driver;

	bool ignore;
};
#define to_gameport_driver(d)	container_of(d, struct gameport_driver, driver)

int gameport_open(struct gameport *gameport, struct gameport_driver *drv, int mode);
void gameport_close(struct gameport *gameport);

#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))

void __gameport_register_port(struct gameport *gameport, struct module *owner);
/* use a define to avoid include chaining to get THIS_MODULE */
#define gameport_register_port(gameport) \
	__gameport_register_port(gameport, THIS_MODULE)

void gameport_unregister_port(struct gameport *gameport);

__printf(2, 3)
void gameport_set_phys(struct gameport *gameport, const char *fmt, ...);

#else

static inline void gameport_register_port(struct gameport *gameport)
{
	return;
}

static inline void gameport_unregister_port(struct gameport *gameport)
{
	return;
}

static inline __printf(2, 3)
void gameport_set_phys(struct gameport *gameport, const char *fmt, ...)
{
	return;
}

#endif

static inline struct gameport *gameport_allocate_port(void)
{
	struct gameport *gameport = kzalloc(sizeof(struct gameport), GFP_KERNEL);

	return gameport;
}

static inline void gameport_free_port(struct gameport *gameport)
{
	kfree(gameport);
}

static inline void gameport_set_name(struct gameport *gameport, const char *name)
{
	strlcpy(gameport->name, name, sizeof(gameport->name));
}

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

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

/*
 * Use the following functions to pin gameport's driver in process context
 */
static inline int gameport_pin_driver(struct gameport *gameport)
{
	return mutex_lock_interruptible(&gameport->drv_mutex);
}

static inline void gameport_unpin_driver(struct gameport *gameport)
{
	mutex_unlock(&gameport->drv_mutex);
}

int __must_check __gameport_register_driver(struct gameport_driver *drv,
				struct module *owner, const char *mod_name);

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

void gameport_unregister_driver(struct gameport_driver *drv);

/**
 * module_gameport_driver() - Helper macro for registering a gameport driver
 * @__gameport_driver: gameport_driver struct
 *
 * Helper macro for gameport 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_gameport_driver(__gameport_driver) \
	module_driver(__gameport_driver, gameport_register_driver, \
		       gameport_unregister_driver)

#endif /* __KERNEL__ */

#define GAMEPORT_MODE_DISABLED		0
#define GAMEPORT_MODE_RAW		1
#define GAMEPORT_MODE_COOKED		2

#define GAMEPORT_ID_VENDOR_ANALOG	0x0001
#define GAMEPORT_ID_VENDOR_MADCATZ	0x0002
#define GAMEPORT_ID_VENDOR_LOGITECH	0x0003
#define GAMEPORT_ID_VENDOR_CREATIVE	0x0004
#define GAMEPORT_ID_VENDOR_GENIUS	0x0005
#define GAMEPORT_ID_VENDOR_INTERACT	0x0006
#define GAMEPORT_ID_VENDOR_MICROSOFT	0x0007
#define GAMEPORT_ID_VENDOR_THRUSTMASTER	0x0008
#define GAMEPORT_ID_VENDOR_GRAVIS	0x0009
#define GAMEPORT_ID_VENDOR_GUILLEMOT	0x000a

#ifdef __KERNEL__

static inline void gameport_trigger(struct gameport *gameport)
{
	if (gameport->trigger)
		gameport->trigger(gameport);
	else
		outb(0xff, gameport->io);
}

static inline unsigned char gameport_read(struct gameport *gameport)
{
	if (gameport->read)
		return gameport->read(gameport);
	else
		return inb(gameport->io);
}

static inline int gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons)
{
	if (gameport->cooked_read)
		return gameport->cooked_read(gameport, axes, buttons);
	else
		return -1;
}

static inline int gameport_calibrate(struct gameport *gameport, int *axes, int *max)
{
	if (gameport->calibrate)
		return gameport->calibrate(gameport, axes, max);
	else
		return -1;
}

static inline int gameport_time(struct gameport *gameport, int time)
{
	return (time * gameport->speed) / 1000;
}

static inline void gameport_set_poll_handler(struct gameport *gameport, void (*handler)(struct gameport *))
{
	gameport->poll_handler = handler;
}

static inline void gameport_set_poll_interval(struct gameport *gameport, unsigned int msecs)
{
	gameport->poll_interval = msecs;
}

void gameport_start_polling(struct gameport *gameport);
void gameport_stop_polling(struct gameport *gameport);

#endif /* __KERNEL__ */
#endif
Commit	Line	Data
1da177e4 LT	1	#ifndef _GAMEPORT_H
	2	#define _GAMEPORT_H
	3
	4	/*
	5	* Copyright (c) 1999-2002 Vojtech Pavlik
	6	*
	7	* This program is free software; you can redistribute it and/or modify it
	8	* under the terms of the GNU General Public License version 2 as published by
	9	* the Free Software Foundation.
	10	*/
	11
25478bb2	12	#ifdef __KERNEL__
1da177e4	13	#include <asm/io.h>
7e044e05	14	#include <linux/types.h>
1da177e4	15	#include <linux/list.h>
286295eb	16	#include <linux/mutex.h>
1da177e4	17	#include <linux/device.h>
4e57b681	18	#include <linux/timer.h>
5a0e3ad6	19	#include <linux/slab.h>
1da177e4 LT	20
	21	struct gameport {
	22
	23	void port_data; / Private pointer for gameport drivers */
	24	char name[32];
	25	char phys[32];
	26
	27	int io;
	28	int speed;
	29	int fuzz;
	30
	31	void (trigger)(struct gameport );
	32	unsigned char (read)(struct gameport );
	33	int (cooked_read)(struct gameport , int , int );
	34	int (calibrate)(struct gameport , int , int );
	35	int (open)(struct gameport , int);
	36	void (close)(struct gameport );
	37
	38	struct timer_list poll_timer;
	39	unsigned int poll_interval; /* in msecs */
	40	spinlock_t timer_lock;
	41	unsigned int poll_cnt;
	42	void (poll_handler)(struct gameport );
	43
	44	struct gameport parent, child;
	45
	46	struct gameport_driver *drv;
286295eb	47	struct mutex drv_mutex; /* protects serio->drv so attributes can pin driver */
1da177e4 LT	48
1da177e4 LT	49	struct device dev;
1da177e4 LT	50
	51	struct list_head node;
	52	};
	53	#define to_gameport_port(d) container_of(d, struct gameport, dev)
	54
	55	struct gameport_driver {
37b0bb11	56	const char *description;
1da177e4 LT	57
	58	int (connect)(struct gameport , struct gameport_driver *drv);
	59	int (reconnect)(struct gameport );
	60	void (disconnect)(struct gameport );
	61
	62	struct device_driver driver;
	63
7e044e05	64	bool ignore;
1da177e4 LT	65	};
	66	#define to_gameport_driver(d) container_of(d, struct gameport_driver, driver)
	67
	68	int gameport_open(struct gameport gameport, struct gameport_driver drv, int mode);
	69	void gameport_close(struct gameport *gameport);
1da177e4	70
668d1e60 AB	71	#if defined(CONFIG_GAMEPORT) \|\| (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
668d1e60 AB	72
1da177e4	73	void __gameport_register_port(struct gameport gameport, struct module owner);
eb5589a8 PG	74	/* use a define to avoid include chaining to get THIS_MODULE */
	75	#define gameport_register_port(gameport) \
	76	__gameport_register_port(gameport, THIS_MODULE)
1da177e4 LT	77
	78	void gameport_unregister_port(struct gameport *gameport);
	79
b9075fa9 JP	80	__printf(2, 3)
b9075fa9 JP	81	void gameport_set_phys(struct gameport gameport, const char fmt, ...);
668d1e60 AB	82
	83	#else
	84
	85	static inline void gameport_register_port(struct gameport *gameport)
	86	{
	87	return;
	88	}
	89
	90	static inline void gameport_unregister_port(struct gameport *gameport)
	91	{
	92	return;
	93	}
	94
b9075fa9 JP	95	static inline __printf(2, 3)
b9075fa9 JP	96	void gameport_set_phys(struct gameport gameport, const char fmt, ...)
668d1e60 AB	97	{
	98	return;
	99	}
	100
	101	#endif
	102
1da177e4 LT	103	static inline struct gameport *gameport_allocate_port(void)
1da177e4 LT	104	{
cd861280	105	struct gameport *gameport = kzalloc(sizeof(struct gameport), GFP_KERNEL);
1da177e4 LT	106
	107	return gameport;
	108	}
	109
	110	static inline void gameport_free_port(struct gameport *gameport)
	111	{
	112	kfree(gameport);
	113	}
	114
	115	static inline void gameport_set_name(struct gameport gameport, const char name)
	116	{
	117	strlcpy(gameport->name, name, sizeof(gameport->name));
	118	}
	119
1da177e4	120	/*
0b28002f	121	* Use the following functions to manipulate gameport's per-port
1da177e4 LT	122	* driver-specific data.
	123	*/
	124	static inline void gameport_get_drvdata(struct gameport gameport)
	125	{
	126	return dev_get_drvdata(&gameport->dev);
	127	}
	128
	129	static inline void gameport_set_drvdata(struct gameport gameport, void data)
	130	{
	131	dev_set_drvdata(&gameport->dev, data);
	132	}
	133
	134	/*
0b28002f	135	* Use the following functions to pin gameport's driver in process context
1da177e4 LT	136	*/
	137	static inline int gameport_pin_driver(struct gameport *gameport)
	138	{
286295eb	139	return mutex_lock_interruptible(&gameport->drv_mutex);
1da177e4 LT	140	}
	141
	142	static inline void gameport_unpin_driver(struct gameport *gameport)
	143	{
286295eb	144	mutex_unlock(&gameport->drv_mutex);
1da177e4 LT	145	}
1da177e4 LT	146
eb5589a8	147	int __must_check __gameport_register_driver(struct gameport_driver *drv,
6902c0be	148	struct module owner, const char mod_name);
eb5589a8 PG	149
	150	/* use a define to avoid include chaining to get THIS_MODULE & friends */
	151	#define gameport_register_driver(drv) \
	152	__gameport_register_driver(drv, THIS_MODULE, KBUILD_MODNAME)
1da177e4 LT	153
	154	void gameport_unregister_driver(struct gameport_driver *drv);
	155
45b2604e AL	156	/**
	157	* module_gameport_driver() - Helper macro for registering a gameport driver
	158	* @__gameport_driver: gameport_driver struct
	159	*
	160	* Helper macro for gameport drivers which do not do anything special in
	161	* module init/exit. This eliminates a lot of boilerplate. Each module may
	162	* only use this macro once, and calling it replaces module_init() and
	163	* module_exit().
	164	*/
	165	#define module_gameport_driver(__gameport_driver) \
	166	module_driver(__gameport_driver, gameport_register_driver, \
	167	gameport_unregister_driver)
	168
25478bb2 DW	169	#endif /* __KERNEL__ */
25478bb2 DW	170
1da177e4 LT	171	#define GAMEPORT_MODE_DISABLED 0
	172	#define GAMEPORT_MODE_RAW 1
	173	#define GAMEPORT_MODE_COOKED 2
	174
	175	#define GAMEPORT_ID_VENDOR_ANALOG 0x0001
	176	#define GAMEPORT_ID_VENDOR_MADCATZ 0x0002
	177	#define GAMEPORT_ID_VENDOR_LOGITECH 0x0003
	178	#define GAMEPORT_ID_VENDOR_CREATIVE 0x0004
	179	#define GAMEPORT_ID_VENDOR_GENIUS 0x0005
	180	#define GAMEPORT_ID_VENDOR_INTERACT 0x0006
	181	#define GAMEPORT_ID_VENDOR_MICROSOFT 0x0007
	182	#define GAMEPORT_ID_VENDOR_THRUSTMASTER 0x0008
	183	#define GAMEPORT_ID_VENDOR_GRAVIS 0x0009
	184	#define GAMEPORT_ID_VENDOR_GUILLEMOT 0x000a
	185
25478bb2 DW	186	#ifdef __KERNEL__
25478bb2 DW	187
1da177e4 LT	188	static inline void gameport_trigger(struct gameport *gameport)
	189	{
	190	if (gameport->trigger)
	191	gameport->trigger(gameport);
	192	else
	193	outb(0xff, gameport->io);
	194	}
	195
	196	static inline unsigned char gameport_read(struct gameport *gameport)
	197	{
	198	if (gameport->read)
	199	return gameport->read(gameport);
	200	else
	201	return inb(gameport->io);
	202	}
	203
	204	static inline int gameport_cooked_read(struct gameport gameport, int axes, int *buttons)
	205	{
	206	if (gameport->cooked_read)
	207	return gameport->cooked_read(gameport, axes, buttons);
	208	else
	209	return -1;
	210	}
	211
	212	static inline int gameport_calibrate(struct gameport gameport, int axes, int *max)
	213	{
	214	if (gameport->calibrate)
	215	return gameport->calibrate(gameport, axes, max);
	216	else
	217	return -1;
	218	}
	219
	220	static inline int gameport_time(struct gameport *gameport, int time)
	221	{
	222	return (time * gameport->speed) / 1000;
	223	}
	224
	225	static inline void gameport_set_poll_handler(struct gameport gameport, void (handler)(struct gameport *))
	226	{
	227	gameport->poll_handler = handler;
	228	}
	229
	230	static inline void gameport_set_poll_interval(struct gameport *gameport, unsigned int msecs)
	231	{
	232	gameport->poll_interval = msecs;
	233	}
	234
	235	void gameport_start_polling(struct gameport *gameport);
	236	void gameport_stop_polling(struct gameport *gameport);
	237
25478bb2	238	#endif /* __KERNEL__ */
1da177e4	239	#endif