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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 34 35 #include <linux/kernel.h> 36 #include <linux/delay.h> 37 #include <linux/module.h> 38 #include <linux/init.h> 39 #include <linux/parport.h> 40 #include <linux/input.h> 41 #include <linux/mutex.h> 42 #include <linux/slab.h> 43 44 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>"); 45 MODULE_DESCRIPTION("NES, SNES, N64, MultiSystem, PSX gamepad driver"); 46 MODULE_LICENSE("GPL"); 47 48 #define GC_MAX_PORTS 3 49 #define GC_MAX_DEVICES 5 50 51 struct gc_config { 52 int args[GC_MAX_DEVICES + 1]; 53 unsigned int nargs; 54 }; 55 56 static struct gc_config gc_cfg[GC_MAX_PORTS] __initdata; 57 58 module_param_array_named(map, gc_cfg[0].args, int, &gc_cfg[0].nargs, 0); 59 MODULE_PARM_DESC(map, "Describes first set of devices (<parport#>,<pad1>,<pad2>,..<pad5>)"); 60 module_param_array_named(map2, gc_cfg[1].args, int, &gc_cfg[1].nargs, 0); 61 MODULE_PARM_DESC(map2, "Describes second set of devices"); 62 module_param_array_named(map3, gc_cfg[2].args, int, &gc_cfg[2].nargs, 0); 63 MODULE_PARM_DESC(map3, "Describes third set of devices"); 64 65 /* see also gs_psx_delay parameter in PSX support section */ 66 67 enum gc_type { 68 GC_NONE = 0, 69 GC_SNES, 70 GC_NES, 71 GC_NES4, 72 GC_MULTI, 73 GC_MULTI2, 74 GC_N64, 75 GC_PSX, 76 GC_DDR, 77 GC_SNESMOUSE, 78 GC_MAX 79 }; 80 81 #define GC_REFRESH_TIME HZ/100 82 83 struct gc_pad { 84 struct input_dev *dev; 85 enum gc_type type; 86 char phys[32]; 87 }; 88 89 struct gc { 90 struct pardevice *pd; 91 struct gc_pad pads[GC_MAX_DEVICES]; 92 struct timer_list timer; 93 int pad_count[GC_MAX]; 94 int used; 95 struct mutex mutex; 96 }; 97 98 struct gc_subdev { 99 unsigned int idx; 100 }; 101 102 static struct gc *gc_base[3]; 103 104 static const int gc_status_bit[] = { 0x40, 0x80, 0x20, 0x10, 0x08 }; 105 106 static const char *gc_names[] = { 107 NULL, "SNES pad", "NES pad", "NES FourPort", "Multisystem joystick", 108 "Multisystem 2-button joystick", "N64 controller", "PSX controller", 109 "PSX DDR controller", "SNES mouse" 110 }; 111 112 /* 113 * N64 support. 114 */ 115 116 static const unsigned char gc_n64_bytes[] = { 0, 1, 13, 15, 14, 12, 10, 11, 2, 3 }; 117 static const short gc_n64_btn[] = { 118 BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, 119 BTN_TL, BTN_TR, BTN_TRIGGER, BTN_START 120 }; 121 122 #define GC_N64_LENGTH 32 /* N64 bit length, not including stop bit */ 123 #define GC_N64_STOP_LENGTH 5 /* Length of encoded stop bit */ 124 #define GC_N64_CMD_00 0x11111111UL 125 #define GC_N64_CMD_01 0xd1111111UL 126 #define GC_N64_CMD_03 0xdd111111UL 127 #define GC_N64_CMD_1b 0xdd1dd111UL 128 #define GC_N64_CMD_c0 0x111111ddUL 129 #define GC_N64_CMD_80 0x1111111dUL 130 #define GC_N64_STOP_BIT 0x1d /* Encoded stop bit */ 131 #define GC_N64_REQUEST_DATA GC_N64_CMD_01 /* the request data command */ 132 #define GC_N64_DELAY 133 /* delay between transmit request, and response ready (us) */ 133 #define GC_N64_DWS 3 /* delay between write segments (required for sound playback because of ISA DMA) */ 134 /* GC_N64_DWS > 24 is known to fail */ 135 #define GC_N64_POWER_W 0xe2 /* power during write (transmit request) */ 136 #define GC_N64_POWER_R 0xfd /* power during read */ 137 #define GC_N64_OUT 0x1d /* output bits to the 4 pads */ 138 /* Reading the main axes of any N64 pad is known to fail if the corresponding bit */ 139 /* in GC_N64_OUT is pulled low on the output port (by any routine) for more */ 140 /* than 123 us */ 141 #define GC_N64_CLOCK 0x02 /* clock bits for read */ 142 143 /* 144 * Used for rumble code. 145 */ 146 147 /* Send encoded command */ 148 static void gc_n64_send_command(struct gc *gc, unsigned long cmd, 149 unsigned char target) 150 { 151 struct parport *port = gc->pd->port; 152 int i; 153 154 for (i = 0; i < GC_N64_LENGTH; i++) { 155 unsigned char data = (cmd >> i) & 1 ? target : 0; 156 parport_write_data(port, GC_N64_POWER_W | data); 157 udelay(GC_N64_DWS); 158 } 159 } 160 161 /* Send stop bit */ 162 static void gc_n64_send_stop_bit(struct gc *gc, unsigned char target) 163 { 164 struct parport *port = gc->pd->port; 165 int i; 166 167 for (i = 0; i < GC_N64_STOP_LENGTH; i++) { 168 unsigned char data = (GC_N64_STOP_BIT >> i) & 1 ? target : 0; 169 parport_write_data(port, GC_N64_POWER_W | data); 170 udelay(GC_N64_DWS); 171 } 172 } 173 174 /* 175 * gc_n64_read_packet() reads an N64 packet. 176 * Each pad uses one bit per byte. So all pads connected to this port 177 * are read in parallel. 178 */ 179 180 static void gc_n64_read_packet(struct gc *gc, unsigned char *data) 181 { 182 int i; 183 unsigned long flags; 184 185 /* 186 * Request the pad to transmit data 187 */ 188 189 local_irq_save(flags); 190 gc_n64_send_command(gc, GC_N64_REQUEST_DATA, GC_N64_OUT); 191 gc_n64_send_stop_bit(gc, GC_N64_OUT); 192 local_irq_restore(flags); 193 194 /* 195 * Wait for the pad response to be loaded into the 33-bit register 196 * of the adapter. 197 */ 198 199 udelay(GC_N64_DELAY); 200 201 /* 202 * Grab data (ignoring the last bit, which is a stop bit) 203 */ 204 205 for (i = 0; i < GC_N64_LENGTH; i++) { 206 parport_write_data(gc->pd->port, GC_N64_POWER_R); 207 udelay(2); 208 data[i] = parport_read_status(gc->pd->port); 209 parport_write_data(gc->pd->port, GC_N64_POWER_R | GC_N64_CLOCK); 210 } 211 212 /* 213 * We must wait 200 ms here for the controller to reinitialize before 214 * the next read request. No worries as long as gc_read is polled less 215 * frequently than this. 216 */ 217 218 } 219 220 static void gc_n64_process_packet(struct gc *gc) 221 { 222 unsigned char data[GC_N64_LENGTH]; 223 struct input_dev *dev; 224 int i, j, s; 225 signed char x, y; 226 227 gc_n64_read_packet(gc, data); 228 229 for (i = 0; i < GC_MAX_DEVICES; i++) { 230 231 if (gc->pads[i].type != GC_N64) 232 continue; 233 234 dev = gc->pads[i].dev; 235 s = gc_status_bit[i]; 236 237 if (s & ~(data[8] | data[9])) { 238 239 x = y = 0; 240 241 for (j = 0; j < 8; j++) { 242 if (data[23 - j] & s) 243 x |= 1 << j; 244 if (data[31 - j] & s) 245 y |= 1 << j; 246 } 247 248 input_report_abs(dev, ABS_X, x); 249 input_report_abs(dev, ABS_Y, -y); 250 251 input_report_abs(dev, ABS_HAT0X, 252 !(s & data[6]) - !(s & data[7])); 253 input_report_abs(dev, ABS_HAT0Y, 254 !(s & data[4]) - !(s & data[5])); 255 256 for (j = 0; j < 10; j++) 257 input_report_key(dev, gc_n64_btn[j], 258 s & data[gc_n64_bytes[j]]); 259 260 input_sync(dev); 261 } 262 } 263 } 264 265 static int gc_n64_play_effect(struct input_dev *dev, void *data, 266 struct ff_effect *effect) 267 { 268 int i; 269 unsigned long flags; 270 struct gc *gc = input_get_drvdata(dev); 271 struct gc_subdev *sdev = data; 272 unsigned char target = 1 << sdev->idx; /* select desired pin */ 273 274 if (effect->type == FF_RUMBLE) { 275 struct ff_rumble_effect *rumble = &effect->u.rumble; 276 unsigned int cmd = 277 rumble->strong_magnitude || rumble->weak_magnitude ? 278 GC_N64_CMD_01 : GC_N64_CMD_00; 279 280 local_irq_save(flags); 281 282 /* Init Rumble - 0x03, 0x80, 0x01, (34)0x80 */ 283 gc_n64_send_command(gc, GC_N64_CMD_03, target); 284 gc_n64_send_command(gc, GC_N64_CMD_80, target); 285 gc_n64_send_command(gc, GC_N64_CMD_01, target); 286 for (i = 0; i < 32; i++) 287 gc_n64_send_command(gc, GC_N64_CMD_80, target); 288 gc_n64_send_stop_bit(gc, target); 289 290 udelay(GC_N64_DELAY); 291 292 /* Now start or stop it - 0x03, 0xc0, 0zx1b, (32)0x01/0x00 */ 293 gc_n64_send_command(gc, GC_N64_CMD_03, target); 294 gc_n64_send_command(gc, GC_N64_CMD_c0, target); 295 gc_n64_send_command(gc, GC_N64_CMD_1b, target); 296 for (i = 0; i < 32; i++) 297 gc_n64_send_command(gc, cmd, target); 298 gc_n64_send_stop_bit(gc, target); 299 300 local_irq_restore(flags); 301 302 } 303 304 return 0; 305 } 306 307 static int __init gc_n64_init_ff(struct input_dev *dev, int i) 308 { 309 struct gc_subdev *sdev; 310 int err; 311 312 sdev = kmalloc(sizeof(*sdev), GFP_KERNEL); 313 if (!sdev) 314 return -ENOMEM; 315 316 sdev->idx = i; 317 318 input_set_capability(dev, EV_FF, FF_RUMBLE); 319 320 err = input_ff_create_memless(dev, sdev, gc_n64_play_effect); 321 if (err) { 322 kfree(sdev); 323 return err; 324 } 325 326 return 0; 327 } 328 329 /* 330 * NES/SNES support. 331 */ 332 333 #define GC_NES_DELAY 6 /* Delay between bits - 6us */ 334 #define GC_NES_LENGTH 8 /* The NES pads use 8 bits of data */ 335 #define GC_SNES_LENGTH 12 /* The SNES true length is 16, but the 336 last 4 bits are unused */ 337 #define GC_SNESMOUSE_LENGTH 32 /* The SNES mouse uses 32 bits, the first 338 16 bits are equivalent to a gamepad */ 339 340 #define GC_NES_POWER 0xfc 341 #define GC_NES_CLOCK 0x01 342 #define GC_NES_LATCH 0x02 343 344 static const unsigned char gc_nes_bytes[] = { 0, 1, 2, 3 }; 345 static const unsigned char gc_snes_bytes[] = { 8, 0, 2, 3, 9, 1, 10, 11 }; 346 static const short gc_snes_btn[] = { 347 BTN_A, BTN_B, BTN_SELECT, BTN_START, BTN_X, BTN_Y, BTN_TL, BTN_TR 348 }; 349 350 /* 351 * gc_nes_read_packet() reads a NES/SNES packet. 352 * Each pad uses one bit per byte. So all pads connected to 353 * this port are read in parallel. 354 */ 355 356 static void gc_nes_read_packet(struct gc *gc, int length, unsigned char *data) 357 { 358 int i; 359 360 parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK | GC_NES_LATCH); 361 udelay(GC_NES_DELAY * 2); 362 parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK); 363 364 for (i = 0; i < length; i++) { 365 udelay(GC_NES_DELAY); 366 parport_write_data(gc->pd->port, GC_NES_POWER); 367 data[i] = parport_read_status(gc->pd->port) ^ 0x7f; 368 udelay(GC_NES_DELAY); 369 parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK); 370 } 371 } 372 373 static void gc_nes_process_packet(struct gc *gc) 374 { 375 unsigned char data[GC_SNESMOUSE_LENGTH]; 376 struct gc_pad *pad; 377 struct input_dev *dev; 378 int i, j, s, len; 379 char x_rel, y_rel; 380 381 len = gc->pad_count[GC_SNESMOUSE] ? GC_SNESMOUSE_LENGTH : 382 (gc->pad_count[GC_SNES] ? GC_SNES_LENGTH : GC_NES_LENGTH); 383 384 gc_nes_read_packet(gc, len, data); 385 386 for (i = 0; i < GC_MAX_DEVICES; i++) { 387 388 pad = &gc->pads[i]; 389 dev = pad->dev; 390 s = gc_status_bit[i]; 391 392 switch (pad->type) { 393 394 case GC_NES: 395 396 input_report_abs(dev, ABS_X, !(s & data[6]) - !(s & data[7])); 397 input_report_abs(dev, ABS_Y, !(s & data[4]) - !(s & data[5])); 398 399 for (j = 0; j < 4; j++) 400 input_report_key(dev, gc_snes_btn[j], 401 s & data[gc_nes_bytes[j]]); 402 input_sync(dev); 403 break; 404 405 case GC_SNES: 406 407 input_report_abs(dev, ABS_X, !(s & data[6]) - !(s & data[7])); 408 input_report_abs(dev, ABS_Y, !(s & data[4]) - !(s & data[5])); 409 410 for (j = 0; j < 8; j++) 411 input_report_key(dev, gc_snes_btn[j], 412 s & data[gc_snes_bytes[j]]); 413 input_sync(dev); 414 break; 415 416 case GC_SNESMOUSE: 417 /* 418 * The 4 unused bits from SNES controllers appear 419 * to be ID bits so use them to make sure we are 420 * dealing with a mouse. 421 * gamepad is connected. This is important since 422 * my SNES gamepad sends 1's for bits 16-31, which 423 * cause the mouse pointer to quickly move to the 424 * upper left corner of the screen. 425 */ 426 if (!(s & data[12]) && !(s & data[13]) && 427 !(s & data[14]) && (s & data[15])) { 428 input_report_key(dev, BTN_LEFT, s & data[9]); 429 input_report_key(dev, BTN_RIGHT, s & data[8]); 430 431 x_rel = y_rel = 0; 432 for (j = 0; j < 7; j++) { 433 x_rel <<= 1; 434 if (data[25 + j] & s) 435 x_rel |= 1; 436 437 y_rel <<= 1; 438 if (data[17 + j] & s) 439 y_rel |= 1; 440 } 441 442 if (x_rel) { 443 if (data[24] & s) 444 x_rel = -x_rel; 445 input_report_rel(dev, REL_X, x_rel); 446 } 447 448 if (y_rel) { 449 if (data[16] & s) 450 y_rel = -y_rel; 451 input_report_rel(dev, REL_Y, y_rel); 452 } 453 454 input_sync(dev); 455 } 456 break; 457 458 default: 459 break; 460 } 461 } 462 } 463 464 /* 465 * Multisystem joystick support 466 */ 467 468 #define GC_MULTI_LENGTH 5 /* Multi system joystick packet length is 5 */ 469 #define GC_MULTI2_LENGTH 6 /* One more bit for one more button */ 470 471 /* 472 * gc_multi_read_packet() reads a Multisystem joystick packet. 473 */ 474 475 static void gc_multi_read_packet(struct gc *gc, int length, unsigned char *data) 476 { 477 int i; 478 479 for (i = 0; i < length; i++) { 480 parport_write_data(gc->pd->port, ~(1 << i)); 481 data[i] = parport_read_status(gc->pd->port) ^ 0x7f; 482 } 483 } 484 485 static void gc_multi_process_packet(struct gc *gc) 486 { 487 unsigned char data[GC_MULTI2_LENGTH]; 488 int data_len = gc->pad_count[GC_MULTI2] ? GC_MULTI2_LENGTH : GC_MULTI_LENGTH; 489 struct gc_pad *pad; 490 struct input_dev *dev; 491 int i, s; 492 493 gc_multi_read_packet(gc, data_len, data); 494 495 for (i = 0; i < GC_MAX_DEVICES; i++) { 496 pad = &gc->pads[i]; 497 dev = pad->dev; 498 s = gc_status_bit[i]; 499 500 switch (pad->type) { 501 case GC_MULTI2: 502 input_report_key(dev, BTN_THUMB, s & data[5]); 503 /* fall through */ 504 505 case GC_MULTI: 506 input_report_abs(dev, ABS_X, 507 !(s & data[2]) - !(s & data[3])); 508 input_report_abs(dev, ABS_Y, 509 !(s & data[0]) - !(s & data[1])); 510 input_report_key(dev, BTN_TRIGGER, s & data[4]); 511 input_sync(dev); 512 break; 513 514 default: 515 break; 516 } 517 } 518 } 519 520 /* 521 * PSX support 522 * 523 * See documentation at: 524 * http://www.dim.com/~mackys/psxmemcard/ps-eng2.txt 525 * http://www.gamesx.com/controldata/psxcont/psxcont.htm 526 * ftp://milano.usal.es/pablo/ 527 * 528 */ 529 530 #define GC_PSX_DELAY 25 /* 25 usec */ 531 #define GC_PSX_LENGTH 8 /* talk to the controller in bits */ 532 #define GC_PSX_BYTES 6 /* the maximum number of bytes to read off the controller */ 533 534 #define GC_PSX_MOUSE 1 /* Mouse */ 535 #define GC_PSX_NEGCON 2 /* NegCon */ 536 #define GC_PSX_NORMAL 4 /* Digital / Analog or Rumble in Digital mode */ 537 #define GC_PSX_ANALOG 5 /* Analog in Analog mode / Rumble in Green mode */ 538 #define GC_PSX_RUMBLE 7 /* Rumble in Red mode */ 539 540 #define GC_PSX_CLOCK 0x04 /* Pin 4 */ 541 #define GC_PSX_COMMAND 0x01 /* Pin 2 */ 542 #define GC_PSX_POWER 0xf8 /* Pins 5-9 */ 543 #define GC_PSX_SELECT 0x02 /* Pin 3 */ 544 545 #define GC_PSX_ID(x) ((x) >> 4) /* High nibble is device type */ 546 #define GC_PSX_LEN(x) (((x) & 0xf) << 1) /* Low nibble is length in bytes/2 */ 547 548 static int gc_psx_delay = GC_PSX_DELAY; 549 module_param_named(psx_delay, gc_psx_delay, uint, 0); 550 MODULE_PARM_DESC(psx_delay, "Delay when accessing Sony PSX controller (usecs)"); 551 552 static const short gc_psx_abs[] = { 553 ABS_X, ABS_Y, ABS_RX, ABS_RY, ABS_HAT0X, ABS_HAT0Y 554 }; 555 static const short gc_psx_btn[] = { 556 BTN_TL, BTN_TR, BTN_TL2, BTN_TR2, BTN_A, BTN_B, BTN_X, BTN_Y, 557 BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR 558 }; 559 static const short gc_psx_ddr_btn[] = { BTN_0, BTN_1, BTN_2, BTN_3 }; 560 561 /* 562 * gc_psx_command() writes 8bit command and reads 8bit data from 563 * the psx pad. 564 */ 565 566 static void gc_psx_command(struct gc *gc, int b, unsigned char *data) 567 { 568 struct parport *port = gc->pd->port; 569 int i, j, cmd, read; 570 571 memset(data, 0, GC_MAX_DEVICES); 572 573 for (i = 0; i < GC_PSX_LENGTH; i++, b >>= 1) { 574 cmd = (b & 1) ? GC_PSX_COMMAND : 0; 575 parport_write_data(port, cmd | GC_PSX_POWER); 576 udelay(gc_psx_delay); 577 578 read = parport_read_status(port) ^ 0x80; 579 580 for (j = 0; j < GC_MAX_DEVICES; j++) { 581 struct gc_pad *pad = &gc->pads[j]; 582 583 if (pad->type == GC_PSX || pad->type == GC_DDR) 584 data[j] |= (read & gc_status_bit[j]) ? (1 << i) : 0; 585 } 586 587 parport_write_data(gc->pd->port, cmd | GC_PSX_CLOCK | GC_PSX_POWER); 588 udelay(gc_psx_delay); 589 } 590 } 591 592 /* 593 * gc_psx_read_packet() reads a whole psx packet and returns 594 * device identifier code. 595 */ 596 597 static void gc_psx_read_packet(struct gc *gc, 598 unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES], 599 unsigned char id[GC_MAX_DEVICES]) 600 { 601 int i, j, max_len = 0; 602 unsigned long flags; 603 unsigned char data2[GC_MAX_DEVICES]; 604 605 /* Select pad */ 606 parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER); 607 udelay(gc_psx_delay); 608 /* Deselect, begin command */ 609 parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_POWER); 610 udelay(gc_psx_delay); 611 612 local_irq_save(flags); 613 614 gc_psx_command(gc, 0x01, data2); /* Access pad */ 615 gc_psx_command(gc, 0x42, id); /* Get device ids */ 616 gc_psx_command(gc, 0, data2); /* Dump status */ 617 618 /* Find the longest pad */ 619 for (i = 0; i < GC_MAX_DEVICES; i++) { 620 struct gc_pad *pad = &gc->pads[i]; 621 622 if ((pad->type == GC_PSX || pad->type == GC_DDR) && 623 GC_PSX_LEN(id[i]) > max_len && 624 GC_PSX_LEN(id[i]) <= GC_PSX_BYTES) { 625 max_len = GC_PSX_LEN(id[i]); 626 } 627 } 628 629 /* Read in all the data */ 630 for (i = 0; i < max_len; i++) { 631 gc_psx_command(gc, 0, data2); 632 for (j = 0; j < GC_MAX_DEVICES; j++) 633 data[j][i] = data2[j]; 634 } 635 636 local_irq_restore(flags); 637 638 parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER); 639 640 /* Set id's to the real value */ 641 for (i = 0; i < GC_MAX_DEVICES; i++) 642 id[i] = GC_PSX_ID(id[i]); 643 } 644 645 static void gc_psx_report_one(struct gc_pad *pad, unsigned char psx_type, 646 unsigned char *data) 647 { 648 struct input_dev *dev = pad->dev; 649 int i; 650 651 switch (psx_type) { 652 653 case GC_PSX_RUMBLE: 654 655 input_report_key(dev, BTN_THUMBL, ~data[0] & 0x04); 656 input_report_key(dev, BTN_THUMBR, ~data[0] & 0x02); 657 658 case GC_PSX_NEGCON: 659 case GC_PSX_ANALOG: 660 661 if (pad->type == GC_DDR) { 662 for (i = 0; i < 4; i++) 663 input_report_key(dev, gc_psx_ddr_btn[i], 664 ~data[0] & (0x10 << i)); 665 } else { 666 for (i = 0; i < 4; i++) 667 input_report_abs(dev, gc_psx_abs[i + 2], 668 data[i + 2]); 669 670 input_report_abs(dev, ABS_X, 671 !!(data[0] & 0x80) * 128 + !(data[0] & 0x20) * 127); 672 input_report_abs(dev, ABS_Y, 673 !!(data[0] & 0x10) * 128 + !(data[0] & 0x40) * 127); 674 } 675 676 for (i = 0; i < 8; i++) 677 input_report_key(dev, gc_psx_btn[i], ~data[1] & (1 << i)); 678 679 input_report_key(dev, BTN_START, ~data[0] & 0x08); 680 input_report_key(dev, BTN_SELECT, ~data[0] & 0x01); 681 682 input_sync(dev); 683 684 break; 685 686 case GC_PSX_NORMAL: 687 688 if (pad->type == GC_DDR) { 689 for (i = 0; i < 4; i++) 690 input_report_key(dev, gc_psx_ddr_btn[i], 691 ~data[0] & (0x10 << i)); 692 } else { 693 input_report_abs(dev, ABS_X, 694 !!(data[0] & 0x80) * 128 + !(data[0] & 0x20) * 127); 695 input_report_abs(dev, ABS_Y, 696 !!(data[0] & 0x10) * 128 + !(data[0] & 0x40) * 127); 697 698 /* 699 * For some reason if the extra axes are left unset 700 * they drift. 701 * for (i = 0; i < 4; i++) 702 input_report_abs(dev, gc_psx_abs[i + 2], 128); 703 * This needs to be debugged properly, 704 * maybe fuzz processing needs to be done 705 * in input_sync() 706 * --vojtech 707 */ 708 } 709 710 for (i = 0; i < 8; i++) 711 input_report_key(dev, gc_psx_btn[i], ~data[1] & (1 << i)); 712 713 input_report_key(dev, BTN_START, ~data[0] & 0x08); 714 input_report_key(dev, BTN_SELECT, ~data[0] & 0x01); 715 716 input_sync(dev); 717 718 break; 719 720 default: /* not a pad, ignore */ 721 break; 722 } 723 } 724 725 static void gc_psx_process_packet(struct gc *gc) 726 { 727 unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES]; 728 unsigned char id[GC_MAX_DEVICES]; 729 struct gc_pad *pad; 730 int i; 731 732 gc_psx_read_packet(gc, data, id); 733 734 for (i = 0; i < GC_MAX_DEVICES; i++) { 735 pad = &gc->pads[i]; 736 if (pad->type == GC_PSX || pad->type == GC_DDR) 737 gc_psx_report_one(pad, id[i], data[i]); 738 } 739 } 740 741 /* 742 * gc_timer() initiates reads of console pads data. 743 */ 744 745 static void gc_timer(unsigned long private) 746 { 747 struct gc *gc = (void *) private; 748 749 /* 750 * N64 pads - must be read first, any read confuses them for 200 us 751 */ 752 753 if (gc->pad_count[GC_N64]) 754 gc_n64_process_packet(gc); 755 756 /* 757 * NES and SNES pads or mouse 758 */ 759 760 if (gc->pad_count[GC_NES] || 761 gc->pad_count[GC_SNES] || 762 gc->pad_count[GC_SNESMOUSE]) { 763 gc_nes_process_packet(gc); 764 } 765 766 /* 767 * Multi and Multi2 joysticks 768 */ 769 770 if (gc->pad_count[GC_MULTI] || gc->pad_count[GC_MULTI2]) 771 gc_multi_process_packet(gc); 772 773 /* 774 * PSX controllers 775 */ 776 777 if (gc->pad_count[GC_PSX] || gc->pad_count[GC_DDR]) 778 gc_psx_process_packet(gc); 779 780 mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME); 781 } 782 783 static int gc_open(struct input_dev *dev) 784 { 785 struct gc *gc = input_get_drvdata(dev); 786 int err; 787 788 err = mutex_lock_interruptible(&gc->mutex); 789 if (err) 790 return err; 791 792 if (!gc->used++) { 793 parport_claim(gc->pd); 794 parport_write_control(gc->pd->port, 0x04); 795 mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME); 796 } 797 798 mutex_unlock(&gc->mutex); 799 return 0; 800 } 801 802 static void gc_close(struct input_dev *dev) 803 { 804 struct gc *gc = input_get_drvdata(dev); 805 806 mutex_lock(&gc->mutex); 807 if (!--gc->used) { 808 del_timer_sync(&gc->timer); 809 parport_write_control(gc->pd->port, 0x00); 810 parport_release(gc->pd); 811 } 812 mutex_unlock(&gc->mutex); 813 } 814 815 static int __init gc_setup_pad(struct gc *gc, int idx, int pad_type) 816 { 817 struct gc_pad *pad = &gc->pads[idx]; 818 struct input_dev *input_dev; 819 int i; 820 int err; 821 822 if (pad_type < 1 || pad_type >= GC_MAX) { 823 pr_err("Pad type %d unknown\n", pad_type); 824 return -EINVAL; 825 } 826 827 pad->dev = input_dev = input_allocate_device(); 828 if (!input_dev) { 829 pr_err("Not enough memory for input device\n"); 830 return -ENOMEM; 831 } 832 833 pad->type = pad_type; 834 835 snprintf(pad->phys, sizeof(pad->phys), 836 "%s/input%d", gc->pd->port->name, idx); 837 838 input_dev->name = gc_names[pad_type]; 839 input_dev->phys = pad->phys; 840 input_dev->id.bustype = BUS_PARPORT; 841 input_dev->id.vendor = 0x0001; 842 input_dev->id.product = pad_type; 843 input_dev->id.version = 0x0100; 844 845 input_set_drvdata(input_dev, gc); 846 847 input_dev->open = gc_open; 848 input_dev->close = gc_close; 849 850 if (pad_type != GC_SNESMOUSE) { 851 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 852 853 for (i = 0; i < 2; i++) 854 input_set_abs_params(input_dev, ABS_X + i, -1, 1, 0, 0); 855 } else 856 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL); 857 858 gc->pad_count[pad_type]++; 859 860 switch (pad_type) { 861 862 case GC_N64: 863 for (i = 0; i < 10; i++) 864 __set_bit(gc_n64_btn[i], input_dev->keybit); 865 866 for (i = 0; i < 2; i++) { 867 input_set_abs_params(input_dev, ABS_X + i, -127, 126, 0, 2); 868 input_set_abs_params(input_dev, ABS_HAT0X + i, -1, 1, 0, 0); 869 } 870 871 err = gc_n64_init_ff(input_dev, idx); 872 if (err) { 873 pr_warning("Failed to initiate rumble for N64 device %d\n", idx); 874 goto err_free_dev; 875 } 876 877 break; 878 879 case GC_SNESMOUSE: 880 __set_bit(BTN_LEFT, input_dev->keybit); 881 __set_bit(BTN_RIGHT, input_dev->keybit); 882 __set_bit(REL_X, input_dev->relbit); 883 __set_bit(REL_Y, input_dev->relbit); 884 break; 885 886 case GC_SNES: 887 for (i = 4; i < 8; i++) 888 __set_bit(gc_snes_btn[i], input_dev->keybit); 889 case GC_NES: 890 for (i = 0; i < 4; i++) 891 __set_bit(gc_snes_btn[i], input_dev->keybit); 892 break; 893 894 case GC_MULTI2: 895 __set_bit(BTN_THUMB, input_dev->keybit); 896 case GC_MULTI: 897 __set_bit(BTN_TRIGGER, input_dev->keybit); 898 break; 899 900 case GC_PSX: 901 for (i = 0; i < 6; i++) 902 input_set_abs_params(input_dev, 903 gc_psx_abs[i], 4, 252, 0, 2); 904 for (i = 0; i < 12; i++) 905 __set_bit(gc_psx_btn[i], input_dev->keybit); 906 907 break; 908 909 case GC_DDR: 910 for (i = 0; i < 4; i++) 911 __set_bit(gc_psx_ddr_btn[i], input_dev->keybit); 912 for (i = 0; i < 12; i++) 913 __set_bit(gc_psx_btn[i], input_dev->keybit); 914 915 break; 916 } 917 918 err = input_register_device(pad->dev); 919 if (err) 920 goto err_free_dev; 921 922 return 0; 923 924 err_free_dev: 925 input_free_device(pad->dev); 926 pad->dev = NULL; 927 return err; 928 } 929 930 static struct gc __init *gc_probe(int parport, int *pads, int n_pads) 931 { 932 struct gc *gc; 933 struct parport *pp; 934 struct pardevice *pd; 935 int i; 936 int count = 0; 937 int err; 938 939 pp = parport_find_number(parport); 940 if (!pp) { 941 pr_err("no such parport %d\n", parport); 942 err = -EINVAL; 943 goto err_out; 944 } 945 946 pd = parport_register_device(pp, "gamecon", NULL, NULL, NULL, PARPORT_DEV_EXCL, NULL); 947 if (!pd) { 948 pr_err("parport busy already - lp.o loaded?\n"); 949 err = -EBUSY; 950 goto err_put_pp; 951 } 952 953 gc = kzalloc(sizeof(struct gc), GFP_KERNEL); 954 if (!gc) { 955 pr_err("Not enough memory\n"); 956 err = -ENOMEM; 957 goto err_unreg_pardev; 958 } 959 960 mutex_init(&gc->mutex); 961 gc->pd = pd; 962 setup_timer(&gc->timer, gc_timer, (long) gc); 963 964 for (i = 0; i < n_pads && i < GC_MAX_DEVICES; i++) { 965 if (!pads[i]) 966 continue; 967 968 err = gc_setup_pad(gc, i, pads[i]); 969 if (err) 970 goto err_unreg_devs; 971 972 count++; 973 } 974 975 if (count == 0) { 976 pr_err("No valid devices specified\n"); 977 err = -EINVAL; 978 goto err_free_gc; 979 } 980 981 parport_put_port(pp); 982 return gc; 983 984 err_unreg_devs: 985 while (--i >= 0) 986 if (gc->pads[i].dev) 987 input_unregister_device(gc->pads[i].dev); 988 err_free_gc: 989 kfree(gc); 990 err_unreg_pardev: 991 parport_unregister_device(pd); 992 err_put_pp: 993 parport_put_port(pp); 994 err_out: 995 return ERR_PTR(err); 996 } 997 998 static void gc_remove(struct gc *gc) 999 { 1000 int i; 1001 1002 for (i = 0; i < GC_MAX_DEVICES; i++) 1003 if (gc->pads[i].dev) 1004 input_unregister_device(gc->pads[i].dev); 1005 parport_unregister_device(gc->pd); 1006 kfree(gc); 1007 } 1008 1009 static int __init gc_init(void) 1010 { 1011 int i; 1012 int have_dev = 0; 1013 int err = 0; 1014 1015 for (i = 0; i < GC_MAX_PORTS; i++) { 1016 if (gc_cfg[i].nargs == 0 || gc_cfg[i].args[0] < 0) 1017 continue; 1018 1019 if (gc_cfg[i].nargs < 2) { 1020 pr_err("at least one device must be specified\n"); 1021 err = -EINVAL; 1022 break; 1023 } 1024 1025 gc_base[i] = gc_probe(gc_cfg[i].args[0], 1026 gc_cfg[i].args + 1, gc_cfg[i].nargs - 1); 1027 if (IS_ERR(gc_base[i])) { 1028 err = PTR_ERR(gc_base[i]); 1029 break; 1030 } 1031 1032 have_dev = 1; 1033 } 1034 1035 if (err) { 1036 while (--i >= 0) 1037 if (gc_base[i]) 1038 gc_remove(gc_base[i]); 1039 return err; 1040 } 1041 1042 return have_dev ? 0 : -ENODEV; 1043 } 1044 1045 static void __exit gc_exit(void) 1046 { 1047 int i; 1048 1049 for (i = 0; i < GC_MAX_PORTS; i++) 1050 if (gc_base[i]) 1051 gc_remove(gc_base[i]); 1052 } 1053 1054 module_init(gc_init); 1055 module_exit(gc_exit); 1056