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 #define DRIVER_DESC "Gravis Grip Multiport driver"
25 MODULE_AUTHOR("Brian Bonnlander");
26 MODULE_DESCRIPTION(DRIVER_DESC);
27 MODULE_LICENSE("GPL");
30 #define dbg(format, arg...) printk(KERN_ERR __FILE__ ": " format "\n" , ## arg)
32 #define dbg(format, arg...) do {} while (0)
35 #define GRIP_MAX_PORTS 4
37 * Grip multiport state
41 struct input_dev *dev;
45 /* individual gamepad states */
49 int dirty; /* has the state been updated? */
53 struct gameport *gameport;
54 struct grip_port *port[GRIP_MAX_PORTS];
55 // struct input_dev *dev[4];
61 /* individual gamepad states */
65 // int dirty[4]; /* has the state been updated? */
69 * Multiport packet interpretation
72 #define PACKET_FULL 0x80000000 /* packet is full */
73 #define PACKET_IO_FAST 0x40000000 /* 3 bits per gameport read */
74 #define PACKET_IO_SLOW 0x20000000 /* 1 bit per gameport read */
75 #define PACKET_MP_MORE 0x04000000 /* multiport wants to send more */
76 #define PACKET_MP_DONE 0x02000000 /* multiport done sending */
79 * Packet status code interpretation
82 #define IO_GOT_PACKET 0x0100 /* Got a packet */
83 #define IO_MODE_FAST 0x0200 /* Used 3 data bits per gameport read */
84 #define IO_SLOT_CHANGE 0x0800 /* Multiport physical slot status changed */
85 #define IO_DONE 0x1000 /* Multiport is done sending packets */
86 #define IO_RETRY 0x4000 /* Try again later to get packet */
87 #define IO_RESET 0x8000 /* Force multiport to resend all packets */
90 * Gamepad configuration data. Other 9-pin digital joystick devices
91 * may work with the multiport, so this may not be an exhaustive list!
92 * Commodore 64 joystick remains untested.
95 #define GRIP_INIT_DELAY 2000 /* 2 ms */
97 #define GRIP_MODE_NONE 0
98 #define GRIP_MODE_RESET 1
99 #define GRIP_MODE_GP 2
100 #define GRIP_MODE_C64 3
102 static const int grip_btn_gp[] = { BTN_TR, BTN_TL, BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, -1 };
103 static const int grip_btn_c64[] = { BTN_JOYSTICK, -1 };
105 static const int grip_abs_gp[] = { ABS_X, ABS_Y, -1 };
106 static const int grip_abs_c64[] = { ABS_X, ABS_Y, -1 };
108 static const int *grip_abs[] = { NULL, NULL, grip_abs_gp, grip_abs_c64 };
109 static const int *grip_btn[] = { NULL, NULL, grip_btn_gp, grip_btn_c64 };
111 static const char *grip_name[] = { NULL, NULL, "Gravis Grip Pad", "Commodore 64 Joystick" };
113 static const int init_seq[] = {
114 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,
115 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,
116 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,
117 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1 };
119 /* Maps multiport directional values to X,Y axis values (each axis encoded in 3 bits) */
121 static const int axis_map[] = { 5, 9, 1, 5, 6, 10, 2, 6, 4, 8, 0, 4, 5, 9, 1, 5 };
123 static int register_slot(int i, struct grip_mp *grip);
126 * Returns whether an odd or even number of bits are on in pkt.
129 static int bit_parity(u32 pkt)
131 int x = pkt ^ (pkt >> 16);
140 * Poll gameport; return true if all bits set in 'onbits' are on and
141 * all bits set in 'offbits' are off.
144 static inline int poll_until(u8 onbits, u8 offbits, int u_sec, struct gameport* gp, u8 *data)
148 nloops = gameport_time(gp, u_sec);
149 for (i = 0; i < nloops; i++) {
150 *data = gameport_read(gp);
151 if ((*data & onbits) == onbits &&
152 (~(*data) & offbits) == offbits)
155 dbg("gameport timed out after %d microseconds.\n", u_sec);
160 * Gets a 28-bit packet from the multiport.
162 * After getting a packet successfully, commands encoded by sendcode may
163 * be sent to the multiport.
165 * The multiport clock value is reflected in gameport bit B4.
167 * Returns a packet status code indicating whether packet is valid, the transfer
168 * mode, and any error conditions.
170 * sendflags: current I/O status
171 * sendcode: data to send to the multiport if sendflags is nonzero
174 static int mp_io(struct gameport* gameport, int sendflags, int sendcode, u32 *packet)
176 u8 raw_data; /* raw data from gameport */
177 u8 data_mask; /* packet data bits from raw_data */
178 u32 pkt; /* packet temporary storage */
179 int bits_per_read; /* num packet bits per gameport read */
180 int portvals = 0; /* used for port value sanity check */
183 /* Gameport bits B0, B4, B5 should first be off, then B4 should come on. */
186 raw_data = gameport_read(gameport);
190 for (i = 0; i < 64; i++) {
191 raw_data = gameport_read(gameport);
192 portvals |= 1 << ((raw_data >> 4) & 3); /* Demux B4, B5 */
195 if (portvals == 1) { /* B4, B5 off */
196 raw_data = gameport_read(gameport);
197 portvals = raw_data & 0xf0;
201 gameport_trigger(gameport);
203 if (!poll_until(0x10, 0, 308, gameport, &raw_data))
208 /* Determine packet transfer mode and prepare for packet construction. */
210 if (raw_data & 0x20) { /* 3 data bits/read */
211 portvals |= raw_data >> 4; /* Compare B4-B7 before & after trigger */
217 pkt = (PACKET_FULL | PACKET_IO_FAST) >> 28;
218 } else { /* 1 data bit/read */
221 pkt = (PACKET_FULL | PACKET_IO_SLOW) >> 28;
224 /* Construct a packet. Final data bits must be zero. */
227 if (!poll_until(0, 0x10, 77, gameport, &raw_data))
229 raw_data = (raw_data >> 5) & data_mask;
231 if (pkt & PACKET_FULL)
233 pkt = (pkt << bits_per_read) | raw_data;
235 if (!poll_until(0x10, 0, 77, gameport, &raw_data))
242 /* If 3 bits/read used, drop from 30 bits to 28. */
244 if (bits_per_read == 3) {
245 pkt = (pkt & 0xffff0000) | ((pkt << 1) & 0xffff);
246 pkt = (pkt >> 2) | 0xf0000000;
249 if (bit_parity(pkt) == 1)
252 /* Acknowledge packet receipt */
254 if (!poll_until(0x30, 0, 77, gameport, &raw_data))
257 raw_data = gameport_read(gameport);
262 gameport_trigger(gameport);
264 if (!poll_until(0, 0x20, 77, gameport, &raw_data))
267 /* Return if we just wanted the packet or multiport wants to send more */
270 if ((sendflags == 0) || ((sendflags & IO_RETRY) && !(pkt & PACKET_MP_DONE)))
271 return IO_GOT_PACKET;
273 if (pkt & PACKET_MP_MORE)
274 return IO_GOT_PACKET | IO_RETRY;
276 /* Multiport is done sending packets and is ready to receive data */
278 if (!poll_until(0x20, 0, 77, gameport, &raw_data))
279 return IO_GOT_PACKET | IO_RESET;
281 raw_data = gameport_read(gameport);
283 return IO_GOT_PACKET | IO_RESET;
285 /* Trigger gameport based on bits in sendcode */
287 gameport_trigger(gameport);
289 if (!poll_until(0x20, 0x10, 116, gameport, &raw_data))
290 return IO_GOT_PACKET | IO_RESET;
292 if (!poll_until(0x30, 0, 193, gameport, &raw_data))
293 return IO_GOT_PACKET | IO_RESET;
296 return IO_GOT_PACKET | IO_RESET;
299 gameport_trigger(gameport);
304 return IO_GOT_PACKET | IO_MODE_FAST;
308 * Disables and restores interrupts for mp_io(), which does the actual I/O.
311 static int multiport_io(struct gameport* gameport, int sendflags, int sendcode, u32 *packet)
316 local_irq_save(flags);
317 status = mp_io(gameport, sendflags, sendcode, packet);
318 local_irq_restore(flags);
324 * Puts multiport into digital mode. Multiport LED turns green.
326 * Returns true if a valid digital packet was received, false otherwise.
329 static int dig_mode_start(struct gameport *gameport, u32 *packet)
331 int i, seq_len = sizeof(init_seq)/sizeof(int);
332 int flags, tries = 0, bads = 0;
334 for (i = 0; i < seq_len; i++) { /* Send magic sequence */
336 gameport_trigger(gameport);
337 udelay(GRIP_INIT_DELAY);
340 for (i = 0; i < 16; i++) /* Wait for multiport to settle */
341 udelay(GRIP_INIT_DELAY);
343 while (tries < 64 && bads < 8) { /* Reset multiport and try getting a packet */
345 flags = multiport_io(gameport, IO_RESET, 0x27, packet);
347 if (flags & IO_MODE_FAST)
350 if (flags & IO_RETRY)
359 * Packet structure: B0-B15 => gamepad state
360 * B16-B20 => gamepad device type
361 * B21-B24 => multiport slot index (1-4)
363 * Known device types: 0x1f (grip pad), 0x0 (no device). Others may exist.
365 * Returns the packet status.
368 static int get_and_decode_packet(struct grip_mp *grip, int flags)
370 struct grip_port *port;
375 /* Get a packet and check for validity */
377 flags &= IO_RESET | IO_RETRY;
378 flags = multiport_io(grip->gameport, flags, 0, &packet);
381 if (packet & PACKET_MP_DONE)
384 if (flags && !(flags & IO_GOT_PACKET)) {
389 /* Ignore non-gamepad packets, e.g. multiport hardware version */
391 slot = ((packet >> 21) & 0xf) - 1;
392 if ((slot < 0) || (slot > 3))
395 port = grip->port[slot];
398 * Handle "reset" packets, which occur at startup, and when gamepads
399 * are removed or plugged in. May contain configuration of a new gamepad.
402 joytype = (packet >> 16) & 0x1f;
405 if (port->registered) {
406 printk(KERN_INFO "grip_mp: removing %s, slot %d\n",
407 grip_name[port->mode], slot);
408 input_unregister_device(port->dev);
409 port->registered = 0;
411 dbg("Reset: grip multiport slot %d\n", slot);
412 port->mode = GRIP_MODE_RESET;
413 flags |= IO_SLOT_CHANGE;
417 /* Interpret a grip pad packet */
419 if (joytype == 0x1f) {
421 int dir = (packet >> 8) & 0xf; /* eight way directional value */
422 port->buttons = (~packet) & 0xff;
423 port->yaxes = ((axis_map[dir] >> 2) & 3) - 1;
424 port->xaxes = (axis_map[dir] & 3) - 1;
427 if (port->mode == GRIP_MODE_RESET)
428 flags |= IO_SLOT_CHANGE;
430 port->mode = GRIP_MODE_GP;
432 if (!port->registered) {
433 dbg("New Grip pad in multiport slot %d.\n", slot);
434 register_slot(slot, grip);
439 /* Handle non-grip device codes. For now, just print diagnostics. */
442 static int strange_code = 0;
443 if (strange_code != joytype) {
444 printk(KERN_INFO "Possible non-grip pad/joystick detected.\n");
445 printk(KERN_INFO "Got joy type 0x%x and packet 0x%x.\n", joytype, packet);
446 strange_code = joytype;
453 * Returns true if all multiport slot states appear valid.
456 static int slots_valid(struct grip_mp *grip)
458 int flags, slot, invalid = 0, active = 0;
460 flags = get_and_decode_packet(grip, 0);
461 if (!(flags & IO_GOT_PACKET))
464 for (slot = 0; slot < 4; slot++) {
465 if (grip->port[slot]->mode == GRIP_MODE_RESET)
467 if (grip->port[slot]->mode != GRIP_MODE_NONE)
471 /* Return true if no active slot but multiport sent all its data */
473 return (flags & IO_DONE) ? 1 : 0;
475 /* Return false if invalid device code received */
476 return invalid ? 0 : 1;
480 * Returns whether the multiport was placed into digital mode and
481 * able to communicate its state successfully.
484 static int multiport_init(struct grip_mp *grip)
486 int dig_mode, initialized = 0, tries = 0;
489 dig_mode = dig_mode_start(grip->gameport, &packet);
490 while (!dig_mode && tries < 4) {
491 dig_mode = dig_mode_start(grip->gameport, &packet);
496 dbg("multiport_init(): digital mode activated.\n");
498 dbg("multiport_init(): unable to activate digital mode.\n");
502 /* Get packets, store multiport state, and check state's validity */
503 for (tries = 0; tries < 4096; tries++) {
504 if (slots_valid(grip)) {
509 dbg("multiport_init(): initialized == %d\n", initialized);
514 * Reports joystick state to the linux input layer.
517 static void report_slot(struct grip_mp *grip, int slot)
519 struct grip_port *port = grip->port[slot];
522 /* Store button states with linux input driver */
524 for (i = 0; i < 8; i++)
525 input_report_key(port->dev, grip_btn_gp[i], (port->buttons >> i) & 1);
527 /* Store axis states with linux driver */
529 input_report_abs(port->dev, ABS_X, port->xaxes);
530 input_report_abs(port->dev, ABS_Y, port->yaxes);
532 /* Tell the receiver of the events to process them */
534 input_sync(port->dev);
540 * Get the multiport state.
543 static void grip_poll(struct gameport *gameport)
545 struct grip_mp *grip = gameport_get_drvdata(gameport);
548 for (npkts = 0; npkts < 4; npkts++) {
550 for (i = 0; i < 32; i++) {
551 flags = get_and_decode_packet(grip, flags);
552 if ((flags & IO_GOT_PACKET) || !(flags & IO_RETRY))
559 for (i = 0; i < 4; i++)
560 if (grip->port[i]->dirty)
561 report_slot(grip, i);
565 * Called when a joystick device file is opened
568 static int grip_open(struct input_dev *dev)
570 struct grip_mp *grip = dev->private;
572 gameport_start_polling(grip->gameport);
577 * Called when a joystick device file is closed
580 static void grip_close(struct input_dev *dev)
582 struct grip_mp *grip = dev->private;
584 gameport_start_polling(grip->gameport);
588 * Tell the linux input layer about a newly plugged-in gamepad.
591 static int register_slot(int slot, struct grip_mp *grip)
593 struct grip_port *port = grip->port[slot];
594 struct input_dev *input_dev;
597 port->dev = input_dev = input_allocate_device();
601 input_dev->name = grip_name[port->mode];
602 input_dev->id.bustype = BUS_GAMEPORT;
603 input_dev->id.vendor = GAMEPORT_ID_VENDOR_GRAVIS;
604 input_dev->id.product = 0x0100 + port->mode;
605 input_dev->id.version = 0x0100;
606 input_dev->cdev.dev = &grip->gameport->dev;
607 input_dev->private = grip;
609 input_dev->open = grip_open;
610 input_dev->close = grip_close;
612 input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
614 for (j = 0; (t = grip_abs[port->mode][j]) >= 0; j++)
615 input_set_abs_params(input_dev, t, -1, 1, 0, 0);
617 for (j = 0; (t = grip_btn[port->mode][j]) >= 0; j++)
619 set_bit(t, input_dev->keybit);
621 input_register_device(port->dev);
622 port->registered = 1;
624 if (port->dirty) /* report initial state, if any */
625 report_slot(grip, slot);
630 static int grip_connect(struct gameport *gameport, struct gameport_driver *drv)
632 struct grip_mp *grip;
635 if (!(grip = kzalloc(sizeof(struct grip_mp), GFP_KERNEL)))
638 grip->gameport = gameport;
640 gameport_set_drvdata(gameport, grip);
642 err = gameport_open(gameport, drv, GAMEPORT_MODE_RAW);
646 gameport_set_poll_handler(gameport, grip_poll);
647 gameport_set_poll_interval(gameport, 20);
649 if (!multiport_init(grip)) {
654 if (!grip->port[0]->mode && !grip->port[1]->mode && !grip->port[2]->mode && !grip->port[3]->mode) {
655 /* nothing plugged in */
662 fail2: gameport_close(gameport);
663 fail1: gameport_set_drvdata(gameport, NULL);
668 static void grip_disconnect(struct gameport *gameport)
670 struct grip_mp *grip = gameport_get_drvdata(gameport);
673 for (i = 0; i < 4; i++)
674 if (grip->port[i]->registered)
675 input_unregister_device(grip->port[i]->dev);
676 gameport_close(gameport);
677 gameport_set_drvdata(gameport, NULL);
681 static struct gameport_driver grip_drv = {
685 .description = DRIVER_DESC,
686 .connect = grip_connect,
687 .disconnect = grip_disconnect,
690 static int __init grip_init(void)
692 gameport_register_driver(&grip_drv);
696 static void __exit grip_exit(void)
698 gameport_unregister_driver(&grip_drv);
701 module_init(grip_init);
702 module_exit(grip_exit);