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