[linux-2.6-block.git] / drivers / input / joystick / grip_mp.c

/*
 *  Driver for the Gravis Grip Multiport, a gamepad "hub" that
 *  connects up to four 9-pin digital gamepads/joysticks.
 *  Driver tested on SMP and UP kernel versions 2.4.18-4 and 2.4.18-5.
 *
 *  Thanks to Chris Gassib for helpful advice.
 *
 *  Copyright (c)      2002 Brian Bonnlander, Bill Soudan
 *  Copyright (c) 1998-2000 Vojtech Pavlik
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/gameport.h>
#include <linux/input.h>
#include <linux/delay.h>
#include <linux/proc_fs.h>
#include <linux/jiffies.h>

#define DRIVER_DESC	"Gravis Grip Multiport driver"

MODULE_AUTHOR("Brian Bonnlander");
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");

#ifdef GRIP_DEBUG
#define dbg(format, arg...) printk(KERN_ERR __FILE__ ": " format "\n" , ## arg)
#else
#define dbg(format, arg...) do {} while (0)
#endif

#define GRIP_MAX_PORTS	4
/*
 * Grip multiport state
 */

struct grip_port {
	struct input_dev *dev;
	int mode;
	int registered;

	/* individual gamepad states */
	int buttons;
	int xaxes;
	int yaxes;
	int dirty;     /* has the state been updated? */
};

struct grip_mp {
	struct gameport *gameport;
	struct grip_port *port[GRIP_MAX_PORTS];
	int reads;
	int bads;
};

/*
 * Multiport packet interpretation
 */

#define PACKET_FULL          0x80000000       /* packet is full                        */
#define PACKET_IO_FAST       0x40000000       /* 3 bits per gameport read              */
#define PACKET_IO_SLOW       0x20000000       /* 1 bit per gameport read               */
#define PACKET_MP_MORE       0x04000000       /* multiport wants to send more          */
#define PACKET_MP_DONE       0x02000000       /* multiport done sending                */

/*
 * Packet status code interpretation
 */

#define IO_GOT_PACKET        0x0100           /* Got a packet                           */
#define IO_MODE_FAST         0x0200           /* Used 3 data bits per gameport read     */
#define IO_SLOT_CHANGE       0x0800           /* Multiport physical slot status changed */
#define IO_DONE              0x1000           /* Multiport is done sending packets      */
#define IO_RETRY             0x4000           /* Try again later to get packet          */
#define IO_RESET             0x8000           /* Force multiport to resend all packets  */

/*
 * Gamepad configuration data.  Other 9-pin digital joystick devices
 * may work with the multiport, so this may not be an exhaustive list!
 * Commodore 64 joystick remains untested.
 */

#define GRIP_INIT_DELAY         2000          /*  2 ms */

#define GRIP_MODE_NONE		0
#define GRIP_MODE_RESET         1
#define GRIP_MODE_GP		2
#define GRIP_MODE_C64		3

static const int grip_btn_gp[]  = { BTN_TR, BTN_TL, BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, -1 };
static const int grip_btn_c64[] = { BTN_JOYSTICK, -1 };

static const int grip_abs_gp[]  = { ABS_X, ABS_Y, -1 };
static const int grip_abs_c64[] = { ABS_X, ABS_Y, -1 };

static const int *grip_abs[] = { NULL, NULL, grip_abs_gp, grip_abs_c64 };
static const int *grip_btn[] = { NULL, NULL, grip_btn_gp, grip_btn_c64 };

static const char *grip_name[] = { NULL, NULL, "Gravis Grip Pad", "Commodore 64 Joystick" };

static const int init_seq[] = {
	1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,
	1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,
	1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,
	0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1 };

/* Maps multiport directional values to X,Y axis values (each axis encoded in 3 bits) */

static const int axis_map[] = { 5, 9, 1, 5, 6, 10, 2, 6, 4, 8, 0, 4, 5, 9, 1, 5 };

static int register_slot(int i, struct grip_mp *grip);

/*
 * Returns whether an odd or even number of bits are on in pkt.
 */

static int bit_parity(u32 pkt)
{
	int x = pkt ^ (pkt >> 16);
	x ^= x >> 8;
	x ^= x >> 4;
	x ^= x >> 2;
	x ^= x >> 1;
	return x & 1;
}

/*
 * Poll gameport; return true if all bits set in 'onbits' are on and
 * all bits set in 'offbits' are off.
 */

static inline int poll_until(u8 onbits, u8 offbits, int u_sec, struct gameport* gp, u8 *data)
{
	int i, nloops;

	nloops = gameport_time(gp, u_sec);
	for (i = 0; i < nloops; i++) {
		*data = gameport_read(gp);
		if ((*data & onbits) == onbits &&
		    (~(*data) & offbits) == offbits)
			return 1;
	}
	dbg("gameport timed out after %d microseconds.\n", u_sec);
	return 0;
}

/*
 * Gets a 28-bit packet from the multiport.
 *
 * After getting a packet successfully, commands encoded by sendcode may
 * be sent to the multiport.
 *
 * The multiport clock value is reflected in gameport bit B4.
 *
 * Returns a packet status code indicating whether packet is valid, the transfer
 * mode, and any error conditions.
 *
 * sendflags:      current I/O status
 * sendcode:   data to send to the multiport if sendflags is nonzero
 */

static int mp_io(struct gameport* gameport, int sendflags, int sendcode, u32 *packet)
{
	u8  raw_data;            /* raw data from gameport */
	u8  data_mask;           /* packet data bits from raw_data */
	u32 pkt;                 /* packet temporary storage */
	int bits_per_read;       /* num packet bits per gameport read */
	int portvals = 0;        /* used for port value sanity check */
	int i;

	/* Gameport bits B0, B4, B5 should first be off, then B4 should come on. */

	*packet = 0;
	raw_data = gameport_read(gameport);
	if (raw_data & 1)
		return IO_RETRY;

	for (i = 0; i < 64; i++) {
		raw_data = gameport_read(gameport);
		portvals |= 1 << ((raw_data >> 4) & 3); /* Demux B4, B5 */
	}

	if (portvals == 1) {                            /* B4, B5 off */
		raw_data = gameport_read(gameport);
		portvals = raw_data & 0xf0;

		if (raw_data & 0x31)
			return IO_RESET;
		gameport_trigger(gameport);

		if (!poll_until(0x10, 0, 308, gameport, &raw_data))
			return IO_RESET;
	} else
		return IO_RETRY;

	/* Determine packet transfer mode and prepare for packet construction. */

	if (raw_data & 0x20) {                 /* 3 data bits/read */
		portvals |= raw_data >> 4;     /* Compare B4-B7 before & after trigger */

		if (portvals != 0xb)
			return 0;
		data_mask = 7;
		bits_per_read = 3;
		pkt = (PACKET_FULL | PACKET_IO_FAST) >> 28;
	} else {                                 /* 1 data bit/read */
		data_mask = 1;
		bits_per_read = 1;
		pkt = (PACKET_FULL | PACKET_IO_SLOW) >> 28;
	}

	/* Construct a packet.  Final data bits must be zero. */

	while (1) {
		if (!poll_until(0, 0x10, 77, gameport, &raw_data))
			return IO_RESET;
		raw_data = (raw_data >> 5) & data_mask;

		if (pkt & PACKET_FULL)
			break;
		pkt = (pkt << bits_per_read) | raw_data;

		if (!poll_until(0x10, 0, 77, gameport, &raw_data))
			return IO_RESET;
	}

	if (raw_data)
		return IO_RESET;

	/* If 3 bits/read used, drop from 30 bits to 28. */

	if (bits_per_read == 3) {
		pkt = (pkt & 0xffff0000) | ((pkt << 1) & 0xffff);
		pkt = (pkt >> 2) | 0xf0000000;
	}

	if (bit_parity(pkt) == 1)
		return IO_RESET;

	/* Acknowledge packet receipt */

	if (!poll_until(0x30, 0, 77, gameport, &raw_data))
		return IO_RESET;

	raw_data = gameport_read(gameport);

	if (raw_data & 1)
		return IO_RESET;

	gameport_trigger(gameport);

	if (!poll_until(0, 0x20, 77, gameport, &raw_data))
		return IO_RESET;

        /* Return if we just wanted the packet or multiport wants to send more */

	*packet = pkt;
	if ((sendflags == 0) || ((sendflags & IO_RETRY) && !(pkt & PACKET_MP_DONE)))
		return IO_GOT_PACKET;

	if (pkt & PACKET_MP_MORE)
		return IO_GOT_PACKET | IO_RETRY;

	/* Multiport is done sending packets and is ready to receive data */

	if (!poll_until(0x20, 0, 77, gameport, &raw_data))
		return IO_GOT_PACKET | IO_RESET;

	raw_data = gameport_read(gameport);
	if (raw_data & 1)
		return IO_GOT_PACKET | IO_RESET;

	/* Trigger gameport based on bits in sendcode */

	gameport_trigger(gameport);
	do {
		if (!poll_until(0x20, 0x10, 116, gameport, &raw_data))
			return IO_GOT_PACKET | IO_RESET;

		if (!poll_until(0x30, 0, 193, gameport, &raw_data))
			return IO_GOT_PACKET | IO_RESET;

		if (raw_data & 1)
			return IO_GOT_PACKET | IO_RESET;

		if (sendcode & 1)
			gameport_trigger(gameport);

		sendcode >>= 1;
	} while (sendcode);

	return IO_GOT_PACKET | IO_MODE_FAST;
}

/*
 * Disables and restores interrupts for mp_io(), which does the actual I/O.
 */

static int multiport_io(struct gameport* gameport, int sendflags, int sendcode, u32 *packet)
{
	int status;
	unsigned long flags;

	local_irq_save(flags);
	status = mp_io(gameport, sendflags, sendcode, packet);
	local_irq_restore(flags);

	return status;
}

/*
 * Puts multiport into digital mode.  Multiport LED turns green.
 *
 * Returns true if a valid digital packet was received, false otherwise.
 */

static int dig_mode_start(struct gameport *gameport, u32 *packet)
{
	int i;
	int flags, tries = 0, bads = 0;

	for (i = 0; i < ARRAY_SIZE(init_seq); i++) {     /* Send magic sequence */
		if (init_seq[i])
			gameport_trigger(gameport);
		udelay(GRIP_INIT_DELAY);
	}

	for (i = 0; i < 16; i++)            /* Wait for multiport to settle */
		udelay(GRIP_INIT_DELAY);

	while (tries < 64 && bads < 8) {    /* Reset multiport and try getting a packet */

		flags = multiport_io(gameport, IO_RESET, 0x27, packet);

		if (flags & IO_MODE_FAST)
			return 1;

		if (flags & IO_RETRY)
			tries++;
		else
			bads++;
	}
	return 0;
}

/*
 * Packet structure: B0-B15   => gamepad state
 *                   B16-B20  => gamepad device type
 *                   B21-B24  => multiport slot index (1-4)
 *
 * Known device types: 0x1f (grip pad), 0x0 (no device).  Others may exist.
 *
 * Returns the packet status.
 */

static int get_and_decode_packet(struct grip_mp *grip, int flags)
{
	struct grip_port *port;
	u32 packet;
	int joytype = 0;
	int slot;

	/* Get a packet and check for validity */

	flags &= IO_RESET | IO_RETRY;
	flags = multiport_io(grip->gameport, flags, 0, &packet);
	grip->reads++;

	if (packet & PACKET_MP_DONE)
		flags |= IO_DONE;

	if (flags && !(flags & IO_GOT_PACKET)) {
		grip->bads++;
		return flags;
	}

	/* Ignore non-gamepad packets, e.g. multiport hardware version */

	slot = ((packet >> 21) & 0xf) - 1;
	if ((slot < 0) || (slot > 3))
		return flags;

	port = grip->port[slot];

	/*
	 * Handle "reset" packets, which occur at startup, and when gamepads
	 * are removed or plugged in.  May contain configuration of a new gamepad.
	 */

	joytype = (packet >> 16) & 0x1f;
	if (!joytype) {

		if (port->registered) {
			printk(KERN_INFO "grip_mp: removing %s, slot %d\n",
			       grip_name[port->mode], slot);
			input_unregister_device(port->dev);
			port->registered = 0;
		}
		dbg("Reset: grip multiport slot %d\n", slot);
		port->mode = GRIP_MODE_RESET;
		flags |= IO_SLOT_CHANGE;
		return flags;
	}

	/* Interpret a grip pad packet */

	if (joytype == 0x1f) {

		int dir = (packet >> 8) & 0xf;          /* eight way directional value */
		port->buttons = (~packet) & 0xff;
		port->yaxes = ((axis_map[dir] >> 2) & 3) - 1;
		port->xaxes = (axis_map[dir] & 3) - 1;
		port->dirty = 1;

		if (port->mode == GRIP_MODE_RESET)
			flags |= IO_SLOT_CHANGE;

		port->mode = GRIP_MODE_GP;

		if (!port->registered) {
			dbg("New Grip pad in multiport slot %d.\n", slot);
			if (register_slot(slot, grip)) {
				port->mode = GRIP_MODE_RESET;
				port->dirty = 0;
			}
		}
		return flags;
	}

	/* Handle non-grip device codes.  For now, just print diagnostics. */

	{
		static int strange_code = 0;
		if (strange_code != joytype) {
			printk(KERN_INFO "Possible non-grip pad/joystick detected.\n");
			printk(KERN_INFO "Got joy type 0x%x and packet 0x%x.\n", joytype, packet);
			strange_code = joytype;
		}
	}
	return flags;
}

/*
 * Returns true if all multiport slot states appear valid.
 */

static int slots_valid(struct grip_mp *grip)
{
	int flags, slot, invalid = 0, active = 0;

	flags = get_and_decode_packet(grip, 0);
	if (!(flags & IO_GOT_PACKET))
		return 0;

	for (slot = 0; slot < 4; slot++) {
		if (grip->port[slot]->mode == GRIP_MODE_RESET)
			invalid = 1;
		if (grip->port[slot]->mode != GRIP_MODE_NONE)
			active = 1;
	}

	/* Return true if no active slot but multiport sent all its data */
	if (!active)
		return (flags & IO_DONE) ? 1 : 0;

	/* Return false if invalid device code received */
	return invalid ? 0 : 1;
}

/*
 * Returns whether the multiport was placed into digital mode and
 * able to communicate its state successfully.
 */

static int multiport_init(struct grip_mp *grip)
{
	int dig_mode, initialized = 0, tries = 0;
	u32 packet;

	dig_mode = dig_mode_start(grip->gameport, &packet);
	while (!dig_mode && tries < 4) {
		dig_mode = dig_mode_start(grip->gameport, &packet);
		tries++;
	}

	if (dig_mode)
		dbg("multiport_init(): digital mode activated.\n");
	else {
		dbg("multiport_init(): unable to activate digital mode.\n");
		return 0;
	}

	/* Get packets, store multiport state, and check state's validity */
	for (tries = 0; tries < 4096; tries++) {
		if (slots_valid(grip)) {
			initialized = 1;
			break;
		}
	}
	dbg("multiport_init(): initialized == %d\n", initialized);
	return initialized;
}

/*
 * Reports joystick state to the linux input layer.
 */

static void report_slot(struct grip_mp *grip, int slot)
{
	struct grip_port *port = grip->port[slot];
	int i;

	/* Store button states with linux input driver */

	for (i = 0; i < 8; i++)
		input_report_key(port->dev, grip_btn_gp[i], (port->buttons >> i) & 1);

	/* Store axis states with linux driver */

	input_report_abs(port->dev, ABS_X, port->xaxes);
	input_report_abs(port->dev, ABS_Y, port->yaxes);

	/* Tell the receiver of the events to process them */

	input_sync(port->dev);

	port->dirty = 0;
}

/*
 * Get the multiport state.
 */

static void grip_poll(struct gameport *gameport)
{
	struct grip_mp *grip = gameport_get_drvdata(gameport);
	int i, npkts, flags;

	for (npkts = 0; npkts < 4; npkts++) {
		flags = IO_RETRY;
		for (i = 0; i < 32; i++) {
			flags = get_and_decode_packet(grip, flags);
			if ((flags & IO_GOT_PACKET) || !(flags & IO_RETRY))
				break;
		}
		if (flags & IO_DONE)
			break;
	}

	for (i = 0; i < 4; i++)
		if (grip->port[i]->dirty)
			report_slot(grip, i);
}

/*
 * Called when a joystick device file is opened
 */

static int grip_open(struct input_dev *dev)
{
	struct grip_mp *grip = input_get_drvdata(dev);

	gameport_start_polling(grip->gameport);
	return 0;
}

/*
 * Called when a joystick device file is closed
 */

static void grip_close(struct input_dev *dev)
{
	struct grip_mp *grip = input_get_drvdata(dev);

	gameport_stop_polling(grip->gameport);
}

/*
 * Tell the linux input layer about a newly plugged-in gamepad.
 */

static int register_slot(int slot, struct grip_mp *grip)
{
	struct grip_port *port = grip->port[slot];
	struct input_dev *input_dev;
	int j, t;
	int err;

	port->dev = input_dev = input_allocate_device();
	if (!input_dev)
		return -ENOMEM;

	input_dev->name = grip_name[port->mode];
	input_dev->id.bustype = BUS_GAMEPORT;
	input_dev->id.vendor = GAMEPORT_ID_VENDOR_GRAVIS;
	input_dev->id.product = 0x0100 + port->mode;
	input_dev->id.version = 0x0100;
	input_dev->dev.parent = &grip->gameport->dev;

	input_set_drvdata(input_dev, grip);

	input_dev->open = grip_open;
	input_dev->close = grip_close;

	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);

	for (j = 0; (t = grip_abs[port->mode][j]) >= 0; j++)
		input_set_abs_params(input_dev, t, -1, 1, 0, 0);

	for (j = 0; (t = grip_btn[port->mode][j]) >= 0; j++)
		if (t > 0)
			set_bit(t, input_dev->keybit);

	err = input_register_device(port->dev);
	if (err) {
		input_free_device(port->dev);
		return err;
	}

	port->registered = 1;

	if (port->dirty)	            /* report initial state, if any */
		report_slot(grip, slot);

	return 0;
}

static int grip_connect(struct gameport *gameport, struct gameport_driver *drv)
{
	struct grip_mp *grip;
	int err;

	if (!(grip = kzalloc(sizeof(struct grip_mp), GFP_KERNEL)))
		return -ENOMEM;

	grip->gameport = gameport;

	gameport_set_drvdata(gameport, grip);

	err = gameport_open(gameport, drv, GAMEPORT_MODE_RAW);
	if (err)
		goto fail1;

	gameport_set_poll_handler(gameport, grip_poll);
	gameport_set_poll_interval(gameport, 20);

	if (!multiport_init(grip)) {
		err = -ENODEV;
		goto fail2;
	}

	if (!grip->port[0]->mode && !grip->port[1]->mode && !grip->port[2]->mode && !grip->port[3]->mode) {
		/* nothing plugged in */
		err = -ENODEV;
		goto fail2;
	}

	return 0;

fail2:	gameport_close(gameport);
fail1:	gameport_set_drvdata(gameport, NULL);
	kfree(grip);
	return err;
}

static void grip_disconnect(struct gameport *gameport)
{
	struct grip_mp *grip = gameport_get_drvdata(gameport);
	int i;

	for (i = 0; i < 4; i++)
		if (grip->port[i]->registered)
			input_unregister_device(grip->port[i]->dev);
	gameport_close(gameport);
	gameport_set_drvdata(gameport, NULL);
	kfree(grip);
}

static struct gameport_driver grip_drv = {
	.driver		= {
		.name	= "grip_mp",
	},
	.description	= DRIVER_DESC,
	.connect	= grip_connect,
	.disconnect	= grip_disconnect,
};

static int __init grip_init(void)
{
	return gameport_register_driver(&grip_drv);
}

static void __exit grip_exit(void)
{
	gameport_unregister_driver(&grip_drv);
}

module_init(grip_init);
module_exit(grip_exit);
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* Driver for the Gravis Grip Multiport, a gamepad "hub" that
	3	* connects up to four 9-pin digital gamepads/joysticks.
	4	* Driver tested on SMP and UP kernel versions 2.4.18-4 and 2.4.18-5.
	5	*
	6	* Thanks to Chris Gassib for helpful advice.
	7	*
	8	* Copyright (c) 2002 Brian Bonnlander, Bill Soudan
	9	* Copyright (c) 1998-2000 Vojtech Pavlik
	10	*/
	11
	12	#include <linux/kernel.h>
	13	#include <linux/module.h>
	14	#include <linux/init.h>
	15	#include <linux/slab.h>
	16	#include <linux/gameport.h>
	17	#include <linux/input.h>
	18	#include <linux/delay.h>
	19	#include <linux/proc_fs.h>
4e57b681	20	#include <linux/jiffies.h>
1da177e4 LT	21
	22	#define DRIVER_DESC "Gravis Grip Multiport driver"
	23
	24	MODULE_AUTHOR("Brian Bonnlander");
	25	MODULE_DESCRIPTION(DRIVER_DESC);
	26	MODULE_LICENSE("GPL");
	27
	28	#ifdef GRIP_DEBUG
	29	#define dbg(format, arg...) printk(KERN_ERR __FILE__ ": " format "\n" , ## arg)
	30	#else
	31	#define dbg(format, arg...) do {} while (0)
	32	#endif
	33
17dd3f0f	34	#define GRIP_MAX_PORTS 4
1da177e4 LT	35	/*
	36	* Grip multiport state
	37	*/
	38
17dd3f0f DT	39	struct grip_port {
	40	struct input_dev *dev;
	41	int mode;
	42	int registered;
	43
	44	/* individual gamepad states */
	45	int buttons;
	46	int xaxes;
	47	int yaxes;
	48	int dirty; /* has the state been updated? */
	49	};
	50
1da177e4 LT	51	struct grip_mp {
1da177e4 LT	52	struct gameport *gameport;
17dd3f0f	53	struct grip_port *port[GRIP_MAX_PORTS];
1da177e4 LT	54	int reads;
1da177e4 LT	55	int bads;
1da177e4 LT	56	};
	57
	58	/*
	59	* Multiport packet interpretation
	60	*/
	61
	62	#define PACKET_FULL 0x80000000 /* packet is full */
	63	#define PACKET_IO_FAST 0x40000000 /* 3 bits per gameport read */
	64	#define PACKET_IO_SLOW 0x20000000 /* 1 bit per gameport read */
	65	#define PACKET_MP_MORE 0x04000000 /* multiport wants to send more */
	66	#define PACKET_MP_DONE 0x02000000 /* multiport done sending */
	67
	68	/*
	69	* Packet status code interpretation
	70	*/
	71
	72	#define IO_GOT_PACKET 0x0100 /* Got a packet */
	73	#define IO_MODE_FAST 0x0200 /* Used 3 data bits per gameport read */
	74	#define IO_SLOT_CHANGE 0x0800 /* Multiport physical slot status changed */
	75	#define IO_DONE 0x1000 /* Multiport is done sending packets */
	76	#define IO_RETRY 0x4000 /* Try again later to get packet */
	77	#define IO_RESET 0x8000 /* Force multiport to resend all packets */
	78
	79	/*
	80	* Gamepad configuration data. Other 9-pin digital joystick devices
	81	* may work with the multiport, so this may not be an exhaustive list!
	82	* Commodore 64 joystick remains untested.
	83	*/
	84
	85	#define GRIP_INIT_DELAY 2000 /* 2 ms */
	86
	87	#define GRIP_MODE_NONE 0
	88	#define GRIP_MODE_RESET 1
	89	#define GRIP_MODE_GP 2
	90	#define GRIP_MODE_C64 3
	91
17dd3f0f DT	92	static const int grip_btn_gp[] = { BTN_TR, BTN_TL, BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, -1 };
17dd3f0f DT	93	static const int grip_btn_c64[] = { BTN_JOYSTICK, -1 };
1da177e4	94
17dd3f0f DT	95	static const int grip_abs_gp[] = { ABS_X, ABS_Y, -1 };
17dd3f0f DT	96	static const int grip_abs_c64[] = { ABS_X, ABS_Y, -1 };
1da177e4	97
17dd3f0f DT	98	static const int *grip_abs[] = { NULL, NULL, grip_abs_gp, grip_abs_c64 };
17dd3f0f DT	99	static const int *grip_btn[] = { NULL, NULL, grip_btn_gp, grip_btn_c64 };
1da177e4	100
17dd3f0f	101	static const char *grip_name[] = { NULL, NULL, "Gravis Grip Pad", "Commodore 64 Joystick" };
1da177e4 LT	102
	103	static const int init_seq[] = {
	104	1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,
	105	1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,
	106	1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,
	107	0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1 };
	108
	109	/* Maps multiport directional values to X,Y axis values (each axis encoded in 3 bits) */
	110
17dd3f0f	111	static const int axis_map[] = { 5, 9, 1, 5, 6, 10, 2, 6, 4, 8, 0, 4, 5, 9, 1, 5 };
1da177e4	112
17dd3f0f	113	static int register_slot(int i, struct grip_mp *grip);
1da177e4 LT	114
	115	/*
	116	* Returns whether an odd or even number of bits are on in pkt.
	117	*/
	118
	119	static int bit_parity(u32 pkt)
	120	{
	121	int x = pkt ^ (pkt >> 16);
	122	x ^= x >> 8;
	123	x ^= x >> 4;
	124	x ^= x >> 2;
	125	x ^= x >> 1;
	126	return x & 1;
	127	}
	128
	129	/*
	130	* Poll gameport; return true if all bits set in 'onbits' are on and
	131	* all bits set in 'offbits' are off.
	132	*/
	133
	134	static inline int poll_until(u8 onbits, u8 offbits, int u_sec, struct gameport* gp, u8 *data)
	135	{
	136	int i, nloops;
	137
	138	nloops = gameport_time(gp, u_sec);
	139	for (i = 0; i < nloops; i++) {
	140	*data = gameport_read(gp);
	141	if ((*data & onbits) == onbits &&
	142	(~(*data) & offbits) == offbits)
	143	return 1;
	144	}
	145	dbg("gameport timed out after %d microseconds.\n", u_sec);
	146	return 0;
	147	}
	148
	149	/*
	150	* Gets a 28-bit packet from the multiport.
	151	*
	152	* After getting a packet successfully, commands encoded by sendcode may
	153	* be sent to the multiport.
	154	*
	155	* The multiport clock value is reflected in gameport bit B4.
	156	*
	157	* Returns a packet status code indicating whether packet is valid, the transfer
	158	* mode, and any error conditions.
	159	*
	160	* sendflags: current I/O status
	161	* sendcode: data to send to the multiport if sendflags is nonzero
	162	*/
	163
	164	static int mp_io(struct gameport* gameport, int sendflags, int sendcode, u32 *packet)
	165	{
	166	u8 raw_data; /* raw data from gameport */
	167	u8 data_mask; /* packet data bits from raw_data */
	168	u32 pkt; /* packet temporary storage */
	169	int bits_per_read; /* num packet bits per gameport read */
	170	int portvals = 0; /* used for port value sanity check */
	171	int i;
	172
	173	/* Gameport bits B0, B4, B5 should first be off, then B4 should come on. */
	174
	175	*packet = 0;
	176	raw_data = gameport_read(gameport);
	177	if (raw_data & 1)
ab0c3443	178	return IO_RETRY;
1da177e4 LT	179
	180	for (i = 0; i < 64; i++) {
	181	raw_data = gameport_read(gameport);
	182	portvals \|= 1 << ((raw_data >> 4) & 3); /* Demux B4, B5 */
	183	}
	184
	185	if (portvals == 1) { /* B4, B5 off */
	186	raw_data = gameport_read(gameport);
	187	portvals = raw_data & 0xf0;
	188
	189	if (raw_data & 0x31)
	190	return IO_RESET;
	191	gameport_trigger(gameport);
	192
	193	if (!poll_until(0x10, 0, 308, gameport, &raw_data))
	194	return IO_RESET;
	195	} else
	196	return IO_RETRY;
	197
	198	/* Determine packet transfer mode and prepare for packet construction. */
	199
	200	if (raw_data & 0x20) { /* 3 data bits/read */
	201	portvals \|= raw_data >> 4; /* Compare B4-B7 before & after trigger */
	202
	203	if (portvals != 0xb)
	204	return 0;
	205	data_mask = 7;
	206	bits_per_read = 3;
	207	pkt = (PACKET_FULL \| PACKET_IO_FAST) >> 28;
	208	} else { /* 1 data bit/read */
	209	data_mask = 1;
	210	bits_per_read = 1;
	211	pkt = (PACKET_FULL \| PACKET_IO_SLOW) >> 28;
	212	}
	213
	214	/* Construct a packet. Final data bits must be zero. */
	215
	216	while (1) {
	217	if (!poll_until(0, 0x10, 77, gameport, &raw_data))
	218	return IO_RESET;
	219	raw_data = (raw_data >> 5) & data_mask;
	220
	221	if (pkt & PACKET_FULL)
	222	break;
	223	pkt = (pkt << bits_per_read) \| raw_data;
	224
	225	if (!poll_until(0x10, 0, 77, gameport, &raw_data))
	226	return IO_RESET;
	227	}
	228
	229	if (raw_data)
	230	return IO_RESET;
	231
	232	/* If 3 bits/read used, drop from 30 bits to 28. */
	233
	234	if (bits_per_read == 3) {
	235	pkt = (pkt & 0xffff0000) \| ((pkt << 1) & 0xffff);
	236	pkt = (pkt >> 2) \| 0xf0000000;
	237	}
	238
	239	if (bit_parity(pkt) == 1)
	240	return IO_RESET;
	241
	242	/* Acknowledge packet receipt */
243
244	if (!poll_until(0x30, 0, 77, gameport, &raw_data))
245	return IO_RESET;
246
247	raw_data = gameport_read(gameport);
248
249	if (raw_data & 1)
250	return IO_RESET;
251
252	gameport_trigger(gameport);
253
254	if (!poll_until(0, 0x20, 77, gameport, &raw_data))
255	return IO_RESET;
256
257	/* Return if we just wanted the packet or multiport wants to send more */
258
259	*packet = pkt;
260	if ((sendflags == 0) \|\| ((sendflags & IO_RETRY) && !(pkt & PACKET_MP_DONE)))
261	return IO_GOT_PACKET;
262
263	if (pkt & PACKET_MP_MORE)
264	return IO_GOT_PACKET \| IO_RETRY;
265
266	/* Multiport is done sending packets and is ready to receive data */
267
268	if (!poll_until(0x20, 0, 77, gameport, &raw_data))
269	return IO_GOT_PACKET \| IO_RESET;
270
271	raw_data = gameport_read(gameport);
272	if (raw_data & 1)
273	return IO_GOT_PACKET \| IO_RESET;
274
275	/* Trigger gameport based on bits in sendcode */
276
277	gameport_trigger(gameport);
278	do {
279	if (!poll_until(0x20, 0x10, 116, gameport, &raw_data))
280	return IO_GOT_PACKET \| IO_RESET;
281
282	if (!poll_until(0x30, 0, 193, gameport, &raw_data))
283	return IO_GOT_PACKET \| IO_RESET;
284
285	if (raw_data & 1)
286	return IO_GOT_PACKET \| IO_RESET;
287
288	if (sendcode & 1)
289	gameport_trigger(gameport);
290
291	sendcode >>= 1;
292	} while (sendcode);
293
294	return IO_GOT_PACKET \| IO_MODE_FAST;
295	}
296
297	/*
298	* Disables and restores interrupts for mp_io(), which does the actual I/O.
299	*/
300
301	static int multiport_io(struct gameport* gameport, int sendflags, int sendcode, u32 *packet)
302	{
303	int status;
304	unsigned long flags;
305
306	local_irq_save(flags);
307	status = mp_io(gameport, sendflags, sendcode, packet);
308	local_irq_restore(flags);
309
310	return status;
311	}
312
313	/*
314	* Puts multiport into digital mode. Multiport LED turns green.
315	*
316	* Returns true if a valid digital packet was received, false otherwise.
317	*/
318
319	static int dig_mode_start(struct gameport gameport, u32 packet)
320	{
5ec1f7f3	321	int i;
1da177e4 LT	322	int flags, tries = 0, bads = 0;
1da177e4 LT	323
5ec1f7f3	324	for (i = 0; i < ARRAY_SIZE(init_seq); i++) { /* Send magic sequence */
1da177e4 LT	325	if (init_seq[i])
	326	gameport_trigger(gameport);
	327	udelay(GRIP_INIT_DELAY);
	328	}
	329
	330	for (i = 0; i < 16; i++) /* Wait for multiport to settle */
	331	udelay(GRIP_INIT_DELAY);
	332
	333	while (tries < 64 && bads < 8) { /* Reset multiport and try getting a packet */
	334
	335	flags = multiport_io(gameport, IO_RESET, 0x27, packet);
	336
	337	if (flags & IO_MODE_FAST)
	338	return 1;
	339
	340	if (flags & IO_RETRY)
	341	tries++;
	342	else
	343	bads++;
	344	}
	345	return 0;
	346	}
	347
	348	/*
	349	* Packet structure: B0-B15 => gamepad state
	350	* B16-B20 => gamepad device type
	351	* B21-B24 => multiport slot index (1-4)
	352	*
	353	* Known device types: 0x1f (grip pad), 0x0 (no device). Others may exist.
	354	*
	355	* Returns the packet status.
	356	*/
	357
	358	static int get_and_decode_packet(struct grip_mp *grip, int flags)
	359	{
17dd3f0f	360	struct grip_port *port;
1da177e4 LT	361	u32 packet;
1da177e4 LT	362	int joytype = 0;
17dd3f0f	363	int slot;
1da177e4 LT	364
	365	/* Get a packet and check for validity */
	366
	367	flags &= IO_RESET \| IO_RETRY;
	368	flags = multiport_io(grip->gameport, flags, 0, &packet);
	369	grip->reads++;
	370
	371	if (packet & PACKET_MP_DONE)
	372	flags \|= IO_DONE;
	373
	374	if (flags && !(flags & IO_GOT_PACKET)) {
	375	grip->bads++;
	376	return flags;
	377	}
	378
	379	/* Ignore non-gamepad packets, e.g. multiport hardware version */
	380
	381	slot = ((packet >> 21) & 0xf) - 1;
	382	if ((slot < 0) \|\| (slot > 3))
	383	return flags;
	384
17dd3f0f DT	385	port = grip->port[slot];
17dd3f0f DT	386
1da177e4 LT	387	/*
	388	* Handle "reset" packets, which occur at startup, and when gamepads
	389	* are removed or plugged in. May contain configuration of a new gamepad.
	390	*/
	391
	392	joytype = (packet >> 16) & 0x1f;
	393	if (!joytype) {
	394
17dd3f0f	395	if (port->registered) {
1da177e4	396	printk(KERN_INFO "grip_mp: removing %s, slot %d\n",
17dd3f0f DT	397	grip_name[port->mode], slot);
	398	input_unregister_device(port->dev);
	399	port->registered = 0;
1da177e4 LT	400	}
1da177e4 LT	401	dbg("Reset: grip multiport slot %d\n", slot);
17dd3f0f	402	port->mode = GRIP_MODE_RESET;
1da177e4 LT	403	flags \|= IO_SLOT_CHANGE;
	404	return flags;
	405	}
	406
	407	/* Interpret a grip pad packet */
	408
	409	if (joytype == 0x1f) {
	410
	411	int dir = (packet >> 8) & 0xf; /* eight way directional value */
17dd3f0f DT	412	port->buttons = (~packet) & 0xff;
	413	port->yaxes = ((axis_map[dir] >> 2) & 3) - 1;
	414	port->xaxes = (axis_map[dir] & 3) - 1;
	415	port->dirty = 1;
1da177e4	416
17dd3f0f	417	if (port->mode == GRIP_MODE_RESET)
1da177e4 LT	418	flags \|= IO_SLOT_CHANGE;
1da177e4 LT	419
17dd3f0f	420	port->mode = GRIP_MODE_GP;
1da177e4	421
17dd3f0f	422	if (!port->registered) {
1da177e4	423	dbg("New Grip pad in multiport slot %d.\n", slot);
127278ce DT	424	if (register_slot(slot, grip)) {
	425	port->mode = GRIP_MODE_RESET;
	426	port->dirty = 0;
	427	}
1da177e4 LT	428	}
	429	return flags;
	430	}
	431
	432	/* Handle non-grip device codes. For now, just print diagnostics. */
	433
	434	{
	435	static int strange_code = 0;
	436	if (strange_code != joytype) {
	437	printk(KERN_INFO "Possible non-grip pad/joystick detected.\n");
	438	printk(KERN_INFO "Got joy type 0x%x and packet 0x%x.\n", joytype, packet);
	439	strange_code = joytype;
	440	}
	441	}
	442	return flags;
	443	}
	444
	445	/*
	446	* Returns true if all multiport slot states appear valid.
	447	*/
	448
	449	static int slots_valid(struct grip_mp *grip)
	450	{
	451	int flags, slot, invalid = 0, active = 0;
	452
	453	flags = get_and_decode_packet(grip, 0);
	454	if (!(flags & IO_GOT_PACKET))
	455	return 0;
	456
	457	for (slot = 0; slot < 4; slot++) {
17dd3f0f	458	if (grip->port[slot]->mode == GRIP_MODE_RESET)
1da177e4	459	invalid = 1;
17dd3f0f	460	if (grip->port[slot]->mode != GRIP_MODE_NONE)
1da177e4 LT	461	active = 1;
	462	}
	463
	464	/* Return true if no active slot but multiport sent all its data */
	465	if (!active)
	466	return (flags & IO_DONE) ? 1 : 0;
	467
	468	/* Return false if invalid device code received */
	469	return invalid ? 0 : 1;
	470	}
	471
	472	/*
	473	* Returns whether the multiport was placed into digital mode and
	474	* able to communicate its state successfully.
	475	*/
	476
	477	static int multiport_init(struct grip_mp *grip)
	478	{
	479	int dig_mode, initialized = 0, tries = 0;
	480	u32 packet;
	481
	482	dig_mode = dig_mode_start(grip->gameport, &packet);
	483	while (!dig_mode && tries < 4) {
	484	dig_mode = dig_mode_start(grip->gameport, &packet);
	485	tries++;
	486	}
	487
	488	if (dig_mode)
	489	dbg("multiport_init(): digital mode activated.\n");
	490	else {
	491	dbg("multiport_init(): unable to activate digital mode.\n");
	492	return 0;
	493	}
	494
	495	/* Get packets, store multiport state, and check state's validity */
	496	for (tries = 0; tries < 4096; tries++) {
17dd3f0f	497	if (slots_valid(grip)) {
1da177e4 LT	498	initialized = 1;
	499	break;
	500	}
	501	}
	502	dbg("multiport_init(): initialized == %d\n", initialized);
	503	return initialized;
	504	}
	505
	506	/*
	507	* Reports joystick state to the linux input layer.
	508	*/
	509
	510	static void report_slot(struct grip_mp *grip, int slot)
	511	{
17dd3f0f DT	512	struct grip_port *port = grip->port[slot];
17dd3f0f DT	513	int i;
1da177e4 LT	514
	515	/* Store button states with linux input driver */
	516
	517	for (i = 0; i < 8; i++)
17dd3f0f	518	input_report_key(port->dev, grip_btn_gp[i], (port->buttons >> i) & 1);
1da177e4 LT	519
	520	/* Store axis states with linux driver */
	521
17dd3f0f DT	522	input_report_abs(port->dev, ABS_X, port->xaxes);
17dd3f0f DT	523	input_report_abs(port->dev, ABS_Y, port->yaxes);
1da177e4 LT	524
	525	/* Tell the receiver of the events to process them */
	526
17dd3f0f	527	input_sync(port->dev);
1da177e4	528
17dd3f0f	529	port->dirty = 0;
1da177e4 LT	530	}
	531
	532	/*
	533	* Get the multiport state.
	534	*/
	535
	536	static void grip_poll(struct gameport *gameport)
	537	{
	538	struct grip_mp *grip = gameport_get_drvdata(gameport);
	539	int i, npkts, flags;
	540
	541	for (npkts = 0; npkts < 4; npkts++) {
	542	flags = IO_RETRY;
	543	for (i = 0; i < 32; i++) {
	544	flags = get_and_decode_packet(grip, flags);
	545	if ((flags & IO_GOT_PACKET) \|\| !(flags & IO_RETRY))
	546	break;
	547	}
	548	if (flags & IO_DONE)
	549	break;
	550	}
	551
	552	for (i = 0; i < 4; i++)
17dd3f0f	553	if (grip->port[i]->dirty)
1da177e4 LT	554	report_slot(grip, i);
	555	}
	556
	557	/*
	558	* Called when a joystick device file is opened
	559	*/
	560
	561	static int grip_open(struct input_dev *dev)
	562	{
8715c1cf	563	struct grip_mp *grip = input_get_drvdata(dev);
1da177e4 LT	564
	565	gameport_start_polling(grip->gameport);
	566	return 0;
	567	}
	568
	569	/*
	570	* Called when a joystick device file is closed
	571	*/
	572
	573	static void grip_close(struct input_dev *dev)
	574	{
8715c1cf	575	struct grip_mp *grip = input_get_drvdata(dev);
1da177e4	576
8715c1cf	577	gameport_stop_polling(grip->gameport);
1da177e4 LT	578	}
	579
	580	/*
	581	* Tell the linux input layer about a newly plugged-in gamepad.
	582	*/
	583
17dd3f0f	584	static int register_slot(int slot, struct grip_mp *grip)
1da177e4	585	{
17dd3f0f DT	586	struct grip_port *port = grip->port[slot];
17dd3f0f DT	587	struct input_dev *input_dev;
1da177e4	588	int j, t;
127278ce	589	int err;
1da177e4	590
17dd3f0f DT	591	port->dev = input_dev = input_allocate_device();
	592	if (!input_dev)
	593	return -ENOMEM;
	594
	595	input_dev->name = grip_name[port->mode];
	596	input_dev->id.bustype = BUS_GAMEPORT;
	597	input_dev->id.vendor = GAMEPORT_ID_VENDOR_GRAVIS;
	598	input_dev->id.product = 0x0100 + port->mode;
	599	input_dev->id.version = 0x0100;
935e658e	600	input_dev->dev.parent = &grip->gameport->dev;
8715c1cf DT	601
8715c1cf DT	602	input_set_drvdata(input_dev, grip);
17dd3f0f DT	603
	604	input_dev->open = grip_open;
	605	input_dev->close = grip_close;
1da177e4	606
7b19ada2	607	input_dev->evbit[0] = BIT_MASK(EV_KEY) \| BIT_MASK(EV_ABS);
1da177e4	608
17dd3f0f DT	609	for (j = 0; (t = grip_abs[port->mode][j]) >= 0; j++)
	610	input_set_abs_params(input_dev, t, -1, 1, 0, 0);
	611
	612	for (j = 0; (t = grip_btn[port->mode][j]) >= 0; j++)
1da177e4	613	if (t > 0)
17dd3f0f	614	set_bit(t, input_dev->keybit);
1da177e4	615
127278ce DT	616	err = input_register_device(port->dev);
	617	if (err) {
	618	input_free_device(port->dev);
	619	return err;
	620	}
	621
17dd3f0f	622	port->registered = 1;
1da177e4	623
17dd3f0f	624	if (port->dirty) /* report initial state, if any */
1da177e4 LT	625	report_slot(grip, slot);
1da177e4 LT	626
17dd3f0f	627	return 0;
1da177e4 LT	628	}
	629
	630	static int grip_connect(struct gameport gameport, struct gameport_driver drv)
	631	{
	632	struct grip_mp *grip;
	633	int err;
	634
a97e148a	635	if (!(grip = kzalloc(sizeof(struct grip_mp), GFP_KERNEL)))
1da177e4 LT	636	return -ENOMEM;
	637
	638	grip->gameport = gameport;
	639
	640	gameport_set_drvdata(gameport, grip);
	641
	642	err = gameport_open(gameport, drv, GAMEPORT_MODE_RAW);
	643	if (err)
	644	goto fail1;
	645
	646	gameport_set_poll_handler(gameport, grip_poll);
	647	gameport_set_poll_interval(gameport, 20);
	648
	649	if (!multiport_init(grip)) {
	650	err = -ENODEV;
	651	goto fail2;
	652	}
	653
17dd3f0f	654	if (!grip->port[0]->mode && !grip->port[1]->mode && !grip->port[2]->mode && !grip->port[3]->mode) {
1da177e4 LT	655	/* nothing plugged in */
	656	err = -ENODEV;
	657	goto fail2;
	658	}
	659
	660	return 0;
	661
	662	fail2: gameport_close(gameport);
	663	fail1: gameport_set_drvdata(gameport, NULL);
	664	kfree(grip);
	665	return err;
	666	}
	667
	668	static void grip_disconnect(struct gameport *gameport)
	669	{
	670	struct grip_mp *grip = gameport_get_drvdata(gameport);
	671	int i;
	672
	673	for (i = 0; i < 4; i++)
17dd3f0f DT	674	if (grip->port[i]->registered)
17dd3f0f DT	675	input_unregister_device(grip->port[i]->dev);
1da177e4 LT	676	gameport_close(gameport);
	677	gameport_set_drvdata(gameport, NULL);
	678	kfree(grip);
	679	}
	680
	681	static struct gameport_driver grip_drv = {
	682	.driver = {
	683	.name = "grip_mp",
	684	},
	685	.description = DRIVER_DESC,
	686	.connect = grip_connect,
	687	.disconnect = grip_disconnect,
	688	};
	689
	690	static int __init grip_init(void)
	691	{
2547203d	692	return gameport_register_driver(&grip_drv);
1da177e4 LT	693	}
	694
	695	static void __exit grip_exit(void)
	696	{
	697	gameport_unregister_driver(&grip_drv);
	698	}
	699
	700	module_init(grip_init);
	701	module_exit(grip_exit);