Merge branch 'i7300_idle' into release
[linux-2.6] / drivers / input / joystick / grip_mp.c
1 /*
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>
20 #include <linux/jiffies.h>
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
34 #define GRIP_MAX_PORTS  4
35 /*
36  * Grip multiport state
37  */
38
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
51 struct grip_mp {
52         struct gameport *gameport;
53         struct grip_port *port[GRIP_MAX_PORTS];
54         int reads;
55         int bads;
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
92 static const int grip_btn_gp[]  = { BTN_TR, BTN_TL, BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, -1 };
93 static const int grip_btn_c64[] = { BTN_JOYSTICK, -1 };
94
95 static const int grip_abs_gp[]  = { ABS_X, ABS_Y, -1 };
96 static const int grip_abs_c64[] = { ABS_X, ABS_Y, -1 };
97
98 static const int *grip_abs[] = { NULL, NULL, grip_abs_gp, grip_abs_c64 };
99 static const int *grip_btn[] = { NULL, NULL, grip_btn_gp, grip_btn_c64 };
100
101 static const char *grip_name[] = { NULL, NULL, "Gravis Grip Pad", "Commodore 64 Joystick" };
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
111 static const int axis_map[] = { 5, 9, 1, 5, 6, 10, 2, 6, 4, 8, 0, 4, 5, 9, 1, 5 };
112
113 static int register_slot(int i, struct grip_mp *grip);
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)
178                 return IO_RETRY;
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 {
321         int i;
322         int flags, tries = 0, bads = 0;
323
324         for (i = 0; i < ARRAY_SIZE(init_seq); i++) {     /* Send magic sequence */
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 {
360         struct grip_port *port;
361         u32 packet;
362         int joytype = 0;
363         int slot;
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
385         port = grip->port[slot];
386
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
395                 if (port->registered) {
396                         printk(KERN_INFO "grip_mp: removing %s, slot %d\n",
397                                grip_name[port->mode], slot);
398                         input_unregister_device(port->dev);
399                         port->registered = 0;
400                 }
401                 dbg("Reset: grip multiport slot %d\n", slot);
402                 port->mode = GRIP_MODE_RESET;
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 */
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;
416
417                 if (port->mode == GRIP_MODE_RESET)
418                         flags |= IO_SLOT_CHANGE;
419
420                 port->mode = GRIP_MODE_GP;
421
422                 if (!port->registered) {
423                         dbg("New Grip pad in multiport slot %d.\n", slot);
424                         if (register_slot(slot, grip)) {
425                                 port->mode = GRIP_MODE_RESET;
426                                 port->dirty = 0;
427                         }
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++) {
458                 if (grip->port[slot]->mode == GRIP_MODE_RESET)
459                         invalid = 1;
460                 if (grip->port[slot]->mode != GRIP_MODE_NONE)
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++) {
497                 if (slots_valid(grip)) {
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 {
512         struct grip_port *port = grip->port[slot];
513         int i;
514
515         /* Store button states with linux input driver */
516
517         for (i = 0; i < 8; i++)
518                 input_report_key(port->dev, grip_btn_gp[i], (port->buttons >> i) & 1);
519
520         /* Store axis states with linux driver */
521
522         input_report_abs(port->dev, ABS_X, port->xaxes);
523         input_report_abs(port->dev, ABS_Y, port->yaxes);
524
525         /* Tell the receiver of the events to process them */
526
527         input_sync(port->dev);
528
529         port->dirty = 0;
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++)
553                 if (grip->port[i]->dirty)
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 {
563         struct grip_mp *grip = input_get_drvdata(dev);
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 {
575         struct grip_mp *grip = input_get_drvdata(dev);
576
577         gameport_stop_polling(grip->gameport);
578 }
579
580 /*
581  * Tell the linux input layer about a newly plugged-in gamepad.
582  */
583
584 static int register_slot(int slot, struct grip_mp *grip)
585 {
586         struct grip_port *port = grip->port[slot];
587         struct input_dev *input_dev;
588         int j, t;
589         int err;
590
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;
600         input_dev->dev.parent = &grip->gameport->dev;
601
602         input_set_drvdata(input_dev, grip);
603
604         input_dev->open = grip_open;
605         input_dev->close = grip_close;
606
607         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
608
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++)
613                 if (t > 0)
614                         set_bit(t, input_dev->keybit);
615
616         err = input_register_device(port->dev);
617         if (err) {
618                 input_free_device(port->dev);
619                 return err;
620         }
621
622         port->registered = 1;
623
624         if (port->dirty)                    /* report initial state, if any */
625                 report_slot(grip, slot);
626
627         return 0;
628 }
629
630 static int grip_connect(struct gameport *gameport, struct gameport_driver *drv)
631 {
632         struct grip_mp *grip;
633         int err;
634
635         if (!(grip = kzalloc(sizeof(struct grip_mp), GFP_KERNEL)))
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
654         if (!grip->port[0]->mode && !grip->port[1]->mode && !grip->port[2]->mode && !grip->port[3]->mode) {
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++)
674                 if (grip->port[i]->registered)
675                         input_unregister_device(grip->port[i]->dev);
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 {
692         return gameport_register_driver(&grip_drv);
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);