drivers/input/joystick/gamecon.c

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