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 #include <linux/mutex.h>
  38 #include <linux/freezer.h>
  39
  40 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
  41 MODULE_DESCRIPTION("Serio abstraction core");
  42 MODULE_LICENSE("GPL");
  43
  44 /*
  45  * serio_mutex protects entire serio subsystem and is taken every time
  46  * serio port or driver registrered or unregistered.
  47  */
  48 static DEFINE_MUTEX(serio_mutex);
  49
  50 static LIST_HEAD(serio_list);
  51
  52 static struct bus_type serio_bus;
  53
  54 static void serio_add_port(struct serio *serio);
  55 static int serio_reconnect_port(struct serio *serio);
  56 static void serio_disconnect_port(struct serio *serio);
  57 static void serio_reconnect_chain(struct serio *serio);
  58 static void serio_attach_driver(struct serio_driver *drv);
  59
  60 static int serio_connect_driver(struct serio *serio, struct serio_driver *drv)
  61 {
  62         int retval;
  63
  64         mutex_lock(&serio->drv_mutex);
  65         retval = drv->connect(serio, drv);
  66         mutex_unlock(&serio->drv_mutex);
  67
  68         return retval;
  69 }
  70
  71 static int serio_reconnect_driver(struct serio *serio)
  72 {
  73         int retval = -1;
  74
  75         mutex_lock(&serio->drv_mutex);
  76         if (serio->drv && serio->drv->reconnect)
  77                 retval = serio->drv->reconnect(serio);
  78         mutex_unlock(&serio->drv_mutex);
  79
  80         return retval;
  81 }
  82
  83 static void serio_disconnect_driver(struct serio *serio)
  84 {
  85         mutex_lock(&serio->drv_mutex);
  86         if (serio->drv)
  87                 serio->drv->disconnect(serio);
  88         mutex_unlock(&serio->drv_mutex);
  89 }
  90
  91 static int serio_match_port(const struct serio_device_id *ids, struct serio *serio)
  92 {
  93         while (ids->type || ids->proto) {
  94                 if ((ids->type == SERIO_ANY || ids->type == serio->id.type) &&
  95                     (ids->proto == SERIO_ANY || ids->proto == serio->id.proto) &&
  96                     (ids->extra == SERIO_ANY || ids->extra == serio->id.extra) &&
  97                     (ids->id == SERIO_ANY || ids->id == serio->id.id))
  98                         return 1;
  99                 ids++;
 100         }
 101         return 0;
 102 }
 103
 104 /*
 105  * Basic serio -> driver core mappings
 106  */
 107
 108 static int serio_bind_driver(struct serio *serio, struct serio_driver *drv)
 109 {
 110         int error;
 111
 112         if (serio_match_port(drv->id_table, serio)) {
 113
 114                 serio->dev.driver = &drv->driver;
 115                 if (serio_connect_driver(serio, drv)) {
 116                         serio->dev.driver = NULL;
 117                         return -ENODEV;
 118                 }
 119
 120                 error = device_bind_driver(&serio->dev);
 121                 if (error) {
 122                         printk(KERN_WARNING
 123                                 "serio: device_bind_driver() failed "
 124                                 "for %s (%s) and %s, error: %d\n",
 125                                 serio->phys, serio->name,
 126                                 drv->description, error);
 127                         serio_disconnect_driver(serio);
 128                         serio->dev.driver = NULL;
 129                         return error;
 130                 }
 131         }
 132         return 0;
 133 }
 134
 135 static void serio_find_driver(struct serio *serio)
 136 {
 137         int error;
 138
 139         error = device_attach(&serio->dev);
 140         if (error < 0)
 141                 printk(KERN_WARNING
 142                         "serio: device_attach() failed for %s (%s), error: %d\n",
 143                         serio->phys, serio->name, error);
 144 }
 145
 146
 147 /*
 148  * Serio event processing.
 149  */
 150
 151 enum serio_event_type {
 152         SERIO_RESCAN_PORT,
 153         SERIO_RECONNECT_PORT,
 154         SERIO_RECONNECT_CHAIN,
 155         SERIO_REGISTER_PORT,
 156         SERIO_ATTACH_DRIVER,
 157 };
 158
 159 struct serio_event {
 160         enum serio_event_type type;
 161         void *object;
 162         struct module *owner;
 163         struct list_head node;
 164 };
 165
 166 static DEFINE_SPINLOCK(serio_event_lock);       /* protects serio_event_list */
 167 static LIST_HEAD(serio_event_list);
 168 static DECLARE_WAIT_QUEUE_HEAD(serio_wait);
 169 static struct task_struct *serio_task;
 170
 171 static int serio_queue_event(void *object, struct module *owner,
 172                              enum serio_event_type event_type)
 173 {
 174         unsigned long flags;
 175         struct serio_event *event;
 176         int retval = 0;
 177
 178         spin_lock_irqsave(&serio_event_lock, flags);
 179
 180         /*
 181          * Scan event list for the other events for the same serio port,
 182          * starting with the most recent one. If event is the same we
 183          * do not need add new one. If event is of different type we
 184          * need to add this event and should not look further because
 185          * we need to preseve sequence of distinct events.
 186          */
 187         list_for_each_entry_reverse(event, &serio_event_list, node) {
 188                 if (event->object == object) {
 189                         if (event->type == event_type)
 190                                 goto out;
 191                         break;
 192                 }
 193         }
 194
 195         event = kmalloc(sizeof(struct serio_event), GFP_ATOMIC);
 196         if (!event) {
 197                 printk(KERN_ERR
 198                         "serio: Not enough memory to queue event %d\n",
 199                         event_type);
 200                 retval = -ENOMEM;
 201                 goto out;
 202         }
 203
 204         if (!try_module_get(owner)) {
 205                 printk(KERN_WARNING
 206                         "serio: Can't get module reference, dropping event %d\n",
 207                         event_type);
 208                 kfree(event);
 209                 retval = -EINVAL;
 210                 goto out;
 211         }
 212
 213         event->type = event_type;
 214         event->object = object;
 215         event->owner = owner;
 216
 217         list_add_tail(&event->node, &serio_event_list);
 218         wake_up(&serio_wait);
 219
 220 out:
 221         spin_unlock_irqrestore(&serio_event_lock, flags);
 222         return retval;
 223 }
 224
 225 static void serio_free_event(struct serio_event *event)
 226 {
 227         module_put(event->owner);
 228         kfree(event);
 229 }
 230
 231 static void serio_remove_duplicate_events(struct serio_event *event)
 232 {
 233         struct list_head *node, *next;
 234         struct serio_event *e;
 235         unsigned long flags;
 236
 237         spin_lock_irqsave(&serio_event_lock, flags);
 238
 239         list_for_each_safe(node, next, &serio_event_list) {
 240                 e = list_entry(node, struct serio_event, node);
 241                 if (event->object == e->object) {
 242                         /*
 243                          * If this event is of different type we should not
 244                          * look further - we only suppress duplicate events
 245                          * that were sent back-to-back.
 246                          */
 247                         if (event->type != e->type)
 248                                 break;
 249
 250                         list_del_init(node);
 251                         serio_free_event(e);
 252                 }
 253         }
 254
 255         spin_unlock_irqrestore(&serio_event_lock, flags);
 256 }
 257
 258
 259 static struct serio_event *serio_get_event(void)
 260 {
 261         struct serio_event *event;
 262         struct list_head *node;
 263         unsigned long flags;
 264
 265         spin_lock_irqsave(&serio_event_lock, flags);
 266
 267         if (list_empty(&serio_event_list)) {
 268                 spin_unlock_irqrestore(&serio_event_lock, flags);
 269                 return NULL;
 270         }
 271
 272         node = serio_event_list.next;
 273         event = list_entry(node, struct serio_event, node);
 274         list_del_init(node);
 275
 276         spin_unlock_irqrestore(&serio_event_lock, flags);
 277
 278         return event;
 279 }
 280
 281 static void serio_handle_event(void)
 282 {
 283         struct serio_event *event;
 284
 285         mutex_lock(&serio_mutex);
 286
 287         /*
 288          * Note that we handle only one event here to give swsusp
 289          * a chance to freeze kseriod thread. Serio events should
 290          * be pretty rare so we are not concerned about taking
 291          * performance hit.
 292          */
 293         if ((event = serio_get_event())) {
 294
 295                 switch (event->type) {
 296                         case SERIO_REGISTER_PORT:
 297                                 serio_add_port(event->object);
 298                                 break;
 299
 300                         case SERIO_RECONNECT_PORT:
 301                                 serio_reconnect_port(event->object);
 302                                 break;
 303
 304                         case SERIO_RESCAN_PORT:
 305                                 serio_disconnect_port(event->object);
 306                                 serio_find_driver(event->object);
 307                                 break;
 308
 309                         case SERIO_RECONNECT_CHAIN:
 310                                 serio_reconnect_chain(event->object);
 311                                 break;
 312
 313                         case SERIO_ATTACH_DRIVER:
 314                                 serio_attach_driver(event->object);
 315                                 break;
 316
 317                         default:
 318                                 break;
 319                 }
 320
 321                 serio_remove_duplicate_events(event);
 322                 serio_free_event(event);
 323         }
 324
 325         mutex_unlock(&serio_mutex);
 326 }
 327
 328 /*
 329  * Remove all events that have been submitted for a given
 330  * object, be it serio port or driver.
 331  */
 332 static void serio_remove_pending_events(void *object)
 333 {
 334         struct list_head *node, *next;
 335         struct serio_event *event;
 336         unsigned long flags;
 337
 338         spin_lock_irqsave(&serio_event_lock, flags);
 339
 340         list_for_each_safe(node, next, &serio_event_list) {
 341                 event = list_entry(node, struct serio_event, node);
 342                 if (event->object == object) {
 343                         list_del_init(node);
 344                         serio_free_event(event);
 345                 }
 346         }
 347
 348         spin_unlock_irqrestore(&serio_event_lock, flags);
 349 }
 350
 351 /*
 352  * Destroy child serio port (if any) that has not been fully registered yet.
 353  *
 354  * Note that we rely on the fact that port can have only one child and therefore
 355  * only one child registration request can be pending. Additionally, children
 356  * are registered by driver's connect() handler so there can't be a grandchild
 357  * pending registration together with a child.
 358  */
 359 static struct serio *serio_get_pending_child(struct serio *parent)
 360 {
 361         struct serio_event *event;
 362         struct serio *serio, *child = NULL;
 363         unsigned long flags;
 364
 365         spin_lock_irqsave(&serio_event_lock, flags);
 366
 367         list_for_each_entry(event, &serio_event_list, node) {
 368                 if (event->type == SERIO_REGISTER_PORT) {
 369                         serio = event->object;
 370                         if (serio->parent == parent) {
 371                                 child = serio;
 372                                 break;
 373                         }
 374                 }
 375         }
 376
 377         spin_unlock_irqrestore(&serio_event_lock, flags);
 378         return child;
 379 }
 380
 381 static int serio_thread(void *nothing)
 382 {
 383         set_freezable();
 384         do {
 385                 serio_handle_event();
 386                 wait_event_freezable(serio_wait,
 387                         kthread_should_stop() || !list_empty(&serio_event_list));
 388         } while (!kthread_should_stop());
 389
 390         printk(KERN_DEBUG "serio: kseriod exiting\n");
 391         return 0;
 392 }
 393
 394
 395 /*
 396  * Serio port operations
 397  */
 398
 399 static ssize_t serio_show_description(struct device *dev, struct device_attribute *attr, char *buf)
 400 {
 401         struct serio *serio = to_serio_port(dev);
 402         return sprintf(buf, "%s\n", serio->name);
 403 }
 404
 405 static ssize_t serio_show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
 406 {
 407         struct serio *serio = to_serio_port(dev);
 408
 409         return sprintf(buf, "serio:ty%02Xpr%02Xid%02Xex%02X\n",
 410                         serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
 411 }
 412
 413 static ssize_t serio_show_id_type(struct device *dev, struct device_attribute *attr, char *buf)
 414 {
 415         struct serio *serio = to_serio_port(dev);
 416         return sprintf(buf, "%02x\n", serio->id.type);
 417 }
 418
 419 static ssize_t serio_show_id_proto(struct device *dev, struct device_attribute *attr, char *buf)
 420 {
 421         struct serio *serio = to_serio_port(dev);
 422         return sprintf(buf, "%02x\n", serio->id.proto);
 423 }
 424
 425 static ssize_t serio_show_id_id(struct device *dev, struct device_attribute *attr, char *buf)
 426 {
 427         struct serio *serio = to_serio_port(dev);
 428         return sprintf(buf, "%02x\n", serio->id.id);
 429 }
 430
 431 static ssize_t serio_show_id_extra(struct device *dev, struct device_attribute *attr, char *buf)
 432 {
 433         struct serio *serio = to_serio_port(dev);
 434         return sprintf(buf, "%02x\n", serio->id.extra);
 435 }
 436
 437 static DEVICE_ATTR(type, S_IRUGO, serio_show_id_type, NULL);
 438 static DEVICE_ATTR(proto, S_IRUGO, serio_show_id_proto, NULL);
 439 static DEVICE_ATTR(id, S_IRUGO, serio_show_id_id, NULL);
 440 static DEVICE_ATTR(extra, S_IRUGO, serio_show_id_extra, NULL);
 441
 442 static struct attribute *serio_device_id_attrs[] = {
 443         &dev_attr_type.attr,
 444         &dev_attr_proto.attr,
 445         &dev_attr_id.attr,
 446         &dev_attr_extra.attr,
 447         NULL
 448 };
 449
 450 static struct attribute_group serio_id_attr_group = {
 451         .name   = "id",
 452         .attrs  = serio_device_id_attrs,
 453 };
 454
 455 static const struct attribute_group *serio_device_attr_groups[] = {
 456         &serio_id_attr_group,
 457         NULL
 458 };
 459
 460 static ssize_t serio_rebind_driver(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 461 {
 462         struct serio *serio = to_serio_port(dev);
 463         struct device_driver *drv;
 464         int error;
 465
 466         error = mutex_lock_interruptible(&serio_mutex);
 467         if (error)
 468                 return error;
 469
 470         if (!strncmp(buf, "none", count)) {
 471                 serio_disconnect_port(serio);
 472         } else if (!strncmp(buf, "reconnect", count)) {
 473                 serio_reconnect_chain(serio);
 474         } else if (!strncmp(buf, "rescan", count)) {
 475                 serio_disconnect_port(serio);
 476                 serio_find_driver(serio);
 477         } else if ((drv = driver_find(buf, &serio_bus)) != NULL) {
 478                 serio_disconnect_port(serio);
 479                 error = serio_bind_driver(serio, to_serio_driver(drv));
 480                 put_driver(drv);
 481         } else {
 482                 error = -EINVAL;
 483         }
 484
 485         mutex_unlock(&serio_mutex);
 486
 487         return error ? error : count;
 488 }
 489
 490 static ssize_t serio_show_bind_mode(struct device *dev, struct device_attribute *attr, char *buf)
 491 {
 492         struct serio *serio = to_serio_port(dev);
 493         return sprintf(buf, "%s\n", serio->manual_bind ? "manual" : "auto");
 494 }
 495
 496 static ssize_t serio_set_bind_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 497 {
 498         struct serio *serio = to_serio_port(dev);
 499         int retval;
 500
 501         retval = count;
 502         if (!strncmp(buf, "manual", count)) {
 503                 serio->manual_bind = true;
 504         } else if (!strncmp(buf, "auto", count)) {
 505                 serio->manual_bind = false;
 506         } else {
 507                 retval = -EINVAL;
 508         }
 509
 510         return retval;
 511 }
 512
 513 static struct device_attribute serio_device_attrs[] = {
 514         __ATTR(description, S_IRUGO, serio_show_description, NULL),
 515         __ATTR(modalias, S_IRUGO, serio_show_modalias, NULL),
 516         __ATTR(drvctl, S_IWUSR, NULL, serio_rebind_driver),
 517         __ATTR(bind_mode, S_IWUSR | S_IRUGO, serio_show_bind_mode, serio_set_bind_mode),
 518         __ATTR_NULL
 519 };
 520
 521
 522 static void serio_release_port(struct device *dev)
 523 {
 524         struct serio *serio = to_serio_port(dev);
 525
 526         kfree(serio);
 527         module_put(THIS_MODULE);
 528 }
 529
 530 /*
 531  * Prepare serio port for registration.
 532  */
 533 static void serio_init_port(struct serio *serio)
 534 {
 535         static atomic_t serio_no = ATOMIC_INIT(0);
 536
 537         __module_get(THIS_MODULE);
 538
 539         INIT_LIST_HEAD(&serio->node);
 540         spin_lock_init(&serio->lock);
 541         mutex_init(&serio->drv_mutex);
 542         device_initialize(&serio->dev);
 543         dev_set_name(&serio->dev, "serio%ld",
 544                         (long)atomic_inc_return(&serio_no) - 1);
 545         serio->dev.bus = &serio_bus;
 546         serio->dev.release = serio_release_port;
 547         serio->dev.groups = serio_device_attr_groups;
 548         if (serio->parent) {
 549                 serio->dev.parent = &serio->parent->dev;
 550                 serio->depth = serio->parent->depth + 1;
 551         } else
 552                 serio->depth = 0;
 553         lockdep_set_subclass(&serio->lock, serio->depth);
 554 }
 555
 556 /*
 557  * Complete serio port registration.
 558  * Driver core will attempt to find appropriate driver for the port.
 559  */
 560 static void serio_add_port(struct serio *serio)
 561 {
 562         int error;
 563
 564         if (serio->parent) {
 565                 serio_pause_rx(serio->parent);
 566                 serio->parent->child = serio;
 567                 serio_continue_rx(serio->parent);
 568         }
 569
 570         list_add_tail(&serio->node, &serio_list);
 571
 572         if (serio->start)
 573                 serio->start(serio);
 574
 575         error = device_add(&serio->dev);
 576         if (error)
 577                 printk(KERN_ERR
 578                         "serio: device_add() failed for %s (%s), error: %d\n",
 579                         serio->phys, serio->name, error);
 580         else
 581                 serio->registered = true;
 582 }
 583
 584 /*
 585  * serio_destroy_port() completes deregistration process and removes
 586  * port from the system
 587  */
 588 static void serio_destroy_port(struct serio *serio)
 589 {
 590         struct serio *child;
 591
 592         child = serio_get_pending_child(serio);
 593         if (child) {
 594                 serio_remove_pending_events(child);
 595                 put_device(&child->dev);
 596         }
 597
 598         if (serio->stop)
 599                 serio->stop(serio);
 600
 601         if (serio->parent) {
 602                 serio_pause_rx(serio->parent);
 603                 serio->parent->child = NULL;
 604                 serio_continue_rx(serio->parent);
 605                 serio->parent = NULL;
 606         }
 607
 608         if (serio->registered) {
 609                 device_del(&serio->dev);
 610                 serio->registered = false;
 611         }
 612
 613         list_del_init(&serio->node);
 614         serio_remove_pending_events(serio);
 615         put_device(&serio->dev);
 616 }
 617
 618 /*
 619  * Reconnect serio port (re-initialize attached device).
 620  * If reconnect fails (old device is no longer attached or
 621  * there was no device to begin with) we do full rescan in
 622  * hope of finding a driver for the port.
 623  */
 624 static int serio_reconnect_port(struct serio *serio)
 625 {
 626         int error = serio_reconnect_driver(serio);
 627
 628         if (error) {
 629                 serio_disconnect_port(serio);
 630                 serio_find_driver(serio);
 631         }
 632
 633         return error;
 634 }
 635
 636 /*
 637  * Reconnect serio port and all its children (re-initialize attached devices)
 638  */
 639 static void serio_reconnect_chain(struct serio *serio)
 640 {
 641         do {
 642                 if (serio_reconnect_port(serio)) {
 643                         /* Ok, old children are now gone, we are done */
 644                         break;
 645                 }
 646                 serio = serio->child;
 647         } while (serio);
 648 }
 649
 650 /*
 651  * serio_disconnect_port() unbinds a port from its driver. As a side effect
 652  * all child ports are unbound and destroyed.
 653  */
 654 static void serio_disconnect_port(struct serio *serio)
 655 {
 656         struct serio *s, *parent;
 657
 658         if (serio->child) {
 659                 /*
 660                  * Children ports should be disconnected and destroyed
 661                  * first, staring with the leaf one, since we don't want
 662                  * to do recursion
 663                  */
 664                 for (s = serio; s->child; s = s->child)
 665                         /* empty */;
 666
 667                 do {
 668                         parent = s->parent;
 669
 670                         device_release_driver(&s->dev);
 671                         serio_destroy_port(s);
 672                 } while ((s = parent) != serio);
 673         }
 674
 675         /*
 676          * Ok, no children left, now disconnect this port
 677          */
 678         device_release_driver(&serio->dev);
 679 }
 680
 681 void serio_rescan(struct serio *serio)
 682 {
 683         serio_queue_event(serio, NULL, SERIO_RESCAN_PORT);
 684 }
 685 EXPORT_SYMBOL(serio_rescan);
 686
 687 void serio_reconnect(struct serio *serio)
 688 {
 689         serio_queue_event(serio, NULL, SERIO_RECONNECT_CHAIN);
 690 }
 691 EXPORT_SYMBOL(serio_reconnect);
 692
 693 /*
 694  * Submits register request to kseriod for subsequent execution.
 695  * Note that port registration is always asynchronous.
 696  */
 697 void __serio_register_port(struct serio *serio, struct module *owner)
 698 {
 699         serio_init_port(serio);
 700         serio_queue_event(serio, owner, SERIO_REGISTER_PORT);
 701 }
 702 EXPORT_SYMBOL(__serio_register_port);
 703
 704 /*
 705  * Synchronously unregisters serio port.
 706  */
 707 void serio_unregister_port(struct serio *serio)
 708 {
 709         mutex_lock(&serio_mutex);
 710         serio_disconnect_port(serio);
 711         serio_destroy_port(serio);
 712         mutex_unlock(&serio_mutex);
 713 }
 714 EXPORT_SYMBOL(serio_unregister_port);
 715
 716 /*
 717  * Safely unregisters child port if one is present.
 718  */
 719 void serio_unregister_child_port(struct serio *serio)
 720 {
 721         mutex_lock(&serio_mutex);
 722         if (serio->child) {
 723                 serio_disconnect_port(serio->child);
 724                 serio_destroy_port(serio->child);
 725         }
 726         mutex_unlock(&serio_mutex);
 727 }
 728 EXPORT_SYMBOL(serio_unregister_child_port);
 729
 730
 731 /*
 732  * Serio driver operations
 733  */
 734
 735 static ssize_t serio_driver_show_description(struct device_driver *drv, char *buf)
 736 {
 737         struct serio_driver *driver = to_serio_driver(drv);
 738         return sprintf(buf, "%s\n", driver->description ? driver->description : "(none)");
 739 }
 740
 741 static ssize_t serio_driver_show_bind_mode(struct device_driver *drv, char *buf)
 742 {
 743         struct serio_driver *serio_drv = to_serio_driver(drv);
 744         return sprintf(buf, "%s\n", serio_drv->manual_bind ? "manual" : "auto");
 745 }
 746
 747 static ssize_t serio_driver_set_bind_mode(struct device_driver *drv, const char *buf, size_t count)
 748 {
 749         struct serio_driver *serio_drv = to_serio_driver(drv);
 750         int retval;
 751
 752         retval = count;
 753         if (!strncmp(buf, "manual", count)) {
 754                 serio_drv->manual_bind = true;
 755         } else if (!strncmp(buf, "auto", count)) {
 756                 serio_drv->manual_bind = false;
 757         } else {
 758                 retval = -EINVAL;
 759         }
 760
 761         return retval;
 762 }
 763
 764
 765 static struct driver_attribute serio_driver_attrs[] = {
 766         __ATTR(description, S_IRUGO, serio_driver_show_description, NULL),
 767         __ATTR(bind_mode, S_IWUSR | S_IRUGO,
 768                 serio_driver_show_bind_mode, serio_driver_set_bind_mode),
 769         __ATTR_NULL
 770 };
 771
 772 static int serio_driver_probe(struct device *dev)
 773 {
 774         struct serio *serio = to_serio_port(dev);
 775         struct serio_driver *drv = to_serio_driver(dev->driver);
 776
 777         return serio_connect_driver(serio, drv);
 778 }
 779
 780 static int serio_driver_remove(struct device *dev)
 781 {
 782         struct serio *serio = to_serio_port(dev);
 783
 784         serio_disconnect_driver(serio);
 785         return 0;
 786 }
 787
 788 static void serio_cleanup(struct serio *serio)
 789 {
 790         mutex_lock(&serio->drv_mutex);
 791         if (serio->drv && serio->drv->cleanup)
 792                 serio->drv->cleanup(serio);
 793         mutex_unlock(&serio->drv_mutex);
 794 }
 795
 796 static void serio_shutdown(struct device *dev)
 797 {
 798         struct serio *serio = to_serio_port(dev);
 799
 800         serio_cleanup(serio);
 801 }
 802
 803 static void serio_attach_driver(struct serio_driver *drv)
 804 {
 805         int error;
 806
 807         error = driver_attach(&drv->driver);
 808         if (error)
 809                 printk(KERN_WARNING
 810                         "serio: driver_attach() failed for %s with error %d\n",
 811                         drv->driver.name, error);
 812 }
 813
 814 int __serio_register_driver(struct serio_driver *drv, struct module *owner, const char *mod_name)
 815 {
 816         bool manual_bind = drv->manual_bind;
 817         int error;
 818
 819         drv->driver.bus = &serio_bus;
 820         drv->driver.owner = owner;
 821         drv->driver.mod_name = mod_name;
 822
 823         /*
 824          * Temporarily disable automatic binding because probing
 825          * takes long time and we are better off doing it in kseriod
 826          */
 827         drv->manual_bind = true;
 828
 829         error = driver_register(&drv->driver);
 830         if (error) {
 831                 printk(KERN_ERR
 832                         "serio: driver_register() failed for %s, error: %d\n",
 833                         drv->driver.name, error);
 834                 return error;
 835         }
 836
 837         /*
 838          * Restore original bind mode and let kseriod bind the
 839          * driver to free ports
 840          */
 841         if (!manual_bind) {
 842                 drv->manual_bind = false;
 843                 error = serio_queue_event(drv, NULL, SERIO_ATTACH_DRIVER);
 844                 if (error) {
 845                         driver_unregister(&drv->driver);
 846                         return error;
 847                 }
 848         }
 849
 850         return 0;
 851 }
 852 EXPORT_SYMBOL(__serio_register_driver);
 853
 854 void serio_unregister_driver(struct serio_driver *drv)
 855 {
 856         struct serio *serio;
 857
 858         mutex_lock(&serio_mutex);
 859
 860         drv->manual_bind = true;        /* so serio_find_driver ignores it */
 861         serio_remove_pending_events(drv);
 862
 863 start_over:
 864         list_for_each_entry(serio, &serio_list, node) {
 865                 if (serio->drv == drv) {
 866                         serio_disconnect_port(serio);
 867                         serio_find_driver(serio);
 868                         /* we could've deleted some ports, restart */
 869                         goto start_over;
 870                 }
 871         }
 872
 873         driver_unregister(&drv->driver);
 874         mutex_unlock(&serio_mutex);
 875 }
 876 EXPORT_SYMBOL(serio_unregister_driver);
 877
 878 static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
 879 {
 880         serio_pause_rx(serio);
 881         serio->drv = drv;
 882         serio_continue_rx(serio);
 883 }
 884
 885 static int serio_bus_match(struct device *dev, struct device_driver *drv)
 886 {
 887         struct serio *serio = to_serio_port(dev);
 888         struct serio_driver *serio_drv = to_serio_driver(drv);
 889
 890         if (serio->manual_bind || serio_drv->manual_bind)
 891                 return 0;
 892
 893         return serio_match_port(serio_drv->id_table, serio);
 894 }
 895
 896 #ifdef CONFIG_HOTPLUG
 897
 898 #define SERIO_ADD_UEVENT_VAR(fmt, val...)                               \
 899         do {                                                            \
 900                 int err = add_uevent_var(env, fmt, val);                \
 901                 if (err)                                                \
 902                         return err;                                     \
 903         } while (0)
 904
 905 static int serio_uevent(struct device *dev, struct kobj_uevent_env *env)
 906 {
 907         struct serio *serio;
 908
 909         if (!dev)
 910                 return -ENODEV;
 911
 912         serio = to_serio_port(dev);
 913
 914         SERIO_ADD_UEVENT_VAR("SERIO_TYPE=%02x", serio->id.type);
 915         SERIO_ADD_UEVENT_VAR("SERIO_PROTO=%02x", serio->id.proto);
 916         SERIO_ADD_UEVENT_VAR("SERIO_ID=%02x", serio->id.id);
 917         SERIO_ADD_UEVENT_VAR("SERIO_EXTRA=%02x", serio->id.extra);
 918         SERIO_ADD_UEVENT_VAR("MODALIAS=serio:ty%02Xpr%02Xid%02Xex%02X",
 919                                 serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
 920
 921         return 0;
 922 }
 923 #undef SERIO_ADD_UEVENT_VAR
 924
 925 #else
 926
 927 static int serio_uevent(struct device *dev, struct kobj_uevent_env *env)
 928 {
 929         return -ENODEV;
 930 }
 931
 932 #endif /* CONFIG_HOTPLUG */
 933
 934 #ifdef CONFIG_PM
 935 static int serio_suspend(struct device *dev)
 936 {
 937         struct serio *serio = to_serio_port(dev);
 938
 939         serio_cleanup(serio);
 940
 941         return 0;
 942 }
 943
 944 static int serio_resume(struct device *dev)
 945 {
 946         struct serio *serio = to_serio_port(dev);
 947
 948         /*
 949          * Driver reconnect can take a while, so better let kseriod
 950          * deal with it.
 951          */
 952         serio_queue_event(serio, NULL, SERIO_RECONNECT_PORT);
 953
 954         return 0;
 955 }
 956
 957 static const struct dev_pm_ops serio_pm_ops = {
 958         .suspend        = serio_suspend,
 959         .resume         = serio_resume,
 960         .poweroff       = serio_suspend,
 961         .restore        = serio_resume,
 962 };
 963 #endif /* CONFIG_PM */
 964
 965 /* called from serio_driver->connect/disconnect methods under serio_mutex */
 966 int serio_open(struct serio *serio, struct serio_driver *drv)
 967 {
 968         serio_set_drv(serio, drv);
 969
 970         if (serio->open && serio->open(serio)) {
 971                 serio_set_drv(serio, NULL);
 972                 return -1;
 973         }
 974         return 0;
 975 }
 976 EXPORT_SYMBOL(serio_open);
 977
 978 /* called from serio_driver->connect/disconnect methods under serio_mutex */
 979 void serio_close(struct serio *serio)
 980 {
 981         if (serio->close)
 982                 serio->close(serio);
 983
 984         serio_set_drv(serio, NULL);
 985 }
 986 EXPORT_SYMBOL(serio_close);
 987
 988 irqreturn_t serio_interrupt(struct serio *serio,
 989                 unsigned char data, unsigned int dfl)
 990 {
 991         unsigned long flags;
 992         irqreturn_t ret = IRQ_NONE;
 993
 994         spin_lock_irqsave(&serio->lock, flags);
 995
 996         if (likely(serio->drv)) {
 997                 ret = serio->drv->interrupt(serio, data, dfl);
 998         } else if (!dfl && serio->registered) {
 999                 serio_rescan(serio);
1000                 ret = IRQ_HANDLED;
1001         }
1002
1003         spin_unlock_irqrestore(&serio->lock, flags);
1004
1005         return ret;
1006 }
1007 EXPORT_SYMBOL(serio_interrupt);
1008
1009 static struct bus_type serio_bus = {
1010         .name           = "serio",
1011         .dev_attrs      = serio_device_attrs,
1012         .drv_attrs      = serio_driver_attrs,
1013         .match          = serio_bus_match,
1014         .uevent         = serio_uevent,
1015         .probe          = serio_driver_probe,
1016         .remove         = serio_driver_remove,
1017         .shutdown       = serio_shutdown,
1018 #ifdef CONFIG_PM
1019         .pm             = &serio_pm_ops,
1020 #endif
1021 };
1022
1023 static int __init serio_init(void)
1024 {
1025         int error;
1026
1027         error = bus_register(&serio_bus);
1028         if (error) {
1029                 printk(KERN_ERR "serio: failed to register serio bus, error: %d\n", error);
1030                 return error;
1031         }
1032
1033         serio_task = kthread_run(serio_thread, NULL, "kseriod");
1034         if (IS_ERR(serio_task)) {
1035                 bus_unregister(&serio_bus);
1036                 error = PTR_ERR(serio_task);
1037                 printk(KERN_ERR "serio: Failed to start kseriod, error: %d\n", error);
1038                 return error;
1039         }
1040
1041         return 0;
1042 }
1043
1044 static void __exit serio_exit(void)
1045 {
1046         bus_unregister(&serio_bus);
1047         kthread_stop(serio_task);
1048 }
1049
1050 subsys_initcall(serio_init);
1051 module_exit(serio_exit);