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/init.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); 691