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