1/* 2 * bus.c - bus driver management 3 * 4 * Copyright (c) 2002-3 Patrick Mochel 5 * Copyright (c) 2002-3 Open Source Development Labs 6 * Copyright (c) 2007 Greg Kroah-Hartman <gregkh@suse.de> 7 * Copyright (c) 2007 Novell Inc. 8 * 9 * This file is released under the GPLv2 10 * 11 */ 12 13#include <linux/device.h> 14#include <linux/module.h> 15#include <linux/errno.h> 16#include <linux/slab.h> 17#include <linux/init.h> 18#include <linux/string.h> 19#include <linux/mutex.h> 20#include <linux/sysfs.h> 21#include "base.h" 22#include "power/power.h" 23 24/* /sys/devices/system */ 25static struct kset *system_kset; 26 27#define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr) 28 29/* 30 * sysfs bindings for drivers 31 */ 32 33#define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr) 34 35 36static int __must_check bus_rescan_devices_helper(struct device *dev, 37 void *data); 38 39static struct bus_type *bus_get(struct bus_type *bus) 40{ 41 if (bus) { 42 kset_get(&bus->p->subsys); 43 return bus; 44 } 45 return NULL; 46} 47 48static void bus_put(struct bus_type *bus) 49{ 50 if (bus) 51 kset_put(&bus->p->subsys); 52} 53 54static ssize_t drv_attr_show(struct kobject *kobj, struct attribute *attr, 55 char *buf) 56{ 57 struct driver_attribute *drv_attr = to_drv_attr(attr); 58 struct driver_private *drv_priv = to_driver(kobj); 59 ssize_t ret = -EIO; 60 61 if (drv_attr->show) 62 ret = drv_attr->show(drv_priv->driver, buf); 63 return ret; 64} 65 66static ssize_t drv_attr_store(struct kobject *kobj, struct attribute *attr, 67 const char *buf, size_t count) 68{ 69 struct driver_attribute *drv_attr = to_drv_attr(attr); 70 struct driver_private *drv_priv = to_driver(kobj); 71 ssize_t ret = -EIO; 72 73 if (drv_attr->store) 74 ret = drv_attr->store(drv_priv->driver, buf, count); 75 return ret; 76} 77 78static const struct sysfs_ops driver_sysfs_ops = { 79 .show = drv_attr_show, 80 .store = drv_attr_store, 81}; 82 83static void driver_release(struct kobject *kobj) 84{ 85 struct driver_private *drv_priv = to_driver(kobj); 86 87 pr_debug("driver: '%s': %s\n", kobject_name(kobj), __func__); 88 kfree(drv_priv); 89} 90 91static struct kobj_type driver_ktype = { 92 .sysfs_ops = &driver_sysfs_ops, 93 .release = driver_release, 94}; 95 96/* 97 * sysfs bindings for buses 98 */ 99static ssize_t bus_attr_show(struct kobject *kobj, struct attribute *attr, 100 char *buf) 101{ 102 struct bus_attribute *bus_attr = to_bus_attr(attr); 103 struct subsys_private *subsys_priv = to_subsys_private(kobj); 104 ssize_t ret = 0; 105 106 if (bus_attr->show) 107 ret = bus_attr->show(subsys_priv->bus, buf); 108 return ret; 109} 110 111static ssize_t bus_attr_store(struct kobject *kobj, struct attribute *attr, 112 const char *buf, size_t count) 113{ 114 struct bus_attribute *bus_attr = to_bus_attr(attr); 115 struct subsys_private *subsys_priv = to_subsys_private(kobj); 116 ssize_t ret = 0; 117 118 if (bus_attr->store) 119 ret = bus_attr->store(subsys_priv->bus, buf, count); 120 return ret; 121} 122 123static const struct sysfs_ops bus_sysfs_ops = { 124 .show = bus_attr_show, 125 .store = bus_attr_store, 126}; 127 128int bus_create_file(struct bus_type *bus, struct bus_attribute *attr) 129{ 130 int error; 131 if (bus_get(bus)) { 132 error = sysfs_create_file(&bus->p->subsys.kobj, &attr->attr); 133 bus_put(bus); 134 } else 135 error = -EINVAL; 136 return error; 137} 138EXPORT_SYMBOL_GPL(bus_create_file); 139 140void bus_remove_file(struct bus_type *bus, struct bus_attribute *attr) 141{ 142 if (bus_get(bus)) { 143 sysfs_remove_file(&bus->p->subsys.kobj, &attr->attr); 144 bus_put(bus); 145 } 146} 147EXPORT_SYMBOL_GPL(bus_remove_file); 148 149static void bus_release(struct kobject *kobj) 150{ 151 struct subsys_private *priv = 152 container_of(kobj, typeof(*priv), subsys.kobj); 153 struct bus_type *bus = priv->bus; 154 155 kfree(priv); 156 bus->p = NULL; 157} 158 159static struct kobj_type bus_ktype = { 160 .sysfs_ops = &bus_sysfs_ops, 161 .release = bus_release, 162}; 163 164static int bus_uevent_filter(struct kset *kset, struct kobject *kobj) 165{ 166 struct kobj_type *ktype = get_ktype(kobj); 167 168 if (ktype == &bus_ktype) 169 return 1; 170 return 0; 171} 172 173static const struct kset_uevent_ops bus_uevent_ops = { 174 .filter = bus_uevent_filter, 175}; 176 177static struct kset *bus_kset; 178 179/* Manually detach a device from its associated driver. */ 180static ssize_t unbind_store(struct device_driver *drv, const char *buf, 181 size_t count) 182{ 183 struct bus_type *bus = bus_get(drv->bus); 184 struct device *dev; 185 int err = -ENODEV; 186 187 dev = bus_find_device_by_name(bus, NULL, buf); 188 if (dev && dev->driver == drv) { 189 if (dev->parent) /* Needed for USB */ 190 device_lock(dev->parent); 191 device_release_driver(dev); 192 if (dev->parent) 193 device_unlock(dev->parent); 194 err = count; 195 } 196 put_device(dev); 197 bus_put(bus); 198 return err; 199} 200static DRIVER_ATTR_WO(unbind); 201 202/* 203 * Manually attach a device to a driver. 204 * Note: the driver must want to bind to the device, 205 * it is not possible to override the driver's id table. 206 */ 207static ssize_t bind_store(struct device_driver *drv, const char *buf, 208 size_t count) 209{ 210 struct bus_type *bus = bus_get(drv->bus); 211 struct device *dev; 212 int err = -ENODEV; 213 214 dev = bus_find_device_by_name(bus, NULL, buf); 215 if (dev && dev->driver == NULL && driver_match_device(drv, dev)) { 216 if (dev->parent) /* Needed for USB */ 217 device_lock(dev->parent); 218 device_lock(dev); 219 err = driver_probe_device(drv, dev); 220 device_unlock(dev); 221 if (dev->parent) 222 device_unlock(dev->parent); 223 224 if (err > 0) { 225 /* success */ 226 err = count; 227 } else if (err == 0) { 228 /* driver didn't accept device */ 229 err = -ENODEV; 230 } 231 } 232 put_device(dev); 233 bus_put(bus); 234 return err; 235} 236static DRIVER_ATTR_WO(bind); 237 238static ssize_t show_drivers_autoprobe(struct bus_type *bus, char *buf) 239{ 240 return sprintf(buf, "%d\n", bus->p->drivers_autoprobe); 241} 242 243static ssize_t store_drivers_autoprobe(struct bus_type *bus, 244 const char *buf, size_t count) 245{ 246 if (buf[0] == '0') 247 bus->p->drivers_autoprobe = 0; 248 else 249 bus->p->drivers_autoprobe = 1; 250 return count; 251} 252 253static ssize_t store_drivers_probe(struct bus_type *bus, 254 const char *buf, size_t count) 255{ 256 struct device *dev; 257 258 dev = bus_find_device_by_name(bus, NULL, buf); 259 if (!dev) 260 return -ENODEV; 261 if (bus_rescan_devices_helper(dev, NULL) != 0) 262 return -EINVAL; 263 return count; 264} 265 266static struct device *next_device(struct klist_iter *i) 267{ 268 struct klist_node *n = klist_next(i); 269 struct device *dev = NULL; 270 struct device_private *dev_prv; 271 272 if (n) { 273 dev_prv = to_device_private_bus(n); 274 dev = dev_prv->device; 275 } 276 return dev; 277} 278 279/** 280 * bus_for_each_dev - device iterator. 281 * @bus: bus type. 282 * @start: device to start iterating from. 283 * @data: data for the callback. 284 * @fn: function to be called for each device. 285 * 286 * Iterate over @bus's list of devices, and call @fn for each, 287 * passing it @data. If @start is not NULL, we use that device to 288 * begin iterating from. 289 * 290 * We check the return of @fn each time. If it returns anything 291 * other than 0, we break out and return that value. 292 * 293 * NOTE: The device that returns a non-zero value is not retained 294 * in any way, nor is its refcount incremented. If the caller needs 295 * to retain this data, it should do so, and increment the reference 296 * count in the supplied callback. 297 */ 298int bus_for_each_dev(struct bus_type *bus, struct device *start, 299 void *data, int (*fn)(struct device *, void *)) 300{ 301 struct klist_iter i; 302 struct device *dev; 303 int error = 0; 304 305 if (!bus || !bus->p) 306 return -EINVAL; 307 308 klist_iter_init_node(&bus->p->klist_devices, &i, 309 (start ? &start->p->knode_bus : NULL)); 310 while ((dev = next_device(&i)) && !error) 311 error = fn(dev, data); 312 klist_iter_exit(&i); 313 return error; 314} 315EXPORT_SYMBOL_GPL(bus_for_each_dev); 316 317/** 318 * bus_find_device - device iterator for locating a particular device. 319 * @bus: bus type 320 * @start: Device to begin with 321 * @data: Data to pass to match function 322 * @match: Callback function to check device 323 * 324 * This is similar to the bus_for_each_dev() function above, but it 325 * returns a reference to a device that is 'found' for later use, as 326 * determined by the @match callback. 327 * 328 * The callback should return 0 if the device doesn't match and non-zero 329 * if it does. If the callback returns non-zero, this function will 330 * return to the caller and not iterate over any more devices. 331 */ 332struct device *bus_find_device(struct bus_type *bus, 333 struct device *start, void *data, 334 int (*match)(struct device *dev, void *data)) 335{ 336 struct klist_iter i; 337 struct device *dev; 338 339 if (!bus || !bus->p) 340 return NULL; 341 342 klist_iter_init_node(&bus->p->klist_devices, &i, 343 (start ? &start->p->knode_bus : NULL)); 344 while ((dev = next_device(&i))) 345 if (match(dev, data) && get_device(dev)) 346 break; 347 klist_iter_exit(&i); 348 return dev; 349} 350EXPORT_SYMBOL_GPL(bus_find_device); 351 352static int match_name(struct device *dev, void *data) 353{ 354 const char *name = data; 355 356 return sysfs_streq(name, dev_name(dev)); 357} 358 359/** 360 * bus_find_device_by_name - device iterator for locating a particular device of a specific name 361 * @bus: bus type 362 * @start: Device to begin with 363 * @name: name of the device to match 364 * 365 * This is similar to the bus_find_device() function above, but it handles 366 * searching by a name automatically, no need to write another strcmp matching 367 * function. 368 */ 369struct device *bus_find_device_by_name(struct bus_type *bus, 370 struct device *start, const char *name) 371{ 372 return bus_find_device(bus, start, (void *)name, match_name); 373} 374EXPORT_SYMBOL_GPL(bus_find_device_by_name); 375 376/** 377 * subsys_find_device_by_id - find a device with a specific enumeration number 378 * @subsys: subsystem 379 * @id: index 'id' in struct device 380 * @hint: device to check first 381 * 382 * Check the hint's next object and if it is a match return it directly, 383 * otherwise, fall back to a full list search. Either way a reference for 384 * the returned object is taken. 385 */ 386struct device *subsys_find_device_by_id(struct bus_type *subsys, unsigned int id, 387 struct device *hint) 388{ 389 struct klist_iter i; 390 struct device *dev; 391 392 if (!subsys) 393 return NULL; 394 395 if (hint) { 396 klist_iter_init_node(&subsys->p->klist_devices, &i, &hint->p->knode_bus); 397 dev = next_device(&i); 398 if (dev && dev->id == id && get_device(dev)) { 399 klist_iter_exit(&i); 400 return dev; 401 } 402 klist_iter_exit(&i); 403 } 404 405 klist_iter_init_node(&subsys->p->klist_devices, &i, NULL); 406 while ((dev = next_device(&i))) { 407 if (dev->id == id && get_device(dev)) { 408 klist_iter_exit(&i); 409 return dev; 410 } 411 } 412 klist_iter_exit(&i); 413 return NULL; 414} 415EXPORT_SYMBOL_GPL(subsys_find_device_by_id); 416 417static struct device_driver *next_driver(struct klist_iter *i) 418{ 419 struct klist_node *n = klist_next(i); 420 struct driver_private *drv_priv; 421 422 if (n) { 423 drv_priv = container_of(n, struct driver_private, knode_bus); 424 return drv_priv->driver; 425 } 426 return NULL; 427} 428 429/** 430 * bus_for_each_drv - driver iterator 431 * @bus: bus we're dealing with. 432 * @start: driver to start iterating on. 433 * @data: data to pass to the callback. 434 * @fn: function to call for each driver. 435 * 436 * This is nearly identical to the device iterator above. 437 * We iterate over each driver that belongs to @bus, and call 438 * @fn for each. If @fn returns anything but 0, we break out 439 * and return it. If @start is not NULL, we use it as the head 440 * of the list. 441 * 442 * NOTE: we don't return the driver that returns a non-zero 443 * value, nor do we leave the reference count incremented for that 444 * driver. If the caller needs to know that info, it must set it 445 * in the callback. It must also be sure to increment the refcount 446 * so it doesn't disappear before returning to the caller. 447 */ 448int bus_for_each_drv(struct bus_type *bus, struct device_driver *start, 449 void *data, int (*fn)(struct device_driver *, void *)) 450{ 451 struct klist_iter i; 452 struct device_driver *drv; 453 int error = 0; 454 455 if (!bus) 456 return -EINVAL; 457 458 klist_iter_init_node(&bus->p->klist_drivers, &i, 459 start ? &start->p->knode_bus : NULL); 460 while ((drv = next_driver(&i)) && !error) 461 error = fn(drv, data); 462 klist_iter_exit(&i); 463 return error; 464} 465EXPORT_SYMBOL_GPL(bus_for_each_drv); 466 467static int device_add_attrs(struct bus_type *bus, struct device *dev) 468{ 469 int error = 0; 470 int i; 471 472 if (!bus->dev_attrs) 473 return 0; 474 475 for (i = 0; bus->dev_attrs[i].attr.name; i++) { 476 error = device_create_file(dev, &bus->dev_attrs[i]); 477 if (error) { 478 while (--i >= 0) 479 device_remove_file(dev, &bus->dev_attrs[i]); 480 break; 481 } 482 } 483 return error; 484} 485 486static void device_remove_attrs(struct bus_type *bus, struct device *dev) 487{ 488 int i; 489 490 if (bus->dev_attrs) { 491 for (i = 0; bus->dev_attrs[i].attr.name; i++) 492 device_remove_file(dev, &bus->dev_attrs[i]); 493 } 494} 495 496/** 497 * bus_add_device - add device to bus 498 * @dev: device being added 499 * 500 * - Add device's bus attributes. 501 * - Create links to device's bus. 502 * - Add the device to its bus's list of devices. 503 */ 504int bus_add_device(struct device *dev) 505{ 506 struct bus_type *bus = bus_get(dev->bus); 507 int error = 0; 508 509 if (bus) { 510 pr_debug("bus: '%s': add device %s\n", bus->name, dev_name(dev)); 511 error = device_add_attrs(bus, dev); 512 if (error) 513 goto out_put; 514 error = device_add_groups(dev, bus->dev_groups); 515 if (error) 516 goto out_groups; 517 error = sysfs_create_link(&bus->p->devices_kset->kobj, 518 &dev->kobj, dev_name(dev)); 519 if (error) 520 goto out_id; 521 error = sysfs_create_link(&dev->kobj, 522 &dev->bus->p->subsys.kobj, "subsystem"); 523 if (error) 524 goto out_subsys; 525 klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices); 526 } 527 return 0; 528 529out_subsys: 530 sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev)); 531out_groups: 532 device_remove_groups(dev, bus->dev_groups); 533out_id: 534 device_remove_attrs(bus, dev); 535out_put: 536 bus_put(dev->bus); 537 return error; 538} 539 540/** 541 * bus_probe_device - probe drivers for a new device 542 * @dev: device to probe 543 * 544 * - Automatically probe for a driver if the bus allows it. 545 */ 546void bus_probe_device(struct device *dev) 547{ 548 struct bus_type *bus = dev->bus; 549 struct subsys_interface *sif; 550 int ret; 551 552 if (!bus) 553 return; 554 555 if (bus->p->drivers_autoprobe) { 556 ret = device_attach(dev); 557 WARN_ON(ret < 0); 558 } 559 560 mutex_lock(&bus->p->mutex); 561 list_for_each_entry(sif, &bus->p->interfaces, node) 562 if (sif->add_dev) 563 sif->add_dev(dev, sif); 564 mutex_unlock(&bus->p->mutex); 565} 566 567/** 568 * bus_remove_device - remove device from bus 569 * @dev: device to be removed 570 * 571 * - Remove device from all interfaces. 572 * - Remove symlink from bus' directory. 573 * - Delete device from bus's list. 574 * - Detach from its driver. 575 * - Drop reference taken in bus_add_device(). 576 */ 577void bus_remove_device(struct device *dev) 578{ 579 struct bus_type *bus = dev->bus; 580 struct subsys_interface *sif; 581 582 if (!bus) 583 return; 584 585 mutex_lock(&bus->p->mutex); 586 list_for_each_entry(sif, &bus->p->interfaces, node) 587 if (sif->remove_dev) 588 sif->remove_dev(dev, sif); 589 mutex_unlock(&bus->p->mutex); 590 591 sysfs_remove_link(&dev->kobj, "subsystem"); 592 sysfs_remove_link(&dev->bus->p->devices_kset->kobj, 593 dev_name(dev)); 594 device_remove_attrs(dev->bus, dev); 595 device_remove_groups(dev, dev->bus->dev_groups); 596 if (klist_node_attached(&dev->p->knode_bus)) 597 klist_del(&dev->p->knode_bus); 598 599 pr_debug("bus: '%s': remove device %s\n", 600 dev->bus->name, dev_name(dev)); 601 device_release_driver(dev); 602 bus_put(dev->bus); 603} 604 605static int __must_check add_bind_files(struct device_driver *drv) 606{ 607 int ret; 608 609 ret = driver_create_file(drv, &driver_attr_unbind); 610 if (ret == 0) { 611 ret = driver_create_file(drv, &driver_attr_bind); 612 if (ret) 613 driver_remove_file(drv, &driver_attr_unbind); 614 } 615 return ret; 616} 617 618static void remove_bind_files(struct device_driver *drv) 619{ 620 driver_remove_file(drv, &driver_attr_bind); 621 driver_remove_file(drv, &driver_attr_unbind); 622} 623 624static BUS_ATTR(drivers_probe, S_IWUSR, NULL, store_drivers_probe); 625static BUS_ATTR(drivers_autoprobe, S_IWUSR | S_IRUGO, 626 show_drivers_autoprobe, store_drivers_autoprobe); 627 628static int add_probe_files(struct bus_type *bus) 629{ 630 int retval; 631 632 retval = bus_create_file(bus, &bus_attr_drivers_probe); 633 if (retval) 634 goto out; 635 636 retval = bus_create_file(bus, &bus_attr_drivers_autoprobe); 637 if (retval) 638 bus_remove_file(bus, &bus_attr_drivers_probe); 639out: 640 return retval; 641} 642 643static void remove_probe_files(struct bus_type *bus) 644{ 645 bus_remove_file(bus, &bus_attr_drivers_autoprobe); 646 bus_remove_file(bus, &bus_attr_drivers_probe); 647} 648 649static ssize_t uevent_store(struct device_driver *drv, const char *buf, 650 size_t count) 651{ 652 enum kobject_action action; 653 654 if (kobject_action_type(buf, count, &action) == 0) 655 kobject_uevent(&drv->p->kobj, action); 656 return count; 657} 658static DRIVER_ATTR_WO(uevent); 659 660/** 661 * bus_add_driver - Add a driver to the bus. 662 * @drv: driver. 663 */ 664int bus_add_driver(struct device_driver *drv) 665{ 666 struct bus_type *bus; 667 struct driver_private *priv; 668 int error = 0; 669 670 bus = bus_get(drv->bus); 671 if (!bus) 672 return -EINVAL; 673 674 pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name); 675 676 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 677 if (!priv) { 678 error = -ENOMEM; 679 goto out_put_bus; 680 } 681 klist_init(&priv->klist_devices, NULL, NULL); 682 priv->driver = drv; 683 drv->p = priv; 684 priv->kobj.kset = bus->p->drivers_kset; 685 error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL, 686 "%s", drv->name); 687 if (error) 688 goto out_unregister; 689 690 klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers); 691 if (drv->bus->p->drivers_autoprobe) { 692 error = driver_attach(drv); 693 if (error) 694 goto out_unregister; 695 } 696 module_add_driver(drv->owner, drv); 697 698 error = driver_create_file(drv, &driver_attr_uevent); 699 if (error) { 700 printk(KERN_ERR "%s: uevent attr (%s) failed\n", 701 __func__, drv->name); 702 } 703 error = driver_add_groups(drv, bus->drv_groups); 704 if (error) { 705 /* How the hell do we get out of this pickle? Give up */ 706 printk(KERN_ERR "%s: driver_create_groups(%s) failed\n", 707 __func__, drv->name); 708 } 709 710 if (!drv->suppress_bind_attrs) { 711 error = add_bind_files(drv); 712 if (error) { 713 /* Ditto */ 714 printk(KERN_ERR "%s: add_bind_files(%s) failed\n", 715 __func__, drv->name); 716 } 717 } 718 719 return 0; 720 721out_unregister: 722 kobject_put(&priv->kobj); 723 kfree(drv->p); 724 drv->p = NULL; 725out_put_bus: 726 bus_put(bus); 727 return error; 728} 729 730/** 731 * bus_remove_driver - delete driver from bus's knowledge. 732 * @drv: driver. 733 * 734 * Detach the driver from the devices it controls, and remove 735 * it from its bus's list of drivers. Finally, we drop the reference 736 * to the bus we took in bus_add_driver(). 737 */ 738void bus_remove_driver(struct device_driver *drv) 739{ 740 if (!drv->bus) 741 return; 742 743 if (!drv->suppress_bind_attrs) 744 remove_bind_files(drv); 745 driver_remove_groups(drv, drv->bus->drv_groups); 746 driver_remove_file(drv, &driver_attr_uevent); 747 klist_remove(&drv->p->knode_bus); 748 pr_debug("bus: '%s': remove driver %s\n", drv->bus->name, drv->name); 749 driver_detach(drv); 750 module_remove_driver(drv); 751 kobject_put(&drv->p->kobj); 752 bus_put(drv->bus); 753} 754 755/* Helper for bus_rescan_devices's iter */ 756static int __must_check bus_rescan_devices_helper(struct device *dev, 757 void *data) 758{ 759 int ret = 0; 760 761 if (!dev->driver) { 762 if (dev->parent) /* Needed for USB */ 763 device_lock(dev->parent); 764 ret = device_attach(dev); 765 if (dev->parent) 766 device_unlock(dev->parent); 767 } 768 return ret < 0 ? ret : 0; 769} 770 771/** 772 * bus_rescan_devices - rescan devices on the bus for possible drivers 773 * @bus: the bus to scan. 774 * 775 * This function will look for devices on the bus with no driver 776 * attached and rescan it against existing drivers to see if it matches 777 * any by calling device_attach() for the unbound devices. 778 */ 779int bus_rescan_devices(struct bus_type *bus) 780{ 781 return bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper); 782} 783EXPORT_SYMBOL_GPL(bus_rescan_devices); 784 785/** 786 * device_reprobe - remove driver for a device and probe for a new driver 787 * @dev: the device to reprobe 788 * 789 * This function detaches the attached driver (if any) for the given 790 * device and restarts the driver probing process. It is intended 791 * to use if probing criteria changed during a devices lifetime and 792 * driver attachment should change accordingly. 793 */ 794int device_reprobe(struct device *dev) 795{ 796 if (dev->driver) { 797 if (dev->parent) /* Needed for USB */ 798 device_lock(dev->parent); 799 device_release_driver(dev); 800 if (dev->parent) 801 device_unlock(dev->parent); 802 } 803 return bus_rescan_devices_helper(dev, NULL); 804} 805EXPORT_SYMBOL_GPL(device_reprobe); 806 807/** 808 * find_bus - locate bus by name. 809 * @name: name of bus. 810 * 811 * Call kset_find_obj() to iterate over list of buses to 812 * find a bus by name. Return bus if found. 813 * 814 * Note that kset_find_obj increments bus' reference count. 815 */ 816#if 0 817struct bus_type *find_bus(char *name) 818{ 819 struct kobject *k = kset_find_obj(bus_kset, name); 820 return k ? to_bus(k) : NULL; 821} 822#endif /* 0 */ 823 824static int bus_add_groups(struct bus_type *bus, 825 const struct attribute_group **groups) 826{ 827 return sysfs_create_groups(&bus->p->subsys.kobj, groups); 828} 829 830static void bus_remove_groups(struct bus_type *bus, 831 const struct attribute_group **groups) 832{ 833 sysfs_remove_groups(&bus->p->subsys.kobj, groups); 834} 835 836static void klist_devices_get(struct klist_node *n) 837{ 838 struct device_private *dev_prv = to_device_private_bus(n); 839 struct device *dev = dev_prv->device; 840 841 get_device(dev); 842} 843 844static void klist_devices_put(struct klist_node *n) 845{ 846 struct device_private *dev_prv = to_device_private_bus(n); 847 struct device *dev = dev_prv->device; 848 849 put_device(dev); 850} 851 852static ssize_t bus_uevent_store(struct bus_type *bus, 853 const char *buf, size_t count) 854{ 855 enum kobject_action action; 856 857 if (kobject_action_type(buf, count, &action) == 0) 858 kobject_uevent(&bus->p->subsys.kobj, action); 859 return count; 860} 861static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store); 862 863/** 864 * bus_register - register a driver-core subsystem 865 * @bus: bus to register 866 * 867 * Once we have that, we register the bus with the kobject 868 * infrastructure, then register the children subsystems it has: 869 * the devices and drivers that belong to the subsystem. 870 */ 871int bus_register(struct bus_type *bus) 872{ 873 int retval; 874 struct subsys_private *priv; 875 struct lock_class_key *key = &bus->lock_key; 876 877 priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL); 878 if (!priv) 879 return -ENOMEM; 880 881 priv->bus = bus; 882 bus->p = priv; 883 884 BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier); 885 886 retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name); 887 if (retval) 888 goto out; 889 890 priv->subsys.kobj.kset = bus_kset; 891 priv->subsys.kobj.ktype = &bus_ktype; 892 priv->drivers_autoprobe = 1; 893 894 retval = kset_register(&priv->subsys); 895 if (retval) 896 goto out; 897 898 retval = bus_create_file(bus, &bus_attr_uevent); 899 if (retval) 900 goto bus_uevent_fail; 901 902 priv->devices_kset = kset_create_and_add("devices", NULL, 903 &priv->subsys.kobj); 904 if (!priv->devices_kset) { 905 retval = -ENOMEM; 906 goto bus_devices_fail; 907 } 908 909 priv->drivers_kset = kset_create_and_add("drivers", NULL, 910 &priv->subsys.kobj); 911 if (!priv->drivers_kset) { 912 retval = -ENOMEM; 913 goto bus_drivers_fail; 914 } 915 916 INIT_LIST_HEAD(&priv->interfaces); 917 __mutex_init(&priv->mutex, "subsys mutex", key); 918 klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put); 919 klist_init(&priv->klist_drivers, NULL, NULL); 920 921 retval = add_probe_files(bus); 922 if (retval) 923 goto bus_probe_files_fail; 924 925 retval = bus_add_groups(bus, bus->bus_groups); 926 if (retval) 927 goto bus_groups_fail; 928 929 pr_debug("bus: '%s': registered\n", bus->name); 930 return 0; 931 932bus_groups_fail: 933 remove_probe_files(bus); 934bus_probe_files_fail: 935 kset_unregister(bus->p->drivers_kset); 936bus_drivers_fail: 937 kset_unregister(bus->p->devices_kset); 938bus_devices_fail: 939 bus_remove_file(bus, &bus_attr_uevent); 940bus_uevent_fail: 941 kset_unregister(&bus->p->subsys); 942out: 943 kfree(bus->p); 944 bus->p = NULL; 945 return retval; 946} 947EXPORT_SYMBOL_GPL(bus_register); 948 949/** 950 * bus_unregister - remove a bus from the system 951 * @bus: bus. 952 * 953 * Unregister the child subsystems and the bus itself. 954 * Finally, we call bus_put() to release the refcount 955 */ 956void bus_unregister(struct bus_type *bus) 957{ 958 pr_debug("bus: '%s': unregistering\n", bus->name); 959 if (bus->dev_root) 960 device_unregister(bus->dev_root); 961 bus_remove_groups(bus, bus->bus_groups); 962 remove_probe_files(bus); 963 kset_unregister(bus->p->drivers_kset); 964 kset_unregister(bus->p->devices_kset); 965 bus_remove_file(bus, &bus_attr_uevent); 966 kset_unregister(&bus->p->subsys); 967} 968EXPORT_SYMBOL_GPL(bus_unregister); 969 970int bus_register_notifier(struct bus_type *bus, struct notifier_block *nb) 971{ 972 return blocking_notifier_chain_register(&bus->p->bus_notifier, nb); 973} 974EXPORT_SYMBOL_GPL(bus_register_notifier); 975 976int bus_unregister_notifier(struct bus_type *bus, struct notifier_block *nb) 977{ 978 return blocking_notifier_chain_unregister(&bus->p->bus_notifier, nb); 979} 980EXPORT_SYMBOL_GPL(bus_unregister_notifier); 981 982struct kset *bus_get_kset(struct bus_type *bus) 983{ 984 return &bus->p->subsys; 985} 986EXPORT_SYMBOL_GPL(bus_get_kset); 987 988struct klist *bus_get_device_klist(struct bus_type *bus) 989{ 990 return &bus->p->klist_devices; 991} 992EXPORT_SYMBOL_GPL(bus_get_device_klist); 993 994/* 995 * Yes, this forcibly breaks the klist abstraction temporarily. It 996 * just wants to sort the klist, not change reference counts and 997 * take/drop locks rapidly in the process. It does all this while 998 * holding the lock for the list, so objects can't otherwise be 999 * added/removed while we're swizzling. 1000 */ 1001static void device_insertion_sort_klist(struct device *a, struct list_head *list, 1002 int (*compare)(const struct device *a, 1003 const struct device *b)) 1004{ 1005 struct list_head *pos; 1006 struct klist_node *n; 1007 struct device_private *dev_prv; 1008 struct device *b; 1009 1010 list_for_each(pos, list) { 1011 n = container_of(pos, struct klist_node, n_node); 1012 dev_prv = to_device_private_bus(n); 1013 b = dev_prv->device; 1014 if (compare(a, b) <= 0) { 1015 list_move_tail(&a->p->knode_bus.n_node, 1016 &b->p->knode_bus.n_node); 1017 return; 1018 } 1019 } 1020 list_move_tail(&a->p->knode_bus.n_node, list); 1021} 1022 1023void bus_sort_breadthfirst(struct bus_type *bus, 1024 int (*compare)(const struct device *a, 1025 const struct device *b)) 1026{ 1027 LIST_HEAD(sorted_devices); 1028 struct list_head *pos, *tmp; 1029 struct klist_node *n; 1030 struct device_private *dev_prv; 1031 struct device *dev; 1032 struct klist *device_klist; 1033 1034 device_klist = bus_get_device_klist(bus); 1035 1036 spin_lock(&device_klist->k_lock); 1037 list_for_each_safe(pos, tmp, &device_klist->k_list) { 1038 n = container_of(pos, struct klist_node, n_node); 1039 dev_prv = to_device_private_bus(n); 1040 dev = dev_prv->device; 1041 device_insertion_sort_klist(dev, &sorted_devices, compare); 1042 } 1043 list_splice(&sorted_devices, &device_klist->k_list); 1044 spin_unlock(&device_klist->k_lock); 1045} 1046EXPORT_SYMBOL_GPL(bus_sort_breadthfirst); 1047 1048/** 1049 * subsys_dev_iter_init - initialize subsys device iterator 1050 * @iter: subsys iterator to initialize 1051 * @subsys: the subsys we wanna iterate over 1052 * @start: the device to start iterating from, if any 1053 * @type: device_type of the devices to iterate over, NULL for all 1054 * 1055 * Initialize subsys iterator @iter such that it iterates over devices 1056 * of @subsys. If @start is set, the list iteration will start there, 1057 * otherwise if it is NULL, the iteration starts at the beginning of 1058 * the list. 1059 */ 1060void subsys_dev_iter_init(struct subsys_dev_iter *iter, struct bus_type *subsys, 1061 struct device *start, const struct device_type *type) 1062{ 1063 struct klist_node *start_knode = NULL; 1064 1065 if (start) 1066 start_knode = &start->p->knode_bus; 1067 klist_iter_init_node(&subsys->p->klist_devices, &iter->ki, start_knode); 1068 iter->type = type; 1069} 1070EXPORT_SYMBOL_GPL(subsys_dev_iter_init); 1071 1072/** 1073 * subsys_dev_iter_next - iterate to the next device 1074 * @iter: subsys iterator to proceed 1075 * 1076 * Proceed @iter to the next device and return it. Returns NULL if 1077 * iteration is complete. 1078 * 1079 * The returned device is referenced and won't be released till 1080 * iterator is proceed to the next device or exited. The caller is 1081 * free to do whatever it wants to do with the device including 1082 * calling back into subsys code. 1083 */ 1084struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter) 1085{ 1086 struct klist_node *knode; 1087 struct device *dev; 1088 1089 for (;;) { 1090 knode = klist_next(&iter->ki); 1091 if (!knode) 1092 return NULL; 1093 dev = container_of(knode, struct device_private, knode_bus)->device; 1094 if (!iter->type || iter->type == dev->type) 1095 return dev; 1096 } 1097} 1098EXPORT_SYMBOL_GPL(subsys_dev_iter_next); 1099 1100/** 1101 * subsys_dev_iter_exit - finish iteration 1102 * @iter: subsys iterator to finish 1103 * 1104 * Finish an iteration. Always call this function after iteration is 1105 * complete whether the iteration ran till the end or not. 1106 */ 1107void subsys_dev_iter_exit(struct subsys_dev_iter *iter) 1108{ 1109 klist_iter_exit(&iter->ki); 1110} 1111EXPORT_SYMBOL_GPL(subsys_dev_iter_exit); 1112 1113int subsys_interface_register(struct subsys_interface *sif) 1114{ 1115 struct bus_type *subsys; 1116 struct subsys_dev_iter iter; 1117 struct device *dev; 1118 1119 if (!sif || !sif->subsys) 1120 return -ENODEV; 1121 1122 subsys = bus_get(sif->subsys); 1123 if (!subsys) 1124 return -EINVAL; 1125 1126 mutex_lock(&subsys->p->mutex); 1127 list_add_tail(&sif->node, &subsys->p->interfaces); 1128 if (sif->add_dev) { 1129 subsys_dev_iter_init(&iter, subsys, NULL, NULL); 1130 while ((dev = subsys_dev_iter_next(&iter))) 1131 sif->add_dev(dev, sif); 1132 subsys_dev_iter_exit(&iter); 1133 } 1134 mutex_unlock(&subsys->p->mutex); 1135 1136 return 0; 1137} 1138EXPORT_SYMBOL_GPL(subsys_interface_register); 1139 1140void subsys_interface_unregister(struct subsys_interface *sif) 1141{ 1142 struct bus_type *subsys; 1143 struct subsys_dev_iter iter; 1144 struct device *dev; 1145 1146 if (!sif || !sif->subsys) 1147 return; 1148 1149 subsys = sif->subsys; 1150 1151 mutex_lock(&subsys->p->mutex); 1152 list_del_init(&sif->node); 1153 if (sif->remove_dev) { 1154 subsys_dev_iter_init(&iter, subsys, NULL, NULL); 1155 while ((dev = subsys_dev_iter_next(&iter))) 1156 sif->remove_dev(dev, sif); 1157 subsys_dev_iter_exit(&iter); 1158 } 1159 mutex_unlock(&subsys->p->mutex); 1160 1161 bus_put(subsys); 1162} 1163EXPORT_SYMBOL_GPL(subsys_interface_unregister); 1164 1165static void system_root_device_release(struct device *dev) 1166{ 1167 kfree(dev); 1168} 1169 1170static int subsys_register(struct bus_type *subsys, 1171 const struct attribute_group **groups, 1172 struct kobject *parent_of_root) 1173{ 1174 struct device *dev; 1175 int err; 1176 1177 err = bus_register(subsys); 1178 if (err < 0) 1179 return err; 1180 1181 dev = kzalloc(sizeof(struct device), GFP_KERNEL); 1182 if (!dev) { 1183 err = -ENOMEM; 1184 goto err_dev; 1185 } 1186 1187 err = dev_set_name(dev, "%s", subsys->name); 1188 if (err < 0) 1189 goto err_name; 1190 1191 dev->kobj.parent = parent_of_root; 1192 dev->groups = groups; 1193 dev->release = system_root_device_release; 1194 1195 err = device_register(dev); 1196 if (err < 0) 1197 goto err_dev_reg; 1198 1199 subsys->dev_root = dev; 1200 return 0; 1201 1202err_dev_reg: 1203 put_device(dev); 1204 dev = NULL; 1205err_name: 1206 kfree(dev); 1207err_dev: 1208 bus_unregister(subsys); 1209 return err; 1210} 1211 1212/** 1213 * subsys_system_register - register a subsystem at /sys/devices/system/ 1214 * @subsys: system subsystem 1215 * @groups: default attributes for the root device 1216 * 1217 * All 'system' subsystems have a /sys/devices/system/<name> root device 1218 * with the name of the subsystem. The root device can carry subsystem- 1219 * wide attributes. All registered devices are below this single root 1220 * device and are named after the subsystem with a simple enumeration 1221 * number appended. The registered devices are not explicitly named; 1222 * only 'id' in the device needs to be set. 1223 * 1224 * Do not use this interface for anything new, it exists for compatibility 1225 * with bad ideas only. New subsystems should use plain subsystems; and 1226 * add the subsystem-wide attributes should be added to the subsystem 1227 * directory itself and not some create fake root-device placed in 1228 * /sys/devices/system/<name>. 1229 */ 1230int subsys_system_register(struct bus_type *subsys, 1231 const struct attribute_group **groups) 1232{ 1233 return subsys_register(subsys, groups, &system_kset->kobj); 1234} 1235EXPORT_SYMBOL_GPL(subsys_system_register); 1236 1237/** 1238 * subsys_virtual_register - register a subsystem at /sys/devices/virtual/ 1239 * @subsys: virtual subsystem 1240 * @groups: default attributes for the root device 1241 * 1242 * All 'virtual' subsystems have a /sys/devices/system/<name> root device 1243 * with the name of the subystem. The root device can carry subsystem-wide 1244 * attributes. All registered devices are below this single root device. 1245 * There's no restriction on device naming. This is for kernel software 1246 * constructs which need sysfs interface. 1247 */ 1248int subsys_virtual_register(struct bus_type *subsys, 1249 const struct attribute_group **groups) 1250{ 1251 struct kobject *virtual_dir; 1252 1253 virtual_dir = virtual_device_parent(NULL); 1254 if (!virtual_dir) 1255 return -ENOMEM; 1256 1257 return subsys_register(subsys, groups, virtual_dir); 1258} 1259EXPORT_SYMBOL_GPL(subsys_virtual_register); 1260 1261int __init buses_init(void) 1262{ 1263 bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL); 1264 if (!bus_kset) 1265 return -ENOMEM; 1266 1267 system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj); 1268 if (!system_kset) 1269 return -ENOMEM; 1270 1271 return 0; 1272} 1273