drivers/input/serio/serio.c

   1 /*
   2  *  The Serio abstraction module
   3  *
   4  *  Copyright (c) 1999-2004 Vojtech Pavlik
   5  *  Copyright (c) 2004 Dmitry Torokhov
   6  *  Copyright (c) 2003 Daniele Bellucci
   7  */
   8
   9 /*
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23  *
  24  * Should you need to contact me, the author, you can do so either by
  25  * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
  26  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
  27  */
  28
  29 #include <linux/stddef.h>
  30 #include <linux/module.h>
  31 #include <linux/serio.h>
  32 #include <linux/errno.h>
  33 #include <linux/wait.h>
  34 #include <linux/sched.h>
  35 #include <linux/slab.h>
  36 #include <linux/kthread.h>
  37
  38 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
  39 MODULE_DESCRIPTION("Serio abstraction core");
  40 MODULE_LICENSE("GPL");
  41
  42 EXPORT_SYMBOL(serio_interrupt);
  43 EXPORT_SYMBOL(__serio_register_port);
  44 EXPORT_SYMBOL(serio_unregister_port);
  45 EXPORT_SYMBOL(serio_unregister_child_port);
  46 EXPORT_SYMBOL(__serio_unregister_port_delayed);
  47 EXPORT_SYMBOL(__serio_register_driver);
  48 EXPORT_SYMBOL(serio_unregister_driver);
  49 EXPORT_SYMBOL(serio_open);
  50 EXPORT_SYMBOL(serio_close);
  51 EXPORT_SYMBOL(serio_rescan);
  52 EXPORT_SYMBOL(serio_reconnect);
  53
  54 /*
  55  * serio_sem protects entire serio subsystem and is taken every time
  56  * serio port or driver registrered or unregistered.
  57  */
  58 static DECLARE_MUTEX(serio_sem);
  59
  60 static LIST_HEAD(serio_list);
  61
  62 static struct bus_type serio_bus = {
  63         .name = "serio",
  64 };
  65
  66 static void serio_add_port(struct serio *serio);
  67 static void serio_destroy_port(struct serio *serio);
  68 static void serio_reconnect_port(struct serio *serio);
  69 static void serio_disconnect_port(struct serio *serio);
  70
  71 static int serio_connect_driver(struct serio *serio, struct serio_driver *drv)
  72 {
  73         int retval;
  74
  75         down(&serio->drv_sem);
  76         retval = drv->connect(serio, drv);
  77         up(&serio->drv_sem);
  78
  79         return retval;
  80 }
  81
  82 static int serio_reconnect_driver(struct serio *serio)
  83 {
  84         int retval = -1;
  85
  86         down(&serio->drv_sem);
  87         if (serio->drv && serio->drv->reconnect)
  88                 retval = serio->drv->reconnect(serio);
  89         up(&serio->drv_sem);
  90
  91         return retval;
  92 }
  93
  94 static void serio_disconnect_driver(struct serio *serio)
  95 {
  96         down(&serio->drv_sem);
  97         if (serio->drv)
  98                 serio->drv->disconnect(serio);
  99         up(&serio->drv_sem);
 100 }
 101
 102 static int serio_match_port(const struct serio_device_id *ids, struct serio *serio)
 103 {
 104         while (ids->type || ids->proto) {
 105                 if ((ids->type == SERIO_ANY || ids->type == serio->id.type) &&
 106                     (ids->proto == SERIO_ANY || ids->proto == serio->id.proto) &&
 107                     (ids->extra == SERIO_ANY || ids->extra == serio->id.extra) &&
 108                     (ids->id == SERIO_ANY || ids->id == serio->id.id))
 109                         return 1;
 110                 ids++;
 111         }
 112         return 0;
 113 }
 114
 115 /*
 116  * Basic serio -> driver core mappings
 117  */
 118
 119 static void serio_bind_driver(struct serio *serio, struct serio_driver *drv)
 120 {
 121         down_write(&serio_bus.subsys.rwsem);
 122
 123         if (serio_match_port(drv->id_table, serio)) {
 124                 serio->dev.driver = &drv->driver;
 125                 if (serio_connect_driver(serio, drv)) {
 126                         serio->dev.driver = NULL;
 127                         goto out;
 128                 }
 129                 device_bind_driver(&serio->dev);
 130         }
 131 out:
 132         up_write(&serio_bus.subsys.rwsem);
 133 }
 134
 135 static void serio_release_driver(struct serio *serio)
 136 {
 137         down_write(&serio_bus.subsys.rwsem);
 138         device_release_driver(&serio->dev);
 139         up_write(&serio_bus.subsys.rwsem);
 140 }
 141
 142 static void serio_find_driver(struct serio *serio)
 143 {
 144         down_write(&serio_bus.subsys.rwsem);
 145         device_attach(&serio->dev);
 146         up_write(&serio_bus.subsys.rwsem);
 147 }
 148
 149
 150 /*
 151  * Serio event processing.
 152  */
 153
 154 enum serio_event_type {
 155         SERIO_RESCAN,
 156         SERIO_RECONNECT,
 157         SERIO_REGISTER_PORT,
 158         SERIO_UNREGISTER_PORT,
 159         SERIO_REGISTER_DRIVER,
 160 };
 161
 162 struct serio_event {
 163         enum serio_event_type type;
 164         void *object;
 165         struct module *owner;
 166         struct list_head node;
 167 };
 168
 169 static DEFINE_SPINLOCK(serio_event_lock);       /* protects serio_event_list */
 170 static LIST_HEAD(serio_event_list);
 171 static DECLARE_WAIT_QUEUE_HEAD(serio_wait);
 172 static struct task_struct *serio_task;
 173
 174 static void serio_queue_event(void *object, struct module *owner,
 175                               enum serio_event_type event_type)
 176 {
 177         unsigned long flags;
 178         struct serio_event *event;
 179
 180         spin_lock_irqsave(&serio_event_lock, flags);
 181
 182         /*
 183          * Scan event list for the other events for the same serio port,
 184          * starting with the most recent one. If event is the same we
 185          * do not need add new one. If event is of different type we
 186          * need to add this event and should not look further because
 187          * we need to preseve sequence of distinct events.
 188          */
 189         list_for_each_entry_reverse(event, &serio_event_list, node) {
 190                 if (event->object == object) {
 191                         if (event->type == event_type)
 192                                 goto out;
 193                         break;
 194                 }
 195         }
 196
 197         if ((event = kmalloc(sizeof(struct serio_event), GFP_ATOMIC))) {
 198                 if (!try_module_get(owner)) {
 199                         printk(KERN_WARNING "serio: Can't get module reference, dropping event %d\n", event_type);
 200                         goto out;
 201                 }
 202
 203                 event->type = event_type;
 204                 event->object = object;
 205                 event->owner = owner;
 206
 207                 list_add_tail(&event->node, &serio_event_list);
 208                 wake_up(&serio_wait);
 209         } else {
 210                 printk(KERN_ERR "serio: Not enough memory to queue event %d\n", event_type);
 211         }
 212 out:
 213         spin_unlock_irqrestore(&serio_event_lock, flags);
 214 }
 215
 216 static void serio_free_event(struct serio_event *event)
 217 {
 218         module_put(event->owner);
 219         kfree(event);
 220 }
 221
 222 static void serio_remove_duplicate_events(struct serio_event *event)
 223 {
 224         struct list_head *node, *next;
 225         struct serio_event *e;
 226         unsigned long flags;
 227
 228         spin_lock_irqsave(&serio_event_lock, flags);
 229
 230         list_for_each_safe(node, next, &serio_event_list) {
 231                 e = list_entry(node, struct serio_event, node);
 232                 if (event->object == e->object) {
 233                         /*
 234                          * If this event is of different type we should not
 235                          * look further - we only suppress duplicate events
 236                          * that were sent back-to-back.
 237                          */
 238                         if (event->type != e->type)
 239                                 break;
 240
 241                         list_del_init(node);
 242                         serio_free_event(e);
 243                 }
 244         }
 245
 246         spin_unlock_irqrestore(&serio_event_lock, flags);
 247 }
 248
 249
 250 static struct serio_event *serio_get_event(void)
 251 {
 252         struct serio_event *event;
 253         struct list_head *node;
 254         unsigned long flags;
 255
 256         spin_lock_irqsave(&serio_event_lock, flags);
 257
 258         if (list_empty(&serio_event_list)) {
 259                 spin_unlock_irqrestore(&serio_event_lock, flags);
 260                 return NULL;
 261         }
 262
 263         node = serio_event_list.next;
 264         event = list_entry(node, struct serio_event, node);
 265         list_del_init(node);
 266
 267         spin_unlock_irqrestore(&serio_event_lock, flags);
 268
 269         return event;
 270 }
 271
 272 static void serio_handle_events(void)
 273 {
 274         struct serio_event *event;
 275         struct serio_driver *serio_drv;
 276
 277         down(&serio_sem);
 278
 279         while ((event = serio_get_event())) {
 280
 281                 switch (event->type) {
 282                         case SERIO_REGISTER_PORT:
 283                                 serio_add_port(event->object);
 284                                 break;
 285
 286                         case SERIO_UNREGISTER_PORT:
 287                                 serio_disconnect_port(event->object);
 288                                 serio_destroy_port(event->object);
 289                                 break;
 290
 291                         case SERIO_RECONNECT:
 292                                 serio_reconnect_port(event->object);
 293                                 break;
 294
 295                         case SERIO_RESCAN:
 296                                 serio_disconnect_port(event->object);
 297                                 serio_find_driver(event->object);
 298                                 break;
 299
 300                         case SERIO_REGISTER_DRIVER:
 301                                 serio_drv = event->object;
 302                                 driver_register(&serio_drv->driver);
 303                                 break;
 304
 305                         default:
 306                                 break;
 307                 }
 308
 309                 serio_remove_duplicate_events(event);
 310                 serio_free_event(event);
 311         }
 312
 313         up(&serio_sem);
 314 }
 315
 316 /*
 317  * Remove all events that have been submitted for a given serio port.
 318  */
 319 static void serio_remove_pending_events(struct serio *serio)
 320 {
 321         struct list_head *node, *next;
 322         struct serio_event *event;
 323         unsigned long flags;
 324
 325         spin_lock_irqsave(&serio_event_lock, flags);
 326
 327         list_for_each_safe(node, next, &serio_event_list) {
 328                 event = list_entry(node, struct serio_event, node);
 329                 if (event->object == serio) {
 330                         list_del_init(node);
 331                         serio_free_event(event);
 332                 }
 333         }
 334
 335         spin_unlock_irqrestore(&serio_event_lock, flags);
 336 }
 337
 338 /*
 339  * Destroy child serio port (if any) that has not been fully registered yet.
 340  *
 341  * Note that we rely on the fact that port can have only one child and therefore
 342  * only one child registration request can be pending. Additionally, children
 343  * are registered by driver's connect() handler so there can't be a grandchild
 344  * pending registration together with a child.
 345  */
 346 static struct serio *serio_get_pending_child(struct serio *parent)
 347 {
 348         struct serio_event *event;
 349         struct serio *serio, *child = NULL;
 350         unsigned long flags;
 351
 352         spin_lock_irqsave(&serio_event_lock, flags);
 353
 354         list_for_each_entry(event, &serio_event_list, node) {
 355                 if (event->type == SERIO_REGISTER_PORT) {
 356                         serio = event->object;
 357                         if (serio->parent == parent) {
 358                                 child = serio;
 359                                 break;
 360                         }
 361                 }
 362         }
 363
 364         spin_unlock_irqrestore(&serio_event_lock, flags);
 365         return child;
 366 }
 367
 368 static int serio_thread(void *nothing)
 369 {
 370         do {
 371                 serio_handle_events();
 372                 wait_event_interruptible(serio_wait,
 373                         kthread_should_stop() || !list_empty(&serio_event_list));
 374                 try_to_freeze(PF_FREEZE);
 375         } while (!kthread_should_stop());
 376
 377         printk(KERN_DEBUG "serio: kseriod exiting\n");
 378         return 0;
 379 }
 380
 381
 382 /*
 383  * Serio port operations
 384  */
 385
 386 static ssize_t serio_show_description(struct device *dev, char *buf)
 387 {
 388         struct serio *serio = to_serio_port(dev);
 389         return sprintf(buf, "%s\n", serio->name);
 390 }
 391
 392 static ssize_t serio_show_id_type(struct device *dev, char *buf)
 393 {
 394         struct serio *serio = to_serio_port(dev);
 395         return sprintf(buf, "%02x\n", serio->id.type);
 396 }
 397
 398 static ssize_t serio_show_id_proto(struct device *dev, char *buf)
 399 {
 400         struct serio *serio = to_serio_port(dev);
 401         return sprintf(buf, "%02x\n", serio->id.proto);
 402 }
 403
 404 static ssize_t serio_show_id_id(struct device *dev, char *buf)
 405 {
 406         struct serio *serio = to_serio_port(dev);
 407         return sprintf(buf, "%02x\n", serio->id.id);
 408 }
 409
 410 static ssize_t serio_show_id_extra(struct device *dev, char *buf)
 411 {
 412         struct serio *serio = to_serio_port(dev);
 413         return sprintf(buf, "%02x\n", serio->id.extra);
 414 }
 415
 416 static DEVICE_ATTR(type, S_IRUGO, serio_show_id_type, NULL);
 417 static DEVICE_ATTR(proto, S_IRUGO, serio_show_id_proto, NULL);
 418 static DEVICE_ATTR(id, S_IRUGO, serio_show_id_id, NULL);
 419 static DEVICE_ATTR(extra, S_IRUGO, serio_show_id_extra, NULL);
 420
 421 static struct attribute *serio_device_id_attrs[] = {
 422         &dev_attr_type.attr,
 423         &dev_attr_proto.attr,
 424         &dev_attr_id.attr,
 425         &dev_attr_extra.attr,
 426         NULL
 427 };
 428
 429 static struct attribute_group serio_id_attr_group = {
 430         .name   = "id",
 431         .attrs  = serio_device_id_attrs,
 432 };
 433
 434 static ssize_t serio_rebind_driver(struct device *dev, const char *buf, size_t count)
 435 {
 436         struct serio *serio = to_serio_port(dev);
 437         struct device_driver *drv;
 438         int retval;
 439
 440         retval = down_interruptible(&serio_sem);
 441         if (retval)
 442                 return retval;
 443
 444         retval = count;
 445         if (!strncmp(buf, "none", count)) {
 446                 serio_disconnect_port(serio);
 447         } else if (!strncmp(buf, "reconnect", count)) {
 448                 serio_reconnect_port(serio);
 449         } else if (!strncmp(buf, "rescan", count)) {
 450                 serio_disconnect_port(serio);
 451                 serio_find_driver(serio);
 452         } else if ((drv = driver_find(buf, &serio_bus)) != NULL) {
 453                 serio_disconnect_port(serio);
 454                 serio_bind_driver(serio, to_serio_driver(drv));
 455                 put_driver(drv);
 456         } else {
 457                 retval = -EINVAL;
 458         }
 459
 460         up(&serio_sem);
 461
 462         return retval;
 463 }
 464
 465 static ssize_t serio_show_bind_mode(struct device *dev, char *buf)
 466 {
 467         struct serio *serio = to_serio_port(dev);
 468         return sprintf(buf, "%s\n", serio->manual_bind ? "manual" : "auto");
 469 }
 470
 471 static ssize_t serio_set_bind_mode(struct device *dev, const char *buf, size_t count)
 472 {
 473         struct serio *serio = to_serio_port(dev);
 474         int retval;
 475
 476         retval = count;
 477         if (!strncmp(buf, "manual", count)) {
 478                 serio->manual_bind = 1;
 479         } else if (!strncmp(buf, "auto", count)) {
 480                 serio->manual_bind = 0;
 481         } else {
 482                 retval = -EINVAL;
 483         }
 484
 485         return retval;
 486 }
 487
 488 static struct device_attribute serio_device_attrs[] = {
 489         __ATTR(description, S_IRUGO, serio_show_description, NULL),
 490         __ATTR(drvctl, S_IWUSR, NULL, serio_rebind_driver),
 491         __ATTR(bind_mode, S_IWUSR | S_IRUGO, serio_show_bind_mode, serio_set_bind_mode),
 492         __ATTR_NULL
 493 };
 494
 495
 496 static void serio_release_port(struct device *dev)
 497 {
 498         struct serio *serio = to_serio_port(dev);
 499
 500         kfree(serio);
 501         module_put(THIS_MODULE);
 502 }
 503
 504 /*
 505  * Prepare serio port for registration.
 506  */
 507 static void serio_init_port(struct serio *serio)
 508 {
 509         static atomic_t serio_no = ATOMIC_INIT(0);
 510
 511         __module_get(THIS_MODULE);
 512
 513         spin_lock_init(&serio->lock);
 514         init_MUTEX(&serio->drv_sem);
 515         device_initialize(&serio->dev);
 516         snprintf(serio->dev.bus_id, sizeof(serio->dev.bus_id),
 517                  "serio%ld", (long)atomic_inc_return(&serio_no) - 1);
 518         serio->dev.bus = &serio_bus;
 519         serio->dev.release = serio_release_port;
 520         if (serio->parent)
 521                 serio->dev.parent = &serio->parent->dev;
 522 }
 523
 524 /*
 525  * Complete serio port registration.
 526  * Driver core will attempt to find appropriate driver for the port.
 527  */
 528 static void serio_add_port(struct serio *serio)
 529 {
 530         if (serio->parent) {
 531                 serio_pause_rx(serio->parent);
 532                 serio->parent->child = serio;
 533                 serio_continue_rx(serio->parent);
 534         }
 535
 536         list_add_tail(&serio->node, &serio_list);
 537         if (serio->start)
 538                 serio->start(serio);
 539         device_add(&serio->dev);
 540         sysfs_create_group(&serio->dev.kobj, &serio_id_attr_group);
 541         serio->registered = 1;
 542 }
 543
 544 /*
 545  * serio_destroy_port() completes deregistration process and removes
 546  * port from the system
 547  */
 548 static void serio_destroy_port(struct serio *serio)
 549 {
 550         struct serio *child;
 551
 552         child = serio_get_pending_child(serio);
 553         if (child) {
 554                 serio_remove_pending_events(child);
 555                 put_device(&child->dev);
 556         }
 557
 558         if (serio->stop)
 559                 serio->stop(serio);
 560
 561         if (serio->parent) {
 562                 serio_pause_rx(serio->parent);
 563                 serio->parent->child = NULL;
 564                 serio_continue_rx(serio->parent);
 565                 serio->parent = NULL;
 566         }
 567
 568         if (serio->registered) {
 569                 sysfs_remove_group(&serio->dev.kobj, &serio_id_attr_group);
 570                 device_del(&serio->dev);
 571                 list_del_init(&serio->node);
 572                 serio->registered = 0;
 573         }
 574
 575         serio_remove_pending_events(serio);
 576         put_device(&serio->dev);
 577 }
 578
 579 /*
 580  * Reconnect serio port and all its children (re-initialize attached devices)
 581  */
 582 static void serio_reconnect_port(struct serio *serio)
 583 {
 584         do {
 585                 if (serio_reconnect_driver(serio)) {
 586                         serio_disconnect_port(serio);
 587                         serio_find_driver(serio);
 588                         /* Ok, old children are now gone, we are done */
 589                         break;
 590                 }
 591                 serio = serio->child;
 592         } while (serio);
 593 }
 594
 595 /*
 596  * serio_disconnect_port() unbinds a port from its driver. As a side effect
 597  * all child ports are unbound and destroyed.
 598  */
 599 static void serio_disconnect_port(struct serio *serio)
 600 {
 601         struct serio *s, *parent;
 602
 603         if (serio->child) {
 604                 /*
 605                  * Children ports should be disconnected and destroyed
 606                  * first, staring with the leaf one, since we don't want
 607                  * to do recursion
 608                  */
 609                 for (s = serio; s->child; s = s->child)
 610                         /* empty */;
 611
 612                 do {
 613                         parent = s->parent;
 614
 615                         serio_release_driver(s);
 616                         serio_destroy_port(s);
 617                 } while ((s = parent) != serio);
 618         }
 619
 620         /*
 621          * Ok, no children left, now disconnect this port
 622          */
 623         serio_release_driver(serio);
 624 }
 625
 626 void serio_rescan(struct serio *serio)
 627 {
 628         serio_queue_event(serio, NULL, SERIO_RESCAN);
 629 }
 630
 631 void serio_reconnect(struct serio *serio)
 632 {
 633         serio_queue_event(serio, NULL, SERIO_RECONNECT);
 634 }
 635
 636 /*
 637  * Submits register request to kseriod for subsequent execution.
 638  * Note that port registration is always asynchronous.
 639  */
 640 void __serio_register_port(struct serio *serio, struct module *owner)
 641 {
 642         serio_init_port(serio);
 643         serio_queue_event(serio, owner, SERIO_REGISTER_PORT);
 644 }
 645
 646 /*
 647  * Synchronously unregisters serio port.
 648  */
 649 void serio_unregister_port(struct serio *serio)
 650 {
 651         down(&serio_sem);
 652         serio_disconnect_port(serio);
 653         serio_destroy_port(serio);
 654         up(&serio_sem);
 655 }
 656
 657 /*
 658  * Safely unregisters child port if one is present.
 659  */
 660 void serio_unregister_child_port(struct serio *serio)
 661 {
 662         down(&serio_sem);
 663         if (serio->child) {
 664                 serio_disconnect_port(serio->child);
 665                 serio_destroy_port(serio->child);
 666         }
 667         up(&serio_sem);
 668 }
 669
 670 /*
 671  * Submits register request to kseriod for subsequent execution.
 672  * Can be used when it is not obvious whether the serio_sem is
 673  * taken or not and when delayed execution is feasible.
 674  */
 675 void __serio_unregister_port_delayed(struct serio *serio, struct module *owner)
 676 {
 677         serio_queue_event(serio, owner, SERIO_UNREGISTER_PORT);
 678 }
 679
 680
 681 /*
 682  * Serio driver operations
 683  */
 684
 685 static ssize_t serio_driver_show_description(struct device_driver *drv, char *buf)
 686 {
 687         struct serio_driver *driver = to_serio_driver(drv);
 688         return sprintf(buf, "%s\n", driver->description ? driver->description : "(none)");
 689 }
 690
 691 static ssize_t serio_driver_show_bind_mode(struct device_driver *drv, char *buf)
 692 {
 693         struct serio_driver *serio_drv = to_serio_driver(drv);
 694         return sprintf(buf, "%s\n", serio_drv->manual_bind ? "manual" : "auto");
 695 }
 696
 697 static ssize_t serio_driver_set_bind_mode(struct device_driver *drv, const char *buf, size_t count)
 698 {
 699         struct serio_driver *serio_drv = to_serio_driver(drv);
 700         int retval;
 701
 702         retval = count;
 703         if (!strncmp(buf, "manual", count)) {
 704                 serio_drv->manual_bind = 1;
 705         } else if (!strncmp(buf, "auto", count)) {
 706                 serio_drv->manual_bind = 0;
 707         } else {
 708                 retval = -EINVAL;
 709         }
 710
 711         return retval;
 712 }
 713
 714
 715 static struct driver_attribute serio_driver_attrs[] = {
 716         __ATTR(description, S_IRUGO, serio_driver_show_description, NULL),
 717         __ATTR(bind_mode, S_IWUSR | S_IRUGO,
 718                 serio_driver_show_bind_mode, serio_driver_set_bind_mode),
 719         __ATTR_NULL
 720 };
 721
 722 static int serio_driver_probe(struct device *dev)
 723 {
 724         struct serio *serio = to_serio_port(dev);
 725         struct serio_driver *drv = to_serio_driver(dev->driver);
 726
 727         return serio_connect_driver(serio, drv);
 728 }
 729
 730 static int serio_driver_remove(struct device *dev)
 731 {
 732         struct serio *serio = to_serio_port(dev);
 733
 734         serio_disconnect_driver(serio);
 735         return 0;
 736 }
 737
 738 void __serio_register_driver(struct serio_driver *drv, struct module *owner)
 739 {
 740         drv->driver.bus = &serio_bus;
 741         drv->driver.probe = serio_driver_probe;
 742         drv->driver.remove = serio_driver_remove;
 743
 744         serio_queue_event(drv, owner, SERIO_REGISTER_DRIVER);
 745 }
 746
 747 void serio_unregister_driver(struct serio_driver *drv)
 748 {
 749         struct serio *serio;
 750
 751         down(&serio_sem);
 752         drv->manual_bind = 1;   /* so serio_find_driver ignores it */
 753
 754 start_over:
 755         list_for_each_entry(serio, &serio_list, node) {
 756                 if (serio->drv == drv) {
 757                         serio_disconnect_port(serio);
 758                         serio_find_driver(serio);
 759                         /* we could've deleted some ports, restart */
 760                         goto start_over;
 761                 }
 762         }
 763
 764         driver_unregister(&drv->driver);
 765         up(&serio_sem);
 766 }
 767
 768 static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
 769 {
 770         serio_pause_rx(serio);
 771         serio->drv = drv;
 772         serio_continue_rx(serio);
 773 }
 774
 775 static int serio_bus_match(struct device *dev, struct device_driver *drv)
 776 {
 777         struct serio *serio = to_serio_port(dev);
 778         struct serio_driver *serio_drv = to_serio_driver(drv);
 779
 780         if (serio->manual_bind || serio_drv->manual_bind)
 781                 return 0;
 782
 783         return serio_match_port(serio_drv->id_table, serio);
 784 }
 785
 786 #ifdef CONFIG_HOTPLUG
 787
 788 #define PUT_ENVP(fmt, val)                                              \
 789 do {                                                                    \
 790         envp[i++] = buffer;                                             \
 791         length += snprintf(buffer, buffer_size - length, fmt, val);     \
 792         if (buffer_size - length <= 0 || i >= num_envp)                 \
 793                 return -ENOMEM;                                         \
 794         length++;                                                       \
 795         buffer += length;                                               \
 796 } while (0)
 797 static int serio_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size)
 798 {
 799         struct serio *serio;
 800         int i = 0;
 801         int length = 0;
 802
 803         if (!dev)
 804                 return -ENODEV;
 805
 806         serio = to_serio_port(dev);
 807
 808         PUT_ENVP("SERIO_TYPE=%02x", serio->id.type);
 809         PUT_ENVP("SERIO_PROTO=%02x", serio->id.proto);
 810         PUT_ENVP("SERIO_ID=%02x", serio->id.id);
 811         PUT_ENVP("SERIO_EXTRA=%02x", serio->id.extra);
 812
 813         envp[i] = NULL;
 814
 815         return 0;
 816 }
 817 #undef PUT_ENVP
 818
 819 #else
 820
 821 static int serio_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size)
 822 {
 823         return -ENODEV;
 824 }
 825
 826 #endif /* CONFIG_HOTPLUG */
 827
 828 static int serio_resume(struct device *dev)
 829 {
 830         struct serio *serio = to_serio_port(dev);
 831
 832         if (serio_reconnect_driver(serio)) {
 833                 /*
 834                  * Driver re-probing can take a while, so better let kseriod
 835                  * deal with it.
 836                  */
 837                 serio_rescan(serio);
 838         }
 839
 840         return 0;
 841 }
 842
 843 /* called from serio_driver->connect/disconnect methods under serio_sem */
 844 int serio_open(struct serio *serio, struct serio_driver *drv)
 845 {
 846         serio_set_drv(serio, drv);
 847
 848         if (serio->open && serio->open(serio)) {
 849                 serio_set_drv(serio, NULL);
 850                 return -1;
 851         }
 852         return 0;
 853 }
 854
 855 /* called from serio_driver->connect/disconnect methods under serio_sem */
 856 void serio_close(struct serio *serio)
 857 {
 858         if (serio->close)
 859                 serio->close(serio);
 860
 861         serio_set_drv(serio, NULL);
 862 }
 863
 864 irqreturn_t serio_interrupt(struct serio *serio,
 865                 unsigned char data, unsigned int dfl, struct pt_regs *regs)
 866 {
 867         unsigned long flags;
 868         irqreturn_t ret = IRQ_NONE;
 869
 870         spin_lock_irqsave(&serio->lock, flags);
 871
 872         if (likely(serio->drv)) {
 873                 ret = serio->drv->interrupt(serio, data, dfl, regs);
 874         } else if (!dfl && serio->registered) {
 875                 serio_rescan(serio);
 876                 ret = IRQ_HANDLED;
 877         }
 878
 879         spin_unlock_irqrestore(&serio->lock, flags);
 880
 881         return ret;
 882 }
 883
 884 static int __init serio_init(void)
 885 {
 886         serio_task = kthread_run(serio_thread, NULL, "kseriod");
 887         if (IS_ERR(serio_task)) {
 888                 printk(KERN_ERR "serio: Failed to start kseriod\n");
 889                 return PTR_ERR(serio_task);
 890         }
 891
 892         serio_bus.dev_attrs = serio_device_attrs;
 893         serio_bus.drv_attrs = serio_driver_attrs;
 894         serio_bus.match = serio_bus_match;
 895         serio_bus.hotplug = serio_hotplug;
 896         serio_bus.resume = serio_resume;
 897         bus_register(&serio_bus);
 898
 899         return 0;
 900 }
 901
 902 static void __exit serio_exit(void)
 903 {
 904         bus_unregister(&serio_bus);
 905         kthread_stop(serio_task);
 906 }
 907
 908 module_init(serio_init);
 909 module_exit(serio_exit);