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/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/* see also gs_psx_delay parameter in PSX support section */ 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 * N64 support. 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 /* N64 bit length, not including stop bit */ 104#define GC_N64_REQUEST_LENGTH 37 /* transmit request sequence is 9 bits long */ 105#define GC_N64_DELAY 133 /* delay between transmit request, and response ready (us) */ 106#define GC_N64_REQUEST 0x1dd1111111ULL /* the request data command (encoded for 000000011) */ 107#define GC_N64_DWS 3 /* delay between write segments (required for sound playback because of ISA DMA) */ 108 /* GC_N64_DWS > 24 is known to fail */ 109#define GC_N64_POWER_W 0xe2 /* power during write (transmit request) */ 110#define GC_N64_POWER_R 0xfd /* power during read */ 111#define GC_N64_OUT 0x1d /* output bits to the 4 pads */ 112 /* Reading the main axes of any N64 pad is known to fail if the corresponding bit */ 113 /* in GC_N64_OUT is pulled low on the output port (by any routine) for more */ 114 /* than 123 us */ 115#define GC_N64_CLOCK 0x02 /* clock bits for read */ 116 117/* 118 * gc_n64_read_packet() reads an N64 packet. 119 * Each pad uses one bit per byte. So all pads connected to this port are read in parallel. 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 * Request the pad to transmit data 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 * Wait for the pad response to be loaded into the 33-bit register of the adapter 140 */ 141 142 udelay(GC_N64_DELAY); 143 144/* 145 * Grab data (ignoring the last bit, which is a stop bit) 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 * We must wait 200 ms here for the controller to reinitialize before the next read request. 156 * No worries as long as gc_read is polled less frequently than this. 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 * NES/SNES support. 205 */ 206 207#define GC_NES_DELAY 6 /* Delay between bits - 6us */ 208#define GC_NES_LENGTH 8 /* The NES pads use 8 bits of data */ 209#define GC_SNES_LENGTH 12 /* The SNES true length is 16, but the 210 last 4 bits are unused */ 211#define GC_SNESMOUSE_LENGTH 32 /* The SNES mouse uses 32 bits, the first 212 16 bits are equivalent to a gamepad */ 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 * gc_nes_read_packet() reads a NES/SNES packet. 224 * Each pad uses one bit per byte. So all pads connected to 225 * this port are read in parallel. 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 * The 4 unused bits from SNES controllers appear to be ID bits 281 * so use them to make sure iwe are dealing with a mouse. 282 * gamepad is connected. This is important since 283 * my SNES gamepad sends 1's for bits 16-31, which 284 * cause the mouse pointer to quickly move to the 285 * upper left corner of the screen. 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 * Multisystem joystick support 322 */ 323 324#define GC_MULTI_LENGTH 5 /* Multi system joystick packet length is 5 */ 325#define GC_MULTI2_LENGTH 6 /* One more bit for one more button */ 326 327/* 328 * gc_multi_read_packet() reads a Multisystem joystick packet. 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 * PSX support 372 * 373 * See documentation at: 374 * http://www.dim.com/~mackys/psxmemcard/ps-eng2.txt 375 * http://www.gamesx.com/controldata/psxcont/psxcont.htm 376 * ftp://milano.usal.es/pablo/ 377 * 378 */ 379 380#define GC_PSX_DELAY 25 /* 25 usec */ 381#define GC_PSX_LENGTH 8 /* talk to the controller in bits */ 382#define GC_PSX_BYTES 6 /* the maximum number of bytes to read off the controller */ 383 384#define GC_PSX_MOUSE 1 /* Mouse */ 385#define GC_PSX_NEGCON 2 /* NegCon */ 386#define GC_PSX_NORMAL 4 /* Digital / Analog or Rumble in Digital mode */ 387#define GC_PSX_ANALOG 5 /* Analog in Analog mode / Rumble in Green mode */ 388#define GC_PSX_RUMBLE 7 /* Rumble in Red mode */ 389 390#define GC_PSX_CLOCK 0x04 /* Pin 4 */ 391#define GC_PSX_COMMAND 0x01 /* Pin 2 */ 392#define GC_PSX_POWER 0xf8 /* Pins 5-9 */ 393#define GC_PSX_SELECT 0x02 /* Pin 3 */ 394 395#define GC_PSX_ID(x) ((x) >> 4) /* High nibble is device type */ 396#define GC_PSX_LEN(x) (((x) & 0xf) << 1) /* Low nibble is length in bytes/2 */ 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 * gc_psx_command() writes 8bit command and reads 8bit data from 409 * the psx pad. 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 * gc_psx_read_packet() reads a whole psx packet and returns 433 * device identifier code. 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); /* Select pad */ 444 udelay(gc_psx_delay); 445 parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_POWER); /* Deselect, begin command */ 446 udelay(gc_psx_delay); 447 448 local_irq_save(flags); 449 450 gc_psx_command(gc, 0x01, data2); /* Access pad */ 451 gc_psx_command(gc, 0x42, id); /* Get device ids */ 452 gc_psx_command(gc, 0, data2); /* Dump status */ 453 454 for (i =0; i < GC_MAX_DEVICES; i++) /* Find the longest pad */ 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++) { /* Read in all the data */ 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++) /* Set id's to the real value */ 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 /* for some reason if the extra axes are left unset they drift */ 529 /* for (j = 0; j < 4; j++) 530 input_report_abs(dev, gc_psx_abs[j + 2], 128); 531 * This needs to be debugged properly, 532 * maybe fuzz processing needs to be done in input_sync() 533 * --vojtech 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: /* not a pad, ignore */ 548 break; 549 } 550 } 551} 552 553/* 554 * gc_timer() initiates reads of console pads data. 555 */ 556 557static void gc_timer(unsigned long private) 558{ 559 struct gc *gc = (void *) private; 560 561/* 562 * N64 pads - must be read first, any read confuses them for 200 us 563 */ 564 565 if (gc->pads[GC_N64]) 566 gc_n64_process_packet(gc); 567 568/* 569 * NES and SNES pads or mouse 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 * Multi and Multi2 joysticks 577 */ 578 579 if (gc->pads[GC_MULTI] || gc->pads[GC_MULTI2]) 580 gc_multi_process_packet(gc); 581 582/* 583 * PSX controllers 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(EV_KEY) | BIT(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(EV_KEY) | BIT(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