Merge branch 'acpica' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux...
[linux-2.6.git] / drivers / input / joystick / gamecon.c
1 /*
2  * NES, SNES, N64, MultiSystem, PSX gamepad driver for Linux
3  *
4  *  Copyright (c) 1999-2004     Vojtech Pavlik <vojtech@suse.cz>
5  *  Copyright (c) 2004          Peter Nelson <rufus-kernel@hackish.org>
6  *
7  *  Based on the work of:
8  *      Andree Borrmann         John Dahlstrom
9  *      David Kuder             Nathan Hand
10  *      Raphael Assenat
11  */
12
13 /*
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27  *
28  * Should you need to contact me, the author, you can do so either by
29  * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
30  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
31  */
32
33 #include <linux/kernel.h>
34 #include <linux/delay.h>
35 #include <linux/module.h>
36 #include <linux/init.h>
37 #include <linux/parport.h>
38 #include <linux/input.h>
39 #include <linux/mutex.h>
40
41 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
42 MODULE_DESCRIPTION("NES, SNES, N64, MultiSystem, PSX gamepad driver");
43 MODULE_LICENSE("GPL");
44
45 #define GC_MAX_PORTS            3
46 #define GC_MAX_DEVICES          5
47
48 struct gc_config {
49         int args[GC_MAX_DEVICES + 1];
50         unsigned int nargs;
51 };
52
53 static struct gc_config gc_cfg[GC_MAX_PORTS] __initdata;
54
55 module_param_array_named(map, gc_cfg[0].args, int, &gc_cfg[0].nargs, 0);
56 MODULE_PARM_DESC(map, "Describes first set of devices (<parport#>,<pad1>,<pad2>,..<pad5>)");
57 module_param_array_named(map2, gc_cfg[1].args, int, &gc_cfg[1].nargs, 0);
58 MODULE_PARM_DESC(map2, "Describes second set of devices");
59 module_param_array_named(map3, gc_cfg[2].args, int, &gc_cfg[2].nargs, 0);
60 MODULE_PARM_DESC(map3, "Describes third set of devices");
61
62 /* see also gs_psx_delay parameter in PSX support section */
63
64 #define GC_SNES         1
65 #define GC_NES          2
66 #define GC_NES4         3
67 #define GC_MULTI        4
68 #define GC_MULTI2       5
69 #define GC_N64          6
70 #define GC_PSX          7
71 #define GC_DDR          8
72 #define GC_SNESMOUSE    9
73
74 #define GC_MAX          9
75
76 #define GC_REFRESH_TIME HZ/100
77
78 struct gc {
79         struct pardevice *pd;
80         struct input_dev *dev[GC_MAX_DEVICES];
81         struct timer_list timer;
82         unsigned char pads[GC_MAX + 1];
83         int used;
84         struct mutex mutex;
85         char phys[GC_MAX_DEVICES][32];
86 };
87
88 static struct gc *gc_base[3];
89
90 static int gc_status_bit[] = { 0x40, 0x80, 0x20, 0x10, 0x08 };
91
92 static char *gc_names[] = { NULL, "SNES pad", "NES pad", "NES FourPort", "Multisystem joystick",
93                                 "Multisystem 2-button joystick", "N64 controller", "PSX controller",
94                                 "PSX DDR controller", "SNES mouse" };
95 /*
96  * N64 support.
97  */
98
99 static unsigned char gc_n64_bytes[] = { 0, 1, 13, 15, 14, 12, 10, 11, 2, 3 };
100 static short gc_n64_btn[] = { BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, BTN_TL, BTN_TR, BTN_TRIGGER, BTN_START };
101
102 #define GC_N64_LENGTH           32              /* N64 bit length, not including stop bit */
103 #define GC_N64_REQUEST_LENGTH   37              /* transmit request sequence is 9 bits long */
104 #define GC_N64_DELAY            133             /* delay between transmit request, and response ready (us) */
105 #define GC_N64_REQUEST          0x1dd1111111ULL /* the request data command (encoded for 000000011) */
106 #define GC_N64_DWS              3               /* delay between write segments (required for sound playback because of ISA DMA) */
107                                                 /* GC_N64_DWS > 24 is known to fail */
108 #define GC_N64_POWER_W          0xe2            /* power during write (transmit request) */
109 #define GC_N64_POWER_R          0xfd            /* power during read */
110 #define GC_N64_OUT              0x1d            /* output bits to the 4 pads */
111                                                 /* Reading the main axes of any N64 pad is known to fail if the corresponding bit */
112                                                 /* in GC_N64_OUT is pulled low on the output port (by any routine) for more */
113                                                 /* than 123 us */
114 #define GC_N64_CLOCK            0x02            /* clock bits for read */
115
116 /*
117  * gc_n64_read_packet() reads an N64 packet.
118  * Each pad uses one bit per byte. So all pads connected to this port are read in parallel.
119  */
120
121 static void gc_n64_read_packet(struct gc *gc, unsigned char *data)
122 {
123         int i;
124         unsigned long flags;
125
126 /*
127  * Request the pad to transmit data
128  */
129
130         local_irq_save(flags);
131         for (i = 0; i < GC_N64_REQUEST_LENGTH; i++) {
132                 parport_write_data(gc->pd->port, GC_N64_POWER_W | ((GC_N64_REQUEST >> i) & 1 ? GC_N64_OUT : 0));
133                 udelay(GC_N64_DWS);
134         }
135         local_irq_restore(flags);
136
137 /*
138  * Wait for the pad response to be loaded into the 33-bit register of the adapter
139  */
140
141         udelay(GC_N64_DELAY);
142
143 /*
144  * Grab data (ignoring the last bit, which is a stop bit)
145  */
146
147         for (i = 0; i < GC_N64_LENGTH; i++) {
148                 parport_write_data(gc->pd->port, GC_N64_POWER_R);
149                 data[i] = parport_read_status(gc->pd->port);
150                 parport_write_data(gc->pd->port, GC_N64_POWER_R | GC_N64_CLOCK);
151          }
152
153 /*
154  * We must wait 200 ms here for the controller to reinitialize before the next read request.
155  * No worries as long as gc_read is polled less frequently than this.
156  */
157
158 }
159
160 static void gc_n64_process_packet(struct gc *gc)
161 {
162         unsigned char data[GC_N64_LENGTH];
163         signed char axes[2];
164         struct input_dev *dev;
165         int i, j, s;
166
167         gc_n64_read_packet(gc, data);
168
169         for (i = 0; i < GC_MAX_DEVICES; i++) {
170
171                 dev = gc->dev[i];
172                 if (!dev)
173                         continue;
174
175                 s = gc_status_bit[i];
176
177                 if (s & gc->pads[GC_N64] & ~(data[8] | data[9])) {
178
179                         axes[0] = axes[1] = 0;
180
181                         for (j = 0; j < 8; j++) {
182                                 if (data[23 - j] & s)
183                                         axes[0] |= 1 << j;
184                                 if (data[31 - j] & s)
185                                         axes[1] |= 1 << j;
186                         }
187
188                         input_report_abs(dev, ABS_X,  axes[0]);
189                         input_report_abs(dev, ABS_Y, -axes[1]);
190
191                         input_report_abs(dev, ABS_HAT0X, !(s & data[6]) - !(s & data[7]));
192                         input_report_abs(dev, ABS_HAT0Y, !(s & data[4]) - !(s & data[5]));
193
194                         for (j = 0; j < 10; j++)
195                                 input_report_key(dev, gc_n64_btn[j], s & data[gc_n64_bytes[j]]);
196
197                         input_sync(dev);
198                 }
199         }
200 }
201
202 /*
203  * NES/SNES support.
204  */
205
206 #define GC_NES_DELAY            6       /* Delay between bits - 6us */
207 #define GC_NES_LENGTH           8       /* The NES pads use 8 bits of data */
208 #define GC_SNES_LENGTH          12      /* The SNES true length is 16, but the
209                                            last 4 bits are unused */
210 #define GC_SNESMOUSE_LENGTH     32      /* The SNES mouse uses 32 bits, the first
211                                            16 bits are equivalent to a gamepad */
212
213 #define GC_NES_POWER    0xfc
214 #define GC_NES_CLOCK    0x01
215 #define GC_NES_LATCH    0x02
216
217 static unsigned char gc_nes_bytes[] = { 0, 1, 2, 3 };
218 static unsigned char gc_snes_bytes[] = { 8, 0, 2, 3, 9, 1, 10, 11 };
219 static short gc_snes_btn[] = { BTN_A, BTN_B, BTN_SELECT, BTN_START, BTN_X, BTN_Y, BTN_TL, BTN_TR };
220
221 /*
222  * gc_nes_read_packet() reads a NES/SNES packet.
223  * Each pad uses one bit per byte. So all pads connected to
224  * this port are read in parallel.
225  */
226
227 static void gc_nes_read_packet(struct gc *gc, int length, unsigned char *data)
228 {
229         int i;
230
231         parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK | GC_NES_LATCH);
232         udelay(GC_NES_DELAY * 2);
233         parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK);
234
235         for (i = 0; i < length; i++) {
236                 udelay(GC_NES_DELAY);
237                 parport_write_data(gc->pd->port, GC_NES_POWER);
238                 data[i] = parport_read_status(gc->pd->port) ^ 0x7f;
239                 udelay(GC_NES_DELAY);
240                 parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK);
241         }
242 }
243
244 static void gc_nes_process_packet(struct gc *gc)
245 {
246         unsigned char data[GC_SNESMOUSE_LENGTH];
247         struct input_dev *dev;
248         int i, j, s, len;
249         char x_rel, y_rel;
250
251         len = gc->pads[GC_SNESMOUSE] ? GC_SNESMOUSE_LENGTH :
252                         (gc->pads[GC_SNES] ? GC_SNES_LENGTH : GC_NES_LENGTH);
253
254         gc_nes_read_packet(gc, len, data);
255
256         for (i = 0; i < GC_MAX_DEVICES; i++) {
257
258                 dev = gc->dev[i];
259                 if (!dev)
260                         continue;
261
262                 s = gc_status_bit[i];
263
264                 if (s & (gc->pads[GC_NES] | gc->pads[GC_SNES])) {
265                         input_report_abs(dev, ABS_X, !(s & data[6]) - !(s & data[7]));
266                         input_report_abs(dev, ABS_Y, !(s & data[4]) - !(s & data[5]));
267                 }
268
269                 if (s & gc->pads[GC_NES])
270                         for (j = 0; j < 4; j++)
271                                 input_report_key(dev, gc_snes_btn[j], s & data[gc_nes_bytes[j]]);
272
273                 if (s & gc->pads[GC_SNES])
274                         for (j = 0; j < 8; j++)
275                                 input_report_key(dev, gc_snes_btn[j], s & data[gc_snes_bytes[j]]);
276
277                 if (s & gc->pads[GC_SNESMOUSE]) {
278                         /*
279                          * The 4 unused bits from SNES controllers appear to be ID bits
280                          * so use them to make sure iwe are dealing with a mouse.
281                          * gamepad is connected. This is important since
282                          * my SNES gamepad sends 1's for bits 16-31, which
283                          * cause the mouse pointer to quickly move to the
284                          * upper left corner of the screen.
285                          */
286                         if (!(s & data[12]) && !(s & data[13]) &&
287                             !(s & data[14]) && (s & data[15])) {
288                                 input_report_key(dev, BTN_LEFT, s & data[9]);
289                                 input_report_key(dev, BTN_RIGHT, s & data[8]);
290
291                                 x_rel = y_rel = 0;
292                                 for (j = 0; j < 7; j++) {
293                                         x_rel <<= 1;
294                                         if (data[25 + j] & s)
295                                                 x_rel |= 1;
296
297                                         y_rel <<= 1;
298                                         if (data[17 + j] & s)
299                                                 y_rel |= 1;
300                                 }
301
302                                 if (x_rel) {
303                                         if (data[24] & s)
304                                                 x_rel = -x_rel;
305                                         input_report_rel(dev, REL_X, x_rel);
306                                 }
307
308                                 if (y_rel) {
309                                         if (data[16] & s)
310                                                 y_rel = -y_rel;
311                                         input_report_rel(dev, REL_Y, y_rel);
312                                 }
313                         }
314                 }
315                 input_sync(dev);
316         }
317 }
318
319 /*
320  * Multisystem joystick support
321  */
322
323 #define GC_MULTI_LENGTH         5       /* Multi system joystick packet length is 5 */
324 #define GC_MULTI2_LENGTH        6       /* One more bit for one more button */
325
326 /*
327  * gc_multi_read_packet() reads a Multisystem joystick packet.
328  */
329
330 static void gc_multi_read_packet(struct gc *gc, int length, unsigned char *data)
331 {
332         int i;
333
334         for (i = 0; i < length; i++) {
335                 parport_write_data(gc->pd->port, ~(1 << i));
336                 data[i] = parport_read_status(gc->pd->port) ^ 0x7f;
337         }
338 }
339
340 static void gc_multi_process_packet(struct gc *gc)
341 {
342         unsigned char data[GC_MULTI2_LENGTH];
343         struct input_dev *dev;
344         int i, s;
345
346         gc_multi_read_packet(gc, gc->pads[GC_MULTI2] ? GC_MULTI2_LENGTH : GC_MULTI_LENGTH, data);
347
348         for (i = 0; i < GC_MAX_DEVICES; i++) {
349
350                 dev = gc->dev[i];
351                 if (!dev)
352                         continue;
353
354                 s = gc_status_bit[i];
355
356                 if (s & (gc->pads[GC_MULTI] | gc->pads[GC_MULTI2])) {
357                         input_report_abs(dev, ABS_X,  !(s & data[2]) - !(s & data[3]));
358                         input_report_abs(dev, ABS_Y,  !(s & data[0]) - !(s & data[1]));
359                         input_report_key(dev, BTN_TRIGGER, s & data[4]);
360                 }
361
362                 if (s & gc->pads[GC_MULTI2])
363                         input_report_key(dev, BTN_THUMB, s & data[5]);
364
365                 input_sync(dev);
366         }
367 }
368
369 /*
370  * PSX support
371  *
372  * See documentation at:
373  *      http://www.dim.com/~mackys/psxmemcard/ps-eng2.txt
374  *      http://www.gamesx.com/controldata/psxcont/psxcont.htm
375  *      ftp://milano.usal.es/pablo/
376  *
377  */
378
379 #define GC_PSX_DELAY    25              /* 25 usec */
380 #define GC_PSX_LENGTH   8               /* talk to the controller in bits */
381 #define GC_PSX_BYTES    6               /* the maximum number of bytes to read off the controller */
382
383 #define GC_PSX_MOUSE    1               /* Mouse */
384 #define GC_PSX_NEGCON   2               /* NegCon */
385 #define GC_PSX_NORMAL   4               /* Digital / Analog or Rumble in Digital mode  */
386 #define GC_PSX_ANALOG   5               /* Analog in Analog mode / Rumble in Green mode */
387 #define GC_PSX_RUMBLE   7               /* Rumble in Red mode */
388
389 #define GC_PSX_CLOCK    0x04            /* Pin 4 */
390 #define GC_PSX_COMMAND  0x01            /* Pin 2 */
391 #define GC_PSX_POWER    0xf8            /* Pins 5-9 */
392 #define GC_PSX_SELECT   0x02            /* Pin 3 */
393
394 #define GC_PSX_ID(x)    ((x) >> 4)      /* High nibble is device type */
395 #define GC_PSX_LEN(x)   (((x) & 0xf) << 1)      /* Low nibble is length in bytes/2 */
396
397 static int gc_psx_delay = GC_PSX_DELAY;
398 module_param_named(psx_delay, gc_psx_delay, uint, 0);
399 MODULE_PARM_DESC(psx_delay, "Delay when accessing Sony PSX controller (usecs)");
400
401 static short gc_psx_abs[] = { ABS_X, ABS_Y, ABS_RX, ABS_RY, ABS_HAT0X, ABS_HAT0Y };
402 static short gc_psx_btn[] = { BTN_TL, BTN_TR, BTN_TL2, BTN_TR2, BTN_A, BTN_B, BTN_X, BTN_Y,
403                                 BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR };
404 static short gc_psx_ddr_btn[] = { BTN_0, BTN_1, BTN_2, BTN_3 };
405
406 /*
407  * gc_psx_command() writes 8bit command and reads 8bit data from
408  * the psx pad.
409  */
410
411 static void gc_psx_command(struct gc *gc, int b, unsigned char data[GC_MAX_DEVICES])
412 {
413         int i, j, cmd, read;
414
415         for (i = 0; i < GC_MAX_DEVICES; i++)
416                 data[i] = 0;
417
418         for (i = 0; i < GC_PSX_LENGTH; i++, b >>= 1) {
419                 cmd = (b & 1) ? GC_PSX_COMMAND : 0;
420                 parport_write_data(gc->pd->port, cmd | GC_PSX_POWER);
421                 udelay(gc_psx_delay);
422                 read = parport_read_status(gc->pd->port) ^ 0x80;
423                 for (j = 0; j < GC_MAX_DEVICES; j++)
424                         data[j] |= (read & gc_status_bit[j] & (gc->pads[GC_PSX] | gc->pads[GC_DDR])) ? (1 << i) : 0;
425                 parport_write_data(gc->pd->port, cmd | GC_PSX_CLOCK | GC_PSX_POWER);
426                 udelay(gc_psx_delay);
427         }
428 }
429
430 /*
431  * gc_psx_read_packet() reads a whole psx packet and returns
432  * device identifier code.
433  */
434
435 static void gc_psx_read_packet(struct gc *gc, unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES],
436                                unsigned char id[GC_MAX_DEVICES])
437 {
438         int i, j, max_len = 0;
439         unsigned long flags;
440         unsigned char data2[GC_MAX_DEVICES];
441
442         parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER);  /* Select pad */
443         udelay(gc_psx_delay);
444         parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_POWER);                  /* Deselect, begin command */
445         udelay(gc_psx_delay);
446
447         local_irq_save(flags);
448
449         gc_psx_command(gc, 0x01, data2);                                                /* Access pad */
450         gc_psx_command(gc, 0x42, id);                                                   /* Get device ids */
451         gc_psx_command(gc, 0, data2);                                                   /* Dump status */
452
453         for (i =0; i < GC_MAX_DEVICES; i++)                                                             /* Find the longest pad */
454                 if((gc_status_bit[i] & (gc->pads[GC_PSX] | gc->pads[GC_DDR]))
455                         && (GC_PSX_LEN(id[i]) > max_len)
456                         && (GC_PSX_LEN(id[i]) <= GC_PSX_BYTES))
457                         max_len = GC_PSX_LEN(id[i]);
458
459         for (i = 0; i < max_len; i++) {                                         /* Read in all the data */
460                 gc_psx_command(gc, 0, data2);
461                 for (j = 0; j < GC_MAX_DEVICES; j++)
462                         data[j][i] = data2[j];
463         }
464
465         local_irq_restore(flags);
466
467         parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER);
468
469         for(i = 0; i < GC_MAX_DEVICES; i++)                                                             /* Set id's to the real value */
470                 id[i] = GC_PSX_ID(id[i]);
471 }
472
473 static void gc_psx_process_packet(struct gc *gc)
474 {
475         unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES];
476         unsigned char id[GC_MAX_DEVICES];
477         struct input_dev *dev;
478         int i, j;
479
480         gc_psx_read_packet(gc, data, id);
481
482         for (i = 0; i < GC_MAX_DEVICES; i++) {
483
484                 dev = gc->dev[i];
485                 if (!dev)
486                         continue;
487
488                 switch (id[i]) {
489
490                         case GC_PSX_RUMBLE:
491
492                                 input_report_key(dev, BTN_THUMBL, ~data[i][0] & 0x04);
493                                 input_report_key(dev, BTN_THUMBR, ~data[i][0] & 0x02);
494
495                         case GC_PSX_NEGCON:
496                         case GC_PSX_ANALOG:
497
498                                 if (gc->pads[GC_DDR] & gc_status_bit[i]) {
499                                         for(j = 0; j < 4; j++)
500                                                 input_report_key(dev, gc_psx_ddr_btn[j], ~data[i][0] & (0x10 << j));
501                                 } else {
502                                         for (j = 0; j < 4; j++)
503                                                 input_report_abs(dev, gc_psx_abs[j + 2], data[i][j + 2]);
504
505                                         input_report_abs(dev, ABS_X, 128 + !(data[i][0] & 0x20) * 127 - !(data[i][0] & 0x80) * 128);
506                                         input_report_abs(dev, ABS_Y, 128 + !(data[i][0] & 0x40) * 127 - !(data[i][0] & 0x10) * 128);
507                                 }
508
509                                 for (j = 0; j < 8; j++)
510                                         input_report_key(dev, gc_psx_btn[j], ~data[i][1] & (1 << j));
511
512                                 input_report_key(dev, BTN_START,  ~data[i][0] & 0x08);
513                                 input_report_key(dev, BTN_SELECT, ~data[i][0] & 0x01);
514
515                                 input_sync(dev);
516
517                                 break;
518
519                         case GC_PSX_NORMAL:
520                                 if (gc->pads[GC_DDR] & gc_status_bit[i]) {
521                                         for(j = 0; j < 4; j++)
522                                                 input_report_key(dev, gc_psx_ddr_btn[j], ~data[i][0] & (0x10 << j));
523                                 } else {
524                                         input_report_abs(dev, ABS_X, 128 + !(data[i][0] & 0x20) * 127 - !(data[i][0] & 0x80) * 128);
525                                         input_report_abs(dev, ABS_Y, 128 + !(data[i][0] & 0x40) * 127 - !(data[i][0] & 0x10) * 128);
526
527                                         /* for some reason if the extra axes are left unset they drift */
528                                         /* for (j = 0; j < 4; j++)
529                                                 input_report_abs(dev, gc_psx_abs[j + 2], 128);
530                                          * This needs to be debugged properly,
531                                          * maybe fuzz processing needs to be done in input_sync()
532                                          *                               --vojtech
533                                          */
534                                 }
535
536                                 for (j = 0; j < 8; j++)
537                                         input_report_key(dev, gc_psx_btn[j], ~data[i][1] & (1 << j));
538
539                                 input_report_key(dev, BTN_START,  ~data[i][0] & 0x08);
540                                 input_report_key(dev, BTN_SELECT, ~data[i][0] & 0x01);
541
542                                 input_sync(dev);
543
544                                 break;
545
546                         case 0: /* not a pad, ignore */
547                                 break;
548                 }
549         }
550 }
551
552 /*
553  * gc_timer() initiates reads of console pads data.
554  */
555
556 static void gc_timer(unsigned long private)
557 {
558         struct gc *gc = (void *) private;
559
560 /*
561  * N64 pads - must be read first, any read confuses them for 200 us
562  */
563
564         if (gc->pads[GC_N64])
565                 gc_n64_process_packet(gc);
566
567 /*
568  * NES and SNES pads or mouse
569  */
570
571         if (gc->pads[GC_NES] || gc->pads[GC_SNES] || gc->pads[GC_SNESMOUSE])
572                 gc_nes_process_packet(gc);
573
574 /*
575  * Multi and Multi2 joysticks
576  */
577
578         if (gc->pads[GC_MULTI] || gc->pads[GC_MULTI2])
579                 gc_multi_process_packet(gc);
580
581 /*
582  * PSX controllers
583  */
584
585         if (gc->pads[GC_PSX] || gc->pads[GC_DDR])
586                 gc_psx_process_packet(gc);
587
588         mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME);
589 }
590
591 static int gc_open(struct input_dev *dev)
592 {
593         struct gc *gc = input_get_drvdata(dev);
594         int err;
595
596         err = mutex_lock_interruptible(&gc->mutex);
597         if (err)
598                 return err;
599
600         if (!gc->used++) {
601                 parport_claim(gc->pd);
602                 parport_write_control(gc->pd->port, 0x04);
603                 mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME);
604         }
605
606         mutex_unlock(&gc->mutex);
607         return 0;
608 }
609
610 static void gc_close(struct input_dev *dev)
611 {
612         struct gc *gc = input_get_drvdata(dev);
613
614         mutex_lock(&gc->mutex);
615         if (!--gc->used) {
616                 del_timer_sync(&gc->timer);
617                 parport_write_control(gc->pd->port, 0x00);
618                 parport_release(gc->pd);
619         }
620         mutex_unlock(&gc->mutex);
621 }
622
623 static int __init gc_setup_pad(struct gc *gc, int idx, int pad_type)
624 {
625         struct input_dev *input_dev;
626         int i;
627
628         if (!pad_type)
629                 return 0;
630
631         if (pad_type < 1 || pad_type > GC_MAX) {
632                 printk(KERN_WARNING "gamecon.c: Pad type %d unknown\n", pad_type);
633                 return -EINVAL;
634         }
635
636         gc->dev[idx] = input_dev = input_allocate_device();
637         if (!input_dev) {
638                 printk(KERN_ERR "gamecon.c: Not enough memory for input device\n");
639                 return -ENOMEM;
640         }
641
642         input_dev->name = gc_names[pad_type];
643         input_dev->phys = gc->phys[idx];
644         input_dev->id.bustype = BUS_PARPORT;
645         input_dev->id.vendor = 0x0001;
646         input_dev->id.product = pad_type;
647         input_dev->id.version = 0x0100;
648
649         input_set_drvdata(input_dev, gc);
650
651         input_dev->open = gc_open;
652         input_dev->close = gc_close;
653
654         if (pad_type != GC_SNESMOUSE) {
655                 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
656
657                 for (i = 0; i < 2; i++)
658                         input_set_abs_params(input_dev, ABS_X + i, -1, 1, 0, 0);
659         } else
660                 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
661
662         gc->pads[0] |= gc_status_bit[idx];
663         gc->pads[pad_type] |= gc_status_bit[idx];
664
665         switch (pad_type) {
666
667                 case GC_N64:
668                         for (i = 0; i < 10; i++)
669                                 set_bit(gc_n64_btn[i], input_dev->keybit);
670
671                         for (i = 0; i < 2; i++) {
672                                 input_set_abs_params(input_dev, ABS_X + i, -127, 126, 0, 2);
673                                 input_set_abs_params(input_dev, ABS_HAT0X + i, -1, 1, 0, 0);
674                         }
675
676                         break;
677
678                 case GC_SNESMOUSE:
679                         set_bit(BTN_LEFT, input_dev->keybit);
680                         set_bit(BTN_RIGHT, input_dev->keybit);
681                         set_bit(REL_X, input_dev->relbit);
682                         set_bit(REL_Y, input_dev->relbit);
683                         break;
684
685                 case GC_SNES:
686                         for (i = 4; i < 8; i++)
687                                 set_bit(gc_snes_btn[i], input_dev->keybit);
688                 case GC_NES:
689                         for (i = 0; i < 4; i++)
690                                 set_bit(gc_snes_btn[i], input_dev->keybit);
691                         break;
692
693                 case GC_MULTI2:
694                         set_bit(BTN_THUMB, input_dev->keybit);
695                 case GC_MULTI:
696                         set_bit(BTN_TRIGGER, input_dev->keybit);
697                         break;
698
699                 case GC_PSX:
700                         for (i = 0; i < 6; i++)
701                                 input_set_abs_params(input_dev, gc_psx_abs[i], 4, 252, 0, 2);
702                         for (i = 0; i < 12; i++)
703                                 set_bit(gc_psx_btn[i], input_dev->keybit);
704
705                         break;
706
707                 case GC_DDR:
708                         for (i = 0; i < 4; i++)
709                                 set_bit(gc_psx_ddr_btn[i], input_dev->keybit);
710                         for (i = 0; i < 12; i++)
711                                 set_bit(gc_psx_btn[i], input_dev->keybit);
712
713                         break;
714         }
715
716         return 0;
717 }
718
719 static struct gc __init *gc_probe(int parport, int *pads, int n_pads)
720 {
721         struct gc *gc;
722         struct parport *pp;
723         struct pardevice *pd;
724         int i;
725         int err;
726
727         pp = parport_find_number(parport);
728         if (!pp) {
729                 printk(KERN_ERR "gamecon.c: no such parport\n");
730                 err = -EINVAL;
731                 goto err_out;
732         }
733
734         pd = parport_register_device(pp, "gamecon", NULL, NULL, NULL, PARPORT_DEV_EXCL, NULL);
735         if (!pd) {
736                 printk(KERN_ERR "gamecon.c: parport busy already - lp.o loaded?\n");
737                 err = -EBUSY;
738                 goto err_put_pp;
739         }
740
741         gc = kzalloc(sizeof(struct gc), GFP_KERNEL);
742         if (!gc) {
743                 printk(KERN_ERR "gamecon.c: Not enough memory\n");
744                 err = -ENOMEM;
745                 goto err_unreg_pardev;
746         }
747
748         mutex_init(&gc->mutex);
749         gc->pd = pd;
750         init_timer(&gc->timer);
751         gc->timer.data = (long) gc;
752         gc->timer.function = gc_timer;
753
754         for (i = 0; i < n_pads && i < GC_MAX_DEVICES; i++) {
755                 if (!pads[i])
756                         continue;
757
758                 snprintf(gc->phys[i], sizeof(gc->phys[i]),
759                          "%s/input%d", gc->pd->port->name, i);
760                 err = gc_setup_pad(gc, i, pads[i]);
761                 if (err)
762                         goto err_unreg_devs;
763
764                 err = input_register_device(gc->dev[i]);
765                 if (err)
766                         goto err_free_dev;
767         }
768
769         if (!gc->pads[0]) {
770                 printk(KERN_ERR "gamecon.c: No valid devices specified\n");
771                 err = -EINVAL;
772                 goto err_free_gc;
773         }
774
775         parport_put_port(pp);
776         return gc;
777
778  err_free_dev:
779         input_free_device(gc->dev[i]);
780  err_unreg_devs:
781         while (--i >= 0)
782                 if (gc->dev[i])
783                         input_unregister_device(gc->dev[i]);
784  err_free_gc:
785         kfree(gc);
786  err_unreg_pardev:
787         parport_unregister_device(pd);
788  err_put_pp:
789         parport_put_port(pp);
790  err_out:
791         return ERR_PTR(err);
792 }
793
794 static void gc_remove(struct gc *gc)
795 {
796         int i;
797
798         for (i = 0; i < GC_MAX_DEVICES; i++)
799                 if (gc->dev[i])
800                         input_unregister_device(gc->dev[i]);
801         parport_unregister_device(gc->pd);
802         kfree(gc);
803 }
804
805 static int __init gc_init(void)
806 {
807         int i;
808         int have_dev = 0;
809         int err = 0;
810
811         for (i = 0; i < GC_MAX_PORTS; i++) {
812                 if (gc_cfg[i].nargs == 0 || gc_cfg[i].args[0] < 0)
813                         continue;
814
815                 if (gc_cfg[i].nargs < 2) {
816                         printk(KERN_ERR "gamecon.c: at least one device must be specified\n");
817                         err = -EINVAL;
818                         break;
819                 }
820
821                 gc_base[i] = gc_probe(gc_cfg[i].args[0],
822                                       gc_cfg[i].args + 1, gc_cfg[i].nargs - 1);
823                 if (IS_ERR(gc_base[i])) {
824                         err = PTR_ERR(gc_base[i]);
825                         break;
826                 }
827
828                 have_dev = 1;
829         }
830
831         if (err) {
832                 while (--i >= 0)
833                         if (gc_base[i])
834                                 gc_remove(gc_base[i]);
835                 return err;
836         }
837
838         return have_dev ? 0 : -ENODEV;
839 }
840
841 static void __exit gc_exit(void)
842 {
843         int i;
844
845         for (i = 0; i < GC_MAX_PORTS; i++)
846                 if (gc_base[i])
847                         gc_remove(gc_base[i]);
848 }
849
850 module_init(gc_init);
851 module_exit(gc_exit);