[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/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,
};

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