2 * $Id: grip_mp.c,v 1.9 2002/07/20 19:28:45 bonnland Exp $
4 * Driver for the Gravis Grip Multiport, a gamepad "hub" that
5 * connects up to four 9-pin digital gamepads/joysticks.
6 * Driver tested on SMP and UP kernel versions 2.4.18-4 and 2.4.18-5.
8 * Thanks to Chris Gassib for helpful advice.
10 * Copyright (c) 2002 Brian Bonnlander, Bill Soudan
11 * Copyright (c) 1998-2000 Vojtech Pavlik
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/slab.h>
18 #include <linux/gameport.h>
19 #include <linux/input.h>
20 #include <linux/delay.h>
21 #include <linux/proc_fs.h>
23 MODULE_AUTHOR("Brian Bonnlander");
24 MODULE_DESCRIPTION("Gravis Grip Multiport driver");
25 MODULE_LICENSE("GPL");
28 #define dbg(format, arg...) printk(KERN_ERR __FILE__ ": " format "\n" , ## arg)
30 #define dbg(format, arg...) do {} while (0)
34 * Grip multiport state
38 struct gameport *gameport;
39 struct timer_list timer;
40 struct input_dev dev[4];
47 /* individual gamepad states */
51 int dirty[4]; /* has the state been updated? */
55 * Multiport packet interpretation
58 #define PACKET_FULL 0x80000000 /* packet is full */
59 #define PACKET_IO_FAST 0x40000000 /* 3 bits per gameport read */
60 #define PACKET_IO_SLOW 0x20000000 /* 1 bit per gameport read */
61 #define PACKET_MP_MORE 0x04000000 /* multiport wants to send more */
62 #define PACKET_MP_DONE 0x02000000 /* multiport done sending */
65 * Packet status code interpretation
68 #define IO_GOT_PACKET 0x0100 /* Got a packet */
69 #define IO_MODE_FAST 0x0200 /* Used 3 data bits per gameport read */
70 #define IO_SLOT_CHANGE 0x0800 /* Multiport physical slot status changed */
71 #define IO_DONE 0x1000 /* Multiport is done sending packets */
72 #define IO_RETRY 0x4000 /* Try again later to get packet */
73 #define IO_RESET 0x8000 /* Force multiport to resend all packets */
76 * Gamepad configuration data. Other 9-pin digital joystick devices
77 * may work with the multiport, so this may not be an exhaustive list!
78 * Commodore 64 joystick remains untested.
81 #define GRIP_INIT_DELAY 2000 /* 2 ms */
82 #define GRIP_REFRESH_TIME HZ/50 /* 20 ms */
84 #define GRIP_MODE_NONE 0
85 #define GRIP_MODE_RESET 1
86 #define GRIP_MODE_GP 2
87 #define GRIP_MODE_C64 3
89 static int grip_btn_gp[] = { BTN_TR, BTN_TL, BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, -1 };
90 static int grip_btn_c64[] = { BTN_JOYSTICK, -1 };
92 static int grip_abs_gp[] = { ABS_X, ABS_Y, -1 };
93 static int grip_abs_c64[] = { ABS_X, ABS_Y, -1 };
95 static int *grip_abs[] = { NULL, NULL, grip_abs_gp, grip_abs_c64 };
96 static int *grip_btn[] = { NULL, NULL, grip_btn_gp, grip_btn_c64 };
98 static char *grip_name[] = { NULL, NULL, "Gravis Grip Pad", "Commodore 64 Joystick" };
100 static const int init_seq[] = {
101 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,
102 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,
103 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,
104 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1 };
106 /* Maps multiport directional values to X,Y axis values (each axis encoded in 3 bits) */
108 static int axis_map[] = { 5, 9, 1, 5, 6, 10, 2, 6, 4, 8, 0, 4, 5, 9, 1, 5 };
111 * Returns whether an odd or even number of bits are on in pkt.
114 static int bit_parity(u32 pkt)
116 int x = pkt ^ (pkt >> 16);
125 * Poll gameport; return true if all bits set in 'onbits' are on and
126 * all bits set in 'offbits' are off.
129 static inline int poll_until(u8 onbits, u8 offbits, int u_sec, struct gameport* gp, u8 *data)
133 nloops = gameport_time(gp, u_sec);
134 for (i = 0; i < nloops; i++) {
135 *data = gameport_read(gp);
136 if ((*data & onbits) == onbits &&
137 (~(*data) & offbits) == offbits)
140 dbg("gameport timed out after %d microseconds.\n", u_sec);
145 * Gets a 28-bit packet from the multiport.
147 * After getting a packet successfully, commands encoded by sendcode may
148 * be sent to the multiport.
150 * The multiport clock value is reflected in gameport bit B4.
152 * Returns a packet status code indicating whether packet is valid, the transfer
153 * mode, and any error conditions.
155 * sendflags: current I/O status
156 * sendcode: data to send to the multiport if sendflags is nonzero
159 static int mp_io(struct gameport* gameport, int sendflags, int sendcode, u32 *packet)
161 u8 raw_data; /* raw data from gameport */
162 u8 data_mask; /* packet data bits from raw_data */
163 u32 pkt; /* packet temporary storage */
164 int bits_per_read; /* num packet bits per gameport read */
165 int portvals = 0; /* used for port value sanity check */
168 /* Gameport bits B0, B4, B5 should first be off, then B4 should come on. */
171 raw_data = gameport_read(gameport);
175 for (i = 0; i < 64; i++) {
176 raw_data = gameport_read(gameport);
177 portvals |= 1 << ((raw_data >> 4) & 3); /* Demux B4, B5 */
180 if (portvals == 1) { /* B4, B5 off */
181 raw_data = gameport_read(gameport);
182 portvals = raw_data & 0xf0;
186 gameport_trigger(gameport);
188 if (!poll_until(0x10, 0, 308, gameport, &raw_data))
193 /* Determine packet transfer mode and prepare for packet construction. */
195 if (raw_data & 0x20) { /* 3 data bits/read */
196 portvals |= raw_data >> 4; /* Compare B4-B7 before & after trigger */
202 pkt = (PACKET_FULL | PACKET_IO_FAST) >> 28;
203 } else { /* 1 data bit/read */
206 pkt = (PACKET_FULL | PACKET_IO_SLOW) >> 28;
209 /* Construct a packet. Final data bits must be zero. */
212 if (!poll_until(0, 0x10, 77, gameport, &raw_data))
214 raw_data = (raw_data >> 5) & data_mask;
216 if (pkt & PACKET_FULL)
218 pkt = (pkt << bits_per_read) | raw_data;
220 if (!poll_until(0x10, 0, 77, gameport, &raw_data))
227 /* If 3 bits/read used, drop from 30 bits to 28. */
229 if (bits_per_read == 3) {
230 pkt = (pkt & 0xffff0000) | ((pkt << 1) & 0xffff);
231 pkt = (pkt >> 2) | 0xf0000000;
234 if (bit_parity(pkt) == 1)
237 /* Acknowledge packet receipt */
239 if (!poll_until(0x30, 0, 77, gameport, &raw_data))
242 raw_data = gameport_read(gameport);
247 gameport_trigger(gameport);
249 if (!poll_until(0, 0x20, 77, gameport, &raw_data))
252 /* Return if we just wanted the packet or multiport wants to send more */
255 if ((sendflags == 0) || ((sendflags & IO_RETRY) && !(pkt & PACKET_MP_DONE)))
256 return IO_GOT_PACKET;
258 if (pkt & PACKET_MP_MORE)
259 return IO_GOT_PACKET | IO_RETRY;
261 /* Multiport is done sending packets and is ready to receive data */
263 if (!poll_until(0x20, 0, 77, gameport, &raw_data))
264 return IO_GOT_PACKET | IO_RESET;
266 raw_data = gameport_read(gameport);
268 return IO_GOT_PACKET | IO_RESET;
270 /* Trigger gameport based on bits in sendcode */
272 gameport_trigger(gameport);
274 if (!poll_until(0x20, 0x10, 116, gameport, &raw_data))
275 return IO_GOT_PACKET | IO_RESET;
277 if (!poll_until(0x30, 0, 193, gameport, &raw_data))
278 return IO_GOT_PACKET | IO_RESET;
281 return IO_GOT_PACKET | IO_RESET;
284 gameport_trigger(gameport);
289 return IO_GOT_PACKET | IO_MODE_FAST;
293 * Disables and restores interrupts for mp_io(), which does the actual I/O.
296 static int multiport_io(struct gameport* gameport, int sendflags, int sendcode, u32 *packet)
301 local_irq_save(flags);
302 status = mp_io(gameport, sendflags, sendcode, packet);
303 local_irq_restore(flags);
309 * Puts multiport into digital mode. Multiport LED turns green.
311 * Returns true if a valid digital packet was received, false otherwise.
314 static int dig_mode_start(struct gameport *gameport, u32 *packet)
316 int i, seq_len = sizeof(init_seq)/sizeof(int);
317 int flags, tries = 0, bads = 0;
319 for (i = 0; i < seq_len; i++) { /* Send magic sequence */
321 gameport_trigger(gameport);
322 udelay(GRIP_INIT_DELAY);
325 for (i = 0; i < 16; i++) /* Wait for multiport to settle */
326 udelay(GRIP_INIT_DELAY);
328 while (tries < 64 && bads < 8) { /* Reset multiport and try getting a packet */
330 flags = multiport_io(gameport, IO_RESET, 0x27, packet);
332 if (flags & IO_MODE_FAST)
335 if (flags & IO_RETRY)
344 * Packet structure: B0-B15 => gamepad state
345 * B16-B20 => gamepad device type
346 * B21-B24 => multiport slot index (1-4)
348 * Known device types: 0x1f (grip pad), 0x0 (no device). Others may exist.
350 * Returns the packet status.
353 static int get_and_decode_packet(struct grip_mp *grip, int flags)
358 static void register_slot(int i, struct grip_mp *grip);
360 /* Get a packet and check for validity */
362 flags &= IO_RESET | IO_RETRY;
363 flags = multiport_io(grip->gameport, flags, 0, &packet);
366 if (packet & PACKET_MP_DONE)
369 if (flags && !(flags & IO_GOT_PACKET)) {
374 /* Ignore non-gamepad packets, e.g. multiport hardware version */
376 slot = ((packet >> 21) & 0xf) - 1;
377 if ((slot < 0) || (slot > 3))
381 * Handle "reset" packets, which occur at startup, and when gamepads
382 * are removed or plugged in. May contain configuration of a new gamepad.
385 joytype = (packet >> 16) & 0x1f;
388 if (grip->registered[slot]) {
389 printk(KERN_INFO "grip_mp: removing %s, slot %d\n",
390 grip_name[grip->mode[slot]], slot);
391 input_unregister_device(grip->dev + slot);
392 grip->registered[slot] = 0;
394 dbg("Reset: grip multiport slot %d\n", slot);
395 grip->mode[slot] = GRIP_MODE_RESET;
396 flags |= IO_SLOT_CHANGE;
400 /* Interpret a grip pad packet */
402 if (joytype == 0x1f) {
404 int dir = (packet >> 8) & 0xf; /* eight way directional value */
405 grip->buttons[slot] = (~packet) & 0xff;
406 grip->yaxes[slot] = ((axis_map[dir] >> 2) & 3) - 1;
407 grip->xaxes[slot] = (axis_map[dir] & 3) - 1;
408 grip->dirty[slot] = 1;
410 if (grip->mode[slot] == GRIP_MODE_RESET)
411 flags |= IO_SLOT_CHANGE;
413 grip->mode[slot] = GRIP_MODE_GP;
415 if (!grip->registered[slot]) {
416 dbg("New Grip pad in multiport slot %d.\n", slot);
417 register_slot(slot, grip);
422 /* Handle non-grip device codes. For now, just print diagnostics. */
425 static int strange_code = 0;
426 if (strange_code != joytype) {
427 printk(KERN_INFO "Possible non-grip pad/joystick detected.\n");
428 printk(KERN_INFO "Got joy type 0x%x and packet 0x%x.\n", joytype, packet);
429 strange_code = joytype;
436 * Returns true if all multiport slot states appear valid.
439 static int slots_valid(struct grip_mp *grip)
441 int flags, slot, invalid = 0, active = 0;
443 flags = get_and_decode_packet(grip, 0);
444 if (!(flags & IO_GOT_PACKET))
447 for (slot = 0; slot < 4; slot++) {
448 if (grip->mode[slot] == GRIP_MODE_RESET)
450 if (grip->mode[slot] != GRIP_MODE_NONE)
454 /* Return true if no active slot but multiport sent all its data */
456 return (flags & IO_DONE) ? 1 : 0;
458 /* Return false if invalid device code received */
459 return invalid ? 0 : 1;
463 * Returns whether the multiport was placed into digital mode and
464 * able to communicate its state successfully.
467 static int multiport_init(struct grip_mp *grip)
469 int dig_mode, initialized = 0, tries = 0;
472 dig_mode = dig_mode_start(grip->gameport, &packet);
473 while (!dig_mode && tries < 4) {
474 dig_mode = dig_mode_start(grip->gameport, &packet);
479 dbg("multiport_init(): digital mode achieved.\n");
481 dbg("multiport_init(): unable to achieve digital mode.\n");
485 /* Get packets, store multiport state, and check state's validity */
486 for (tries = 0; tries < 4096; tries++) {
487 if ( slots_valid(grip) ) {
492 dbg("multiport_init(): initialized == %d\n", initialized);
497 * Reports joystick state to the linux input layer.
500 static void report_slot(struct grip_mp *grip, int slot)
502 struct input_dev *dev = &(grip->dev[slot]);
503 int i, buttons = grip->buttons[slot];
505 /* Store button states with linux input driver */
507 for (i = 0; i < 8; i++)
508 input_report_key(dev, grip_btn_gp[i], (buttons >> i) & 1);
510 /* Store axis states with linux driver */
512 input_report_abs(dev, ABS_X, grip->xaxes[slot]);
513 input_report_abs(dev, ABS_Y, grip->yaxes[slot]);
515 /* Tell the receiver of the events to process them */
519 grip->dirty[slot] = 0;
523 * Get the multiport state.
526 static void get_and_report_mp_state(struct grip_mp *grip)
530 for (npkts = 0; npkts < 4; npkts++) {
532 for (i = 0; i < 32; i++) {
533 flags = get_and_decode_packet(grip, flags);
534 if ((flags & IO_GOT_PACKET) || !(flags & IO_RETRY))
541 for (i = 0; i < 4; i++)
543 report_slot(grip, i);
547 * Called when a joystick device file is opened
550 static int grip_open(struct input_dev *dev)
552 struct grip_mp *grip = dev->private;
554 mod_timer(&grip->timer, jiffies + GRIP_REFRESH_TIME);
559 * Called when a joystick device file is closed
562 static void grip_close(struct input_dev *dev)
564 struct grip_mp *grip = dev->private;
566 del_timer(&grip->timer);
570 * Tell the linux input layer about a newly plugged-in gamepad.
573 static void register_slot(int slot, struct grip_mp *grip)
577 grip->dev[slot].private = grip;
578 grip->dev[slot].open = grip_open;
579 grip->dev[slot].close = grip_close;
580 grip->dev[slot].name = grip_name[grip->mode[slot]];
581 grip->dev[slot].id.bustype = BUS_GAMEPORT;
582 grip->dev[slot].id.vendor = GAMEPORT_ID_VENDOR_GRAVIS;
583 grip->dev[slot].id.product = 0x0100 + grip->mode[slot];
584 grip->dev[slot].id.version = 0x0100;
585 grip->dev[slot].evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
587 for (j = 0; (t = grip_abs[grip->mode[slot]][j]) >= 0; j++) {
588 set_bit(t, grip->dev[slot].absbit);
589 grip->dev[slot].absmin[t] = -1;
590 grip->dev[slot].absmax[t] = 1;
593 for (j = 0; (t = grip_btn[grip->mode[slot]][j]) >= 0; j++)
595 set_bit(t, grip->dev[slot].keybit);
597 input_register_device(grip->dev + slot);
598 grip->registered[slot] = 1;
600 if (grip->dirty[slot]) /* report initial state, if any */
601 report_slot(grip, slot);
603 printk(KERN_INFO "grip_mp: added %s, slot %d\n",
604 grip_name[grip->mode[slot]], slot);
608 * Repeatedly polls the multiport and generates events.
611 static void grip_timer(unsigned long private)
613 struct grip_mp *grip = (void*) private;
614 get_and_report_mp_state(grip);
615 mod_timer(&grip->timer, jiffies + GRIP_REFRESH_TIME);
618 static void grip_connect(struct gameport *gameport, struct gameport_dev *dev)
620 struct grip_mp *grip;
622 if (!(grip = kmalloc(sizeof(struct grip_mp), GFP_KERNEL)))
624 memset(grip, 0, sizeof(struct grip_mp));
625 gameport->private = grip;
626 grip->gameport = gameport;
627 init_timer(&grip->timer);
628 grip->timer.data = (long) grip;
629 grip->timer.function = grip_timer;
631 if (gameport_open(gameport, dev, GAMEPORT_MODE_RAW))
633 if (!multiport_init(grip))
635 if (!grip->mode[0] && !grip->mode[1] && /* nothing plugged in */
636 !grip->mode[2] && !grip->mode[3])
640 fail2: gameport_close(gameport);
644 static void grip_disconnect(struct gameport *gameport)
648 struct grip_mp *grip = gameport->private;
649 for (i = 0; i < 4; i++)
650 if (grip->registered[i])
651 input_unregister_device(grip->dev + i);
652 gameport_close(gameport);
656 static struct gameport_dev grip_dev = {
657 .connect = grip_connect,
658 .disconnect = grip_disconnect,
661 static int grip_init(void)
663 gameport_register_device(&grip_dev);
667 static void grip_exit(void)
669 gameport_unregister_device(&grip_dev);
672 module_init(grip_init);
673 module_exit(grip_exit);