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/init.h> 17 #include <linux/string.h> 18 #include "base.h" 19 #include "power/power.h" 20 21 #define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr) 22 #define to_bus(obj) container_of(obj, struct bus_type_private, subsys.kobj) 23 24 /* 25 * sysfs bindings for drivers 26 */ 27 28 #define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr) 29 30 31 static int __must_check bus_rescan_devices_helper(struct device *dev, 32 void *data); 33 34 static struct bus_type *bus_get(struct bus_type *bus) 35 { 36 if (bus) { 37 kset_get(&bus->p->subsys); 38 return bus; 39 } 40 return NULL; 41 } 42 43 static void bus_put(struct bus_type *bus) 44 { 45 if (bus) 46 kset_put(&bus->p->subsys); 47 } 48 49 static ssize_t drv_attr_show(struct kobject *kobj, struct attribute *attr, 50 char *buf) 51 { 52 struct driver_attribute *drv_attr = to_drv_attr(attr); 53 struct driver_private *drv_priv = to_driver(kobj); 54 ssize_t ret = -EIO; 55 56 if (drv_attr->show) 57 ret = drv_attr->show(drv_priv->driver, buf); 58 return ret; 59 } 60 61 static ssize_t drv_attr_store(struct kobject *kobj, struct attribute *attr, 62 const char *buf, size_t count) 63 { 64 struct driver_attribute *drv_attr = to_drv_attr(attr); 65 struct driver_private *drv_priv = to_driver(kobj); 66 ssize_t ret = -EIO; 67 68 if (drv_attr->store) 69 ret = drv_attr->store(drv_priv->driver, buf, count); 70 return ret; 71 } 72 73 static struct sysfs_ops driver_sysfs_ops = { 74 .show = drv_attr_show, 75 .store = drv_attr_store, 76 }; 77 78 static void driver_release(struct kobject *kobj) 79 { 80 struct driver_private *drv_priv = to_driver(kobj); 81 82 pr_debug("driver: '%s': %s\n", kobject_name(kobj), __func__); 83 kfree(drv_priv); 84 } 85 86 static struct kobj_type driver_ktype = { 87 .sysfs_ops = &driver_sysfs_ops, 88 .release = driver_release, 89 }; 90 91 /* 92 * sysfs bindings for buses 93 */ 94 static ssize_t bus_attr_show(struct kobject *kobj, struct attribute *attr, 95 char *buf) 96 { 97 struct bus_attribute *bus_attr = to_bus_attr(attr); 98 struct bus_type_private *bus_priv = to_bus(kobj); 99 ssize_t ret = 0; 100 101 if (bus_attr->show) 102 ret = bus_attr->show(bus_priv->bus, buf); 103 return ret; 104 } 105 106 static ssize_t bus_attr_store(struct kobject *kobj, struct attribute *attr, 107 const char *buf, size_t count) 108 { 109 struct bus_attribute *bus_attr = to_bus_attr(attr); 110 struct bus_type_private *bus_priv = to_bus(kobj); 111 ssize_t ret = 0; 112 113 if (bus_attr->store) 114 ret = bus_attr->store(bus_priv->bus, buf, count); 115 return ret; 116 } 117 118 static struct sysfs_ops bus_sysfs_ops = { 119 .show = bus_attr_show, 120 .store = bus_attr_store, 121 }; 122 123 int bus_create_file(struct bus_type *bus, struct bus_attribute *attr) 124 { 125 int error; 126 if (bus_get(bus)) { 127 error = sysfs_create_file(&bus->p->subsys.kobj, &attr->attr); 128 bus_put(bus); 129 } else 130 error = -EINVAL; 131 return error; 132 } 133 EXPORT_SYMBOL_GPL(bus_create_file); 134 135 void bus_remove_file(struct bus_type *bus, struct bus_attribute *attr) 136 { 137 if (bus_get(bus)) { 138 sysfs_remove_file(&bus->p->subsys.kobj, &attr->attr); 139 bus_put(bus); 140 } 141 } 142 EXPORT_SYMBOL_GPL(bus_remove_file); 143 144 static struct kobj_type bus_ktype = { 145 .sysfs_ops = &bus_sysfs_ops, 146 }; 147 148 static int bus_uevent_filter(struct kset *kset, struct kobject *kobj) 149 { 150 struct kobj_type *ktype = get_ktype(kobj); 151 152 if (ktype == &bus_ktype) 153 return 1; 154 return 0; 155 } 156 157 static struct kset_uevent_ops bus_uevent_ops = { 158 .filter = bus_uevent_filter, 159 }; 160 161 static struct kset *bus_kset; 162 163 164 #ifdef CONFIG_HOTPLUG 165 /* Manually detach a device from its associated driver. */ 166 static ssize_t driver_unbind(struct device_driver *drv, 167 const char *buf, size_t count) 168 { 169 struct bus_type *bus = bus_get(drv->bus); 170 struct device *dev; 171 int err = -ENODEV; 172 173 dev = bus_find_device_by_name(bus, NULL, buf); 174 if (dev && dev->driver == drv) { 175 if (dev->parent) /* Needed for USB */ 176 down(&dev->parent->sem); 177 device_release_driver(dev); 178 if (dev->parent) 179 up(&dev->parent->sem); 180 err = count; 181 } 182 put_device(dev); 183 bus_put(bus); 184 return err; 185 } 186 static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind); 187 188 /* 189 * Manually attach a device to a driver. 190 * Note: the driver must want to bind to the device, 191 * it is not possible to override the driver's id table. 192 */ 193 static ssize_t driver_bind(struct device_driver *drv, 194 const char *buf, size_t count) 195 { 196 struct bus_type *bus = bus_get(drv->bus); 197 struct device *dev; 198 int err = -ENODEV; 199 200 dev = bus_find_device_by_name(bus, NULL, buf); 201 if (dev && dev->driver == NULL) { 202 if (dev->parent) /* Needed for USB */ 203 down(&dev->parent->sem); 204 down(&dev->sem); 205 err = driver_probe_device(drv, dev); 206 up(&dev->sem); 207 if (dev->parent) 208 up(&dev->parent->sem); 209 210 if (err > 0) { 211 /* success */ 212 err = count; 213 } else if (err == 0) { 214 /* driver didn't accept device */ 215 err = -ENODEV; 216 } 217 } 218 put_device(dev); 219 bus_put(bus); 220 return err; 221 } 222 static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind); 223 224 static ssize_t show_drivers_autoprobe(struct bus_type *bus, char *buf) 225 { 226 return sprintf(buf, "%d\n", bus->p->drivers_autoprobe); 227 } 228 229 static ssize_t store_drivers_autoprobe(struct bus_type *bus, 230 const char *buf, size_t count) 231 { 232 if (buf[0] == '0') 233 bus->p->drivers_autoprobe = 0; 234 else 235 bus->p->drivers_autoprobe = 1; 236 return count; 237 } 238 239 static ssize_t store_drivers_probe(struct bus_type *bus, 240 const char *buf, size_t count) 241 { 242 struct device *dev; 243 244 dev = bus_find_device_by_name(bus, NULL, buf); 245 if (!dev) 246 return -ENODEV; 247 if (bus_rescan_devices_helper(dev, NULL) != 0) 248 return -EINVAL; 249 return count; 250 } 251 #endif 252 253 static struct device *next_device(struct klist_iter *i) 254 { 255 struct klist_node *n = klist_next(i); 256 return n ? container_of(n, struct device, knode_bus) : NULL; 257 } 258 259 /** 260 * bus_for_each_dev - device iterator. 261 * @bus: bus type. 262 * @start: device to start iterating from. 263 * @data: data for the callback. 264 * @fn: function to be called for each device. 265 * 266 * Iterate over @bus's list of devices, and call @fn for each, 267 * passing it @data. If @start is not NULL, we use that device to 268 * begin iterating from. 269 * 270 * We check the return of @fn each time. If it returns anything 271 * other than 0, we break out and return that value. 272 * 273 * NOTE: The device that returns a non-zero value is not retained 274 * in any way, nor is its refcount incremented. If the caller needs 275 * to retain this data, it should do, and increment the reference 276 * count in the supplied callback. 277 */ 278 int bus_for_each_dev(struct bus_type *bus, struct device *start, 279 void *data, int (*fn)(struct device *, void *)) 280 { 281 struct klist_iter i; 282 struct device *dev; 283 int error = 0; 284 285 if (!bus) 286 return -EINVAL; 287 288 klist_iter_init_node(&bus->p->klist_devices, &i, 289 (start ? &start->knode_bus : NULL)); 290 while ((dev = next_device(&i)) && !error) 291 error = fn(dev, data); 292 klist_iter_exit(&i); 293 return error; 294 } 295 EXPORT_SYMBOL_GPL(bus_for_each_dev); 296 297 /** 298 * bus_find_device - device iterator for locating a particular device. 299 * @bus: bus type 300 * @start: Device to begin with 301 * @data: Data to pass to match function 302 * @match: Callback function to check device 303 * 304 * This is similar to the bus_for_each_dev() function above, but it 305 * returns a reference to a device that is 'found' for later use, as 306 * determined by the @match callback. 307 * 308 * The callback should return 0 if the device doesn't match and non-zero 309 * if it does. If the callback returns non-zero, this function will 310 * return to the caller and not iterate over any more devices. 311 */ 312 struct device *bus_find_device(struct bus_type *bus, 313 struct device *start, void *data, 314 int (*match)(struct device *dev, void *data)) 315 { 316 struct klist_iter i; 317 struct device *dev; 318 319 if (!bus) 320 return NULL; 321 322 klist_iter_init_node(&bus->p->klist_devices, &i, 323 (start ? &start->knode_bus : NULL)); 324 while ((dev = next_device(&i))) 325 if (match(dev, data) && get_device(dev)) 326 break; 327 klist_iter_exit(&i); 328 return dev; 329 } 330 EXPORT_SYMBOL_GPL(bus_find_device); 331 332 static int match_name(struct device *dev, void *data) 333 { 334 const char *name = data; 335 336 return sysfs_streq(name, dev->bus_id); 337 } 338 339 /** 340 * bus_find_device_by_name - device iterator for locating a particular device of a specific name 341 * @bus: bus type 342 * @start: Device to begin with 343 * @name: name of the device to match 344 * 345 * This is similar to the bus_find_device() function above, but it handles 346 * searching by a name automatically, no need to write another strcmp matching 347 * function. 348 */ 349 struct device *bus_find_device_by_name(struct bus_type *bus, 350 struct device *start, const char *name) 351 { 352 return bus_find_device(bus, start, (void *)name, match_name); 353 } 354 EXPORT_SYMBOL_GPL(bus_find_device_by_name); 355 356 static struct device_driver *next_driver(struct klist_iter *i) 357 { 358 struct klist_node *n = klist_next(i); 359 struct driver_private *drv_priv; 360 361 if (n) { 362 drv_priv = container_of(n, struct driver_private, knode_bus); 363 return drv_priv->driver; 364 } 365 return NULL; 366 } 367 368 /** 369 * bus_for_each_drv - driver iterator 370 * @bus: bus we're dealing with. 371 * @start: driver to start iterating on. 372 * @data: data to pass to the callback. 373 * @fn: function to call for each driver. 374 * 375 * This is nearly identical to the device iterator above. 376 * We iterate over each driver that belongs to @bus, and call 377 * @fn for each. If @fn returns anything but 0, we break out 378 * and return it. If @start is not NULL, we use it as the head 379 * of the list. 380 * 381 * NOTE: we don't return the driver that returns a non-zero 382 * value, nor do we leave the reference count incremented for that 383 * driver. If the caller needs to know that info, it must set it 384 * in the callback. It must also be sure to increment the refcount 385 * so it doesn't disappear before returning to the caller. 386 */ 387 int bus_for_each_drv(struct bus_type *bus, struct device_driver *start, 388 void *data, int (*fn)(struct device_driver *, void *)) 389 { 390 struct klist_iter i; 391 struct device_driver *drv; 392 int error = 0; 393 394 if (!bus) 395 return -EINVAL; 396 397 klist_iter_init_node(&bus->p->klist_drivers, &i, 398 start ? &start->p->knode_bus : NULL); 399 while ((drv = next_driver(&i)) && !error) 400 error = fn(drv, data); 401 klist_iter_exit(&i); 402 return error; 403 } 404 EXPORT_SYMBOL_GPL(bus_for_each_drv); 405 406 static int device_add_attrs(struct bus_type *bus, struct device *dev) 407 { 408 int error = 0; 409 int i; 410 411 if (!bus->dev_attrs) 412 return 0; 413 414 for (i = 0; attr_name(bus->dev_attrs[i]); i++) { 415 error = device_create_file(dev, &bus->dev_attrs[i]); 416 if (error) { 417 while (--i >= 0) 418 device_remove_file(dev, &bus->dev_attrs[i]); 419 break; 420 } 421 } 422 return error; 423 } 424 425 static void device_remove_attrs(struct bus_type *bus, struct device *dev) 426 { 427 int i; 428 429 if (bus->dev_attrs) { 430 for (i = 0; attr_name(bus->dev_attrs[i]); i++) 431 device_remove_file(dev, &bus->dev_attrs[i]); 432 } 433 } 434 435 #ifdef CONFIG_SYSFS_DEPRECATED 436 static int make_deprecated_bus_links(struct device *dev) 437 { 438 return sysfs_create_link(&dev->kobj, 439 &dev->bus->p->subsys.kobj, "bus"); 440 } 441 442 static void remove_deprecated_bus_links(struct device *dev) 443 { 444 sysfs_remove_link(&dev->kobj, "bus"); 445 } 446 #else 447 static inline int make_deprecated_bus_links(struct device *dev) { return 0; } 448 static inline void remove_deprecated_bus_links(struct device *dev) { } 449 #endif 450 451 /** 452 * bus_add_device - add device to bus 453 * @dev: device being added 454 * 455 * - Add the device to its bus's list of devices. 456 * - Create link to device's bus. 457 */ 458 int bus_add_device(struct device *dev) 459 { 460 struct bus_type *bus = bus_get(dev->bus); 461 int error = 0; 462 463 if (bus) { 464 pr_debug("bus: '%s': add device %s\n", bus->name, dev->bus_id); 465 error = device_add_attrs(bus, dev); 466 if (error) 467 goto out_put; 468 error = sysfs_create_link(&bus->p->devices_kset->kobj, 469 &dev->kobj, dev->bus_id); 470 if (error) 471 goto out_id; 472 error = sysfs_create_link(&dev->kobj, 473 &dev->bus->p->subsys.kobj, "subsystem"); 474 if (error) 475 goto out_subsys; 476 error = make_deprecated_bus_links(dev); 477 if (error) 478 goto out_deprecated; 479 } 480 return 0; 481 482 out_deprecated: 483 sysfs_remove_link(&dev->kobj, "subsystem"); 484 out_subsys: 485 sysfs_remove_link(&bus->p->devices_kset->kobj, dev->bus_id); 486 out_id: 487 device_remove_attrs(bus, dev); 488 out_put: 489 bus_put(dev->bus); 490 return error; 491 } 492 493 /** 494 * bus_attach_device - add device to bus 495 * @dev: device tried to attach to a driver 496 * 497 * - Add device to bus's list of devices. 498 * - Try to attach to driver. 499 */ 500 void bus_attach_device(struct device *dev) 501 { 502 struct bus_type *bus = dev->bus; 503 int ret = 0; 504 505 if (bus) { 506 if (bus->p->drivers_autoprobe) 507 ret = device_attach(dev); 508 WARN_ON(ret < 0); 509 if (ret >= 0) 510 klist_add_tail(&dev->knode_bus, &bus->p->klist_devices); 511 } 512 } 513 514 /** 515 * bus_remove_device - remove device from bus 516 * @dev: device to be removed 517 * 518 * - Remove symlink from bus's directory. 519 * - Delete device from bus's list. 520 * - Detach from its driver. 521 * - Drop reference taken in bus_add_device(). 522 */ 523 void bus_remove_device(struct device *dev) 524 { 525 if (dev->bus) { 526 sysfs_remove_link(&dev->kobj, "subsystem"); 527 remove_deprecated_bus_links(dev); 528 sysfs_remove_link(&dev->bus->p->devices_kset->kobj, 529 dev->bus_id); 530 device_remove_attrs(dev->bus, dev); 531 if (klist_node_attached(&dev->knode_bus)) 532 klist_del(&dev->knode_bus); 533 534 pr_debug("bus: '%s': remove device %s\n", 535 dev->bus->name, dev->bus_id); 536 device_release_driver(dev); 537 bus_put(dev->bus); 538 } 539 } 540 541 static int driver_add_attrs(struct bus_type *bus, struct device_driver *drv) 542 { 543 int error = 0; 544 int i; 545 546 if (bus->drv_attrs) { 547 for (i = 0; attr_name(bus->drv_attrs[i]); i++) { 548 error = driver_create_file(drv, &bus->drv_attrs[i]); 549 if (error) 550 goto err; 551 } 552 } 553 done: 554 return error; 555 err: 556 while (--i >= 0) 557 driver_remove_file(drv, &bus->drv_attrs[i]); 558 goto done; 559 } 560 561 static void driver_remove_attrs(struct bus_type *bus, 562 struct device_driver *drv) 563 { 564 int i; 565 566 if (bus->drv_attrs) { 567 for (i = 0; attr_name(bus->drv_attrs[i]); i++) 568 driver_remove_file(drv, &bus->drv_attrs[i]); 569 } 570 } 571 572 #ifdef CONFIG_HOTPLUG 573 /* 574 * Thanks to drivers making their tables __devinit, we can't allow manual 575 * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled. 576 */ 577 static int __must_check add_bind_files(struct device_driver *drv) 578 { 579 int ret; 580 581 ret = driver_create_file(drv, &driver_attr_unbind); 582 if (ret == 0) { 583 ret = driver_create_file(drv, &driver_attr_bind); 584 if (ret) 585 driver_remove_file(drv, &driver_attr_unbind); 586 } 587 return ret; 588 } 589 590 static void remove_bind_files(struct device_driver *drv) 591 { 592 driver_remove_file(drv, &driver_attr_bind); 593 driver_remove_file(drv, &driver_attr_unbind); 594 } 595 596 static BUS_ATTR(drivers_probe, S_IWUSR, NULL, store_drivers_probe); 597 static BUS_ATTR(drivers_autoprobe, S_IWUSR | S_IRUGO, 598 show_drivers_autoprobe, store_drivers_autoprobe); 599 600 static int add_probe_files(struct bus_type *bus) 601 { 602 int retval; 603 604 retval = bus_create_file(bus, &bus_attr_drivers_probe); 605 if (retval) 606 goto out; 607 608 retval = bus_create_file(bus, &bus_attr_drivers_autoprobe); 609 if (retval) 610 bus_remove_file(bus, &bus_attr_drivers_probe); 611 out: 612 return retval; 613 } 614 615 static void remove_probe_files(struct bus_type *bus) 616 { 617 bus_remove_file(bus, &bus_attr_drivers_autoprobe); 618 bus_remove_file(bus, &bus_attr_drivers_probe); 619 } 620 #else 621 static inline int add_bind_files(struct device_driver *drv) { return 0; } 622 static inline void remove_bind_files(struct device_driver *drv) {} 623 static inline int add_probe_files(struct bus_type *bus) { return 0; } 624 static inline void remove_probe_files(struct bus_type *bus) {} 625 #endif 626 627 static ssize_t driver_uevent_store(struct device_driver *drv, 628 const char *buf, size_t count) 629 { 630 enum kobject_action action; 631 632 if (kobject_action_type(buf, count, &action) == 0) 633 kobject_uevent(&drv->p->kobj, action); 634 return count; 635 } 636 static DRIVER_ATTR(uevent, S_IWUSR, NULL, driver_uevent_store); 637 638 /** 639 * bus_add_driver - Add a driver to the bus. 640 * @drv: driver. 641 */ 642 int bus_add_driver(struct device_driver *drv) 643 { 644 struct bus_type *bus; 645 struct driver_private *priv; 646 int error = 0; 647 648 bus = bus_get(drv->bus); 649 if (!bus) 650 return -EINVAL; 651 652 pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name); 653 654 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 655 if (!priv) { 656 error = -ENOMEM; 657 goto out_put_bus; 658 } 659 klist_init(&priv->klist_devices, NULL, NULL); 660 priv->driver = drv; 661 drv->p = priv; 662 priv->kobj.kset = bus->p->drivers_kset; 663 error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL, 664 "%s", drv->name); 665 if (error) 666 goto out_unregister; 667 668 if (drv->bus->p->drivers_autoprobe) { 669 error = driver_attach(drv); 670 if (error) 671 goto out_unregister; 672 } 673 klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers); 674 module_add_driver(drv->owner, drv); 675 676 error = driver_create_file(drv, &driver_attr_uevent); 677 if (error) { 678 printk(KERN_ERR "%s: uevent attr (%s) failed\n", 679 __func__, drv->name); 680 } 681 error = driver_add_attrs(bus, drv); 682 if (error) { 683 /* How the hell do we get out of this pickle? Give up */ 684 printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n", 685 __func__, drv->name); 686 } 687 error = add_bind_files(drv); 688 if (error) { 689 /* Ditto */ 690 printk(KERN_ERR "%s: add_bind_files(%s) failed\n", 691 __func__, drv->name); 692 } 693 694 kobject_uevent(&priv->kobj, KOBJ_ADD); 695 return error; 696 out_unregister: 697 kobject_put(&priv->kobj); 698 out_put_bus: 699 bus_put(bus); 700 return error; 701 } 702 703 /** 704 * bus_remove_driver - delete driver from bus's knowledge. 705 * @drv: driver. 706 * 707 * Detach the driver from the devices it controls, and remove 708 * it from its bus's list of drivers. Finally, we drop the reference 709 * to the bus we took in bus_add_driver(). 710 */ 711 void bus_remove_driver(struct device_driver *drv) 712 { 713 if (!drv->bus) 714 return; 715 716 remove_bind_files(drv); 717 driver_remove_attrs(drv->bus, drv); 718 driver_remove_file(drv, &driver_attr_uevent); 719 klist_remove(&drv->p->knode_bus); 720 pr_debug("bus: '%s': remove driver %s\n", drv->bus->name, drv->name); 721 driver_detach(drv); 722 module_remove_driver(drv); 723 kobject_put(&drv->p->kobj); 724 bus_put(drv->bus); 725 } 726 727 /* Helper for bus_rescan_devices's iter */ 728 static int __must_check bus_rescan_devices_helper(struct device *dev, 729 void *data) 730 { 731 int ret = 0; 732 733 if (!dev->driver) { 734 if (dev->parent) /* Needed for USB */ 735 down(&dev->parent->sem); 736 ret = device_attach(dev); 737 if (dev->parent) 738 up(&dev->parent->sem); 739 } 740 return ret < 0 ? ret : 0; 741 } 742 743 /** 744 * bus_rescan_devices - rescan devices on the bus for possible drivers 745 * @bus: the bus to scan. 746 * 747 * This function will look for devices on the bus with no driver 748 * attached and rescan it against existing drivers to see if it matches 749 * any by calling device_attach() for the unbound devices. 750 */ 751 int bus_rescan_devices(struct bus_type *bus) 752 { 753 return bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper); 754 } 755 EXPORT_SYMBOL_GPL(bus_rescan_devices); 756 757 /** 758 * device_reprobe - remove driver for a device and probe for a new driver 759 * @dev: the device to reprobe 760 * 761 * This function detaches the attached driver (if any) for the given 762 * device and restarts the driver probing process. It is intended 763 * to use if probing criteria changed during a devices lifetime and 764 * driver attachment should change accordingly. 765 */ 766 int device_reprobe(struct device *dev) 767 { 768 if (dev->driver) { 769 if (dev->parent) /* Needed for USB */ 770 down(&dev->parent->sem); 771 device_release_driver(dev); 772 if (dev->parent) 773 up(&dev->parent->sem); 774 } 775 return bus_rescan_devices_helper(dev, NULL); 776 } 777 EXPORT_SYMBOL_GPL(device_reprobe); 778 779 /** 780 * find_bus - locate bus by name. 781 * @name: name of bus. 782 * 783 * Call kset_find_obj() to iterate over list of buses to 784 * find a bus by name. Return bus if found. 785 * 786 * Note that kset_find_obj increments bus' reference count. 787 */ 788 #if 0 789 struct bus_type *find_bus(char *name) 790 { 791 struct kobject *k = kset_find_obj(bus_kset, name); 792 return k ? to_bus(k) : NULL; 793 } 794 #endif /* 0 */ 795 796 797 /** 798 * bus_add_attrs - Add default attributes for this bus. 799 * @bus: Bus that has just been registered. 800 */ 801 802 static int bus_add_attrs(struct bus_type *bus) 803 { 804 int error = 0; 805 int i; 806 807 if (bus->bus_attrs) { 808 for (i = 0; attr_name(bus->bus_attrs[i]); i++) { 809 error = bus_create_file(bus, &bus->bus_attrs[i]); 810 if (error) 811 goto err; 812 } 813 } 814 done: 815 return error; 816 err: 817 while (--i >= 0) 818 bus_remove_file(bus, &bus->bus_attrs[i]); 819 goto done; 820 } 821 822 static void bus_remove_attrs(struct bus_type *bus) 823 { 824 int i; 825 826 if (bus->bus_attrs) { 827 for (i = 0; attr_name(bus->bus_attrs[i]); i++) 828 bus_remove_file(bus, &bus->bus_attrs[i]); 829 } 830 } 831 832 static void klist_devices_get(struct klist_node *n) 833 { 834 struct device *dev = container_of(n, struct device, knode_bus); 835 836 get_device(dev); 837 } 838 839 static void klist_devices_put(struct klist_node *n) 840 { 841 struct device *dev = container_of(n, struct device, knode_bus); 842 843 put_device(dev); 844 } 845 846 static ssize_t bus_uevent_store(struct bus_type *bus, 847 const char *buf, size_t count) 848 { 849 enum kobject_action action; 850 851 if (kobject_action_type(buf, count, &action) == 0) 852 kobject_uevent(&bus->p->subsys.kobj, action); 853 return count; 854 } 855 static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store); 856 857 /** 858 * bus_register - register a bus with the system. 859 * @bus: bus. 860 * 861 * Once we have that, we registered the bus with the kobject 862 * infrastructure, then register the children subsystems it has: 863 * the devices and drivers that belong to the bus. 864 */ 865 int bus_register(struct bus_type *bus) 866 { 867 int retval; 868 struct bus_type_private *priv; 869 870 priv = kzalloc(sizeof(struct bus_type_private), GFP_KERNEL); 871 if (!priv) 872 return -ENOMEM; 873 874 priv->bus = bus; 875 bus->p = priv; 876 877 BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier); 878 879 retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name); 880 if (retval) 881 goto out; 882 883 priv->subsys.kobj.kset = bus_kset; 884 priv->subsys.kobj.ktype = &bus_ktype; 885 priv->drivers_autoprobe = 1; 886 887 retval = kset_register(&priv->subsys); 888 if (retval) 889 goto out; 890 891 retval = bus_create_file(bus, &bus_attr_uevent); 892 if (retval) 893 goto bus_uevent_fail; 894 895 priv->devices_kset = kset_create_and_add("devices", NULL, 896 &priv->subsys.kobj); 897 if (!priv->devices_kset) { 898 retval = -ENOMEM; 899 goto bus_devices_fail; 900 } 901 902 priv->drivers_kset = kset_create_and_add("drivers", NULL, 903 &priv->subsys.kobj); 904 if (!priv->drivers_kset) { 905 retval = -ENOMEM; 906 goto bus_drivers_fail; 907 } 908 909 klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put); 910 klist_init(&priv->klist_drivers, NULL, NULL); 911 912 retval = add_probe_files(bus); 913 if (retval) 914 goto bus_probe_files_fail; 915 916 retval = bus_add_attrs(bus); 917 if (retval) 918 goto bus_attrs_fail; 919 920 pr_debug("bus: '%s': registered\n", bus->name); 921 return 0; 922 923 bus_attrs_fail: 924 remove_probe_files(bus); 925 bus_probe_files_fail: 926 kset_unregister(bus->p->drivers_kset); 927 bus_drivers_fail: 928 kset_unregister(bus->p->devices_kset); 929 bus_devices_fail: 930 bus_remove_file(bus, &bus_attr_uevent); 931 bus_uevent_fail: 932 kset_unregister(&bus->p->subsys); 933 kfree(bus->p); 934 out: 935 return retval; 936 } 937 EXPORT_SYMBOL_GPL(bus_register); 938 939 /** 940 * bus_unregister - remove a bus from the system 941 * @bus: bus. 942 * 943 * Unregister the child subsystems and the bus itself. 944 * Finally, we call bus_put() to release the refcount 945 */ 946 void bus_unregister(struct bus_type *bus) 947 { 948 pr_debug("bus: '%s': unregistering\n", bus->name); 949 bus_remove_attrs(bus); 950 remove_probe_files(bus); 951 kset_unregister(bus->p->drivers_kset); 952 kset_unregister(bus->p->devices_kset); 953 bus_remove_file(bus, &bus_attr_uevent); 954 kset_unregister(&bus->p->subsys); 955 kfree(bus->p); 956 } 957 EXPORT_SYMBOL_GPL(bus_unregister); 958 959 int bus_register_notifier(struct bus_type *bus, struct notifier_block *nb) 960 { 961 return blocking_notifier_chain_register(&bus->p->bus_notifier, nb); 962 } 963 EXPORT_SYMBOL_GPL(bus_register_notifier); 964 965 int bus_unregister_notifier(struct bus_type *bus, struct notifier_block *nb) 966 { 967 return blocking_notifier_chain_unregister(&bus->p->bus_notifier, nb); 968 } 969 EXPORT_SYMBOL_GPL(bus_unregister_notifier); 970 971 struct kset *bus_get_kset(struct bus_type *bus) 972 { 973 return &bus->p->subsys; 974 } 975 EXPORT_SYMBOL_GPL(bus_get_kset); 976 977 struct klist *bus_get_device_klist(struct bus_type *bus) 978 { 979 return &bus->p->klist_devices; 980 } 981 EXPORT_SYMBOL_GPL(bus_get_device_klist); 982 983 /* 984 * Yes, this forcably breaks the klist abstraction temporarily. It 985 * just wants to sort the klist, not change reference counts and 986 * take/drop locks rapidly in the process. It does all this while 987 * holding the lock for the list, so objects can't otherwise be 988 * added/removed while we're swizzling. 989 */ 990 static void device_insertion_sort_klist(struct device *a, struct list_head *list, 991 int (*compare)(const struct device *a, 992 const struct device *b)) 993 { 994 struct list_head *pos; 995 struct klist_node *n; 996 struct device *b; 997 998 list_for_each(pos, list) { 999 n = container_of(pos, struct klist_node, n_node); 1000 b = container_of(n, struct device, knode_bus); 1001 if (compare(a, b) <= 0) { 1002 list_move_tail(&a->knode_bus.n_node, 1003 &b->knode_bus.n_node); 1004 return; 1005 } 1006 } 1007 list_move_tail(&a->knode_bus.n_node, list); 1008 } 1009 1010 void bus_sort_breadthfirst(struct bus_type *bus, 1011 int (*compare)(const struct device *a, 1012 const struct device *b)) 1013 { 1014 LIST_HEAD(sorted_devices); 1015 struct list_head *pos, *tmp; 1016 struct klist_node *n; 1017 struct device *dev; 1018 struct klist *device_klist; 1019 1020 device_klist = bus_get_device_klist(bus); 1021 1022 spin_lock(&device_klist->k_lock); 1023 list_for_each_safe(pos, tmp, &device_klist->k_list) { 1024 n = container_of(pos, struct klist_node, n_node); 1025 dev = container_of(n, struct device, knode_bus); 1026 device_insertion_sort_klist(dev, &sorted_devices, compare); 1027 } 1028 list_splice(&sorted_devices, &device_klist->k_list); 1029 spin_unlock(&device_klist->k_lock); 1030 } 1031 EXPORT_SYMBOL_GPL(bus_sort_breadthfirst); 1032 1033 int __init buses_init(void) 1034 { 1035 bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL); 1036 if (!bus_kset) 1037 return -ENOMEM; 1038 return 0; 1039 } 1040