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