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); 704