drivers/input/joystick/grip_mp.c

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