LXR linux-old/drivers/char/joystick/gamecon.c

   1/*
   2 * $Id: gamecon.c,v 1.14 2001/04/29 22:42:14 vojtech Exp $
   3 *
   4 *  Copyright (c) 1999-2001 Vojtech Pavlik
   5 *
   6 *  Based on the work of:
   7 *      Andree Borrmann         John Dahlstrom
   8 *      David Kuder             Nathan Hand
   9 *
  10 *  Sponsored by SuSE
  11 */
  12
  13/*
  14 * NES, SNES, N64, Multi1, Multi2, PSX gamepad driver for Linux
  15 */
  16
  17/*
  18 * This program is free software; you can redistribute it and/or modify
  19 * it under the terms of the GNU General Public License as published by
  20 * the Free Software Foundation; either version 2 of the License, or 
  21 * (at your option) any later version.
  22 * 
  23 * This program is distributed in the hope that it will be useful,
  24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26 * GNU General Public License for more details.
  27 * 
  28 * You should have received a copy of the GNU General Public License
  29 * along with this program; if not, write to the Free Software
  30 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  31 *
  32 * Should you need to contact me, the author, you can do so either by
  33 * e-mail - mail your message to <vojtech@suse.cz>, or by paper mail:
  34 * Vojtech Pavlik, Ucitelska 1576, Prague 8, 182 00 Czech Republic
  35 */
  36
  37#include <linux/kernel.h>
  38#include <linux/delay.h>
  39#include <linux/module.h>
  40#include <linux/init.h>
  41#include <linux/parport.h>
  42#include <linux/input.h>
  43
  44MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
  45MODULE_LICENSE("GPL");
  46MODULE_PARM(gc, "2-6i");
  47MODULE_PARM(gc_2,"2-6i");
  48MODULE_PARM(gc_3,"2-6i");
  49
  50#define GC_SNES         1
  51#define GC_NES          2
  52#define GC_NES4         3
  53#define GC_MULTI        4
  54#define GC_MULTI2       5
  55#define GC_N64          6       
  56#define GC_PSX          7
  57
  58#define GC_MAX          7
  59
  60#define GC_REFRESH_TIME HZ/100
  61 
  62struct gc {
  63        struct pardevice *pd;
  64        struct input_dev dev[5];
  65        struct timer_list timer;
  66        unsigned char pads[GC_MAX + 1];
  67        int used;
  68};
  69
  70static struct gc *gc_base[3];
  71
  72static int gc[] __initdata = { -1, 0, 0, 0, 0, 0 };
  73static int gc_2[] __initdata = { -1, 0, 0, 0, 0, 0 };
  74static int gc_3[] __initdata = { -1, 0, 0, 0, 0, 0 };
  75
  76static int gc_status_bit[] = { 0x40, 0x80, 0x20, 0x10, 0x08 };
  77
  78static char *gc_names[] = { NULL, "SNES pad", "NES pad", "NES FourPort", "Multisystem joystick",
  79                                "Multisystem 2-button joystick", "N64 controller", "PSX controller" };
  80/*
  81 * N64 support.
  82 */
  83
  84static unsigned char gc_n64_bytes[] = { 0, 1, 13, 15, 14, 12, 10, 11, 2, 3 };
  85static short gc_n64_btn[] = { BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, BTN_TL, BTN_TR, BTN_TRIGGER, BTN_START };
  86
  87#define GC_N64_LENGTH           32              /* N64 bit length, not including stop bit */
  88#define GC_N64_REQUEST_LENGTH   37              /* transmit request sequence is 9 bits long */
  89#define GC_N64_DELAY            133             /* delay between transmit request, and response ready (us) */
  90#define GC_N64_REQUEST          0x1dd1111111ULL /* the request data command (encoded for 000000011) */
  91#define GC_N64_DWS              3               /* delay between write segments (required for sound playback because of ISA DMA) */
  92                                                /* GC_N64_DWS > 24 is known to fail */ 
  93#define GC_N64_POWER_W          0xe2            /* power during write (transmit request) */
  94#define GC_N64_POWER_R          0xfd            /* power during read */
  95#define GC_N64_OUT              0x1d            /* output bits to the 4 pads */
  96                                                /* Reading the main axes of any N64 pad is known to fail if the corresponding bit */
  97                                                /* in GC_N64_OUT is pulled low on the output port (by any routine) for more */
  98                                                /* than 123 us */
  99#define GC_N64_CLOCK            0x02            /* clock bits for read */
 100
 101/* 
 102 * gc_n64_read_packet() reads an N64 packet. 
 103 * Each pad uses one bit per byte. So all pads connected to this port are read in parallel.
 104 */
 105
 106static void gc_n64_read_packet(struct gc *gc, unsigned char *data)
 107{
 108        int i;
 109        unsigned long flags;
 110
 111/*
 112 * Request the pad to transmit data
 113 */
 114
 115        __save_flags(flags);
 116        __cli();
 117        for (i = 0; i < GC_N64_REQUEST_LENGTH; i++) {
 118                parport_write_data(gc->pd->port, GC_N64_POWER_W | ((GC_N64_REQUEST >> i) & 1 ? GC_N64_OUT : 0));
 119                udelay(GC_N64_DWS);
 120        }
 121        __restore_flags(flags);
 122
 123/*
 124 * Wait for the pad response to be loaded into the 33-bit register of the adapter
 125 */
 126
 127        udelay(GC_N64_DELAY);
 128
 129/*
 130 * Grab data (ignoring the last bit, which is a stop bit)
 131 */
 132
 133        for (i = 0; i < GC_N64_LENGTH; i++) {
 134                parport_write_data(gc->pd->port, GC_N64_POWER_R);
 135                data[i] = parport_read_status(gc->pd->port);
 136                parport_write_data(gc->pd->port, GC_N64_POWER_R | GC_N64_CLOCK);
 137         }
 138
 139/*
 140 * We must wait 200 ms here for the controller to reinitialize before the next read request.
 141 * No worries as long as gc_read is polled less frequently than this.
 142 */
 143
 144}
 145
 146/*
 147 * NES/SNES support.
 148 */
 149
 150#define GC_NES_DELAY    6       /* Delay between bits - 6us */
 151#define GC_NES_LENGTH   8       /* The NES pads use 8 bits of data */
 152#define GC_SNES_LENGTH  12      /* The SNES true length is 16, but the last 4 bits are unused */
 153
 154#define GC_NES_POWER    0xfc
 155#define GC_NES_CLOCK    0x01
 156#define GC_NES_LATCH    0x02
 157
 158static unsigned char gc_nes_bytes[] = { 0, 1, 2, 3 };
 159static unsigned char gc_snes_bytes[] = { 8, 0, 2, 3, 9, 1, 10, 11 };
 160static short gc_snes_btn[] = { BTN_A, BTN_B, BTN_SELECT, BTN_START, BTN_X, BTN_Y, BTN_TL, BTN_TR };
 161
 162/*
 163 * gc_nes_read_packet() reads a NES/SNES packet.
 164 * Each pad uses one bit per byte. So all pads connected to
 165 * this port are read in parallel.
 166 */
 167
 168static void gc_nes_read_packet(struct gc *gc, int length, unsigned char *data)
 169{
 170        int i;
 171
 172        parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK | GC_NES_LATCH);
 173        udelay(GC_NES_DELAY * 2);
 174        parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK);
 175
 176        for (i = 0; i < length; i++) {
 177                udelay(GC_NES_DELAY);
 178                parport_write_data(gc->pd->port, GC_NES_POWER);
 179                data[i] = parport_read_status(gc->pd->port) ^ 0x7f;
 180                udelay(GC_NES_DELAY);
 181                parport_write_data(gc->pd->port, GC_NES_POWER | GC_NES_CLOCK);
 182        }
 183}
 184
 185/*
 186 * Multisystem joystick support
 187 */
 188
 189#define GC_MULTI_LENGTH         5       /* Multi system joystick packet length is 5 */
 190#define GC_MULTI2_LENGTH        6       /* One more bit for one more button */
 191
 192/*
 193 * gc_multi_read_packet() reads a Multisystem joystick packet.
 194 */
 195
 196static void gc_multi_read_packet(struct gc *gc, int length, unsigned char *data)
 197{
 198        int i;
 199
 200        for (i = 0; i < length; i++) {
 201                parport_write_data(gc->pd->port, ~(1 << i));
 202                data[i] = parport_read_status(gc->pd->port) ^ 0x7f;
 203        }
 204}
 205
 206/*
 207 * PSX support
 208 *
 209 * See documentation at:
 210 *      http://www.dim.com/~mackys/psxmemcard/ps-eng2.txt
 211 *      http://www.gamesx.com/controldata/psxcont/psxcont.htm
 212 *      ftp://milano.usal.es/pablo/
 213 *      
 214 */
 215
 216#define GC_PSX_DELAY    60              /* 60 usec */
 217#define GC_PSX_LENGTH   8               /* talk to the controller in bytes */
 218
 219#define GC_PSX_MOUSE    1               /* Mouse */
 220#define GC_PSX_NEGCON   2               /* NegCon */
 221#define GC_PSX_NORMAL   4               /* Digital / Analog or Rumble in Digital mode  */
 222#define GC_PSX_ANALOG   5               /* Analog in Analog mode / Rumble in Green mode */
 223#define GC_PSX_RUMBLE   7               /* Rumble in Red mode */
 224
 225#define GC_PSX_CLOCK    0x04            /* Pin 4 */
 226#define GC_PSX_COMMAND  0x01            /* Pin 1 */
 227#define GC_PSX_POWER    0xf8            /* Pins 5-9 */
 228#define GC_PSX_SELECT   0x02            /* Pin 3 */
 229
 230#define GC_PSX_ID(x)    ((x) >> 4)      /* High nibble is device type */
 231#define GC_PSX_LEN(x)   ((x) & 0xf)     /* Low nibble is length in words */
 232
 233static short gc_psx_abs[] = { ABS_X, ABS_Y, ABS_RX, ABS_RY, ABS_HAT0X, ABS_HAT0Y };
 234static short gc_psx_btn[] = { BTN_TL, BTN_TR, BTN_TL2, BTN_TR2, BTN_A, BTN_B, BTN_X, BTN_Y,
 235                                BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR };
 236
 237/*
 238 * gc_psx_command() writes 8bit command and reads 8bit data from
 239 * the psx pad.
 240 */
 241
 242static int gc_psx_command(struct gc *gc, int b)
 243{
 244        int i, cmd, data = 0;
 245
 246        for (i = 0; i < 8; i++, b >>= 1) {
 247                cmd = (b & 1) ? GC_PSX_COMMAND : 0;
 248                parport_write_data(gc->pd->port, cmd | GC_PSX_POWER);
 249                udelay(GC_PSX_DELAY);
 250                data |= ((parport_read_status(gc->pd->port) ^ 0x80) & gc->pads[GC_PSX]) ? (1 << i) : 0;
 251                parport_write_data(gc->pd->port, cmd | GC_PSX_CLOCK | GC_PSX_POWER);
 252                udelay(GC_PSX_DELAY);
 253        }
 254        return data;
 255}
 256
 257/*
 258 * gc_psx_read_packet() reads a whole psx packet and returns
 259 * device identifier code.
 260 */
 261
 262static int gc_psx_read_packet(struct gc *gc, unsigned char *data)
 263{
 264        int i, id;
 265        unsigned long flags;
 266
 267        parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER);  /* Select pad */
 268        udelay(GC_PSX_DELAY * 2);
 269        parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_POWER);                  /* Deselect, begin command */
 270        udelay(GC_PSX_DELAY * 2);
 271
 272        __save_flags(flags);
 273        __cli();
 274
 275        gc_psx_command(gc, 0x01);                                                       /* Access pad */
 276        id = gc_psx_command(gc, 0x42);                                                  /* Get device id */
 277        if (gc_psx_command(gc, 0) == 0x5a) {                                            /* Okay? */
 278                for (i = 0; i < GC_PSX_LEN(id) * 2; i++)
 279                        data[i] = gc_psx_command(gc, 0);
 280        } else id = 0;
 281
 282        __restore_flags(flags);
 283
 284        parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER);
 285
 286        return GC_PSX_ID(id);
 287}
 288
 289/*
 290 * gc_timer() reads and analyzes console pads data.
 291 */
 292
 293#define GC_MAX_LENGTH GC_N64_LENGTH
 294
 295static void gc_timer(unsigned long private)
 296{
 297        struct gc *gc = (void *) private;
 298        struct input_dev *dev = gc->dev;
 299        unsigned char data[GC_MAX_LENGTH];
 300        int i, j, s;
 301
 302/*
 303 * N64 pads - must be read first, any read confuses them for 200 us
 304 */
 305
 306        if (gc->pads[GC_N64]) {
 307
 308                gc_n64_read_packet(gc, data);
 309
 310                for (i = 0; i < 5; i++) {
 311
 312                        s = gc_status_bit[i];
 313
 314                        if (s & gc->pads[GC_N64] & ~(data[8] | data[9])) {
 315        
 316                                signed char axes[2];
 317                                axes[0] = axes[1] = 0;
 318
 319                                for (j = 0; j < 8; j++) {
 320                                        if (data[23 - j] & s) axes[0] |= 1 << j; 
 321                                        if (data[31 - j] & s) axes[1] |= 1 << j; 
 322                                }
 323
 324                                input_report_abs(dev + i, ABS_X,  axes[0]);
 325                                input_report_abs(dev + i, ABS_Y, -axes[1]);
 326
 327                                input_report_abs(dev + i, ABS_HAT0X, !(s & data[6]) - !(s & data[7]));
 328                                input_report_abs(dev + i, ABS_HAT0Y, !(s & data[4]) - !(s & data[5]));
 329
 330                                for (j = 0; j < 10; j++)
 331                                        input_report_key(dev + i, gc_n64_btn[j], s & data[gc_n64_bytes[j]]);
 332                        }
 333                }
 334        }
 335
 336/*
 337 * NES and SNES pads
 338 */
 339
 340        if (gc->pads[GC_NES] || gc->pads[GC_SNES]) {
 341
 342                gc_nes_read_packet(gc, gc->pads[GC_SNES] ? GC_SNES_LENGTH : GC_NES_LENGTH, data);
 343
 344                for (i = 0; i < 5; i++) {
 345
 346                        s = gc_status_bit[i];
 347
 348                        if (s & (gc->pads[GC_NES] | gc->pads[GC_SNES])) {
 349                                input_report_abs(dev + i, ABS_X, !(s & data[6]) - !(s & data[7]));
 350                                input_report_abs(dev + i, ABS_Y, !(s & data[4]) - !(s & data[5]));
 351                        }
 352
 353                        if (s & gc->pads[GC_NES])
 354                                for (j = 0; j < 4; j++)
 355                                        input_report_key(dev + i, gc_snes_btn[j], s & data[gc_nes_bytes[j]]);
 356
 357                        if (s & gc->pads[GC_SNES])
 358                                for (j = 0; j < 8; j++)
 359                                        input_report_key(dev + i, gc_snes_btn[j], s & data[gc_snes_bytes[j]]);
 360                }
 361        }
 362
 363/*
 364 * Multi and Multi2 joysticks
 365 */
 366
 367        if (gc->pads[GC_MULTI] || gc->pads[GC_MULTI2]) {
 368
 369                gc_multi_read_packet(gc, gc->pads[GC_MULTI2] ? GC_MULTI2_LENGTH : GC_MULTI_LENGTH, data);
 370
 371                for (i = 0; i < 5; i++) {
 372
 373                        s = gc_status_bit[i];
 374
 375                        if (s & (gc->pads[GC_MULTI] | gc->pads[GC_MULTI2])) {
 376                                input_report_abs(dev + i, ABS_X,  !(s & data[2]) - !(s & data[3]));
 377                                input_report_abs(dev + i, ABS_Y,  !(s & data[0]) - !(s & data[1]));
 378                                input_report_key(dev + i, BTN_TRIGGER, s & data[4]);
 379                        }
 380
 381                        if (s & gc->pads[GC_MULTI2])
 382                                input_report_key(dev + i, BTN_THUMB, s & data[5]);
 383                }
 384        }
 385
 386/*
 387 * PSX controllers
 388 */
 389
 390        if (gc->pads[GC_PSX]) {
 391
 392                for (i = 0; i < 5; i++)
 393                        if (gc->pads[GC_PSX] & gc_status_bit[i])
 394                                break;
 395
 396                switch (gc_psx_read_packet(gc, data)) {
 397
 398                        case GC_PSX_RUMBLE:
 399
 400                                input_report_key(dev + i, BTN_THUMB,  ~data[0] & 0x04);
 401                                input_report_key(dev + i, BTN_THUMB2, ~data[0] & 0x02);
 402
 403                        case GC_PSX_NEGCON:
 404                        case GC_PSX_ANALOG:
 405
 406                                for (j = 0; j < 4; j++)
 407                                        input_report_abs(dev + i, gc_psx_abs[j], data[j + 2]);
 408
 409                                input_report_abs(dev + i, ABS_HAT0X, !(data[0] & 0x20) - !(data[0] & 0x80));
 410                                input_report_abs(dev + i, ABS_HAT0Y, !(data[0] & 0x40) - !(data[0] & 0x10));
 411
 412                                for (j = 0; j < 8; j++)
 413                                        input_report_key(dev + i, gc_psx_btn[j], ~data[1] & (1 << j));
 414
 415                                input_report_key(dev + i, BTN_START,  ~data[0] & 0x08);
 416                                input_report_key(dev + i, BTN_SELECT, ~data[0] & 0x01);
 417
 418                                break;
 419
 420                        case GC_PSX_NORMAL:
 421
 422                                input_report_abs(dev + i, ABS_X, 128 + !(data[0] & 0x20) * 127 - !(data[0] & 0x80) * 128);
 423                                input_report_abs(dev + i, ABS_Y, 128 + !(data[0] & 0x40) * 127 - !(data[0] & 0x10) * 128);
 424
 425                                for (j = 0; j < 8; j++)
 426                                        input_report_key(dev + i, gc_psx_btn[j], ~data[1] & (1 << j));
 427
 428                                input_report_key(dev + i, BTN_START,  ~data[0] & 0x08);
 429                                input_report_key(dev + i, BTN_SELECT, ~data[0] & 0x01);
 430
 431                                break;
 432                }
 433        }
 434
 435        mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME);
 436}
 437
 438static int gc_open(struct input_dev *dev)
 439{
 440        struct gc *gc = dev->private;
 441        if (!gc->used++) {
 442                parport_claim(gc->pd);
 443                parport_write_control(gc->pd->port, 0x04);
 444                mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME);
 445        }
 446        return 0;
 447}
 448
 449static void gc_close(struct input_dev *dev)
 450{
 451        struct gc *gc = dev->private;
 452        if (!--gc->used) {
 453                del_timer(&gc->timer);
 454                parport_write_control(gc->pd->port, 0x00);
 455                parport_release(gc->pd);
 456        }
 457}
 458
 459static struct gc __init *gc_probe(int *config)
 460{
 461        struct gc *gc;
 462        struct parport *pp;
 463        int i, j, psx;
 464        unsigned char data[32];
 465
 466        if (config[0] < 0)
 467                return NULL;
 468
 469        for (pp = parport_enumerate(); pp && (config[0] > 0); pp = pp->next)
 470                config[0]--;
 471
 472        if (!pp) {
 473                printk(KERN_ERR "gamecon.c: no such parport\n");
 474                return NULL;
 475        }
 476
 477        if (!(gc = kmalloc(sizeof(struct gc), GFP_KERNEL)))
 478                return NULL;
 479        memset(gc, 0, sizeof(struct gc));
 480
 481        gc->pd = parport_register_device(pp, "gamecon", NULL, NULL, NULL, PARPORT_DEV_EXCL, NULL);
 482
 483        if (!gc->pd) {
 484                printk(KERN_ERR "gamecon.c: parport busy already - lp.o loaded?\n");
 485                kfree(gc);
 486                return NULL;
 487        }
 488
 489        parport_claim(gc->pd);
 490
 491        init_timer(&gc->timer);
 492        gc->timer.data = (long) gc;
 493        gc->timer.function = gc_timer;
 494
 495        for (i = 0; i < 5; i++) {
 496
 497                if (!config[i + 1])
 498                        continue;
 499
 500                if (config[i + 1] < 1 || config[i + 1] > GC_MAX) {
 501                        printk(KERN_WARNING "gamecon.c: Pad type %d unknown\n", config[i + 1]);
 502                        continue;
 503                }
 504
 505                gc->dev[i].private = gc;
 506                gc->dev[i].open = gc_open;
 507                gc->dev[i].close = gc_close;
 508
 509                gc->dev[i].evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
 510
 511                for (j = 0; j < 2; j++) {
 512                        set_bit(ABS_X + j, gc->dev[i].absbit);
 513                        gc->dev[i].absmin[ABS_X + j] = -1;
 514                        gc->dev[i].absmax[ABS_X + j] =  1;
 515                }
 516
 517                gc->pads[0] |= gc_status_bit[i];
 518                gc->pads[config[i + 1]] |= gc_status_bit[i];
 519
 520                switch(config[i + 1]) {
 521
 522                        case GC_N64:
 523                                for (j = 0; j < 10; j++)
 524                                        set_bit(gc_n64_btn[j], gc->dev[i].keybit);
 525
 526                                for (j = 0; j < 2; j++) {
 527                                        set_bit(ABS_X + j, gc->dev[i].absbit);
 528                                        gc->dev[i].absmin[ABS_X + j] = -127;
 529                                        gc->dev[i].absmax[ABS_X + j] =  126;
 530                                        gc->dev[i].absflat[ABS_X + j] = 2;
 531                                        set_bit(ABS_HAT0X + j, gc->dev[i].absbit);
 532                                        gc->dev[i].absmin[ABS_HAT0X + j] = -1;
 533                                        gc->dev[i].absmax[ABS_HAT0X + j] =  1;
 534                                }
 535
 536                                break;
 537
 538                        case GC_SNES:
 539                                for (j = 4; j < 8; j++)
 540                                        set_bit(gc_snes_btn[j], gc->dev[i].keybit);
 541                        case GC_NES:
 542                                for (j = 0; j < 4; j++)
 543                                        set_bit(gc_snes_btn[j], gc->dev[i].keybit);
 544                                break;
 545
 546                        case GC_MULTI2:
 547                                set_bit(BTN_THUMB, gc->dev[i].keybit);
 548                        case GC_MULTI:
 549                                set_bit(BTN_TRIGGER, gc->dev[i].keybit);
 550                                break;
 551
 552                        case GC_PSX:
 553                                
 554                                psx = gc_psx_read_packet(gc, data);
 555
 556                                switch(psx) {
 557                                        case GC_PSX_NEGCON:
 558                                        case GC_PSX_NORMAL:
 559                                        case GC_PSX_ANALOG:
 560                                        case GC_PSX_RUMBLE:
 561
 562                                                for (j = 0; j < 6; j++) {
 563                                                        psx = gc_psx_abs[j];
 564                                                        set_bit(psx, gc->dev[i].absbit);
 565                                                        if (j < 4) {
 566                                                                gc->dev[i].absmin[psx] = 4;
 567                                                                gc->dev[i].absmax[psx] = 252;
 568                                                                gc->dev[i].absflat[psx] = 2;
 569                                                        } else {
 570                                                                gc->dev[i].absmin[psx] = -1;
 571                                                                gc->dev[i].absmax[psx] = 1;
 572                                                        }
 573                                                }
 574
 575                                                for (j = 0; j < 12; j++)
 576                                                        set_bit(gc_psx_btn[j], gc->dev[i].keybit);
 577
 578                                                break;
 579
 580                                        case 0:
 581                                                gc->pads[GC_PSX] &= ~gc_status_bit[i];
 582                                                printk(KERN_ERR "gamecon.c: No PSX controller found.\n");
 583                                                break;
 584
 585                                        default:
 586                                                gc->pads[GC_PSX] &= ~gc_status_bit[i];
 587                                                printk(KERN_WARNING "gamecon.c: Unsupported PSX controller %#x,"
 588                                                        " please report to <vojtech@suse.cz>.\n", psx);
 589                                }
 590                                break;
 591                }
 592
 593                gc->dev[i].name = gc_names[config[i + 1]];
 594                gc->dev[i].idbus = BUS_PARPORT;
 595                gc->dev[i].idvendor = 0x0001;
 596                gc->dev[i].idproduct = config[i + 1];
 597                gc->dev[i].idversion = 0x0100;
 598        }
 599
 600        parport_release(gc->pd);
 601
 602        if (!gc->pads[0]) {
 603                parport_unregister_device(gc->pd);
 604                kfree(gc);
 605                return NULL;
 606        }
 607
 608        for (i = 0; i < 5; i++) 
 609                if (gc->pads[0] & gc_status_bit[i]) {
 610                        input_register_device(gc->dev + i);
 611                        printk(KERN_INFO "input%d: %s on %s\n", gc->dev[i].number, gc->dev[i].name, gc->pd->port->name);
 612                }
 613
 614        return gc;
 615}
 616
 617#ifndef MODULE
 618int __init gc_setup(char *str)
 619{
 620        int i, ints[7];
 621        get_options(str, ARRAY_SIZE(ints), ints);
 622        for (i = 0; i <= ints[0] && i < 6; i++) gc[i] = ints[i + 1];
 623        return 1;
 624}
 625int __init gc_setup_2(char *str)
 626{
 627        int i, ints[7];
 628        get_options(str, ARRAY_SIZE(ints), ints);
 629        for (i = 0; i <= ints[0] && i < 6; i++) gc_2[i] = ints[i + 1];
 630        return 1;
 631}
 632int __init gc_setup_3(char *str)
 633{
 634        int i, ints[7];
 635        get_options(str, ARRAY_SIZE(ints), ints);
 636        for (i = 0; i <= ints[0] && i < 6; i++) gc_3[i] = ints[i + 1];
 637        return 1;
 638}
 639__setup("gc=", gc_setup);
 640__setup("gc_2=", gc_setup_2);
 641__setup("gc_3=", gc_setup_3);
 642#endif
 643
 644int __init gc_init(void)
 645{
 646        gc_base[0] = gc_probe(gc);
 647        gc_base[1] = gc_probe(gc_2);
 648        gc_base[2] = gc_probe(gc_3);
 649
 650        if (gc_base[0] || gc_base[1] || gc_base[2])
 651                return 0;
 652
 653        return -ENODEV;
 654}
 655
 656void __exit gc_exit(void)
 657{
 658        int i, j;
 659
 660        for (i = 0; i < 3; i++)
 661                if (gc_base[i]) {
 662                        for (j = 0; j < 5; j++)
 663                                if (gc_base[i]->pads[0] & gc_status_bit[j])
 664                                        input_unregister_device(gc_base[i]->dev + j); 
 665                        parport_unregister_device(gc_base[i]->pd);
 666                }
 667}
 668
 669module_init(gc_init);
 670module_exit(gc_exit);
 671