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