1 /* 2 * Generic gameport layer 3 * 4 * Copyright (c) 1999-2002 Vojtech Pavlik 5 * Copyright (c) 2005 Dmitry Torokhov 6 */ 7 8 /* 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License version 2 as published by 11 * the Free Software Foundation. 12 */ 13 14 #include <linux/stddef.h> 15 #include <linux/module.h> 16 #include <linux/ioport.h> 17 #include <linux/init.h> 18 #include <linux/gameport.h> 19 #include <linux/wait.h> 20 #include <linux/sched.h> 21 #include <linux/slab.h> 22 #include <linux/delay.h> 23 #include <linux/kthread.h> 24 25 /*#include <asm/io.h>*/ 26 27 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>"); 28 MODULE_DESCRIPTION("Generic gameport layer"); 29 MODULE_LICENSE("GPL"); 30 31 EXPORT_SYMBOL(__gameport_register_port); 32 EXPORT_SYMBOL(gameport_unregister_port); 33 EXPORT_SYMBOL(__gameport_register_driver); 34 EXPORT_SYMBOL(gameport_unregister_driver); 35 EXPORT_SYMBOL(gameport_open); 36 EXPORT_SYMBOL(gameport_close); 37 EXPORT_SYMBOL(gameport_rescan); 38 EXPORT_SYMBOL(gameport_cooked_read); 39 EXPORT_SYMBOL(gameport_set_name); 40 EXPORT_SYMBOL(gameport_set_phys); 41 EXPORT_SYMBOL(gameport_start_polling); 42 EXPORT_SYMBOL(gameport_stop_polling); 43 44 /* 45 * gameport_sem protects entire gameport subsystem and is taken 46 * every time gameport port or driver registrered or unregistered. 47 */ 48 static DECLARE_MUTEX(gameport_sem); 49 50 static LIST_HEAD(gameport_list); 51 52 static struct bus_type gameport_bus = { 53 .name = "gameport", 54 }; 55 56 static void gameport_add_port(struct gameport *gameport); 57 static void gameport_destroy_port(struct gameport *gameport); 58 static void gameport_reconnect_port(struct gameport *gameport); 59 static void gameport_disconnect_port(struct gameport *gameport); 60 61 #if defined(__i386__) 62 63 #include <asm/i8253.h> 64 65 #define DELTA(x,y) ((y)-(x)+((y)<(x)?1193182/HZ:0)) 66 #define GET_TIME(x) do { x = get_time_pit(); } while (0) 67 68 static unsigned int get_time_pit(void) 69 { 70 unsigned long flags; 71 unsigned int count; 72 73 spin_lock_irqsave(&i8253_lock, flags); 74 outb_p(0x00, 0x43); 75 count = inb_p(0x40); 76 count |= inb_p(0x40) << 8; 77 spin_unlock_irqrestore(&i8253_lock, flags); 78 79 return count; 80 } 81 82 #endif 83 84 85 86 /* 87 * gameport_measure_speed() measures the gameport i/o speed. 88 */ 89 90 static int gameport_measure_speed(struct gameport *gameport) 91 { 92 #if defined(__i386__) 93 94 unsigned int i, t, t1, t2, t3, tx; 95 unsigned long flags; 96 97 if (gameport_open(gameport, NULL, GAMEPORT_MODE_RAW)) 98 return 0; 99 100 tx = 1 << 30; 101 102 for(i = 0; i < 50; i++) { 103 local_irq_save(flags); 104 GET_TIME(t1); 105 for (t = 0; t < 50; t++) gameport_read(gameport); 106 GET_TIME(t2); 107 GET_TIME(t3); 108 local_irq_restore(flags); 109 udelay(i * 10); 110 if ((t = DELTA(t2,t1) - DELTA(t3,t2)) < tx) tx = t; 111 } 112 113 gameport_close(gameport); 114 return 59659 / (tx < 1 ? 1 : tx); 115 116 #elif defined (__x86_64__) 117 118 unsigned int i, t; 119 unsigned long tx, t1, t2, flags; 120 121 if (gameport_open(gameport, NULL, GAMEPORT_MODE_RAW)) 122 return 0; 123 124 tx = 1 << 30; 125 126 for(i = 0; i < 50; i++) { 127 local_irq_save(flags); 128 rdtscl(t1); 129 for (t = 0; t < 50; t++) gameport_read(gameport); 130 rdtscl(t2); 131 local_irq_restore(flags); 132 udelay(i * 10); 133 if (t2 - t1 < tx) tx = t2 - t1; 134 } 135 136 gameport_close(gameport); 137 return (cpu_data[raw_smp_processor_id()].loops_per_jiffy * (unsigned long)HZ / (1000 / 50)) / (tx < 1 ? 1 : tx); 138 139 #else 140 141 unsigned int j, t = 0; 142 143 if (gameport_open(gameport, NULL, GAMEPORT_MODE_RAW)) 144 return 0; 145 146 j = jiffies; while (j == jiffies); 147 j = jiffies; while (j == jiffies) { t++; gameport_read(gameport); } 148 149 gameport_close(gameport); 150 return t * HZ / 1000; 151 152 #endif 153 } 154 155 void gameport_start_polling(struct gameport *gameport) 156 { 157 spin_lock(&gameport->timer_lock); 158 159 if (!gameport->poll_cnt++) { 160 BUG_ON(!gameport->poll_handler); 161 BUG_ON(!gameport->poll_interval); 162 mod_timer(&gameport->poll_timer, jiffies + msecs_to_jiffies(gameport->poll_interval)); 163 } 164 165 spin_unlock(&gameport->timer_lock); 166 } 167 168 void gameport_stop_polling(struct gameport *gameport) 169 { 170 spin_lock(&gameport->timer_lock); 171 172 if (!--gameport->poll_cnt) 173 del_timer(&gameport->poll_timer); 174 175 spin_unlock(&gameport->timer_lock); 176 } 177 178 static void gameport_run_poll_handler(unsigned long d) 179 { 180 struct gameport *gameport = (struct gameport *)d; 181 182 gameport->poll_handler(gameport); 183 if (gameport->poll_cnt) 184 mod_timer(&gameport->poll_timer, jiffies + msecs_to_jiffies(gameport->poll_interval)); 185 } 186 187 /* 188 * Basic gameport -> driver core mappings 189 */ 190 191 static void gameport_bind_driver(struct gameport *gameport, struct gameport_driver *drv) 192 { 193 down_write(&gameport_bus.subsys.rwsem); 194 195 gameport->dev.driver = &drv->driver; 196 if (drv->connect(gameport, drv)) { 197 gameport->dev.driver = NULL; 198 goto out; 199 } 200 device_bind_driver(&gameport->dev); 201 out: 202 up_write(&gameport_bus.subsys.rwsem); 203 } 204 205 static void gameport_release_driver(struct gameport *gameport) 206 { 207 down_write(&gameport_bus.subsys.rwsem); 208 device_release_driver(&gameport->dev); 209 up_write(&gameport_bus.subsys.rwsem); 210 } 211 212 static void gameport_find_driver(struct gameport *gameport) 213 { 214 down_write(&gameport_bus.subsys.rwsem); 215 device_attach(&gameport->dev); 216 up_write(&gameport_bus.subsys.rwsem); 217 } 218 219 220 /* 221 * Gameport event processing. 222 */ 223 224 enum gameport_event_type { 225 GAMEPORT_RESCAN, 226 GAMEPORT_RECONNECT, 227 GAMEPORT_REGISTER_PORT, 228 GAMEPORT_REGISTER_DRIVER, 229 }; 230 231 struct gameport_event { 232 enum gameport_event_type type; 233 void *object; 234 struct module *owner; 235 struct list_head node; 236 }; 237 238 static DEFINE_SPINLOCK(gameport_event_lock); /* protects gameport_event_list */ 239 static LIST_HEAD(gameport_event_list); 240 static DECLARE_WAIT_QUEUE_HEAD(gameport_wait); 241 static struct task_struct *gameport_task; 242 243 static void gameport_queue_event(void *object, struct module *owner, 244 enum gameport_event_type event_type) 245 { 246 unsigned long flags; 247 struct gameport_event *event; 248 249 spin_lock_irqsave(&gameport_event_lock, flags); 250 251 /* 252 * Scan event list for the other events for the same gameport port, 253 * starting with the most recent one. If event is the same we 254 * do not need add new one. If event is of different type we 255 * need to add this event and should not look further because 256 * we need to preseve sequence of distinct events. 257 */ 258 list_for_each_entry_reverse(event, &gameport_event_list, node) { 259 if (event->object == object) { 260 if (event->type == event_type) 261 goto out; 262 break; 263 } 264 } 265 266 if ((event = kmalloc(sizeof(struct gameport_event), GFP_ATOMIC))) { 267 if (!try_module_get(owner)) { 268 printk(KERN_WARNING "gameport: Can't get module reference, dropping event %d\n", event_type); 269 goto out; 270 } 271 272 event->type = event_type; 273 event->object = object; 274 event->owner = owner; 275 276 list_add_tail(&event->node, &gameport_event_list); 277 wake_up(&gameport_wait); 278 } else { 279 printk(KERN_ERR "gameport: Not enough memory to queue event %d\n", event_type); 280 } 281 out: 282 spin_unlock_irqrestore(&gameport_event_lock, flags); 283 } 284 285 static void gameport_free_event(struct gameport_event *event) 286 { 287 module_put(event->owner); 288 kfree(event); 289 } 290 291 static void gameport_remove_duplicate_events(struct gameport_event *event) 292 { 293 struct list_head *node, *next; 294 struct gameport_event *e; 295 unsigned long flags; 296 297 spin_lock_irqsave(&gameport_event_lock, flags); 298 299 list_for_each_safe(node, next, &gameport_event_list) { 300 e = list_entry(node, struct gameport_event, node); 301 if (event->object == e->object) { 302 /* 303 * If this event is of different type we should not 304 * look further - we only suppress duplicate events 305 * that were sent back-to-back. 306 */ 307 if (event->type != e->type) 308 break; 309 310 list_del_init(node); 311 gameport_free_event(e); 312 } 313 } 314 315 spin_unlock_irqrestore(&gameport_event_lock, flags); 316 } 317 318 319 static struct gameport_event *gameport_get_event(void) 320 { 321 struct gameport_event *event; 322 struct list_head *node; 323 unsigned long flags; 324 325 spin_lock_irqsave(&gameport_event_lock, flags); 326 327 if (list_empty(&gameport_event_list)) { 328 spin_unlock_irqrestore(&gameport_event_lock, flags); 329 return NULL; 330 } 331 332 node = gameport_event_list.next; 333 event = list_entry(node, struct gameport_event, node); 334 list_del_init(node); 335 336 spin_unlock_irqrestore(&gameport_event_lock, flags); 337 338 return event; 339 } 340 341 static void gameport_handle_events(void) 342 { 343 struct gameport_event *event; 344 struct gameport_driver *gameport_drv; 345 346 down(&gameport_sem); 347 348 while ((event = gameport_get_event())) { 349 350 switch (event->type) { 351 case GAMEPORT_REGISTER_PORT: 352 gameport_add_port(event->object); 353 break; 354 355 case GAMEPORT_RECONNECT: 356 gameport_reconnect_port(event->object); 357 break; 358 359 case GAMEPORT_RESCAN: 360 gameport_disconnect_port(event->object); 361 gameport_find_driver(event->object); 362 break; 363 364 case GAMEPORT_REGISTER_DRIVER: 365 gameport_drv = event->object; 366 driver_register(&gameport_drv->driver); 367 break; 368 369 default: 370 break; 371 } 372 373 gameport_remove_duplicate_events(event); 374 gameport_free_event(event); 375 } 376 377 up(&gameport_sem); 378 } 379 380 /* 381 * Remove all events that have been submitted for a given gameport port. 382 */ 383 static void gameport_remove_pending_events(struct gameport *gameport) 384 { 385 struct list_head *node, *next; 386 struct gameport_event *event; 387 unsigned long flags; 388 389 spin_lock_irqsave(&gameport_event_lock, flags); 390 391 list_for_each_safe(node, next, &gameport_event_list) { 392 event = list_entry(node, struct gameport_event, node); 393 if (event->object == gameport) { 394 list_del_init(node); 395 gameport_free_event(event); 396 } 397 } 398 399 spin_unlock_irqrestore(&gameport_event_lock, flags); 400 } 401 402 /* 403 * Destroy child gameport port (if any) that has not been fully registered yet. 404 * 405 * Note that we rely on the fact that port can have only one child and therefore 406 * only one child registration request can be pending. Additionally, children 407 * are registered by driver's connect() handler so there can't be a grandchild 408 * pending registration together with a child. 409 */ 410 static struct gameport *gameport_get_pending_child(struct gameport *parent) 411 { 412 struct gameport_event *event; 413 struct gameport *gameport, *child = NULL; 414 unsigned long flags; 415 416 spin_lock_irqsave(&gameport_event_lock, flags); 417 418 list_for_each_entry(event, &gameport_event_list, node) { 419 if (event->type == GAMEPORT_REGISTER_PORT) { 420 gameport = event->object; 421 if (gameport->parent == parent) { 422 child = gameport; 423 break; 424 } 425 } 426 } 427 428 spin_unlock_irqrestore(&gameport_event_lock, flags); 429 return child; 430 } 431 432 static int gameport_thread(void *nothing) 433 { 434 do { 435 gameport_handle_events(); 436 wait_event_interruptible(gameport_wait, 437 kthread_should_stop() || !list_empty(&gameport_event_list)); 438 try_to_freeze(); 439 } while (!kthread_should_stop()); 440 441 printk(KERN_DEBUG "gameport: kgameportd exiting\n"); 442 return 0; 443 } 444 445 446 /* 447 * Gameport port operations 448 */ 449 450 static ssize_t gameport_show_description(struct device *dev, struct device_attribute *attr, char *buf) 451 { 452 struct gameport *gameport = to_gameport_port(dev); 453 return sprintf(buf, "%s\n", gameport->name); 454 } 455 456 static ssize_t gameport_rebind_driver(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 457 { 458 struct gameport *gameport = to_gameport_port(dev); 459 struct device_driver *drv; 460 int retval; 461 462 retval = down_interruptible(&gameport_sem); 463 if (retval) 464 return retval; 465 466 retval = count; 467 if (!strncmp(buf, "none", count)) { 468 gameport_disconnect_port(gameport); 469 } else if (!strncmp(buf, "reconnect", count)) { 470 gameport_reconnect_port(gameport); 471 } else if (!strncmp(buf, "rescan", count)) { 472 gameport_disconnect_port(gameport); 473 gameport_find_driver(gameport); 474 } else if ((drv = driver_find(buf, &gameport_bus)) != NULL) { 475 gameport_disconnect_port(gameport); 476 gameport_bind_driver(gameport, to_gameport_driver(drv)); 477 put_driver(drv); 478 } else { 479 retval = -EINVAL; 480 } 481 482 up(&gameport_sem); 483 484 return retval; 485 } 486 487 static struct device_attribute gameport_device_attrs[] = { 488 __ATTR(description, S_IRUGO, gameport_show_description, NULL), 489 __ATTR(drvctl, S_IWUSR, NULL, gameport_rebind_driver), 490 __ATTR_NULL 491 }; 492 493 static void gameport_release_port(struct device *dev) 494 { 495 struct gameport *gameport = to_gameport_port(dev); 496 497 kfree(gameport); 498 module_put(THIS_MODULE); 499 } 500 501 void gameport_set_phys(struct gameport *gameport, const char *fmt, ...) 502 { 503 va_list args; 504 505 va_start(args, fmt); 506 vsnprintf(gameport->phys, sizeof(gameport->phys), fmt, args); 507 va_end(args); 508 } 509 510 /* 511 * Prepare gameport port for registration. 512 */ 513 static void gameport_init_port(struct gameport *gameport) 514 { 515 static atomic_t gameport_no = ATOMIC_INIT(0); 516 517 __module_get(THIS_MODULE); 518 519 init_MUTEX(&gameport->drv_sem); 520 device_initialize(&gameport->dev); 521 snprintf(gameport->dev.bus_id, sizeof(gameport->dev.bus_id), 522 "gameport%lu", (unsigned long)atomic_inc_return(&gameport_no) - 1); 523 gameport->dev.bus = &gameport_bus; 524 gameport->dev.release = gameport_release_port; 525 if (gameport->parent) 526 gameport->dev.parent = &gameport->parent->dev; 527 528 spin_lock_init(&gameport->timer_lock); 529 init_timer(&gameport->poll_timer); 530 gameport->poll_timer.function = gameport_run_poll_handler; 531 gameport->poll_timer.data = (unsigned long)gameport; 532 } 533 534 /* 535 * Complete gameport port registration. 536 * Driver core will attempt to find appropriate driver for the port. 537 */ 538 static void gameport_add_port(struct gameport *gameport) 539 { 540 if (gameport->parent) 541 gameport->parent->child = gameport; 542 543 gameport->speed = gameport_measure_speed(gameport); 544 545 list_add_tail(&gameport->node, &gameport_list); 546 547 if (gameport->io) 548 printk(KERN_INFO "gameport: %s is %s, io %#x, speed %dkHz\n", 549 gameport->name, gameport->phys, gameport->io, gameport->speed); 550 else 551 printk(KERN_INFO "gameport: %s is %s, speed %dkHz\n", 552 gameport->name, gameport->phys, gameport->speed); 553 554 device_add(&gameport->dev); 555 gameport->registered = 1; 556 } 557 558 /* 559 * gameport_destroy_port() completes deregistration process and removes 560 * port from the system 561 */ 562 static void gameport_destroy_port(struct gameport *gameport) 563 { 564 struct gameport *child; 565 566 child = gameport_get_pending_child(gameport); 567 if (child) { 568 gameport_remove_pending_events(child); 569 put_device(&child->dev); 570 } 571 572 if (gameport->parent) { 573 gameport->parent->child = NULL; 574 gameport->parent = NULL; 575 } 576 577 if (gameport->registered) { 578 device_del(&gameport->dev); 579 list_del_init(&gameport->node); 580 gameport->registered = 0; 581 } 582 583 gameport_remove_pending_events(gameport); 584 put_device(&gameport->dev); 585 } 586 587 /* 588 * Reconnect gameport port and all its children (re-initialize attached devices) 589 */ 590 static void gameport_reconnect_port(struct gameport *gameport) 591 { 592 do { 593 if (!gameport->drv || !gameport->drv->reconnect || gameport->drv->reconnect(gameport)) { 594 gameport_disconnect_port(gameport); 595 gameport_find_driver(gameport); 596 /* Ok, old children are now gone, we are done */ 597 break; 598 } 599 gameport = gameport->child; 600 } while (gameport); 601 } 602 603 /* 604 * gameport_disconnect_port() unbinds a port from its driver. As a side effect 605 * all child ports are unbound and destroyed. 606 */ 607 static void gameport_disconnect_port(struct gameport *gameport) 608 { 609 struct gameport *s, *parent; 610 611 if (gameport->child) { 612 /* 613 * Children ports should be disconnected and destroyed 614 * first, staring with the leaf one, since we don't want 615 * to do recursion 616 */ 617 for (s = gameport; s->child; s = s->child) 618 /* empty */; 619 620 do { 621 parent = s->parent; 622 623 gameport_release_driver(s); 624 gameport_destroy_port(s); 625 } while ((s = parent) != gameport); 626 } 627 628 /* 629 * Ok, no children left, now disconnect this port 630 */ 631 gameport_release_driver(gameport); 632 } 633 634 void gameport_rescan(struct gameport *gameport) 635 { 636 gameport_queue_event(gameport, NULL, GAMEPORT_RESCAN); 637 } 638 639 void gameport_reconnect(struct gameport *gameport) 640 { 641 gameport_queue_event(gameport, NULL, GAMEPORT_RECONNECT); 642 } 643 644 /* 645 * Submits register request to kgameportd for subsequent execution. 646 * Note that port registration is always asynchronous. 647 */ 648 void __gameport_register_port(struct gameport *gameport, struct module *owner) 649 { 650 gameport_init_port(gameport); 651 gameport_queue_event(gameport, owner, GAMEPORT_REGISTER_PORT); 652 } 653 654 /* 655 * Synchronously unregisters gameport port. 656 */ 657 void gameport_unregister_port(struct gameport *gameport) 658 { 659 down(&gameport_sem); 660 gameport_disconnect_port(gameport); 661 gameport_destroy_port(gameport); 662 up(&gameport_sem); 663 } 664 665 666 /* 667 * Gameport driver operations 668 */ 669 670 static ssize_t gameport_driver_show_description(struct device_driver *drv, char *buf) 671 { 672 struct gameport_driver *driver = to_gameport_driver(drv); 673 return sprintf(buf, "%s\n", driver->description ? driver->description : "(none)"); 674 } 675 676 static struct driver_attribute gameport_driver_attrs[] = { 677 __ATTR(description, S_IRUGO, gameport_driver_show_description, NULL), 678 __ATTR_NULL 679 }; 680 681 static int gameport_driver_probe(struct device *dev) 682 { 683 struct gameport *gameport = to_gameport_port(dev); 684 struct gameport_driver *drv = to_gameport_driver(dev->driver); 685 686 drv->connect(gameport, drv); 687 return gameport->drv ? 0 : -ENODEV; 688 } 689 690 static int gameport_driver_remove(struct device *dev) 691 { 692 struct gameport *gameport = to_gameport_port(dev); 693 struct gameport_driver *drv = to_gameport_driver(dev->driver); 694 695 drv->disconnect(gameport); 696 return 0; 697 } 698 699 void __gameport_register_driver(struct gameport_driver *drv, struct module *owner) 700 { 701 drv->driver.bus = &gameport_bus; 702 drv->driver.probe = gameport_driver_probe; 703 drv->driver.remove = gameport_driver_remove; 704 gameport_queue_event(drv, owner, GAMEPORT_REGISTER_DRIVER); 705 } 706 707 void gameport_unregister_driver(struct gameport_driver *drv) 708 { 709 struct gameport *gameport; 710 711 down(&gameport_sem); 712 drv->ignore = 1; /* so gameport_find_driver ignores it */ 713 714 start_over: 715 list_for_each_entry(gameport, &gameport_list, node) { 716 if (gameport->drv == drv) { 717 gameport_disconnect_port(gameport); 718 gameport_find_driver(gameport); 719 /* we could've deleted some ports, restart */ 720 goto start_over; 721 } 722 } 723 724 driver_unregister(&drv->driver); 725 up(&gameport_sem); 726 } 727 728 static int gameport_bus_match(struct device *dev, struct device_driver *drv) 729 { 730 struct gameport_driver *gameport_drv = to_gameport_driver(drv); 731 732 return !gameport_drv->ignore; 733 } 734 735 static void gameport_set_drv(struct gameport *gameport, struct gameport_driver *drv) 736 { 737 down(&gameport->drv_sem); 738 gameport->drv = drv; 739 up(&gameport->drv_sem); 740 } 741 742 int gameport_open(struct gameport *gameport, struct gameport_driver *drv, int mode) 743 { 744 745 if (gameport->open) { 746 if (gameport->open(gameport, mode)) { 747 return -1; 748 } 749 } else { 750 if (mode != GAMEPORT_MODE_RAW) 751 return -1; 752 } 753 754 gameport_set_drv(gameport, drv); 755 return 0; 756 } 757 758 void gameport_close(struct gameport *gameport) 759 { 760 del_timer_sync(&gameport->poll_timer); 761 gameport->poll_handler = NULL; 762 gameport->poll_interval = 0; 763 gameport_set_drv(gameport, NULL); 764 if (gameport->close) 765 gameport->close(gameport); 766 } 767 768 static int __init gameport_init(void) 769 { 770 gameport_task = kthread_run(gameport_thread, NULL, "kgameportd"); 771 if (IS_ERR(gameport_task)) { 772 printk(KERN_ERR "gameport: Failed to start kgameportd\n"); 773 return PTR_ERR(gameport_task); 774 } 775 776 gameport_bus.dev_attrs = gameport_device_attrs; 777 gameport_bus.drv_attrs = gameport_driver_attrs; 778 gameport_bus.match = gameport_bus_match; 779 bus_register(&gameport_bus); 780 781 return 0; 782 } 783 784 static void __exit gameport_exit(void) 785 { 786 bus_unregister(&gameport_bus); 787 kthread_stop(gameport_task); 788 } 789 790 module_init(gameport_init); 791 module_exit(gameport_exit); 792