kernel/drivers/input/joystick/grip_mp.c

   1 /*
   2  *  Driver for the Gravis Grip Multiport, a gamepad "hub" that
   3  *  connects up to four 9-pin digital gamepads/joysticks.
   4  *  Driver tested on SMP and UP kernel versions 2.4.18-4 and 2.4.18-5.
   5  *
   6  *  Thanks to Chris Gassib for helpful advice.
   7  *
   8  *  Copyright (c)      2002 Brian Bonnlander, Bill Soudan
   9  *  Copyright (c) 1998-2000 Vojtech Pavlik
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/slab.h>
  15 #include <linux/gameport.h>
  16 #include <linux/input.h>
  17 #include <linux/delay.h>
  18 #include <linux/proc_fs.h>
  19 #include <linux/jiffies.h>
  20
  21 #define DRIVER_DESC     "Gravis Grip Multiport driver"
  22
  23 MODULE_AUTHOR("Brian Bonnlander");
  24 MODULE_DESCRIPTION(DRIVER_DESC);
  25 MODULE_LICENSE("GPL");
  26
  27 #ifdef GRIP_DEBUG
  28 #define dbg(format, arg...) printk(KERN_ERR __FILE__ ": " format "\n" , ## arg)
  29 #else
  30 #define dbg(format, arg...) do {} while (0)
  31 #endif
  32
  33 #define GRIP_MAX_PORTS  4
  34 /*
  35  * Grip multiport state
  36  */
  37
  38 struct grip_port {
  39         struct input_dev *dev;
  40         int mode;
  41         int registered;
  42
  43         /* individual gamepad states */
  44         int buttons;
  45         int xaxes;
  46         int yaxes;
  47         int dirty;     /* has the state been updated? */
  48 };
  49
  50 struct grip_mp {
  51         struct gameport *gameport;
  52         struct grip_port *port[GRIP_MAX_PORTS];
  53         int reads;
  54         int bads;
  55 };
  56
  57 /*
  58  * Multiport packet interpretation
  59  */
  60
  61 #define PACKET_FULL          0x80000000       /* packet is full                        */
  62 #define PACKET_IO_FAST       0x40000000       /* 3 bits per gameport read              */
  63 #define PACKET_IO_SLOW       0x20000000       /* 1 bit per gameport read               */
  64 #define PACKET_MP_MORE       0x04000000       /* multiport wants to send more          */
  65 #define PACKET_MP_DONE       0x02000000       /* multiport done sending                */
  66
  67 /*
  68  * Packet status code interpretation
  69  */
  70
  71 #define IO_GOT_PACKET        0x0100           /* Got a packet                           */
  72 #define IO_MODE_FAST         0x0200           /* Used 3 data bits per gameport read     */
  73 #define IO_SLOT_CHANGE       0x0800           /* Multiport physical slot status changed */
  74 #define IO_DONE              0x1000           /* Multiport is done sending packets      */
  75 #define IO_RETRY             0x4000           /* Try again later to get packet          */
  76 #define IO_RESET             0x8000           /* Force multiport to resend all packets  */
  77
  78 /*
  79  * Gamepad configuration data.  Other 9-pin digital joystick devices
  80  * may work with the multiport, so this may not be an exhaustive list!
  81  * Commodore 64 joystick remains untested.
  82  */
  83
  84 #define GRIP_INIT_DELAY         2000          /*  2 ms */
  85
  86 #define GRIP_MODE_NONE          0
  87 #define GRIP_MODE_RESET         1
  88 #define GRIP_MODE_GP            2
  89 #define GRIP_MODE_C64           3
  90
  91 static const int grip_btn_gp[]  = { BTN_TR, BTN_TL, BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, -1 };
  92 static const int grip_btn_c64[] = { BTN_JOYSTICK, -1 };
  93
  94 static const int grip_abs_gp[]  = { ABS_X, ABS_Y, -1 };
  95 static const int grip_abs_c64[] = { ABS_X, ABS_Y, -1 };
  96
  97 static const int *grip_abs[] = { NULL, NULL, grip_abs_gp, grip_abs_c64 };
  98 static const int *grip_btn[] = { NULL, NULL, grip_btn_gp, grip_btn_c64 };
  99
 100 static const char *grip_name[] = { NULL, NULL, "Gravis Grip Pad", "Commodore 64 Joystick" };
 101
 102 static const int init_seq[] = {
 103         1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,
 104         1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,
 105         1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,
 106         0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1 };
 107
 108 /* Maps multiport directional values to X,Y axis values (each axis encoded in 3 bits) */
 109
 110 static const int axis_map[] = { 5, 9, 1, 5, 6, 10, 2, 6, 4, 8, 0, 4, 5, 9, 1, 5 };
 111
 112 static int register_slot(int i, struct grip_mp *grip);
 113
 114 /*
 115  * Returns whether an odd or even number of bits are on in pkt.
 116  */
 117
 118 static int bit_parity(u32 pkt)
 119 {
 120         int x = pkt ^ (pkt >> 16);
 121         x ^= x >> 8;
 122         x ^= x >> 4;
 123         x ^= x >> 2;
 124         x ^= x >> 1;
 125         return x & 1;
 126 }
 127
 128 /*
 129  * Poll gameport; return true if all bits set in 'onbits' are on and
 130  * all bits set in 'offbits' are off.
 131  */
 132
 133 static inline int poll_until(u8 onbits, u8 offbits, int u_sec, struct gameport* gp, u8 *data)
 134 {
 135         int i, nloops;
 136
 137         nloops = gameport_time(gp, u_sec);
 138         for (i = 0; i < nloops; i++) {
 139                 *data = gameport_read(gp);
 140                 if ((*data & onbits) == onbits &&
 141                     (~(*data) & offbits) == offbits)
 142                         return 1;
 143         }
 144         dbg("gameport timed out after %d microseconds.\n", u_sec);
 145         return 0;
 146 }
 147
 148 /*
 149  * Gets a 28-bit packet from the multiport.
 150  *
 151  * After getting a packet successfully, commands encoded by sendcode may
 152  * be sent to the multiport.
 153  *
 154  * The multiport clock value is reflected in gameport bit B4.
 155  *
 156  * Returns a packet status code indicating whether packet is valid, the transfer
 157  * mode, and any error conditions.
 158  *
 159  * sendflags:      current I/O status
 160  * sendcode:   data to send to the multiport if sendflags is nonzero
 161  */
 162
 163 static int mp_io(struct gameport* gameport, int sendflags, int sendcode, u32 *packet)
 164 {
 165         u8  raw_data;            /* raw data from gameport */
 166         u8  data_mask;           /* packet data bits from raw_data */
 167         u32 pkt;                 /* packet temporary storage */
 168         int bits_per_read;       /* num packet bits per gameport read */
 169         int portvals = 0;        /* used for port value sanity check */
 170         int i;
 171
 172         /* Gameport bits B0, B4, B5 should first be off, then B4 should come on. */
 173
 174         *packet = 0;
 175         raw_data = gameport_read(gameport);
 176         if (raw_data & 1)
 177                 return IO_RETRY;
 178
 179         for (i = 0; i < 64; i++) {
 180                 raw_data = gameport_read(gameport);
 181                 portvals |= 1 << ((raw_data >> 4) & 3); /* Demux B4, B5 */
 182         }
 183
 184         if (portvals == 1) {                            /* B4, B5 off */
 185                 raw_data = gameport_read(gameport);
 186                 portvals = raw_data & 0xf0;
 187
 188                 if (raw_data & 0x31)
 189                         return IO_RESET;
 190                 gameport_trigger(gameport);
 191
 192                 if (!poll_until(0x10, 0, 308, gameport, &raw_data))
 193                         return IO_RESET;
 194         } else
 195                 return IO_RETRY;
 196
 197         /* Determine packet transfer mode and prepare for packet construction. */
 198
 199         if (raw_data & 0x20) {                 /* 3 data bits/read */
 200                 portvals |= raw_data >> 4;     /* Compare B4-B7 before & after trigger */
 201
 202                 if (portvals != 0xb)
 203                         return 0;
 204                 data_mask = 7;
 205                 bits_per_read = 3;
 206                 pkt = (PACKET_FULL | PACKET_IO_FAST) >> 28;
 207         } else {                                 /* 1 data bit/read */
 208                 data_mask = 1;
 209                 bits_per_read = 1;
 210                 pkt = (PACKET_FULL | PACKET_IO_SLOW) >> 28;
 211         }
 212
 213         /* Construct a packet.  Final data bits must be zero. */
 214
 215         while (1) {
 216                 if (!poll_until(0, 0x10, 77, gameport, &raw_data))
 217                         return IO_RESET;
 218                 raw_data = (raw_data >> 5) & data_mask;
 219
 220                 if (pkt & PACKET_FULL)
 221                         break;
 222                 pkt = (pkt << bits_per_read) | raw_data;
 223
 224                 if (!poll_until(0x10, 0, 77, gameport, &raw_data))
 225                         return IO_RESET;
 226         }
 227
 228         if (raw_data)
 229                 return IO_RESET;
 230
 231         /* If 3 bits/read used, drop from 30 bits to 28. */
 232
 233         if (bits_per_read == 3) {
 234                 pkt = (pkt & 0xffff0000) | ((pkt << 1) & 0xffff);
 235                 pkt = (pkt >> 2) | 0xf0000000;
 236         }
 237
 238         if (bit_parity(pkt) == 1)
 239                 return IO_RESET;
 240
 241         /* Acknowledge packet receipt */
 242
 243         if (!poll_until(0x30, 0, 77, gameport, &raw_data))
 244                 return IO_RESET;
 245
 246         raw_data = gameport_read(gameport);
 247
 248         if (raw_data & 1)
 249                 return IO_RESET;
 250
 251         gameport_trigger(gameport);
 252
 253         if (!poll_until(0, 0x20, 77, gameport, &raw_data))
 254                 return IO_RESET;
 255
 256         /* Return if we just wanted the packet or multiport wants to send more */
 257
 258         *packet = pkt;
 259         if ((sendflags == 0) || ((sendflags & IO_RETRY) && !(pkt & PACKET_MP_DONE)))
 260                 return IO_GOT_PACKET;
 261
 262         if (pkt & PACKET_MP_MORE)
 263                 return IO_GOT_PACKET | IO_RETRY;
 264
 265         /* Multiport is done sending packets and is ready to receive data */
 266
 267         if (!poll_until(0x20, 0, 77, gameport, &raw_data))
 268                 return IO_GOT_PACKET | IO_RESET;
 269
 270         raw_data = gameport_read(gameport);
 271         if (raw_data & 1)
 272                 return IO_GOT_PACKET | IO_RESET;
 273
 274         /* Trigger gameport based on bits in sendcode */
 275
 276         gameport_trigger(gameport);
 277         do {
 278                 if (!poll_until(0x20, 0x10, 116, gameport, &raw_data))
 279                         return IO_GOT_PACKET | IO_RESET;
 280
 281                 if (!poll_until(0x30, 0, 193, gameport, &raw_data))
 282                         return IO_GOT_PACKET | IO_RESET;
 283
 284                 if (raw_data & 1)
 285                         return IO_GOT_PACKET | IO_RESET;
 286
 287                 if (sendcode & 1)
 288                         gameport_trigger(gameport);
 289
 290                 sendcode >>= 1;
 291         } while (sendcode);
 292
 293         return IO_GOT_PACKET | IO_MODE_FAST;
 294 }
 295
 296 /*
 297  * Disables and restores interrupts for mp_io(), which does the actual I/O.
 298  */
 299
 300 static int multiport_io(struct gameport* gameport, int sendflags, int sendcode, u32 *packet)
 301 {
 302         int status;
 303         unsigned long flags;
 304
 305         local_irq_save(flags);
 306         status = mp_io(gameport, sendflags, sendcode, packet);
 307         local_irq_restore(flags);
 308
 309         return status;
 310 }
 311
 312 /*
 313  * Puts multiport into digital mode.  Multiport LED turns green.
 314  *
 315  * Returns true if a valid digital packet was received, false otherwise.
 316  */
 317
 318 static int dig_mode_start(struct gameport *gameport, u32 *packet)
 319 {
 320         int i;
 321         int flags, tries = 0, bads = 0;
 322
 323         for (i = 0; i < ARRAY_SIZE(init_seq); i++) {     /* Send magic sequence */
 324                 if (init_seq[i])
 325                         gameport_trigger(gameport);
 326                 udelay(GRIP_INIT_DELAY);
 327         }
 328
 329         for (i = 0; i < 16; i++)            /* Wait for multiport to settle */
 330                 udelay(GRIP_INIT_DELAY);
 331
 332         while (tries < 64 && bads < 8) {    /* Reset multiport and try getting a packet */
 333
 334                 flags = multiport_io(gameport, IO_RESET, 0x27, packet);
 335
 336                 if (flags & IO_MODE_FAST)
 337                         return 1;
 338
 339                 if (flags & IO_RETRY)
 340                         tries++;
 341                 else
 342                         bads++;
 343         }
 344         return 0;
 345 }
 346
 347 /*
 348  * Packet structure: B0-B15   => gamepad state
 349  *                   B16-B20  => gamepad device type
 350  *                   B21-B24  => multiport slot index (1-4)
 351  *
 352  * Known device types: 0x1f (grip pad), 0x0 (no device).  Others may exist.
 353  *
 354  * Returns the packet status.
 355  */
 356
 357 static int get_and_decode_packet(struct grip_mp *grip, int flags)
 358 {
 359         struct grip_port *port;
 360         u32 packet;
 361         int joytype = 0;
 362         int slot;
 363
 364         /* Get a packet and check for validity */
 365
 366         flags &= IO_RESET | IO_RETRY;
 367         flags = multiport_io(grip->gameport, flags, 0, &packet);
 368         grip->reads++;
 369
 370         if (packet & PACKET_MP_DONE)
 371                 flags |= IO_DONE;
 372
 373         if (flags && !(flags & IO_GOT_PACKET)) {
 374                 grip->bads++;
 375                 return flags;
 376         }
 377
 378         /* Ignore non-gamepad packets, e.g. multiport hardware version */
 379
 380         slot = ((packet >> 21) & 0xf) - 1;
 381         if ((slot < 0) || (slot > 3))
 382                 return flags;
 383
 384         port = grip->port[slot];
 385
 386         /*
 387          * Handle "reset" packets, which occur at startup, and when gamepads
 388          * are removed or plugged in.  May contain configuration of a new gamepad.
 389          */
 390
 391         joytype = (packet >> 16) & 0x1f;
 392         if (!joytype) {
 393
 394                 if (port->registered) {
 395                         printk(KERN_INFO "grip_mp: removing %s, slot %d\n",
 396                                grip_name[port->mode], slot);
 397                         input_unregister_device(port->dev);
 398                         port->registered = 0;
 399                 }
 400                 dbg("Reset: grip multiport slot %d\n", slot);
 401                 port->mode = GRIP_MODE_RESET;
 402                 flags |= IO_SLOT_CHANGE;
 403                 return flags;
 404         }
 405
 406         /* Interpret a grip pad packet */
 407
 408         if (joytype == 0x1f) {
 409
 410                 int dir = (packet >> 8) & 0xf;          /* eight way directional value */
 411                 port->buttons = (~packet) & 0xff;
 412                 port->yaxes = ((axis_map[dir] >> 2) & 3) - 1;
 413                 port->xaxes = (axis_map[dir] & 3) - 1;
 414                 port->dirty = 1;
 415
 416                 if (port->mode == GRIP_MODE_RESET)
 417                         flags |= IO_SLOT_CHANGE;
 418
 419                 port->mode = GRIP_MODE_GP;
 420
 421                 if (!port->registered) {
 422                         dbg("New Grip pad in multiport slot %d.\n", slot);
 423                         if (register_slot(slot, grip)) {
 424                                 port->mode = GRIP_MODE_RESET;
 425                                 port->dirty = 0;
 426                         }
 427                 }
 428                 return flags;
 429         }
 430
 431         /* Handle non-grip device codes.  For now, just print diagnostics. */
 432
 433         {
 434                 static int strange_code = 0;
 435                 if (strange_code != joytype) {
 436                         printk(KERN_INFO "Possible non-grip pad/joystick detected.\n");
 437                         printk(KERN_INFO "Got joy type 0x%x and packet 0x%x.\n", joytype, packet);
 438                         strange_code = joytype;
 439                 }
 440         }
 441         return flags;
 442 }
 443
 444 /*
 445  * Returns true if all multiport slot states appear valid.
 446  */
 447
 448 static int slots_valid(struct grip_mp *grip)
 449 {
 450         int flags, slot, invalid = 0, active = 0;
 451
 452         flags = get_and_decode_packet(grip, 0);
 453         if (!(flags & IO_GOT_PACKET))
 454                 return 0;
 455
 456         for (slot = 0; slot < 4; slot++) {
 457                 if (grip->port[slot]->mode == GRIP_MODE_RESET)
 458                         invalid = 1;
 459                 if (grip->port[slot]->mode != GRIP_MODE_NONE)
 460                         active = 1;
 461         }
 462
 463         /* Return true if no active slot but multiport sent all its data */
 464         if (!active)
 465                 return (flags & IO_DONE) ? 1 : 0;
 466
 467         /* Return false if invalid device code received */
 468         return invalid ? 0 : 1;
 469 }
 470
 471 /*
 472  * Returns whether the multiport was placed into digital mode and
 473  * able to communicate its state successfully.
 474  */
 475
 476 static int multiport_init(struct grip_mp *grip)
 477 {
 478         int dig_mode, initialized = 0, tries = 0;
 479         u32 packet;
 480
 481         dig_mode = dig_mode_start(grip->gameport, &packet);
 482         while (!dig_mode && tries < 4) {
 483                 dig_mode = dig_mode_start(grip->gameport, &packet);
 484                 tries++;
 485         }
 486
 487         if (dig_mode)
 488                 dbg("multiport_init(): digital mode activated.\n");
 489         else {
 490                 dbg("multiport_init(): unable to activate digital mode.\n");
 491                 return 0;
 492         }
 493
 494         /* Get packets, store multiport state, and check state's validity */
 495         for (tries = 0; tries < 4096; tries++) {
 496                 if (slots_valid(grip)) {
 497                         initialized = 1;
 498                         break;
 499                 }
 500         }
 501         dbg("multiport_init(): initialized == %d\n", initialized);
 502         return initialized;
 503 }
 504
 505 /*
 506  * Reports joystick state to the linux input layer.
 507  */
 508
 509 static void report_slot(struct grip_mp *grip, int slot)
 510 {
 511         struct grip_port *port = grip->port[slot];
 512         int i;
 513
 514         /* Store button states with linux input driver */
 515
 516         for (i = 0; i < 8; i++)
 517                 input_report_key(port->dev, grip_btn_gp[i], (port->buttons >> i) & 1);
 518
 519         /* Store axis states with linux driver */
 520
 521         input_report_abs(port->dev, ABS_X, port->xaxes);
 522         input_report_abs(port->dev, ABS_Y, port->yaxes);
 523
 524         /* Tell the receiver of the events to process them */
 525
 526         input_sync(port->dev);
 527
 528         port->dirty = 0;
 529 }
 530
 531 /*
 532  * Get the multiport state.
 533  */
 534
 535 static void grip_poll(struct gameport *gameport)
 536 {
 537         struct grip_mp *grip = gameport_get_drvdata(gameport);
 538         int i, npkts, flags;
 539
 540         for (npkts = 0; npkts < 4; npkts++) {
 541                 flags = IO_RETRY;
 542                 for (i = 0; i < 32; i++) {
 543                         flags = get_and_decode_packet(grip, flags);
 544                         if ((flags & IO_GOT_PACKET) || !(flags & IO_RETRY))
 545                                 break;
 546                 }
 547                 if (flags & IO_DONE)
 548                         break;
 549         }
 550
 551         for (i = 0; i < 4; i++)
 552                 if (grip->port[i]->dirty)
 553                         report_slot(grip, i);
 554 }
 555
 556 /*
 557  * Called when a joystick device file is opened
 558  */
 559
 560 static int grip_open(struct input_dev *dev)
 561 {
 562         struct grip_mp *grip = input_get_drvdata(dev);
 563
 564         gameport_start_polling(grip->gameport);
 565         return 0;
 566 }
 567
 568 /*
 569  * Called when a joystick device file is closed
 570  */
 571
 572 static void grip_close(struct input_dev *dev)
 573 {
 574         struct grip_mp *grip = input_get_drvdata(dev);
 575
 576         gameport_stop_polling(grip->gameport);
 577 }
 578
 579 /*
 580  * Tell the linux input layer about a newly plugged-in gamepad.
 581  */
 582
 583 static int register_slot(int slot, struct grip_mp *grip)
 584 {
 585         struct grip_port *port = grip->port[slot];
 586         struct input_dev *input_dev;
 587         int j, t;
 588         int err;
 589
 590         port->dev = input_dev = input_allocate_device();
 591         if (!input_dev)
 592                 return -ENOMEM;
 593
 594         input_dev->name = grip_name[port->mode];
 595         input_dev->id.bustype = BUS_GAMEPORT;
 596         input_dev->id.vendor = GAMEPORT_ID_VENDOR_GRAVIS;
 597         input_dev->id.product = 0x0100 + port->mode;
 598         input_dev->id.version = 0x0100;
 599         input_dev->dev.parent = &grip->gameport->dev;
 600
 601         input_set_drvdata(input_dev, grip);
 602
 603         input_dev->open = grip_open;
 604         input_dev->close = grip_close;
 605
 606         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 607
 608         for (j = 0; (t = grip_abs[port->mode][j]) >= 0; j++)
 609                 input_set_abs_params(input_dev, t, -1, 1, 0, 0);
 610
 611         for (j = 0; (t = grip_btn[port->mode][j]) >= 0; j++)
 612                 if (t > 0)
 613                         set_bit(t, input_dev->keybit);
 614
 615         err = input_register_device(port->dev);
 616         if (err) {
 617                 input_free_device(port->dev);
 618                 return err;
 619         }
 620
 621         port->registered = 1;
 622
 623         if (port->dirty)                    /* report initial state, if any */
 624                 report_slot(grip, slot);
 625
 626         return 0;
 627 }
 628
 629 static int grip_connect(struct gameport *gameport, struct gameport_driver *drv)
 630 {
 631         struct grip_mp *grip;
 632         int err;
 633
 634         if (!(grip = kzalloc(sizeof(struct grip_mp), GFP_KERNEL)))
 635                 return -ENOMEM;
 636
 637         grip->gameport = gameport;
 638
 639         gameport_set_drvdata(gameport, grip);
 640
 641         err = gameport_open(gameport, drv, GAMEPORT_MODE_RAW);
 642         if (err)
 643                 goto fail1;
 644
 645         gameport_set_poll_handler(gameport, grip_poll);
 646         gameport_set_poll_interval(gameport, 20);
 647
 648         if (!multiport_init(grip)) {
 649                 err = -ENODEV;
 650                 goto fail2;
 651         }
 652
 653         if (!grip->port[0]->mode && !grip->port[1]->mode && !grip->port[2]->mode && !grip->port[3]->mode) {
 654                 /* nothing plugged in */
 655                 err = -ENODEV;
 656                 goto fail2;
 657         }
 658
 659         return 0;
 660
 661 fail2:  gameport_close(gameport);
 662 fail1:  gameport_set_drvdata(gameport, NULL);
 663         kfree(grip);
 664         return err;
 665 }
 666
 667 static void grip_disconnect(struct gameport *gameport)
 668 {
 669         struct grip_mp *grip = gameport_get_drvdata(gameport);
 670         int i;
 671
 672         for (i = 0; i < 4; i++)
 673                 if (grip->port[i]->registered)
 674                         input_unregister_device(grip->port[i]->dev);
 675         gameport_close(gameport);
 676         gameport_set_drvdata(gameport, NULL);
 677         kfree(grip);
 678 }
 679
 680 static struct gameport_driver grip_drv = {
 681         .driver         = {
 682                 .name   = "grip_mp",
 683         },
 684         .description    = DRIVER_DESC,
 685         .connect        = grip_connect,
 686         .disconnect     = grip_disconnect,
 687 };
 688
 689 module_gameport_driver(grip_drv);