1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33#include <linux/kernel.h>
34#include <linux/delay.h>
35#include <linux/module.h>
36#include <linux/moduleparam.h>
37#include <linux/init.h>
38#include <linux/parport.h>
39#include <linux/input.h>
40#include <linux/mutex.h>
41
42MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
43MODULE_DESCRIPTION("NES, SNES, N64, MultiSystem, PSX gamepad driver");
44MODULE_LICENSE("GPL");
45
46#define GC_MAX_PORTS 3
47#define GC_MAX_DEVICES 5
48
49struct gc_config {
50 int args[GC_MAX_DEVICES + 1];
51 unsigned int nargs;
52};
53
54static struct gc_config gc_cfg[GC_MAX_PORTS] __initdata;
55
56module_param_array_named(map, gc_cfg[0].args, int, &gc_cfg[0].nargs, 0);
57MODULE_PARM_DESC(map, "Describes first set of devices (<parport#>,<pad1>,<pad2>,..<pad5>)");
58module_param_array_named(map2, gc_cfg[1].args, int, &gc_cfg[1].nargs, 0);
59MODULE_PARM_DESC(map2, "Describes second set of devices");
60module_param_array_named(map3, gc_cfg[2].args, int, &gc_cfg[2].nargs, 0);
61MODULE_PARM_DESC(map3, "Describes third set of devices");
62
63
64
65#define GC_SNES 1
66#define GC_NES 2
67#define GC_NES4 3
68#define GC_MULTI 4
69#define GC_MULTI2 5
70#define GC_N64 6
71#define GC_PSX 7
72#define GC_DDR 8
73#define GC_SNESMOUSE 9
74
75#define GC_MAX 9
76
77#define GC_REFRESH_TIME HZ/100
78
79struct gc {
80 struct pardevice *pd;
81 struct input_dev *dev[GC_MAX_DEVICES];
82 struct timer_list timer;
83 unsigned char pads[GC_MAX + 1];
84 int used;
85 struct mutex mutex;
86 char phys[GC_MAX_DEVICES][32];
87};
88
89static struct gc *gc_base[3];
90
91static int gc_status_bit[] = { 0x40, 0x80, 0x20, 0x10, 0x08 };
92
93static char *gc_names[] = { NULL, "SNES pad", "NES pad", "NES FourPort", "Multisystem joystick",
94 "Multisystem 2-button joystick", "N64 controller", "PSX controller",
95 "PSX DDR controller", "SNES mouse" };
96
97
98
99
100static unsigned char gc_n64_bytes[] = { 0, 1, 13, 15, 14, 12, 10, 11, 2, 3 };
101static short gc_n64_btn[] = { BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, BTN_TL, BTN_TR, BTN_TRIGGER, BTN_START };
102
103#define GC_N64_LENGTH 32
104#define GC_N64_REQUEST_LENGTH 37
105#define GC_N64_DELAY 133
106#define GC_N64_REQUEST 0x1dd1111111ULL
107#define GC_N64_DWS 3
108
109#define GC_N64_POWER_W 0xe2
110#define GC_N64_POWER_R 0xfd
111#define GC_N64_OUT 0x1d
112
113
114
115#define GC_N64_CLOCK 0x02
116
117
118
119
120
121
122static void gc_n64_read_packet(struct gc *gc, unsigned char *data)
123{
124 int i;
125 unsigned long flags;
126
127
128
129
130
131 local_irq_save(flags);
132 for (i = 0; i < GC_N64_REQUEST_LENGTH; i++) {
133 parport_write_data(gc->pd->port, GC_N64_POWER_W | ((GC_N64_REQUEST >> i) & 1 ? GC_N64_OUT : 0));
134 udelay(GC_N64_DWS);
135 }
136 local_irq_restore(flags);
137
138
139
140
141
142 udelay(GC_N64_DELAY);
143
144
145
146
147
148 for (i = 0; i < GC_N64_LENGTH; i++) {
149 parport_write_data(gc->pd->port, GC_N64_POWER_R);
150 data[i] = parport_read_status(gc->pd->port);
151 parport_write_data(gc->pd->port, GC_N64_POWER_R | GC_N64_CLOCK);
152 }
153
154
155
156
157
158
159}
160
161static void gc_n64_process_packet(struct gc *gc)
162{
163 unsigned char data[GC_N64_LENGTH];
164 signed char axes[2];
165 struct input_dev *dev;
166 int i, j, s;
167
168 gc_n64_read_packet(gc, data);
169
170 for (i = 0; i < GC_MAX_DEVICES; i++) {
171
172 dev = gc->dev[i];
173 if (!dev)
174 continue;
175
176 s = gc_status_bit[i];
177
178 if (s & gc->pads[GC_N64] & ~(data[8] | data[9])) {
179
180 axes[0] = axes[1] = 0;
181
182 for (j = 0; j < 8; j++) {
183 if (data[23 - j] & s)
184 axes[0] |= 1 << j;
185 if (data[31 - j] & s)
186 axes[1] |= 1 << j;
187 }
188
189 input_report_abs(dev, ABS_X, axes[0]);
190 input_report_abs(dev, ABS_Y, -axes[1]);
191
192 input_report_abs(dev, ABS_HAT0X, !(s & data[6]) - !(s & data[7]));
193 input_report_abs(dev, ABS_HAT0Y, !(s & data[4]) - !(s & data[5]));
194
195 for (j = 0; j < 10; j++)
196 input_report_key(dev, gc_n64_btn[j], s & data[gc_n64_bytes[j]]);
197
198 input_sync(dev);
199 }
200 }
201}
202
203
204
205
206
207#define GC_NES_DELAY 6
208#define GC_NES_LENGTH 8
209#define GC_SNES_LENGTH 12
210
211#define GC_SNESMOUSE_LENGTH 32
212
213
214#define GC_NES_POWER 0xfc
215#define GC_NES_CLOCK 0x01
216#define GC_NES_LATCH 0x02
217
218static unsigned char gc_nes_bytes[] = { 0, 1, 2, 3 };
219static unsigned char gc_snes_bytes[] = { 8, 0, 2, 3, 9, 1, 10, 11 };
220static short gc_snes_btn[] = { BTN_A, BTN_B, BTN_SELECT, BTN_START, BTN_X, BTN_Y, BTN_TL, BTN_TR };
221
222
223
224
225
226
227
228static void gc_nes_read_packet(struct gc *gc, int length, unsigned char *data)
229{
230 int i;
231
232 parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK | GC_NES_LATCH);
233 udelay(GC_NES_DELAY * 2);
234 parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK);
235
236 for (i = 0; i < length; i++) {
237 udelay(GC_NES_DELAY);
238 parport_write_data(gc->pd->port, GC_NES_POWER);
239 data[i] = parport_read_status(gc->pd->port) ^ 0x7f;
240 udelay(GC_NES_DELAY);
241 parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK);
242 }
243}
244
245static void gc_nes_process_packet(struct gc *gc)
246{
247 unsigned char data[GC_SNESMOUSE_LENGTH];
248 struct input_dev *dev;
249 int i, j, s, len;
250 char x_rel, y_rel;
251
252 len = gc->pads[GC_SNESMOUSE] ? GC_SNESMOUSE_LENGTH :
253 (gc->pads[GC_SNES] ? GC_SNES_LENGTH : GC_NES_LENGTH);
254
255 gc_nes_read_packet(gc, len, data);
256
257 for (i = 0; i < GC_MAX_DEVICES; i++) {
258
259 dev = gc->dev[i];
260 if (!dev)
261 continue;
262
263 s = gc_status_bit[i];
264
265 if (s & (gc->pads[GC_NES] | gc->pads[GC_SNES])) {
266 input_report_abs(dev, ABS_X, !(s & data[6]) - !(s & data[7]));
267 input_report_abs(dev, ABS_Y, !(s & data[4]) - !(s & data[5]));
268 }
269
270 if (s & gc->pads[GC_NES])
271 for (j = 0; j < 4; j++)
272 input_report_key(dev, gc_snes_btn[j], s & data[gc_nes_bytes[j]]);
273
274 if (s & gc->pads[GC_SNES])
275 for (j = 0; j < 8; j++)
276 input_report_key(dev, gc_snes_btn[j], s & data[gc_snes_bytes[j]]);
277
278 if (s & gc->pads[GC_SNESMOUSE]) {
279
280
281
282
283
284
285
286
287 if (!(s & data[12]) && !(s & data[13]) &&
288 !(s & data[14]) && (s & data[15])) {
289 input_report_key(dev, BTN_LEFT, s & data[9]);
290 input_report_key(dev, BTN_RIGHT, s & data[8]);
291
292 x_rel = y_rel = 0;
293 for (j = 0; j < 7; j++) {
294 x_rel <<= 1;
295 if (data[25 + j] & s)
296 x_rel |= 1;
297
298 y_rel <<= 1;
299 if (data[17 + j] & s)
300 y_rel |= 1;
301 }
302
303 if (x_rel) {
304 if (data[24] & s)
305 x_rel = -x_rel;
306 input_report_rel(dev, REL_X, x_rel);
307 }
308
309 if (y_rel) {
310 if (data[16] & s)
311 y_rel = -y_rel;
312 input_report_rel(dev, REL_Y, y_rel);
313 }
314 }
315 }
316 input_sync(dev);
317 }
318}
319
320
321
322
323
324#define GC_MULTI_LENGTH 5
325#define GC_MULTI2_LENGTH 6
326
327
328
329
330
331static void gc_multi_read_packet(struct gc *gc, int length, unsigned char *data)
332{
333 int i;
334
335 for (i = 0; i < length; i++) {
336 parport_write_data(gc->pd->port, ~(1 << i));
337 data[i] = parport_read_status(gc->pd->port) ^ 0x7f;
338 }
339}
340
341static void gc_multi_process_packet(struct gc *gc)
342{
343 unsigned char data[GC_MULTI2_LENGTH];
344 struct input_dev *dev;
345 int i, s;
346
347 gc_multi_read_packet(gc, gc->pads[GC_MULTI2] ? GC_MULTI2_LENGTH : GC_MULTI_LENGTH, data);
348
349 for (i = 0; i < GC_MAX_DEVICES; i++) {
350
351 dev = gc->dev[i];
352 if (!dev)
353 continue;
354
355 s = gc_status_bit[i];
356
357 if (s & (gc->pads[GC_MULTI] | gc->pads[GC_MULTI2])) {
358 input_report_abs(dev, ABS_X, !(s & data[2]) - !(s & data[3]));
359 input_report_abs(dev, ABS_Y, !(s & data[0]) - !(s & data[1]));
360 input_report_key(dev, BTN_TRIGGER, s & data[4]);
361 }
362
363 if (s & gc->pads[GC_MULTI2])
364 input_report_key(dev, BTN_THUMB, s & data[5]);
365
366 input_sync(dev);
367 }
368}
369
370
371
372
373
374
375
376
377
378
379
380#define GC_PSX_DELAY 25
381#define GC_PSX_LENGTH 8
382#define GC_PSX_BYTES 6
383
384#define GC_PSX_MOUSE 1
385#define GC_PSX_NEGCON 2
386#define GC_PSX_NORMAL 4
387#define GC_PSX_ANALOG 5
388#define GC_PSX_RUMBLE 7
389
390#define GC_PSX_CLOCK 0x04
391#define GC_PSX_COMMAND 0x01
392#define GC_PSX_POWER 0xf8
393#define GC_PSX_SELECT 0x02
394
395#define GC_PSX_ID(x) ((x) >> 4)
396#define GC_PSX_LEN(x) (((x) & 0xf) << 1)
397
398static int gc_psx_delay = GC_PSX_DELAY;
399module_param_named(psx_delay, gc_psx_delay, uint, 0);
400MODULE_PARM_DESC(psx_delay, "Delay when accessing Sony PSX controller (usecs)");
401
402static short gc_psx_abs[] = { ABS_X, ABS_Y, ABS_RX, ABS_RY, ABS_HAT0X, ABS_HAT0Y };
403static short gc_psx_btn[] = { BTN_TL, BTN_TR, BTN_TL2, BTN_TR2, BTN_A, BTN_B, BTN_X, BTN_Y,
404 BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR };
405static short gc_psx_ddr_btn[] = { BTN_0, BTN_1, BTN_2, BTN_3 };
406
407
408
409
410
411
412static void gc_psx_command(struct gc *gc, int b, unsigned char data[GC_MAX_DEVICES])
413{
414 int i, j, cmd, read;
415
416 for (i = 0; i < GC_MAX_DEVICES; i++)
417 data[i] = 0;
418
419 for (i = 0; i < GC_PSX_LENGTH; i++, b >>= 1) {
420 cmd = (b & 1) ? GC_PSX_COMMAND : 0;
421 parport_write_data(gc->pd->port, cmd | GC_PSX_POWER);
422 udelay(gc_psx_delay);
423 read = parport_read_status(gc->pd->port) ^ 0x80;
424 for (j = 0; j < GC_MAX_DEVICES; j++)
425 data[j] |= (read & gc_status_bit[j] & (gc->pads[GC_PSX] | gc->pads[GC_DDR])) ? (1 << i) : 0;
426 parport_write_data(gc->pd->port, cmd | GC_PSX_CLOCK | GC_PSX_POWER);
427 udelay(gc_psx_delay);
428 }
429}
430
431
432
433
434
435
436static void gc_psx_read_packet(struct gc *gc, unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES],
437 unsigned char id[GC_MAX_DEVICES])
438{
439 int i, j, max_len = 0;
440 unsigned long flags;
441 unsigned char data2[GC_MAX_DEVICES];
442
443 parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER);
444 udelay(gc_psx_delay);
445 parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_POWER);
446 udelay(gc_psx_delay);
447
448 local_irq_save(flags);
449
450 gc_psx_command(gc, 0x01, data2);
451 gc_psx_command(gc, 0x42, id);
452 gc_psx_command(gc, 0, data2);
453
454 for (i =0; i < GC_MAX_DEVICES; i++)
455 if((gc_status_bit[i] & (gc->pads[GC_PSX] | gc->pads[GC_DDR]))
456 && (GC_PSX_LEN(id[i]) > max_len)
457 && (GC_PSX_LEN(id[i]) <= GC_PSX_BYTES))
458 max_len = GC_PSX_LEN(id[i]);
459
460 for (i = 0; i < max_len; i++) {
461 gc_psx_command(gc, 0, data2);
462 for (j = 0; j < GC_MAX_DEVICES; j++)
463 data[j][i] = data2[j];
464 }
465
466 local_irq_restore(flags);
467
468 parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER);
469
470 for(i = 0; i < GC_MAX_DEVICES; i++)
471 id[i] = GC_PSX_ID(id[i]);
472}
473
474static void gc_psx_process_packet(struct gc *gc)
475{
476 unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES];
477 unsigned char id[GC_MAX_DEVICES];
478 struct input_dev *dev;
479 int i, j;
480
481 gc_psx_read_packet(gc, data, id);
482
483 for (i = 0; i < GC_MAX_DEVICES; i++) {
484
485 dev = gc->dev[i];
486 if (!dev)
487 continue;
488
489 switch (id[i]) {
490
491 case GC_PSX_RUMBLE:
492
493 input_report_key(dev, BTN_THUMBL, ~data[i][0] & 0x04);
494 input_report_key(dev, BTN_THUMBR, ~data[i][0] & 0x02);
495
496 case GC_PSX_NEGCON:
497 case GC_PSX_ANALOG:
498
499 if (gc->pads[GC_DDR] & gc_status_bit[i]) {
500 for(j = 0; j < 4; j++)
501 input_report_key(dev, gc_psx_ddr_btn[j], ~data[i][0] & (0x10 << j));
502 } else {
503 for (j = 0; j < 4; j++)
504 input_report_abs(dev, gc_psx_abs[j + 2], data[i][j + 2]);
505
506 input_report_abs(dev, ABS_X, 128 + !(data[i][0] & 0x20) * 127 - !(data[i][0] & 0x80) * 128);
507 input_report_abs(dev, ABS_Y, 128 + !(data[i][0] & 0x40) * 127 - !(data[i][0] & 0x10) * 128);
508 }
509
510 for (j = 0; j < 8; j++)
511 input_report_key(dev, gc_psx_btn[j], ~data[i][1] & (1 << j));
512
513 input_report_key(dev, BTN_START, ~data[i][0] & 0x08);
514 input_report_key(dev, BTN_SELECT, ~data[i][0] & 0x01);
515
516 input_sync(dev);
517
518 break;
519
520 case GC_PSX_NORMAL:
521 if (gc->pads[GC_DDR] & gc_status_bit[i]) {
522 for(j = 0; j < 4; j++)
523 input_report_key(dev, gc_psx_ddr_btn[j], ~data[i][0] & (0x10 << j));
524 } else {
525 input_report_abs(dev, ABS_X, 128 + !(data[i][0] & 0x20) * 127 - !(data[i][0] & 0x80) * 128);
526 input_report_abs(dev, ABS_Y, 128 + !(data[i][0] & 0x40) * 127 - !(data[i][0] & 0x10) * 128);
527
528
529
530
531
532
533
534
535 }
536
537 for (j = 0; j < 8; j++)
538 input_report_key(dev, gc_psx_btn[j], ~data[i][1] & (1 << j));
539
540 input_report_key(dev, BTN_START, ~data[i][0] & 0x08);
541 input_report_key(dev, BTN_SELECT, ~data[i][0] & 0x01);
542
543 input_sync(dev);
544
545 break;
546
547 case 0:
548 break;
549 }
550 }
551}
552
553
554
555
556
557static void gc_timer(unsigned long private)
558{
559 struct gc *gc = (void *) private;
560
561
562
563
564
565 if (gc->pads[GC_N64])
566 gc_n64_process_packet(gc);
567
568
569
570
571
572 if (gc->pads[GC_NES] || gc->pads[GC_SNES] || gc->pads[GC_SNESMOUSE])
573 gc_nes_process_packet(gc);
574
575
576
577
578
579 if (gc->pads[GC_MULTI] || gc->pads[GC_MULTI2])
580 gc_multi_process_packet(gc);
581
582
583
584
585
586 if (gc->pads[GC_PSX] || gc->pads[GC_DDR])
587 gc_psx_process_packet(gc);
588
589 mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME);
590}
591
592static int gc_open(struct input_dev *dev)
593{
594 struct gc *gc = input_get_drvdata(dev);
595 int err;
596
597 err = mutex_lock_interruptible(&gc->mutex);
598 if (err)
599 return err;
600
601 if (!gc->used++) {
602 parport_claim(gc->pd);
603 parport_write_control(gc->pd->port, 0x04);
604 mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME);
605 }
606
607 mutex_unlock(&gc->mutex);
608 return 0;
609}
610
611static void gc_close(struct input_dev *dev)
612{
613 struct gc *gc = input_get_drvdata(dev);
614
615 mutex_lock(&gc->mutex);
616 if (!--gc->used) {
617 del_timer_sync(&gc->timer);
618 parport_write_control(gc->pd->port, 0x00);
619 parport_release(gc->pd);
620 }
621 mutex_unlock(&gc->mutex);
622}
623
624static int __init gc_setup_pad(struct gc *gc, int idx, int pad_type)
625{
626 struct input_dev *input_dev;
627 int i;
628
629 if (!pad_type)
630 return 0;
631
632 if (pad_type < 1 || pad_type > GC_MAX) {
633 printk(KERN_WARNING "gamecon.c: Pad type %d unknown\n", pad_type);
634 return -EINVAL;
635 }
636
637 gc->dev[idx] = input_dev = input_allocate_device();
638 if (!input_dev) {
639 printk(KERN_ERR "gamecon.c: Not enough memory for input device\n");
640 return -ENOMEM;
641 }
642
643 input_dev->name = gc_names[pad_type];
644 input_dev->phys = gc->phys[idx];
645 input_dev->id.bustype = BUS_PARPORT;
646 input_dev->id.vendor = 0x0001;
647 input_dev->id.product = pad_type;
648 input_dev->id.version = 0x0100;
649
650 input_set_drvdata(input_dev, gc);
651
652 input_dev->open = gc_open;
653 input_dev->close = gc_close;
654
655 if (pad_type != GC_SNESMOUSE) {
656 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
657
658 for (i = 0; i < 2; i++)
659 input_set_abs_params(input_dev, ABS_X + i, -1, 1, 0, 0);
660 } else
661 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
662
663 gc->pads[0] |= gc_status_bit[idx];
664 gc->pads[pad_type] |= gc_status_bit[idx];
665
666 switch (pad_type) {
667
668 case GC_N64:
669 for (i = 0; i < 10; i++)
670 set_bit(gc_n64_btn[i], input_dev->keybit);
671
672 for (i = 0; i < 2; i++) {
673 input_set_abs_params(input_dev, ABS_X + i, -127, 126, 0, 2);
674 input_set_abs_params(input_dev, ABS_HAT0X + i, -1, 1, 0, 0);
675 }
676
677 break;
678
679 case GC_SNESMOUSE:
680 set_bit(BTN_LEFT, input_dev->keybit);
681 set_bit(BTN_RIGHT, input_dev->keybit);
682 set_bit(REL_X, input_dev->relbit);
683 set_bit(REL_Y, input_dev->relbit);
684 break;
685
686 case GC_SNES:
687 for (i = 4; i < 8; i++)
688 set_bit(gc_snes_btn[i], input_dev->keybit);
689 case GC_NES:
690 for (i = 0; i < 4; i++)
691 set_bit(gc_snes_btn[i], input_dev->keybit);
692 break;
693
694 case GC_MULTI2:
695 set_bit(BTN_THUMB, input_dev->keybit);
696 case GC_MULTI:
697 set_bit(BTN_TRIGGER, input_dev->keybit);
698 break;
699
700 case GC_PSX:
701 for (i = 0; i < 6; i++)
702 input_set_abs_params(input_dev, gc_psx_abs[i], 4, 252, 0, 2);
703 for (i = 0; i < 12; i++)
704 set_bit(gc_psx_btn[i], input_dev->keybit);
705
706 break;
707
708 case GC_DDR:
709 for (i = 0; i < 4; i++)
710 set_bit(gc_psx_ddr_btn[i], input_dev->keybit);
711 for (i = 0; i < 12; i++)
712 set_bit(gc_psx_btn[i], input_dev->keybit);
713
714 break;
715 }
716
717 return 0;
718}
719
720static struct gc __init *gc_probe(int parport, int *pads, int n_pads)
721{
722 struct gc *gc;
723 struct parport *pp;
724 struct pardevice *pd;
725 int i;
726 int err;
727
728 pp = parport_find_number(parport);
729 if (!pp) {
730 printk(KERN_ERR "gamecon.c: no such parport\n");
731 err = -EINVAL;
732 goto err_out;
733 }
734
735 pd = parport_register_device(pp, "gamecon", NULL, NULL, NULL, PARPORT_DEV_EXCL, NULL);
736 if (!pd) {
737 printk(KERN_ERR "gamecon.c: parport busy already - lp.o loaded?\n");
738 err = -EBUSY;
739 goto err_put_pp;
740 }
741
742 gc = kzalloc(sizeof(struct gc), GFP_KERNEL);
743 if (!gc) {
744 printk(KERN_ERR "gamecon.c: Not enough memory\n");
745 err = -ENOMEM;
746 goto err_unreg_pardev;
747 }
748
749 mutex_init(&gc->mutex);
750 gc->pd = pd;
751 init_timer(&gc->timer);
752 gc->timer.data = (long) gc;
753 gc->timer.function = gc_timer;
754
755 for (i = 0; i < n_pads && i < GC_MAX_DEVICES; i++) {
756 if (!pads[i])
757 continue;
758
759 snprintf(gc->phys[i], sizeof(gc->phys[i]),
760 "%s/input%d", gc->pd->port->name, i);
761 err = gc_setup_pad(gc, i, pads[i]);
762 if (err)
763 goto err_unreg_devs;
764
765 err = input_register_device(gc->dev[i]);
766 if (err)
767 goto err_free_dev;
768 }
769
770 if (!gc->pads[0]) {
771 printk(KERN_ERR "gamecon.c: No valid devices specified\n");
772 err = -EINVAL;
773 goto err_free_gc;
774 }
775
776 parport_put_port(pp);
777 return gc;
778
779 err_free_dev:
780 input_free_device(gc->dev[i]);
781 err_unreg_devs:
782 while (--i >= 0)
783 if (gc->dev[i])
784 input_unregister_device(gc->dev[i]);
785 err_free_gc:
786 kfree(gc);
787 err_unreg_pardev:
788 parport_unregister_device(pd);
789 err_put_pp:
790 parport_put_port(pp);
791 err_out:
792 return ERR_PTR(err);
793}
794
795static void gc_remove(struct gc *gc)
796{
797 int i;
798
799 for (i = 0; i < GC_MAX_DEVICES; i++)
800 if (gc->dev[i])
801 input_unregister_device(gc->dev[i]);
802 parport_unregister_device(gc->pd);
803 kfree(gc);
804}
805
806static int __init gc_init(void)
807{
808 int i;
809 int have_dev = 0;
810 int err = 0;
811
812 for (i = 0; i < GC_MAX_PORTS; i++) {
813 if (gc_cfg[i].nargs == 0 || gc_cfg[i].args[0] < 0)
814 continue;
815
816 if (gc_cfg[i].nargs < 2) {
817 printk(KERN_ERR "gamecon.c: at least one device must be specified\n");
818 err = -EINVAL;
819 break;
820 }
821
822 gc_base[i] = gc_probe(gc_cfg[i].args[0],
823 gc_cfg[i].args + 1, gc_cfg[i].nargs - 1);
824 if (IS_ERR(gc_base[i])) {
825 err = PTR_ERR(gc_base[i]);
826 break;
827 }
828
829 have_dev = 1;
830 }
831
832 if (err) {
833 while (--i >= 0)
834 if (gc_base[i])
835 gc_remove(gc_base[i]);
836 return err;
837 }
838
839 return have_dev ? 0 : -ENODEV;
840}
841
842static void __exit gc_exit(void)
843{
844 int i;
845
846 for (i = 0; i < GC_MAX_PORTS; i++)
847 if (gc_base[i])
848 gc_remove(gc_base[i]);
849}
850
851module_init(gc_init);
852module_exit(gc_exit);
853