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]; 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 int parportno; 96 struct mutex mutex; 97 }; 98 99 struct gc_subdev { 100 unsigned int idx; 101 }; 102 103 static struct gc *gc_base[3]; 104 105 static const int gc_status_bit[] = { 0x40, 0x80, 0x20, 0x10, 0x08 }; 106 107 static const char *gc_names[] = { 108 NULL, "SNES pad", "NES pad", "NES FourPort", "Multisystem joystick", 109 "Multisystem 2-button joystick", "N64 controller", "PSX controller", 110 "PSX DDR controller", "SNES mouse" 111 }; 112 113 /* 114 * N64 support. 115 */ 116 117 static const unsigned char gc_n64_bytes[] = { 0, 1, 13, 15, 14, 12, 10, 11, 2, 3 }; 118 static const short gc_n64_btn[] = { 119 BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, 120 BTN_TL, BTN_TR, BTN_TRIGGER, BTN_START 121 }; 122 123 #define GC_N64_LENGTH 32 /* N64 bit length, not including stop bit */ 124 #define GC_N64_STOP_LENGTH 5 /* Length of encoded stop bit */ 125 #define GC_N64_CMD_00 0x11111111UL 126 #define GC_N64_CMD_01 0xd1111111UL 127 #define GC_N64_CMD_03 0xdd111111UL 128 #define GC_N64_CMD_1b 0xdd1dd111UL 129 #define GC_N64_CMD_c0 0x111111ddUL 130 #define GC_N64_CMD_80 0x1111111dUL 131 #define GC_N64_STOP_BIT 0x1d /* Encoded stop bit */ 132 #define GC_N64_REQUEST_DATA GC_N64_CMD_01 /* the request data command */ 133 #define GC_N64_DELAY 133 /* delay between transmit request, and response ready (us) */ 134 #define GC_N64_DWS 3 /* delay between write segments (required for sound playback because of ISA DMA) */ 135 /* GC_N64_DWS > 24 is known to fail */ 136 #define GC_N64_POWER_W 0xe2 /* power during write (transmit request) */ 137 #define GC_N64_POWER_R 0xfd /* power during read */ 138 #define GC_N64_OUT 0x1d /* output bits to the 4 pads */ 139 /* Reading the main axes of any N64 pad is known to fail if the corresponding bit */ 140 /* in GC_N64_OUT is pulled low on the output port (by any routine) for more */ 141 /* than 123 us */ 142 #define GC_N64_CLOCK 0x02 /* clock bits for read */ 143 144 /* 145 * Used for rumble code. 146 */ 147 148 /* Send encoded command */ 149 static void gc_n64_send_command(struct gc *gc, unsigned long cmd, 150 unsigned char target) 151 { 152 struct parport *port = gc->pd->port; 153 int i; 154 155 for (i = 0; i < GC_N64_LENGTH; i++) { 156 unsigned char data = (cmd >> i) & 1 ? target : 0; 157 parport_write_data(port, GC_N64_POWER_W | data); 158 udelay(GC_N64_DWS); 159 } 160 } 161 162 /* Send stop bit */ 163 static void gc_n64_send_stop_bit(struct gc *gc, unsigned char target) 164 { 165 struct parport *port = gc->pd->port; 166 int i; 167 168 for (i = 0; i < GC_N64_STOP_LENGTH; i++) { 169 unsigned char data = (GC_N64_STOP_BIT >> i) & 1 ? target : 0; 170 parport_write_data(port, GC_N64_POWER_W | data); 171 udelay(GC_N64_DWS); 172 } 173 } 174 175 /* 176 * gc_n64_read_packet() reads an N64 packet. 177 * Each pad uses one bit per byte. So all pads connected to this port 178 * are read in parallel. 179 */ 180 181 static void gc_n64_read_packet(struct gc *gc, unsigned char *data) 182 { 183 int i; 184 unsigned long flags; 185 186 /* 187 * Request the pad to transmit data 188 */ 189 190 local_irq_save(flags); 191 gc_n64_send_command(gc, GC_N64_REQUEST_DATA, GC_N64_OUT); 192 gc_n64_send_stop_bit(gc, GC_N64_OUT); 193 local_irq_restore(flags); 194 195 /* 196 * Wait for the pad response to be loaded into the 33-bit register 197 * of the adapter. 198 */ 199 200 udelay(GC_N64_DELAY); 201 202 /* 203 * Grab data (ignoring the last bit, which is a stop bit) 204 */ 205 206 for (i = 0; i < GC_N64_LENGTH; i++) { 207 parport_write_data(gc->pd->port, GC_N64_POWER_R); 208 udelay(2); 209 data[i] = parport_read_status(gc->pd->port); 210 parport_write_data(gc->pd->port, GC_N64_POWER_R | GC_N64_CLOCK); 211 } 212 213 /* 214 * We must wait 200 ms here for the controller to reinitialize before 215 * the next read request. No worries as long as gc_read is polled less 216 * frequently than this. 217 */ 218 219 } 220 221 static void gc_n64_process_packet(struct gc *gc) 222 { 223 unsigned char data[GC_N64_LENGTH]; 224 struct input_dev *dev; 225 int i, j, s; 226 signed char x, y; 227 228 gc_n64_read_packet(gc, data); 229 230 for (i = 0; i < GC_MAX_DEVICES; i++) { 231 232 if (gc->pads[i].type != GC_N64) 233 continue; 234 235 dev = gc->pads[i].dev; 236 s = gc_status_bit[i]; 237 238 if (s & ~(data[8] | data[9])) { 239 240 x = y = 0; 241 242 for (j = 0; j < 8; j++) { 243 if (data[23 - j] & s) 244 x |= 1 << j; 245 if (data[31 - j] & s) 246 y |= 1 << j; 247 } 248 249 input_report_abs(dev, ABS_X, x); 250 input_report_abs(dev, ABS_Y, -y); 251 252 input_report_abs(dev, ABS_HAT0X, 253 !(s & data[6]) - !(s & data[7])); 254 input_report_abs(dev, ABS_HAT0Y, 255 !(s & data[4]) - !(s & data[5])); 256 257 for (j = 0; j < 10; j++) 258 input_report_key(dev, gc_n64_btn[j], 259 s & data[gc_n64_bytes[j]]); 260 261 input_sync(dev); 262 } 263 } 264 } 265 266 static int gc_n64_play_effect(struct input_dev *dev, void *data, 267 struct ff_effect *effect) 268 { 269 int i; 270 unsigned long flags; 271 struct gc *gc = input_get_drvdata(dev); 272 struct gc_subdev *sdev = data; 273 unsigned char target = 1 << sdev->idx; /* select desired pin */ 274 275 if (effect->type == FF_RUMBLE) { 276 struct ff_rumble_effect *rumble = &effect->u.rumble; 277 unsigned int cmd = 278 rumble->strong_magnitude || rumble->weak_magnitude ? 279 GC_N64_CMD_01 : GC_N64_CMD_00; 280 281 local_irq_save(flags); 282 283 /* Init Rumble - 0x03, 0x80, 0x01, (34)0x80 */ 284 gc_n64_send_command(gc, GC_N64_CMD_03, target); 285 gc_n64_send_command(gc, GC_N64_CMD_80, target); 286 gc_n64_send_command(gc, GC_N64_CMD_01, target); 287 for (i = 0; i < 32; i++) 288 gc_n64_send_command(gc, GC_N64_CMD_80, target); 289 gc_n64_send_stop_bit(gc, target); 290 291 udelay(GC_N64_DELAY); 292 293 /* Now start or stop it - 0x03, 0xc0, 0zx1b, (32)0x01/0x00 */ 294 gc_n64_send_command(gc, GC_N64_CMD_03, target); 295 gc_n64_send_command(gc, GC_N64_CMD_c0, target); 296 gc_n64_send_command(gc, GC_N64_CMD_1b, target); 297 for (i = 0; i < 32; i++) 298 gc_n64_send_command(gc, cmd, target); 299 gc_n64_send_stop_bit(gc, target); 300 301 local_irq_restore(flags); 302 303 } 304 305 return 0; 306 } 307 308 static int gc_n64_init_ff(struct input_dev *dev, int i) 309 { 310 struct gc_subdev *sdev; 311 int err; 312 313 sdev = kmalloc(sizeof(*sdev), GFP_KERNEL); 314 if (!sdev) 315 return -ENOMEM; 316 317 sdev->idx = i; 318 319 input_set_capability(dev, EV_FF, FF_RUMBLE); 320 321 err = input_ff_create_memless(dev, sdev, gc_n64_play_effect); 322 if (err) { 323 kfree(sdev); 324 return err; 325 } 326 327 return 0; 328 } 329 330 /* 331 * NES/SNES support. 332 */ 333 334 #define GC_NES_DELAY 6 /* Delay between bits - 6us */ 335 #define GC_NES_LENGTH 8 /* The NES pads use 8 bits of data */ 336 #define GC_SNES_LENGTH 12 /* The SNES true length is 16, but the 337 last 4 bits are unused */ 338 #define GC_SNESMOUSE_LENGTH 32 /* The SNES mouse uses 32 bits, the first 339 16 bits are equivalent to a gamepad */ 340 341 #define GC_NES_POWER 0xfc 342 #define GC_NES_CLOCK 0x01 343 #define GC_NES_LATCH 0x02 344 345 static const unsigned char gc_nes_bytes[] = { 0, 1, 2, 3 }; 346 static const unsigned char gc_snes_bytes[] = { 8, 0, 2, 3, 9, 1, 10, 11 }; 347 static const short gc_snes_btn[] = { 348 BTN_A, BTN_B, BTN_SELECT, BTN_START, BTN_X, BTN_Y, BTN_TL, BTN_TR 349 }; 350 351 /* 352 * gc_nes_read_packet() reads a NES/SNES packet. 353 * Each pad uses one bit per byte. So all pads connected to 354 * this port are read in parallel. 355 */ 356 357 static void gc_nes_read_packet(struct gc *gc, int length, unsigned char *data) 358 { 359 int i; 360 361 parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK | GC_NES_LATCH); 362 udelay(GC_NES_DELAY * 2); 363 parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK); 364 365 for (i = 0; i < length; i++) { 366 udelay(GC_NES_DELAY); 367 parport_write_data(gc->pd->port, GC_NES_POWER); 368 data[i] = parport_read_status(gc->pd->port) ^ 0x7f; 369 udelay(GC_NES_DELAY); 370 parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK); 371 } 372 } 373 374 static void gc_nes_process_packet(struct gc *gc) 375 { 376 unsigned char data[GC_SNESMOUSE_LENGTH]; 377 struct gc_pad *pad; 378 struct input_dev *dev; 379 int i, j, s, len; 380 char x_rel, y_rel; 381 382 len = gc->pad_count[GC_SNESMOUSE] ? GC_SNESMOUSE_LENGTH : 383 (gc->pad_count[GC_SNES] ? GC_SNES_LENGTH : GC_NES_LENGTH); 384 385 gc_nes_read_packet(gc, len, data); 386 387 for (i = 0; i < GC_MAX_DEVICES; i++) { 388 389 pad = &gc->pads[i]; 390 dev = pad->dev; 391 s = gc_status_bit[i]; 392 393 switch (pad->type) { 394 395 case GC_NES: 396 397 input_report_abs(dev, ABS_X, !(s & data[6]) - !(s & data[7])); 398 input_report_abs(dev, ABS_Y, !(s & data[4]) - !(s & data[5])); 399 400 for (j = 0; j < 4; j++) 401 input_report_key(dev, gc_snes_btn[j], 402 s & data[gc_nes_bytes[j]]); 403 input_sync(dev); 404 break; 405 406 case GC_SNES: 407 408 input_report_abs(dev, ABS_X, !(s & data[6]) - !(s & data[7])); 409 input_report_abs(dev, ABS_Y, !(s & data[4]) - !(s & data[5])); 410 411 for (j = 0; j < 8; j++) 412 input_report_key(dev, gc_snes_btn[j], 413 s & data[gc_snes_bytes[j]]); 414 input_sync(dev); 415 break; 416 417 case GC_SNESMOUSE: 418 /* 419 * The 4 unused bits from SNES controllers appear 420 * to be ID bits so use them to make sure we are 421 * dealing with a mouse. 422 * gamepad is connected. This is important since 423 * my SNES gamepad sends 1's for bits 16-31, which 424 * cause the mouse pointer to quickly move to the 425 * upper left corner of the screen. 426 */ 427 if (!(s & data[12]) && !(s & data[13]) && 428 !(s & data[14]) && (s & data[15])) { 429 input_report_key(dev, BTN_LEFT, s & data[9]); 430 input_report_key(dev, BTN_RIGHT, s & data[8]); 431 432 x_rel = y_rel = 0; 433 for (j = 0; j < 7; j++) { 434 x_rel <<= 1; 435 if (data[25 + j] & s) 436 x_rel |= 1; 437 438 y_rel <<= 1; 439 if (data[17 + j] & s) 440 y_rel |= 1; 441 } 442 443 if (x_rel) { 444 if (data[24] & s) 445 x_rel = -x_rel; 446 input_report_rel(dev, REL_X, x_rel); 447 } 448 449 if (y_rel) { 450 if (data[16] & s) 451 y_rel = -y_rel; 452 input_report_rel(dev, REL_Y, y_rel); 453 } 454 455 input_sync(dev); 456 } 457 break; 458 459 default: 460 break; 461 } 462 } 463 } 464 465 /* 466 * Multisystem joystick support 467 */ 468 469 #define GC_MULTI_LENGTH 5 /* Multi system joystick packet length is 5 */ 470 #define GC_MULTI2_LENGTH 6 /* One more bit for one more button */ 471 472 /* 473 * gc_multi_read_packet() reads a Multisystem joystick packet. 474 */ 475 476 static void gc_multi_read_packet(struct gc *gc, int length, unsigned char *data) 477 { 478 int i; 479 480 for (i = 0; i < length; i++) { 481 parport_write_data(gc->pd->port, ~(1 << i)); 482 data[i] = parport_read_status(gc->pd->port) ^ 0x7f; 483 } 484 } 485 486 static void gc_multi_process_packet(struct gc *gc) 487 { 488 unsigned char data[GC_MULTI2_LENGTH]; 489 int data_len = gc->pad_count[GC_MULTI2] ? GC_MULTI2_LENGTH : GC_MULTI_LENGTH; 490 struct gc_pad *pad; 491 struct input_dev *dev; 492 int i, s; 493 494 gc_multi_read_packet(gc, data_len, data); 495 496 for (i = 0; i < GC_MAX_DEVICES; i++) { 497 pad = &gc->pads[i]; 498 dev = pad->dev; 499 s = gc_status_bit[i]; 500 501 switch (pad->type) { 502 case GC_MULTI2: 503 input_report_key(dev, BTN_THUMB, s & data[5]); 504 /* fall through */ 505 506 case GC_MULTI: 507 input_report_abs(dev, ABS_X, 508 !(s & data[2]) - !(s & data[3])); 509 input_report_abs(dev, ABS_Y, 510 !(s & data[0]) - !(s & data[1])); 511 input_report_key(dev, BTN_TRIGGER, s & data[4]); 512 input_sync(dev); 513 break; 514 515 default: 516 break; 517 } 518 } 519 } 520 521 /* 522 * PSX support 523 * 524 * See documentation at: 525 * http://www.geocities.co.jp/Playtown/2004/psx/ps_eng.txt 526 * http://www.gamesx.com/controldata/psxcont/psxcont.htm 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 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_warn("Failed to initiate rumble for N64 device %d\n", 874 idx); 875 goto err_free_dev; 876 } 877 878 break; 879 880 case GC_SNESMOUSE: 881 __set_bit(BTN_LEFT, input_dev->keybit); 882 __set_bit(BTN_RIGHT, input_dev->keybit); 883 __set_bit(REL_X, input_dev->relbit); 884 __set_bit(REL_Y, input_dev->relbit); 885 break; 886 887 case GC_SNES: 888 for (i = 4; i < 8; i++) 889 __set_bit(gc_snes_btn[i], input_dev->keybit); 890 case GC_NES: 891 for (i = 0; i < 4; i++) 892 __set_bit(gc_snes_btn[i], input_dev->keybit); 893 break; 894 895 case GC_MULTI2: 896 __set_bit(BTN_THUMB, input_dev->keybit); 897 case GC_MULTI: 898 __set_bit(BTN_TRIGGER, input_dev->keybit); 899 break; 900 901 case GC_PSX: 902 for (i = 0; i < 6; i++) 903 input_set_abs_params(input_dev, 904 gc_psx_abs[i], 4, 252, 0, 2); 905 for (i = 0; i < 12; i++) 906 __set_bit(gc_psx_btn[i], input_dev->keybit); 907 908 break; 909 910 case GC_DDR: 911 for (i = 0; i < 4; i++) 912 __set_bit(gc_psx_ddr_btn[i], input_dev->keybit); 913 for (i = 0; i < 12; i++) 914 __set_bit(gc_psx_btn[i], input_dev->keybit); 915 916 break; 917 } 918 919 err = input_register_device(pad->dev); 920 if (err) 921 goto err_free_dev; 922 923 return 0; 924 925 err_free_dev: 926 input_free_device(pad->dev); 927 pad->dev = NULL; 928 return err; 929 } 930 931 static void gc_attach(struct parport *pp) 932 { 933 struct gc *gc; 934 struct pardevice *pd; 935 int i, port_idx; 936 int count = 0; 937 int *pads, n_pads; 938 struct pardev_cb gc_parport_cb; 939 940 for (port_idx = 0; port_idx < GC_MAX_PORTS; port_idx++) { 941 if (gc_cfg[port_idx].nargs == 0 || gc_cfg[port_idx].args[0] < 0) 942 continue; 943 944 if (gc_cfg[port_idx].args[0] == pp->number) 945 break; 946 } 947 948 if (port_idx == GC_MAX_PORTS) { 949 pr_debug("Not using parport%d.\n", pp->number); 950 return; 951 } 952 pads = gc_cfg[port_idx].args + 1; 953 n_pads = gc_cfg[port_idx].nargs - 1; 954 955 memset(&gc_parport_cb, 0, sizeof(gc_parport_cb)); 956 gc_parport_cb.flags = PARPORT_FLAG_EXCL; 957 958 pd = parport_register_dev_model(pp, "gamecon", &gc_parport_cb, 959 port_idx); 960 if (!pd) { 961 pr_err("parport busy already - lp.o loaded?\n"); 962 return; 963 } 964 965 gc = kzalloc(sizeof(struct gc), GFP_KERNEL); 966 if (!gc) { 967 pr_err("Not enough memory\n"); 968 goto err_unreg_pardev; 969 } 970 971 mutex_init(&gc->mutex); 972 gc->pd = pd; 973 gc->parportno = pp->number; 974 setup_timer(&gc->timer, gc_timer, (long) gc); 975 976 for (i = 0; i < n_pads && i < GC_MAX_DEVICES; i++) { 977 if (!pads[i]) 978 continue; 979 980 if (gc_setup_pad(gc, i, pads[i])) 981 goto err_unreg_devs; 982 983 count++; 984 } 985 986 if (count == 0) { 987 pr_err("No valid devices specified\n"); 988 goto err_free_gc; 989 } 990 991 gc_base[port_idx] = gc; 992 return; 993 994 err_unreg_devs: 995 while (--i >= 0) 996 if (gc->pads[i].dev) 997 input_unregister_device(gc->pads[i].dev); 998 err_free_gc: 999 kfree(gc); 1000 err_unreg_pardev: 1001 parport_unregister_device(pd); 1002 } 1003 1004 static void gc_detach(struct parport *port) 1005 { 1006 int i; 1007 struct gc *gc; 1008 1009 for (i = 0; i < GC_MAX_PORTS; i++) { 1010 if (gc_base[i] && gc_base[i]->parportno == port->number) 1011 break; 1012 } 1013 1014 if (i == GC_MAX_PORTS) 1015 return; 1016 1017 gc = gc_base[i]; 1018 gc_base[i] = NULL; 1019 1020 for (i = 0; i < GC_MAX_DEVICES; i++) 1021 if (gc->pads[i].dev) 1022 input_unregister_device(gc->pads[i].dev); 1023 parport_unregister_device(gc->pd); 1024 kfree(gc); 1025 } 1026 1027 static struct parport_driver gc_parport_driver = { 1028 .name = "gamecon", 1029 .match_port = gc_attach, 1030 .detach = gc_detach, 1031 .devmodel = true, 1032 }; 1033 1034 static int __init gc_init(void) 1035 { 1036 int i; 1037 int have_dev = 0; 1038 1039 for (i = 0; i < GC_MAX_PORTS; i++) { 1040 if (gc_cfg[i].nargs == 0 || gc_cfg[i].args[0] < 0) 1041 continue; 1042 1043 if (gc_cfg[i].nargs < 2) { 1044 pr_err("at least one device must be specified\n"); 1045 return -EINVAL; 1046 } 1047 1048 have_dev = 1; 1049 } 1050 1051 if (!have_dev) 1052 return -ENODEV; 1053 1054 return parport_register_driver(&gc_parport_driver); 1055 } 1056 1057 static void __exit gc_exit(void) 1058 { 1059 parport_unregister_driver(&gc_parport_driver); 1060 } 1061 1062 module_init(gc_init); 1063 module_exit(gc_exit); 1064