2 * $Id: gamecon.c,v 1.22 2002/07/01 15:42:25 vojtech Exp $
4 * Copyright (c) 1999-2001 Vojtech Pavlik
6 * Based on the work of:
7 * Andree Borrmann John Dahlstrom
8 * David Kuder Nathan Hand
12 * NES, SNES, N64, MultiSystem, PSX gamepad driver for Linux
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30 * Should you need to contact me, the author, you can do so either by
31 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
32 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
35 #include <linux/kernel.h>
36 #include <linux/delay.h>
37 #include <linux/module.h>
38 #include <linux/moduleparam.h>
39 #include <linux/init.h>
40 #include <linux/parport.h>
41 #include <linux/input.h>
43 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
44 MODULE_DESCRIPTION("NES, SNES, N64, MultiSystem, PSX gamepad driver");
45 MODULE_LICENSE("GPL");
47 static int gc[] __initdata = { -1, 0, 0, 0, 0, 0 };
48 static int gc_nargs __initdata = 0;
49 module_param_array_named(map, gc, int, gc_nargs, 0);
50 MODULE_PARM_DESC(map, "Describers first set of devices (<parport#>,<pad1>,<pad2>,..<pad5>)");
52 static int gc_2[] __initdata = { -1, 0, 0, 0, 0, 0 };
53 static int gc_nargs_2 __initdata = 0;
54 module_param_array_named(map2, gc_2, int, gc_nargs_2, 0);
55 MODULE_PARM_DESC(map2, "Describers second set of devices");
57 static int gc_3[] __initdata = { -1, 0, 0, 0, 0, 0 };
58 static int gc_nargs_3 __initdata = 0;
59 module_param_array_named(map3, gc_3, int, gc_nargs_3, 0);
60 MODULE_PARM_DESC(map3, "Describers third set of devices");
62 __obsolete_setup("gc=");
63 __obsolete_setup("gc_2=");
64 __obsolete_setup("gc_3=");
66 /* see also gs_psx_delay parameter in PSX support section */
78 #define GC_REFRESH_TIME HZ/100
82 struct input_dev dev[5];
83 struct timer_list timer;
84 unsigned char pads[GC_MAX + 1];
89 static struct gc *gc_base[3];
91 static int gc_status_bit[] = { 0x40, 0x80, 0x20, 0x10, 0x08 };
93 static char *gc_names[] = { NULL, "SNES pad", "NES pad", "NES FourPort", "Multisystem joystick",
94 "Multisystem 2-button joystick", "N64 controller", "PSX controller" };
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 };
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 */
114 #define GC_N64_CLOCK 0x02 /* clock bits for read */
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.
121 static void gc_n64_read_packet(struct gc *gc, unsigned char *data)
127 * Request the pad to transmit data
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));
135 local_irq_restore(flags);
138 * Wait for the pad response to be loaded into the 33-bit register of the adapter
141 udelay(GC_N64_DELAY);
144 * Grab data (ignoring the last bit, which is a stop bit)
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);
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.
164 #define GC_NES_DELAY 6 /* Delay between bits - 6us */
165 #define GC_NES_LENGTH 8 /* The NES pads use 8 bits of data */
166 #define GC_SNES_LENGTH 12 /* The SNES true length is 16, but the last 4 bits are unused */
168 #define GC_NES_POWER 0xfc
169 #define GC_NES_CLOCK 0x01
170 #define GC_NES_LATCH 0x02
172 static unsigned char gc_nes_bytes[] = { 0, 1, 2, 3 };
173 static unsigned char gc_snes_bytes[] = { 8, 0, 2, 3, 9, 1, 10, 11 };
174 static short gc_snes_btn[] = { BTN_A, BTN_B, BTN_SELECT, BTN_START, BTN_X, BTN_Y, BTN_TL, BTN_TR };
177 * gc_nes_read_packet() reads a NES/SNES packet.
178 * Each pad uses one bit per byte. So all pads connected to
179 * this port are read in parallel.
182 static void gc_nes_read_packet(struct gc *gc, int length, unsigned char *data)
186 parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK | GC_NES_LATCH);
187 udelay(GC_NES_DELAY * 2);
188 parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK);
190 for (i = 0; i < length; i++) {
191 udelay(GC_NES_DELAY);
192 parport_write_data(gc->pd->port, GC_NES_POWER);
193 data[i] = parport_read_status(gc->pd->port) ^ 0x7f;
194 udelay(GC_NES_DELAY);
195 parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK);
200 * Multisystem joystick support
203 #define GC_MULTI_LENGTH 5 /* Multi system joystick packet length is 5 */
204 #define GC_MULTI2_LENGTH 6 /* One more bit for one more button */
207 * gc_multi_read_packet() reads a Multisystem joystick packet.
210 static void gc_multi_read_packet(struct gc *gc, int length, unsigned char *data)
214 for (i = 0; i < length; i++) {
215 parport_write_data(gc->pd->port, ~(1 << i));
216 data[i] = parport_read_status(gc->pd->port) ^ 0x7f;
223 * See documentation at:
224 * http://www.dim.com/~mackys/psxmemcard/ps-eng2.txt
225 * http://www.gamesx.com/controldata/psxcont/psxcont.htm
226 * ftp://milano.usal.es/pablo/
230 #define GC_PSX_DELAY 25 /* 25 usec */
231 #define GC_PSX_LENGTH 8 /* talk to the controller in bytes */
233 #define GC_PSX_MOUSE 1 /* Mouse */
234 #define GC_PSX_NEGCON 2 /* NegCon */
235 #define GC_PSX_NORMAL 4 /* Digital / Analog or Rumble in Digital mode */
236 #define GC_PSX_ANALOG 5 /* Analog in Analog mode / Rumble in Green mode */
237 #define GC_PSX_RUMBLE 7 /* Rumble in Red mode */
239 #define GC_PSX_CLOCK 0x04 /* Pin 4 */
240 #define GC_PSX_COMMAND 0x01 /* Pin 1 */
241 #define GC_PSX_POWER 0xf8 /* Pins 5-9 */
242 #define GC_PSX_SELECT 0x02 /* Pin 3 */
244 #define GC_PSX_ID(x) ((x) >> 4) /* High nibble is device type */
245 #define GC_PSX_LEN(x) ((x) & 0xf) /* Low nibble is length in words */
247 static int gc_psx_delay = GC_PSX_DELAY;
248 module_param_named(psx_delay, gc_psx_delay, uint, 0);
249 MODULE_PARM_DESC(psx_delay, "Delay when accessing Sony PSX controller (usecs)");
251 __obsolete_setup("gc_psx_delay=");
253 static short gc_psx_abs[] = { ABS_X, ABS_Y, ABS_RX, ABS_RY, ABS_HAT0X, ABS_HAT0Y };
254 static short gc_psx_btn[] = { BTN_TL, BTN_TR, BTN_TL2, BTN_TR2, BTN_A, BTN_B, BTN_X, BTN_Y,
255 BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR };
258 * gc_psx_command() writes 8bit command and reads 8bit data from
262 static int gc_psx_command(struct gc *gc, int b)
264 int i, cmd, data = 0;
266 for (i = 0; i < 8; i++, b >>= 1) {
267 cmd = (b & 1) ? GC_PSX_COMMAND : 0;
268 parport_write_data(gc->pd->port, cmd | GC_PSX_POWER);
269 udelay(gc_psx_delay);
270 data |= ((parport_read_status(gc->pd->port) ^ 0x80) & gc->pads[GC_PSX]) ? (1 << i) : 0;
271 parport_write_data(gc->pd->port, cmd | GC_PSX_CLOCK | GC_PSX_POWER);
272 udelay(gc_psx_delay);
278 * gc_psx_read_packet() reads a whole psx packet and returns
279 * device identifier code.
282 static int gc_psx_read_packet(struct gc *gc, unsigned char *data)
287 parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER); /* Select pad */
288 udelay(gc_psx_delay * 2);
289 parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_POWER); /* Deselect, begin command */
290 udelay(gc_psx_delay * 2);
292 local_irq_save(flags);
294 gc_psx_command(gc, 0x01); /* Access pad */
295 id = gc_psx_command(gc, 0x42); /* Get device id */
296 if (gc_psx_command(gc, 0) == 0x5a) { /* Okay? */
297 for (i = 0; i < GC_PSX_LEN(id) * 2; i++)
298 data[i] = gc_psx_command(gc, 0);
301 local_irq_restore(flags);
303 parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER);
305 return GC_PSX_ID(id);
309 * gc_timer() reads and analyzes console pads data.
312 #define GC_MAX_LENGTH GC_N64_LENGTH
314 static void gc_timer(unsigned long private)
316 struct gc *gc = (void *) private;
317 struct input_dev *dev = gc->dev;
318 unsigned char data[GC_MAX_LENGTH];
322 * N64 pads - must be read first, any read confuses them for 200 us
325 if (gc->pads[GC_N64]) {
327 gc_n64_read_packet(gc, data);
329 for (i = 0; i < 5; i++) {
331 s = gc_status_bit[i];
333 if (s & gc->pads[GC_N64] & ~(data[8] | data[9])) {
336 axes[0] = axes[1] = 0;
338 for (j = 0; j < 8; j++) {
339 if (data[23 - j] & s) axes[0] |= 1 << j;
340 if (data[31 - j] & s) axes[1] |= 1 << j;
343 input_report_abs(dev + i, ABS_X, axes[0]);
344 input_report_abs(dev + i, ABS_Y, -axes[1]);
346 input_report_abs(dev + i, ABS_HAT0X, !(s & data[6]) - !(s & data[7]));
347 input_report_abs(dev + i, ABS_HAT0Y, !(s & data[4]) - !(s & data[5]));
349 for (j = 0; j < 10; j++)
350 input_report_key(dev + i, gc_n64_btn[j], s & data[gc_n64_bytes[j]]);
361 if (gc->pads[GC_NES] || gc->pads[GC_SNES]) {
363 gc_nes_read_packet(gc, gc->pads[GC_SNES] ? GC_SNES_LENGTH : GC_NES_LENGTH, data);
365 for (i = 0; i < 5; i++) {
367 s = gc_status_bit[i];
369 if (s & (gc->pads[GC_NES] | gc->pads[GC_SNES])) {
370 input_report_abs(dev + i, ABS_X, !(s & data[6]) - !(s & data[7]));
371 input_report_abs(dev + i, ABS_Y, !(s & data[4]) - !(s & data[5]));
374 if (s & gc->pads[GC_NES])
375 for (j = 0; j < 4; j++)
376 input_report_key(dev + i, gc_snes_btn[j], s & data[gc_nes_bytes[j]]);
378 if (s & gc->pads[GC_SNES])
379 for (j = 0; j < 8; j++)
380 input_report_key(dev + i, gc_snes_btn[j], s & data[gc_snes_bytes[j]]);
387 * Multi and Multi2 joysticks
390 if (gc->pads[GC_MULTI] || gc->pads[GC_MULTI2]) {
392 gc_multi_read_packet(gc, gc->pads[GC_MULTI2] ? GC_MULTI2_LENGTH : GC_MULTI_LENGTH, data);
394 for (i = 0; i < 5; i++) {
396 s = gc_status_bit[i];
398 if (s & (gc->pads[GC_MULTI] | gc->pads[GC_MULTI2])) {
399 input_report_abs(dev + i, ABS_X, !(s & data[2]) - !(s & data[3]));
400 input_report_abs(dev + i, ABS_Y, !(s & data[0]) - !(s & data[1]));
401 input_report_key(dev + i, BTN_TRIGGER, s & data[4]);
404 if (s & gc->pads[GC_MULTI2])
405 input_report_key(dev + i, BTN_THUMB, s & data[5]);
415 if (gc->pads[GC_PSX]) {
417 for (i = 0; i < 5; i++)
418 if (gc->pads[GC_PSX] & gc_status_bit[i])
421 switch (gc_psx_read_packet(gc, data)) {
425 input_report_key(dev + i, BTN_THUMBL, ~data[0] & 0x04);
426 input_report_key(dev + i, BTN_THUMBR, ~data[0] & 0x02);
432 for (j = 0; j < 4; j++)
433 input_report_abs(dev + i, gc_psx_abs[j], data[j + 2]);
435 input_report_abs(dev + i, ABS_HAT0X, !(data[0] & 0x20) - !(data[0] & 0x80));
436 input_report_abs(dev + i, ABS_HAT0Y, !(data[0] & 0x40) - !(data[0] & 0x10));
438 for (j = 0; j < 8; j++)
439 input_report_key(dev + i, gc_psx_btn[j], ~data[1] & (1 << j));
441 input_report_key(dev + i, BTN_START, ~data[0] & 0x08);
442 input_report_key(dev + i, BTN_SELECT, ~data[0] & 0x01);
450 input_report_abs(dev + i, ABS_X, 128 + !(data[0] & 0x20) * 127 - !(data[0] & 0x80) * 128);
451 input_report_abs(dev + i, ABS_Y, 128 + !(data[0] & 0x40) * 127 - !(data[0] & 0x10) * 128);
453 for (j = 0; j < 8; j++)
454 input_report_key(dev + i, gc_psx_btn[j], ~data[1] & (1 << j));
456 input_report_key(dev + i, BTN_START, ~data[0] & 0x08);
457 input_report_key(dev + i, BTN_SELECT, ~data[0] & 0x01);
465 mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME);
468 static int gc_open(struct input_dev *dev)
470 struct gc *gc = dev->private;
472 parport_claim(gc->pd);
473 parport_write_control(gc->pd->port, 0x04);
474 mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME);
479 static void gc_close(struct input_dev *dev)
481 struct gc *gc = dev->private;
483 del_timer(&gc->timer);
484 parport_write_control(gc->pd->port, 0x00);
485 parport_release(gc->pd);
489 static struct gc __init *gc_probe(int *config, int nargs)
494 unsigned char data[32];
500 printk(KERN_ERR "gamecon.c: at least one device must be specified\n");
504 pp = parport_find_number(config[0]);
507 printk(KERN_ERR "gamecon.c: no such parport\n");
511 if (!(gc = kmalloc(sizeof(struct gc), GFP_KERNEL))) {
512 parport_put_port(pp);
515 memset(gc, 0, sizeof(struct gc));
517 gc->pd = parport_register_device(pp, "gamecon", NULL, NULL, NULL, PARPORT_DEV_EXCL, NULL);
519 parport_put_port(pp);
522 printk(KERN_ERR "gamecon.c: parport busy already - lp.o loaded?\n");
527 parport_claim(gc->pd);
529 init_timer(&gc->timer);
530 gc->timer.data = (long) gc;
531 gc->timer.function = gc_timer;
533 for (i = 0; i < nargs - 1; i++) {
538 if (config[i + 1] < 1 || config[i + 1] > GC_MAX) {
539 printk(KERN_WARNING "gamecon.c: Pad type %d unknown\n", config[i + 1]);
543 gc->dev[i].private = gc;
544 gc->dev[i].open = gc_open;
545 gc->dev[i].close = gc_close;
547 gc->dev[i].evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
549 for (j = 0; j < 2; j++) {
550 set_bit(ABS_X + j, gc->dev[i].absbit);
551 gc->dev[i].absmin[ABS_X + j] = -1;
552 gc->dev[i].absmax[ABS_X + j] = 1;
555 gc->pads[0] |= gc_status_bit[i];
556 gc->pads[config[i + 1]] |= gc_status_bit[i];
558 switch(config[i + 1]) {
561 for (j = 0; j < 10; j++)
562 set_bit(gc_n64_btn[j], gc->dev[i].keybit);
564 for (j = 0; j < 2; j++) {
565 set_bit(ABS_X + j, gc->dev[i].absbit);
566 gc->dev[i].absmin[ABS_X + j] = -127;
567 gc->dev[i].absmax[ABS_X + j] = 126;
568 gc->dev[i].absflat[ABS_X + j] = 2;
569 set_bit(ABS_HAT0X + j, gc->dev[i].absbit);
570 gc->dev[i].absmin[ABS_HAT0X + j] = -1;
571 gc->dev[i].absmax[ABS_HAT0X + j] = 1;
577 for (j = 4; j < 8; j++)
578 set_bit(gc_snes_btn[j], gc->dev[i].keybit);
580 for (j = 0; j < 4; j++)
581 set_bit(gc_snes_btn[j], gc->dev[i].keybit);
585 set_bit(BTN_THUMB, gc->dev[i].keybit);
587 set_bit(BTN_TRIGGER, gc->dev[i].keybit);
592 psx = gc_psx_read_packet(gc, data);
600 for (j = 0; j < 6; j++) {
602 set_bit(psx, gc->dev[i].absbit);
604 gc->dev[i].absmin[psx] = 4;
605 gc->dev[i].absmax[psx] = 252;
606 gc->dev[i].absflat[psx] = 2;
608 gc->dev[i].absmin[psx] = -1;
609 gc->dev[i].absmax[psx] = 1;
613 for (j = 0; j < 12; j++)
614 set_bit(gc_psx_btn[j], gc->dev[i].keybit);
619 gc->pads[GC_PSX] &= ~gc_status_bit[i];
620 printk(KERN_ERR "gamecon.c: No PSX controller found.\n");
624 gc->pads[GC_PSX] &= ~gc_status_bit[i];
625 printk(KERN_WARNING "gamecon.c: Unsupported PSX controller %#x,"
626 " please report to <vojtech@ucw.cz>.\n", psx);
631 sprintf(gc->phys[i], "%s/input%d", gc->pd->port->name, i);
633 gc->dev[i].name = gc_names[config[i + 1]];
634 gc->dev[i].phys = gc->phys[i];
635 gc->dev[i].id.bustype = BUS_PARPORT;
636 gc->dev[i].id.vendor = 0x0001;
637 gc->dev[i].id.product = config[i + 1];
638 gc->dev[i].id.version = 0x0100;
641 parport_release(gc->pd);
644 parport_unregister_device(gc->pd);
649 for (i = 0; i < 5; i++)
650 if (gc->pads[0] & gc_status_bit[i]) {
651 input_register_device(gc->dev + i);
652 printk(KERN_INFO "input: %s on %s\n", gc->dev[i].name, gc->pd->port->name);
658 int __init gc_init(void)
660 gc_base[0] = gc_probe(gc, gc_nargs);
661 gc_base[1] = gc_probe(gc_2, gc_nargs_2);
662 gc_base[2] = gc_probe(gc_3, gc_nargs_3);
664 if (gc_base[0] || gc_base[1] || gc_base[2])
670 void __exit gc_exit(void)
674 for (i = 0; i < 3; i++)
676 for (j = 0; j < 5; j++)
677 if (gc_base[i]->pads[0] & gc_status_bit[j])
678 input_unregister_device(gc_base[i]->dev + j);
679 parport_unregister_device(gc_base[i]->pd);
683 module_init(gc_init);
684 module_exit(gc_exit);