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>
22 #include <linux/jiffies.h>
24 #define DRIVER_DESC "Gravis Grip Multiport driver"
26 MODULE_AUTHOR("Brian Bonnlander");
27 MODULE_DESCRIPTION(DRIVER_DESC);
28 MODULE_LICENSE("GPL");
31 #define dbg(format, arg...) printk(KERN_ERR __FILE__ ": " format "\n" , ## arg)
33 #define dbg(format, arg...) do {} while (0)
36 #define GRIP_MAX_PORTS 4
38 * Grip multiport state
42 struct input_dev *dev;
46 /* individual gamepad states */
50 int dirty; /* has the state been updated? */
54 struct gameport *gameport;
55 struct grip_port *port[GRIP_MAX_PORTS];
56 // struct input_dev *dev[4];
62 /* individual gamepad states */
66 // int dirty[4]; /* has the state been updated? */
70 * Multiport packet interpretation
73 #define PACKET_FULL 0x80000000 /* packet is full */
74 #define PACKET_IO_FAST 0x40000000 /* 3 bits per gameport read */
75 #define PACKET_IO_SLOW 0x20000000 /* 1 bit per gameport read */
76 #define PACKET_MP_MORE 0x04000000 /* multiport wants to send more */
77 #define PACKET_MP_DONE 0x02000000 /* multiport done sending */
80 * Packet status code interpretation
83 #define IO_GOT_PACKET 0x0100 /* Got a packet */
84 #define IO_MODE_FAST 0x0200 /* Used 3 data bits per gameport read */
85 #define IO_SLOT_CHANGE 0x0800 /* Multiport physical slot status changed */
86 #define IO_DONE 0x1000 /* Multiport is done sending packets */
87 #define IO_RETRY 0x4000 /* Try again later to get packet */
88 #define IO_RESET 0x8000 /* Force multiport to resend all packets */
91 * Gamepad configuration data. Other 9-pin digital joystick devices
92 * may work with the multiport, so this may not be an exhaustive list!
93 * Commodore 64 joystick remains untested.
96 #define GRIP_INIT_DELAY 2000 /* 2 ms */
98 #define GRIP_MODE_NONE 0
99 #define GRIP_MODE_RESET 1
100 #define GRIP_MODE_GP 2
101 #define GRIP_MODE_C64 3
103 static const int grip_btn_gp[] = { BTN_TR, BTN_TL, BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, -1 };
104 static const int grip_btn_c64[] = { BTN_JOYSTICK, -1 };
106 static const int grip_abs_gp[] = { ABS_X, ABS_Y, -1 };
107 static const int grip_abs_c64[] = { ABS_X, ABS_Y, -1 };
109 static const int *grip_abs[] = { NULL, NULL, grip_abs_gp, grip_abs_c64 };
110 static const int *grip_btn[] = { NULL, NULL, grip_btn_gp, grip_btn_c64 };
112 static const char *grip_name[] = { NULL, NULL, "Gravis Grip Pad", "Commodore 64 Joystick" };
114 static const int init_seq[] = {
115 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,
116 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,
117 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,
118 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1 };
120 /* Maps multiport directional values to X,Y axis values (each axis encoded in 3 bits) */
122 static const int axis_map[] = { 5, 9, 1, 5, 6, 10, 2, 6, 4, 8, 0, 4, 5, 9, 1, 5 };
124 static int register_slot(int i, struct grip_mp *grip);
127 * Returns whether an odd or even number of bits are on in pkt.
130 static int bit_parity(u32 pkt)
132 int x = pkt ^ (pkt >> 16);
141 * Poll gameport; return true if all bits set in 'onbits' are on and
142 * all bits set in 'offbits' are off.
145 static inline int poll_until(u8 onbits, u8 offbits, int u_sec, struct gameport* gp, u8 *data)
149 nloops = gameport_time(gp, u_sec);
150 for (i = 0; i < nloops; i++) {
151 *data = gameport_read(gp);
152 if ((*data & onbits) == onbits &&
153 (~(*data) & offbits) == offbits)
156 dbg("gameport timed out after %d microseconds.\n", u_sec);
161 * Gets a 28-bit packet from the multiport.
163 * After getting a packet successfully, commands encoded by sendcode may
164 * be sent to the multiport.
166 * The multiport clock value is reflected in gameport bit B4.
168 * Returns a packet status code indicating whether packet is valid, the transfer
169 * mode, and any error conditions.
171 * sendflags: current I/O status
172 * sendcode: data to send to the multiport if sendflags is nonzero
175 static int mp_io(struct gameport* gameport, int sendflags, int sendcode, u32 *packet)
177 u8 raw_data; /* raw data from gameport */
178 u8 data_mask; /* packet data bits from raw_data */
179 u32 pkt; /* packet temporary storage */
180 int bits_per_read; /* num packet bits per gameport read */
181 int portvals = 0; /* used for port value sanity check */
184 /* Gameport bits B0, B4, B5 should first be off, then B4 should come on. */
187 raw_data = gameport_read(gameport);
191 for (i = 0; i < 64; i++) {
192 raw_data = gameport_read(gameport);
193 portvals |= 1 << ((raw_data >> 4) & 3); /* Demux B4, B5 */
196 if (portvals == 1) { /* B4, B5 off */
197 raw_data = gameport_read(gameport);
198 portvals = raw_data & 0xf0;
202 gameport_trigger(gameport);
204 if (!poll_until(0x10, 0, 308, gameport, &raw_data))
209 /* Determine packet transfer mode and prepare for packet construction. */
211 if (raw_data & 0x20) { /* 3 data bits/read */
212 portvals |= raw_data >> 4; /* Compare B4-B7 before & after trigger */
218 pkt = (PACKET_FULL | PACKET_IO_FAST) >> 28;
219 } else { /* 1 data bit/read */
222 pkt = (PACKET_FULL | PACKET_IO_SLOW) >> 28;
225 /* Construct a packet. Final data bits must be zero. */
228 if (!poll_until(0, 0x10, 77, gameport, &raw_data))
230 raw_data = (raw_data >> 5) & data_mask;
232 if (pkt & PACKET_FULL)
234 pkt = (pkt << bits_per_read) | raw_data;
236 if (!poll_until(0x10, 0, 77, gameport, &raw_data))
243 /* If 3 bits/read used, drop from 30 bits to 28. */
245 if (bits_per_read == 3) {
246 pkt = (pkt & 0xffff0000) | ((pkt << 1) & 0xffff);
247 pkt = (pkt >> 2) | 0xf0000000;
250 if (bit_parity(pkt) == 1)
253 /* Acknowledge packet receipt */
255 if (!poll_until(0x30, 0, 77, gameport, &raw_data))
258 raw_data = gameport_read(gameport);
263 gameport_trigger(gameport);
265 if (!poll_until(0, 0x20, 77, gameport, &raw_data))
268 /* Return if we just wanted the packet or multiport wants to send more */
271 if ((sendflags == 0) || ((sendflags & IO_RETRY) && !(pkt & PACKET_MP_DONE)))
272 return IO_GOT_PACKET;
274 if (pkt & PACKET_MP_MORE)
275 return IO_GOT_PACKET | IO_RETRY;
277 /* Multiport is done sending packets and is ready to receive data */
279 if (!poll_until(0x20, 0, 77, gameport, &raw_data))
280 return IO_GOT_PACKET | IO_RESET;
282 raw_data = gameport_read(gameport);
284 return IO_GOT_PACKET | IO_RESET;
286 /* Trigger gameport based on bits in sendcode */
288 gameport_trigger(gameport);
290 if (!poll_until(0x20, 0x10, 116, gameport, &raw_data))
291 return IO_GOT_PACKET | IO_RESET;
293 if (!poll_until(0x30, 0, 193, gameport, &raw_data))
294 return IO_GOT_PACKET | IO_RESET;
297 return IO_GOT_PACKET | IO_RESET;
300 gameport_trigger(gameport);
305 return IO_GOT_PACKET | IO_MODE_FAST;
309 * Disables and restores interrupts for mp_io(), which does the actual I/O.
312 static int multiport_io(struct gameport* gameport, int sendflags, int sendcode, u32 *packet)
317 local_irq_save(flags);
318 status = mp_io(gameport, sendflags, sendcode, packet);
319 local_irq_restore(flags);
325 * Puts multiport into digital mode. Multiport LED turns green.
327 * Returns true if a valid digital packet was received, false otherwise.
330 static int dig_mode_start(struct gameport *gameport, u32 *packet)
332 int i, seq_len = sizeof(init_seq)/sizeof(int);
333 int flags, tries = 0, bads = 0;
335 for (i = 0; i < seq_len; i++) { /* Send magic sequence */
337 gameport_trigger(gameport);
338 udelay(GRIP_INIT_DELAY);
341 for (i = 0; i < 16; i++) /* Wait for multiport to settle */
342 udelay(GRIP_INIT_DELAY);
344 while (tries < 64 && bads < 8) { /* Reset multiport and try getting a packet */
346 flags = multiport_io(gameport, IO_RESET, 0x27, packet);
348 if (flags & IO_MODE_FAST)
351 if (flags & IO_RETRY)
360 * Packet structure: B0-B15 => gamepad state
361 * B16-B20 => gamepad device type
362 * B21-B24 => multiport slot index (1-4)
364 * Known device types: 0x1f (grip pad), 0x0 (no device). Others may exist.
366 * Returns the packet status.
369 static int get_and_decode_packet(struct grip_mp *grip, int flags)
371 struct grip_port *port;
376 /* Get a packet and check for validity */
378 flags &= IO_RESET | IO_RETRY;
379 flags = multiport_io(grip->gameport, flags, 0, &packet);
382 if (packet & PACKET_MP_DONE)
385 if (flags && !(flags & IO_GOT_PACKET)) {
390 /* Ignore non-gamepad packets, e.g. multiport hardware version */
392 slot = ((packet >> 21) & 0xf) - 1;
393 if ((slot < 0) || (slot > 3))
396 port = grip->port[slot];
399 * Handle "reset" packets, which occur at startup, and when gamepads
400 * are removed or plugged in. May contain configuration of a new gamepad.
403 joytype = (packet >> 16) & 0x1f;
406 if (port->registered) {
407 printk(KERN_INFO "grip_mp: removing %s, slot %d\n",
408 grip_name[port->mode], slot);
409 input_unregister_device(port->dev);
410 port->registered = 0;
412 dbg("Reset: grip multiport slot %d\n", slot);
413 port->mode = GRIP_MODE_RESET;
414 flags |= IO_SLOT_CHANGE;
418 /* Interpret a grip pad packet */
420 if (joytype == 0x1f) {
422 int dir = (packet >> 8) & 0xf; /* eight way directional value */
423 port->buttons = (~packet) & 0xff;
424 port->yaxes = ((axis_map[dir] >> 2) & 3) - 1;
425 port->xaxes = (axis_map[dir] & 3) - 1;
428 if (port->mode == GRIP_MODE_RESET)
429 flags |= IO_SLOT_CHANGE;
431 port->mode = GRIP_MODE_GP;
433 if (!port->registered) {
434 dbg("New Grip pad in multiport slot %d.\n", slot);
435 register_slot(slot, grip);
440 /* Handle non-grip device codes. For now, just print diagnostics. */
443 static int strange_code = 0;
444 if (strange_code != joytype) {
445 printk(KERN_INFO "Possible non-grip pad/joystick detected.\n");
446 printk(KERN_INFO "Got joy type 0x%x and packet 0x%x.\n", joytype, packet);
447 strange_code = joytype;
454 * Returns true if all multiport slot states appear valid.
457 static int slots_valid(struct grip_mp *grip)
459 int flags, slot, invalid = 0, active = 0;
461 flags = get_and_decode_packet(grip, 0);
462 if (!(flags & IO_GOT_PACKET))
465 for (slot = 0; slot < 4; slot++) {
466 if (grip->port[slot]->mode == GRIP_MODE_RESET)
468 if (grip->port[slot]->mode != GRIP_MODE_NONE)
472 /* Return true if no active slot but multiport sent all its data */
474 return (flags & IO_DONE) ? 1 : 0;
476 /* Return false if invalid device code received */
477 return invalid ? 0 : 1;
481 * Returns whether the multiport was placed into digital mode and
482 * able to communicate its state successfully.
485 static int multiport_init(struct grip_mp *grip)
487 int dig_mode, initialized = 0, tries = 0;
490 dig_mode = dig_mode_start(grip->gameport, &packet);
491 while (!dig_mode && tries < 4) {
492 dig_mode = dig_mode_start(grip->gameport, &packet);
497 dbg("multiport_init(): digital mode activated.\n");
499 dbg("multiport_init(): unable to activate digital mode.\n");
503 /* Get packets, store multiport state, and check state's validity */
504 for (tries = 0; tries < 4096; tries++) {
505 if (slots_valid(grip)) {
510 dbg("multiport_init(): initialized == %d\n", initialized);
515 * Reports joystick state to the linux input layer.
518 static void report_slot(struct grip_mp *grip, int slot)
520 struct grip_port *port = grip->port[slot];
523 /* Store button states with linux input driver */
525 for (i = 0; i < 8; i++)
526 input_report_key(port->dev, grip_btn_gp[i], (port->buttons >> i) & 1);
528 /* Store axis states with linux driver */
530 input_report_abs(port->dev, ABS_X, port->xaxes);
531 input_report_abs(port->dev, ABS_Y, port->yaxes);
533 /* Tell the receiver of the events to process them */
535 input_sync(port->dev);
541 * Get the multiport state.
544 static void grip_poll(struct gameport *gameport)
546 struct grip_mp *grip = gameport_get_drvdata(gameport);
549 for (npkts = 0; npkts < 4; npkts++) {
551 for (i = 0; i < 32; i++) {
552 flags = get_and_decode_packet(grip, flags);
553 if ((flags & IO_GOT_PACKET) || !(flags & IO_RETRY))
560 for (i = 0; i < 4; i++)
561 if (grip->port[i]->dirty)
562 report_slot(grip, i);
566 * Called when a joystick device file is opened
569 static int grip_open(struct input_dev *dev)
571 struct grip_mp *grip = dev->private;
573 gameport_start_polling(grip->gameport);
578 * Called when a joystick device file is closed
581 static void grip_close(struct input_dev *dev)
583 struct grip_mp *grip = dev->private;
585 gameport_start_polling(grip->gameport);
589 * Tell the linux input layer about a newly plugged-in gamepad.
592 static int register_slot(int slot, struct grip_mp *grip)
594 struct grip_port *port = grip->port[slot];
595 struct input_dev *input_dev;
598 port->dev = input_dev = input_allocate_device();
602 input_dev->name = grip_name[port->mode];
603 input_dev->id.bustype = BUS_GAMEPORT;
604 input_dev->id.vendor = GAMEPORT_ID_VENDOR_GRAVIS;
605 input_dev->id.product = 0x0100 + port->mode;
606 input_dev->id.version = 0x0100;
607 input_dev->cdev.dev = &grip->gameport->dev;
608 input_dev->private = grip;
610 input_dev->open = grip_open;
611 input_dev->close = grip_close;
613 input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
615 for (j = 0; (t = grip_abs[port->mode][j]) >= 0; j++)
616 input_set_abs_params(input_dev, t, -1, 1, 0, 0);
618 for (j = 0; (t = grip_btn[port->mode][j]) >= 0; j++)
620 set_bit(t, input_dev->keybit);
622 input_register_device(port->dev);
623 port->registered = 1;
625 if (port->dirty) /* report initial state, if any */
626 report_slot(grip, slot);
631 static int grip_connect(struct gameport *gameport, struct gameport_driver *drv)
633 struct grip_mp *grip;
636 if (!(grip = kzalloc(sizeof(struct grip_mp), GFP_KERNEL)))
639 grip->gameport = gameport;
641 gameport_set_drvdata(gameport, grip);
643 err = gameport_open(gameport, drv, GAMEPORT_MODE_RAW);
647 gameport_set_poll_handler(gameport, grip_poll);
648 gameport_set_poll_interval(gameport, 20);
650 if (!multiport_init(grip)) {
655 if (!grip->port[0]->mode && !grip->port[1]->mode && !grip->port[2]->mode && !grip->port[3]->mode) {
656 /* nothing plugged in */
663 fail2: gameport_close(gameport);
664 fail1: gameport_set_drvdata(gameport, NULL);
669 static void grip_disconnect(struct gameport *gameport)
671 struct grip_mp *grip = gameport_get_drvdata(gameport);
674 for (i = 0; i < 4; i++)
675 if (grip->port[i]->registered)
676 input_unregister_device(grip->port[i]->dev);
677 gameport_close(gameport);
678 gameport_set_drvdata(gameport, NULL);
682 static struct gameport_driver grip_drv = {
686 .description = DRIVER_DESC,
687 .connect = grip_connect,
688 .disconnect = grip_disconnect,
691 static int __init grip_init(void)
693 gameport_register_driver(&grip_drv);
697 static void __exit grip_exit(void)
699 gameport_unregister_driver(&grip_drv);
702 module_init(grip_init);
703 module_exit(grip_exit);