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