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