drivers/input/joystick/grip_mp.c

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