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 44MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>"); 45MODULE_DESCRIPTION("NES, SNES, N64, MultiSystem, PSX gamepad driver"); 46MODULE_LICENSE("GPL"); 47 48#define GC_MAX_PORTS 3 49#define GC_MAX_DEVICES 5 50 51struct gc_config { 52 int args[GC_MAX_DEVICES + 1]; 53 unsigned int nargs; 54}; 55 56static struct gc_config gc_cfg[GC_MAX_PORTS]; 57 58module_param_array_named(map, gc_cfg[0].args, int, &gc_cfg[0].nargs, 0); 59MODULE_PARM_DESC(map, "Describes first set of devices (<parport#>,<pad1>,<pad2>,..<pad5>)"); 60module_param_array_named(map2, gc_cfg[1].args, int, &gc_cfg[1].nargs, 0); 61MODULE_PARM_DESC(map2, "Describes second set of devices"); 62module_param_array_named(map3, gc_cfg[2].args, int, &gc_cfg[2].nargs, 0); 63MODULE_PARM_DESC(map3, "Describes third set of devices"); 64 65/* see also gs_psx_delay parameter in PSX support section */ 66 67enum 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 83struct gc_pad { 84 struct input_dev *dev; 85 enum gc_type type; 86 char phys[32]; 87}; 88 89struct 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 99struct gc_subdev { 100 unsigned int idx; 101}; 102 103static struct gc *gc_base[3]; 104 105static const int gc_status_bit[] = { 0x40, 0x80, 0x20, 0x10, 0x08 }; 106 107static 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 117static const unsigned char gc_n64_bytes[] = { 0, 1, 13, 15, 14, 12, 10, 11, 2, 3 }; 118static 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 */ 149static 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 */ 163static 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 181static 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 221static 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 266static 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 308static 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 345static const unsigned char gc_nes_bytes[] = { 0, 1, 2, 3 }; 346static const unsigned char gc_snes_bytes[] = { 8, 0, 2, 3, 9, 1, 10, 11 }; 347static 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 357static 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 374static 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 476static 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 486static 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 548static int gc_psx_delay = GC_PSX_DELAY; 549module_param_named(psx_delay, gc_psx_delay, uint, 0); 550MODULE_PARM_DESC(psx_delay, "Delay when accessing Sony PSX controller (usecs)"); 551 552static const short gc_psx_abs[] = { 553 ABS_X, ABS_Y, ABS_RX, ABS_RY, ABS_HAT0X, ABS_HAT0Y 554}; 555static 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}; 559static 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 566static 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 597static 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 645static 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 725static 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 745static 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 783static 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 802static 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 815static 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_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 924err_free_dev: 925 input_free_device(pad->dev); 926 pad->dev = NULL; 927 return err; 928} 929 930static void gc_attach(struct parport *pp) 931{ 932 struct gc *gc; 933 struct pardevice *pd; 934 int i, port_idx; 935 int count = 0; 936 int *pads, n_pads; 937 struct pardev_cb gc_parport_cb; 938 939 for (port_idx = 0; port_idx < GC_MAX_PORTS; port_idx++) { 940 if (gc_cfg[port_idx].nargs == 0 || gc_cfg[port_idx].args[0] < 0) 941 continue; 942 943 if (gc_cfg[port_idx].args[0] == pp->number) 944 break; 945 } 946 947 if (port_idx == GC_MAX_PORTS) { 948 pr_debug("Not using parport%d.\n", pp->number); 949 return; 950 } 951 pads = gc_cfg[port_idx].args + 1; 952 n_pads = gc_cfg[port_idx].nargs - 1; 953 954 memset(&gc_parport_cb, 0, sizeof(gc_parport_cb)); 955 gc_parport_cb.flags = PARPORT_FLAG_EXCL; 956 957 pd = parport_register_dev_model(pp, "gamecon", &gc_parport_cb, 958 port_idx); 959 if (!pd) { 960 pr_err("parport busy already - lp.o loaded?\n"); 961 return; 962 } 963 964 gc = kzalloc(sizeof(struct gc), GFP_KERNEL); 965 if (!gc) { 966 pr_err("Not enough memory\n"); 967 goto err_unreg_pardev; 968 } 969 970 mutex_init(&gc->mutex); 971 gc->pd = pd; 972 gc->parportno = pp->number; 973 setup_timer(&gc->timer, gc_timer, (long) gc); 974 975 for (i = 0; i < n_pads && i < GC_MAX_DEVICES; i++) { 976 if (!pads[i]) 977 continue; 978 979 if (gc_setup_pad(gc, i, pads[i])) 980 goto err_unreg_devs; 981 982 count++; 983 } 984 985 if (count == 0) { 986 pr_err("No valid devices specified\n"); 987 goto err_free_gc; 988 } 989 990 gc_base[port_idx] = gc; 991 return; 992 993 err_unreg_devs: 994 while (--i >= 0) 995 if (gc->pads[i].dev) 996 input_unregister_device(gc->pads[i].dev); 997 err_free_gc: 998 kfree(gc); 999 err_unreg_pardev: 1000 parport_unregister_device(pd); 1001} 1002 1003static void gc_detach(struct parport *port) 1004{ 1005 int i; 1006 struct gc *gc; 1007 1008 for (i = 0; i < GC_MAX_PORTS; i++) { 1009 if (gc_base[i] && gc_base[i]->parportno == port->number) 1010 break; 1011 } 1012 1013 if (i == GC_MAX_PORTS) 1014 return; 1015 1016 gc = gc_base[i]; 1017 gc_base[i] = NULL; 1018 1019 for (i = 0; i < GC_MAX_DEVICES; i++) 1020 if (gc->pads[i].dev) 1021 input_unregister_device(gc->pads[i].dev); 1022 parport_unregister_device(gc->pd); 1023 kfree(gc); 1024} 1025 1026static struct parport_driver gc_parport_driver = { 1027 .name = "gamecon", 1028 .match_port = gc_attach, 1029 .detach = gc_detach, 1030 .devmodel = true, 1031}; 1032 1033static int __init gc_init(void) 1034{ 1035 int i; 1036 int have_dev = 0; 1037 1038 for (i = 0; i < GC_MAX_PORTS; i++) { 1039 if (gc_cfg[i].nargs == 0 || gc_cfg[i].args[0] < 0) 1040 continue; 1041 1042 if (gc_cfg[i].nargs < 2) { 1043 pr_err("at least one device must be specified\n"); 1044 return -EINVAL; 1045 } 1046 1047 have_dev = 1; 1048 } 1049 1050 if (!have_dev) 1051 return -ENODEV; 1052 1053 return parport_register_driver(&gc_parport_driver); 1054} 1055 1056static void __exit gc_exit(void) 1057{ 1058 parport_unregister_driver(&gc_parport_driver); 1059} 1060 1061module_init(gc_init); 1062module_exit(gc_exit); 1063