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();
 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, struct device_attribute *attr, 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_modalias(struct device *dev, struct device_attribute *attr, char *buf)
 393 {
 394         struct serio *serio = to_serio_port(dev);
 395
 396         return sprintf(buf, "serio:ty%02Xpr%02Xid%02Xex%02X\n",
 397                         serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
 398 }
 399
 400 static ssize_t serio_show_id_type(struct device *dev, struct device_attribute *attr, char *buf)
 401 {
 402         struct serio *serio = to_serio_port(dev);
 403         return sprintf(buf, "%02x\n", serio->id.type);
 404 }
 405
 406 static ssize_t serio_show_id_proto(struct device *dev, struct device_attribute *attr, char *buf)
 407 {
 408         struct serio *serio = to_serio_port(dev);
 409         return sprintf(buf, "%02x\n", serio->id.proto);
 410 }
 411
 412 static ssize_t serio_show_id_id(struct device *dev, struct device_attribute *attr, char *buf)
 413 {
 414         struct serio *serio = to_serio_port(dev);
 415         return sprintf(buf, "%02x\n", serio->id.id);
 416 }
 417
 418 static ssize_t serio_show_id_extra(struct device *dev, struct device_attribute *attr, char *buf)
 419 {
 420         struct serio *serio = to_serio_port(dev);
 421         return sprintf(buf, "%02x\n", serio->id.extra);
 422 }
 423
 424 static DEVICE_ATTR(type, S_IRUGO, serio_show_id_type, NULL);
 425 static DEVICE_ATTR(proto, S_IRUGO, serio_show_id_proto, NULL);
 426 static DEVICE_ATTR(id, S_IRUGO, serio_show_id_id, NULL);
 427 static DEVICE_ATTR(extra, S_IRUGO, serio_show_id_extra, NULL);
 428
 429 static struct attribute *serio_device_id_attrs[] = {
 430         &dev_attr_type.attr,
 431         &dev_attr_proto.attr,
 432         &dev_attr_id.attr,
 433         &dev_attr_extra.attr,
 434         NULL
 435 };
 436
 437 static struct attribute_group serio_id_attr_group = {
 438         .name   = "id",
 439         .attrs  = serio_device_id_attrs,
 440 };
 441
 442 static ssize_t serio_rebind_driver(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 443 {
 444         struct serio *serio = to_serio_port(dev);
 445         struct device_driver *drv;
 446         int retval;
 447
 448         retval = down_interruptible(&serio_sem);
 449         if (retval)
 450                 return retval;
 451
 452         retval = count;
 453         if (!strncmp(buf, "none", count)) {
 454                 serio_disconnect_port(serio);
 455         } else if (!strncmp(buf, "reconnect", count)) {
 456                 serio_reconnect_port(serio);
 457         } else if (!strncmp(buf, "rescan", count)) {
 458                 serio_disconnect_port(serio);
 459                 serio_find_driver(serio);
 460         } else if ((drv = driver_find(buf, &serio_bus)) != NULL) {
 461                 serio_disconnect_port(serio);
 462                 serio_bind_driver(serio, to_serio_driver(drv));
 463                 put_driver(drv);
 464         } else {
 465                 retval = -EINVAL;
 466         }
 467
 468         up(&serio_sem);
 469
 470         return retval;
 471 }
 472
 473 static ssize_t serio_show_bind_mode(struct device *dev, struct device_attribute *attr, char *buf)
 474 {
 475         struct serio *serio = to_serio_port(dev);
 476         return sprintf(buf, "%s\n", serio->manual_bind ? "manual" : "auto");
 477 }
 478
 479 static ssize_t serio_set_bind_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 480 {
 481         struct serio *serio = to_serio_port(dev);
 482         int retval;
 483
 484         retval = count;
 485         if (!strncmp(buf, "manual", count)) {
 486                 serio->manual_bind = 1;
 487         } else if (!strncmp(buf, "auto", count)) {
 488                 serio->manual_bind = 0;
 489         } else {
 490                 retval = -EINVAL;
 491         }
 492
 493         return retval;
 494 }
 495
 496 static struct device_attribute serio_device_attrs[] = {
 497         __ATTR(description, S_IRUGO, serio_show_description, NULL),
 498         __ATTR(modalias, S_IRUGO, serio_show_modalias, NULL),
 499         __ATTR(drvctl, S_IWUSR, NULL, serio_rebind_driver),
 500         __ATTR(bind_mode, S_IWUSR | S_IRUGO, serio_show_bind_mode, serio_set_bind_mode),
 501         __ATTR_NULL
 502 };
 503
 504
 505 static void serio_release_port(struct device *dev)
 506 {
 507         struct serio *serio = to_serio_port(dev);
 508
 509         kfree(serio);
 510         module_put(THIS_MODULE);
 511 }
 512
 513 /*
 514  * Prepare serio port for registration.
 515  */
 516 static void serio_init_port(struct serio *serio)
 517 {
 518         static atomic_t serio_no = ATOMIC_INIT(0);
 519
 520         __module_get(THIS_MODULE);
 521
 522         spin_lock_init(&serio->lock);
 523         init_MUTEX(&serio->drv_sem);
 524         device_initialize(&serio->dev);
 525         snprintf(serio->dev.bus_id, sizeof(serio->dev.bus_id),
 526                  "serio%ld", (long)atomic_inc_return(&serio_no) - 1);
 527         serio->dev.bus = &serio_bus;
 528         serio->dev.release = serio_release_port;
 529         if (serio->parent)
 530                 serio->dev.parent = &serio->parent->dev;
 531 }
 532
 533 /*
 534  * Complete serio port registration.
 535  * Driver core will attempt to find appropriate driver for the port.
 536  */
 537 static void serio_add_port(struct serio *serio)
 538 {
 539         if (serio->parent) {
 540                 serio_pause_rx(serio->parent);
 541                 serio->parent->child = serio;
 542                 serio_continue_rx(serio->parent);
 543         }
 544
 545         list_add_tail(&serio->node, &serio_list);
 546         if (serio->start)
 547                 serio->start(serio);
 548         device_add(&serio->dev);
 549         sysfs_create_group(&serio->dev.kobj, &serio_id_attr_group);
 550         serio->registered = 1;
 551 }
 552
 553 /*
 554  * serio_destroy_port() completes deregistration process and removes
 555  * port from the system
 556  */
 557 static void serio_destroy_port(struct serio *serio)
 558 {
 559         struct serio *child;
 560
 561         child = serio_get_pending_child(serio);
 562         if (child) {
 563                 serio_remove_pending_events(child);
 564                 put_device(&child->dev);
 565         }
 566
 567         if (serio->stop)
 568                 serio->stop(serio);
 569
 570         if (serio->parent) {
 571                 serio_pause_rx(serio->parent);
 572                 serio->parent->child = NULL;
 573                 serio_continue_rx(serio->parent);
 574                 serio->parent = NULL;
 575         }
 576
 577         if (serio->registered) {
 578                 sysfs_remove_group(&serio->dev.kobj, &serio_id_attr_group);
 579                 device_del(&serio->dev);
 580                 list_del_init(&serio->node);
 581                 serio->registered = 0;
 582         }
 583
 584         serio_remove_pending_events(serio);
 585         put_device(&serio->dev);
 586 }
 587
 588 /*
 589  * Reconnect serio port and all its children (re-initialize attached devices)
 590  */
 591 static void serio_reconnect_port(struct serio *serio)
 592 {
 593         do {
 594                 if (serio_reconnect_driver(serio)) {
 595                         serio_disconnect_port(serio);
 596                         serio_find_driver(serio);
 597                         /* Ok, old children are now gone, we are done */
 598                         break;
 599                 }
 600                 serio = serio->child;
 601         } while (serio);
 602 }
 603
 604 /*
 605  * serio_disconnect_port() unbinds a port from its driver. As a side effect
 606  * all child ports are unbound and destroyed.
 607  */
 608 static void serio_disconnect_port(struct serio *serio)
 609 {
 610         struct serio *s, *parent;
 611
 612         if (serio->child) {
 613                 /*
 614                  * Children ports should be disconnected and destroyed
 615                  * first, staring with the leaf one, since we don't want
 616                  * to do recursion
 617                  */
 618                 for (s = serio; s->child; s = s->child)
 619                         /* empty */;
 620
 621                 do {
 622                         parent = s->parent;
 623
 624                         serio_release_driver(s);
 625                         serio_destroy_port(s);
 626                 } while ((s = parent) != serio);
 627         }
 628
 629         /*
 630          * Ok, no children left, now disconnect this port
 631          */
 632         serio_release_driver(serio);
 633 }
 634
 635 void serio_rescan(struct serio *serio)
 636 {
 637         serio_queue_event(serio, NULL, SERIO_RESCAN);
 638 }
 639
 640 void serio_reconnect(struct serio *serio)
 641 {
 642         serio_queue_event(serio, NULL, SERIO_RECONNECT);
 643 }
 644
 645 /*
 646  * Submits register request to kseriod for subsequent execution.
 647  * Note that port registration is always asynchronous.
 648  */
 649 void __serio_register_port(struct serio *serio, struct module *owner)
 650 {
 651         serio_init_port(serio);
 652         serio_queue_event(serio, owner, SERIO_REGISTER_PORT);
 653 }
 654
 655 /*
 656  * Synchronously unregisters serio port.
 657  */
 658 void serio_unregister_port(struct serio *serio)
 659 {
 660         down(&serio_sem);
 661         serio_disconnect_port(serio);
 662         serio_destroy_port(serio);
 663         up(&serio_sem);
 664 }
 665
 666 /*
 667  * Safely unregisters child port if one is present.
 668  */
 669 void serio_unregister_child_port(struct serio *serio)
 670 {
 671         down(&serio_sem);
 672         if (serio->child) {
 673                 serio_disconnect_port(serio->child);
 674                 serio_destroy_port(serio->child);
 675         }
 676         up(&serio_sem);
 677 }
 678
 679 /*
 680  * Submits register request to kseriod for subsequent execution.
 681  * Can be used when it is not obvious whether the serio_sem is
 682  * taken or not and when delayed execution is feasible.
 683  */
 684 void __serio_unregister_port_delayed(struct serio *serio, struct module *owner)
 685 {
 686         serio_queue_event(serio, owner, SERIO_UNREGISTER_PORT);
 687 }
 688
 689
 690 /*
 691  * Serio driver operations
 692  */
 693
 694 static ssize_t serio_driver_show_description(struct device_driver *drv, char *buf)
 695 {
 696         struct serio_driver *driver = to_serio_driver(drv);
 697         return sprintf(buf, "%s\n", driver->description ? driver->description : "(none)");
 698 }
 699
 700 static ssize_t serio_driver_show_bind_mode(struct device_driver *drv, char *buf)
 701 {
 702         struct serio_driver *serio_drv = to_serio_driver(drv);
 703         return sprintf(buf, "%s\n", serio_drv->manual_bind ? "manual" : "auto");
 704 }
 705
 706 static ssize_t serio_driver_set_bind_mode(struct device_driver *drv, const char *buf, size_t count)
 707 {
 708         struct serio_driver *serio_drv = to_serio_driver(drv);
 709         int retval;
 710
 711         retval = count;
 712         if (!strncmp(buf, "manual", count)) {
 713                 serio_drv->manual_bind = 1;
 714         } else if (!strncmp(buf, "auto", count)) {
 715                 serio_drv->manual_bind = 0;
 716         } else {
 717                 retval = -EINVAL;
 718         }
 719
 720         return retval;
 721 }
 722
 723
 724 static struct driver_attribute serio_driver_attrs[] = {
 725         __ATTR(description, S_IRUGO, serio_driver_show_description, NULL),
 726         __ATTR(bind_mode, S_IWUSR | S_IRUGO,
 727                 serio_driver_show_bind_mode, serio_driver_set_bind_mode),
 728         __ATTR_NULL
 729 };
 730
 731 static int serio_driver_probe(struct device *dev)
 732 {
 733         struct serio *serio = to_serio_port(dev);
 734         struct serio_driver *drv = to_serio_driver(dev->driver);
 735
 736         return serio_connect_driver(serio, drv);
 737 }
 738
 739 static int serio_driver_remove(struct device *dev)
 740 {
 741         struct serio *serio = to_serio_port(dev);
 742
 743         serio_disconnect_driver(serio);
 744         return 0;
 745 }
 746
 747 void __serio_register_driver(struct serio_driver *drv, struct module *owner)
 748 {
 749         drv->driver.bus = &serio_bus;
 750         drv->driver.probe = serio_driver_probe;
 751         drv->driver.remove = serio_driver_remove;
 752
 753         serio_queue_event(drv, owner, SERIO_REGISTER_DRIVER);
 754 }
 755
 756 void serio_unregister_driver(struct serio_driver *drv)
 757 {
 758         struct serio *serio;
 759
 760         down(&serio_sem);
 761         drv->manual_bind = 1;   /* so serio_find_driver ignores it */
 762
 763 start_over:
 764         list_for_each_entry(serio, &serio_list, node) {
 765                 if (serio->drv == drv) {
 766                         serio_disconnect_port(serio);
 767                         serio_find_driver(serio);
 768                         /* we could've deleted some ports, restart */
 769                         goto start_over;
 770                 }
 771         }
 772
 773         driver_unregister(&drv->driver);
 774         up(&serio_sem);
 775 }
 776
 777 static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
 778 {
 779         serio_pause_rx(serio);
 780         serio->drv = drv;
 781         serio_continue_rx(serio);
 782 }
 783
 784 static int serio_bus_match(struct device *dev, struct device_driver *drv)
 785 {
 786         struct serio *serio = to_serio_port(dev);
 787         struct serio_driver *serio_drv = to_serio_driver(drv);
 788
 789         if (serio->manual_bind || serio_drv->manual_bind)
 790                 return 0;
 791
 792         return serio_match_port(serio_drv->id_table, serio);
 793 }
 794
 795 #ifdef CONFIG_HOTPLUG
 796
 797 #define SERIO_ADD_HOTPLUG_VAR(fmt, val...)                              \
 798         do {                                                            \
 799                 int err = add_hotplug_env_var(envp, num_envp, &i,       \
 800                                         buffer, buffer_size, &len,      \
 801                                         fmt, val);                      \
 802                 if (err)                                                \
 803                         return err;                                     \
 804         } while (0)
 805
 806 static int serio_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size)
 807 {
 808         struct serio *serio;
 809         int i = 0;
 810         int len = 0;
 811
 812         if (!dev)
 813                 return -ENODEV;
 814
 815         serio = to_serio_port(dev);
 816
 817         SERIO_ADD_HOTPLUG_VAR("SERIO_TYPE=%02x", serio->id.type);
 818         SERIO_ADD_HOTPLUG_VAR("SERIO_PROTO=%02x", serio->id.proto);
 819         SERIO_ADD_HOTPLUG_VAR("SERIO_ID=%02x", serio->id.id);
 820         SERIO_ADD_HOTPLUG_VAR("SERIO_EXTRA=%02x", serio->id.extra);
 821         SERIO_ADD_HOTPLUG_VAR("MODALIAS=serio:ty%02Xpr%02Xid%02Xex%02X",
 822                                 serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
 823         envp[i] = NULL;
 824
 825         return 0;
 826 }
 827 #undef SERIO_ADD_HOTPLUG_VAR
 828
 829 #else
 830
 831 static int serio_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size)
 832 {
 833         return -ENODEV;
 834 }
 835
 836 #endif /* CONFIG_HOTPLUG */
 837
 838 static int serio_resume(struct device *dev)
 839 {
 840         struct serio *serio = to_serio_port(dev);
 841
 842         if (serio_reconnect_driver(serio)) {
 843                 /*
 844                  * Driver re-probing can take a while, so better let kseriod
 845                  * deal with it.
 846                  */
 847                 serio_rescan(serio);
 848         }
 849
 850         return 0;
 851 }
 852
 853 /* called from serio_driver->connect/disconnect methods under serio_sem */
 854 int serio_open(struct serio *serio, struct serio_driver *drv)
 855 {
 856         serio_set_drv(serio, drv);
 857
 858         if (serio->open && serio->open(serio)) {
 859                 serio_set_drv(serio, NULL);
 860                 return -1;
 861         }
 862         return 0;
 863 }
 864
 865 /* called from serio_driver->connect/disconnect methods under serio_sem */
 866 void serio_close(struct serio *serio)
 867 {
 868         if (serio->close)
 869                 serio->close(serio);
 870
 871         serio_set_drv(serio, NULL);
 872 }
 873
 874 irqreturn_t serio_interrupt(struct serio *serio,
 875                 unsigned char data, unsigned int dfl, struct pt_regs *regs)
 876 {
 877         unsigned long flags;
 878         irqreturn_t ret = IRQ_NONE;
 879
 880         spin_lock_irqsave(&serio->lock, flags);
 881
 882         if (likely(serio->drv)) {
 883                 ret = serio->drv->interrupt(serio, data, dfl, regs);
 884         } else if (!dfl && serio->registered) {
 885                 serio_rescan(serio);
 886                 ret = IRQ_HANDLED;
 887         }
 888
 889         spin_unlock_irqrestore(&serio->lock, flags);
 890
 891         return ret;
 892 }
 893
 894 static int __init serio_init(void)
 895 {
 896         serio_task = kthread_run(serio_thread, NULL, "kseriod");
 897         if (IS_ERR(serio_task)) {
 898                 printk(KERN_ERR "serio: Failed to start kseriod\n");
 899                 return PTR_ERR(serio_task);
 900         }
 901
 902         serio_bus.dev_attrs = serio_device_attrs;
 903         serio_bus.drv_attrs = serio_driver_attrs;
 904         serio_bus.match = serio_bus_match;
 905         serio_bus.hotplug = serio_hotplug;
 906         serio_bus.resume = serio_resume;
 907         bus_register(&serio_bus);
 908
 909         return 0;
 910 }
 911
 912 static void __exit serio_exit(void)
 913 {
 914         bus_unregister(&serio_bus);
 915         kthread_stop(serio_task);
 916 }
 917
 918 module_init(serio_init);
 919 module_exit(serio_exit);