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 && driver_match_device(drv, dev)) { 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 struct device *dev = NULL; 257 struct device_private *dev_prv; 258 259 if (n) { 260 dev_prv = to_device_private_bus(n); 261 dev = dev_prv->device; 262 } 263 return dev; 264 } 265 266 /** 267 * bus_for_each_dev - device iterator. 268 * @bus: bus type. 269 * @start: device to start iterating from. 270 * @data: data for the callback. 271 * @fn: function to be called for each device. 272 * 273 * Iterate over @bus's list of devices, and call @fn for each, 274 * passing it @data. If @start is not NULL, we use that device to 275 * begin iterating from. 276 * 277 * We check the return of @fn each time. If it returns anything 278 * other than 0, we break out and return that value. 279 * 280 * NOTE: The device that returns a non-zero value is not retained 281 * in any way, nor is its refcount incremented. If the caller needs 282 * to retain this data, it should do so, and increment the reference 283 * count in the supplied callback. 284 */ 285 int bus_for_each_dev(struct bus_type *bus, struct device *start, 286 void *data, int (*fn)(struct device *, void *)) 287 { 288 struct klist_iter i; 289 struct device *dev; 290 int error = 0; 291 292 if (!bus) 293 return -EINVAL; 294 295 klist_iter_init_node(&bus->p->klist_devices, &i, 296 (start ? &start->p->knode_bus : NULL)); 297 while ((dev = next_device(&i)) && !error) 298 error = fn(dev, data); 299 klist_iter_exit(&i); 300 return error; 301 } 302 EXPORT_SYMBOL_GPL(bus_for_each_dev); 303 304 /** 305 * bus_find_device - device iterator for locating a particular device. 306 * @bus: bus type 307 * @start: Device to begin with 308 * @data: Data to pass to match function 309 * @match: Callback function to check device 310 * 311 * This is similar to the bus_for_each_dev() function above, but it 312 * returns a reference to a device that is 'found' for later use, as 313 * determined by the @match callback. 314 * 315 * The callback should return 0 if the device doesn't match and non-zero 316 * if it does. If the callback returns non-zero, this function will 317 * return to the caller and not iterate over any more devices. 318 */ 319 struct device *bus_find_device(struct bus_type *bus, 320 struct device *start, void *data, 321 int (*match)(struct device *dev, void *data)) 322 { 323 struct klist_iter i; 324 struct device *dev; 325 326 if (!bus) 327 return NULL; 328 329 klist_iter_init_node(&bus->p->klist_devices, &i, 330 (start ? &start->p->knode_bus : NULL)); 331 while ((dev = next_device(&i))) 332 if (match(dev, data) && get_device(dev)) 333 break; 334 klist_iter_exit(&i); 335 return dev; 336 } 337 EXPORT_SYMBOL_GPL(bus_find_device); 338 339 static int match_name(struct device *dev, void *data) 340 { 341 const char *name = data; 342 343 return sysfs_streq(name, dev_name(dev)); 344 } 345 346 /** 347 * bus_find_device_by_name - device iterator for locating a particular device of a specific name 348 * @bus: bus type 349 * @start: Device to begin with 350 * @name: name of the device to match 351 * 352 * This is similar to the bus_find_device() function above, but it handles 353 * searching by a name automatically, no need to write another strcmp matching 354 * function. 355 */ 356 struct device *bus_find_device_by_name(struct bus_type *bus, 357 struct device *start, const char *name) 358 { 359 return bus_find_device(bus, start, (void *)name, match_name); 360 } 361 EXPORT_SYMBOL_GPL(bus_find_device_by_name); 362 363 static struct device_driver *next_driver(struct klist_iter *i) 364 { 365 struct klist_node *n = klist_next(i); 366 struct driver_private *drv_priv; 367 368 if (n) { 369 drv_priv = container_of(n, struct driver_private, knode_bus); 370 return drv_priv->driver; 371 } 372 return NULL; 373 } 374 375 /** 376 * bus_for_each_drv - driver iterator 377 * @bus: bus we're dealing with. 378 * @start: driver to start iterating on. 379 * @data: data to pass to the callback. 380 * @fn: function to call for each driver. 381 * 382 * This is nearly identical to the device iterator above. 383 * We iterate over each driver that belongs to @bus, and call 384 * @fn for each. If @fn returns anything but 0, we break out 385 * and return it. If @start is not NULL, we use it as the head 386 * of the list. 387 * 388 * NOTE: we don't return the driver that returns a non-zero 389 * value, nor do we leave the reference count incremented for that 390 * driver. If the caller needs to know that info, it must set it 391 * in the callback. It must also be sure to increment the refcount 392 * so it doesn't disappear before returning to the caller. 393 */ 394 int bus_for_each_drv(struct bus_type *bus, struct device_driver *start, 395 void *data, int (*fn)(struct device_driver *, void *)) 396 { 397 struct klist_iter i; 398 struct device_driver *drv; 399 int error = 0; 400 401 if (!bus) 402 return -EINVAL; 403 404 klist_iter_init_node(&bus->p->klist_drivers, &i, 405 start ? &start->p->knode_bus : NULL); 406 while ((drv = next_driver(&i)) && !error) 407 error = fn(drv, data); 408 klist_iter_exit(&i); 409 return error; 410 } 411 EXPORT_SYMBOL_GPL(bus_for_each_drv); 412 413 static int device_add_attrs(struct bus_type *bus, struct device *dev) 414 { 415 int error = 0; 416 int i; 417 418 if (!bus->dev_attrs) 419 return 0; 420 421 for (i = 0; attr_name(bus->dev_attrs[i]); i++) { 422 error = device_create_file(dev, &bus->dev_attrs[i]); 423 if (error) { 424 while (--i >= 0) 425 device_remove_file(dev, &bus->dev_attrs[i]); 426 break; 427 } 428 } 429 return error; 430 } 431 432 static void device_remove_attrs(struct bus_type *bus, struct device *dev) 433 { 434 int i; 435 436 if (bus->dev_attrs) { 437 for (i = 0; attr_name(bus->dev_attrs[i]); i++) 438 device_remove_file(dev, &bus->dev_attrs[i]); 439 } 440 } 441 442 #ifdef CONFIG_SYSFS_DEPRECATED 443 static int make_deprecated_bus_links(struct device *dev) 444 { 445 return sysfs_create_link(&dev->kobj, 446 &dev->bus->p->subsys.kobj, "bus"); 447 } 448 449 static void remove_deprecated_bus_links(struct device *dev) 450 { 451 sysfs_remove_link(&dev->kobj, "bus"); 452 } 453 #else 454 static inline int make_deprecated_bus_links(struct device *dev) { return 0; } 455 static inline void remove_deprecated_bus_links(struct device *dev) { } 456 #endif 457 458 /** 459 * bus_add_device - add device to bus 460 * @dev: device being added 461 * 462 * - Add device's bus attributes. 463 * - Create links to device's bus. 464 * - Add the device to its bus's list of devices. 465 */ 466 int bus_add_device(struct device *dev) 467 { 468 struct bus_type *bus = bus_get(dev->bus); 469 int error = 0; 470 471 if (bus) { 472 pr_debug("bus: '%s': add device %s\n", bus->name, dev_name(dev)); 473 error = device_add_attrs(bus, dev); 474 if (error) 475 goto out_put; 476 error = sysfs_create_link(&bus->p->devices_kset->kobj, 477 &dev->kobj, dev_name(dev)); 478 if (error) 479 goto out_id; 480 error = sysfs_create_link(&dev->kobj, 481 &dev->bus->p->subsys.kobj, "subsystem"); 482 if (error) 483 goto out_subsys; 484 error = make_deprecated_bus_links(dev); 485 if (error) 486 goto out_deprecated; 487 klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices); 488 } 489 return 0; 490 491 out_deprecated: 492 sysfs_remove_link(&dev->kobj, "subsystem"); 493 out_subsys: 494 sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev)); 495 out_id: 496 device_remove_attrs(bus, dev); 497 out_put: 498 bus_put(dev->bus); 499 return error; 500 } 501 502 /** 503 * bus_probe_device - probe drivers for a new device 504 * @dev: device to probe 505 * 506 * - Automatically probe for a driver if the bus allows it. 507 */ 508 void bus_probe_device(struct device *dev) 509 { 510 struct bus_type *bus = dev->bus; 511 int ret; 512 513 if (bus && bus->p->drivers_autoprobe) { 514 ret = device_attach(dev); 515 WARN_ON(ret < 0); 516 } 517 } 518 519 /** 520 * bus_remove_device - remove device from bus 521 * @dev: device to be removed 522 * 523 * - Remove symlink from bus's directory. 524 * - Delete device from bus's list. 525 * - Detach from its driver. 526 * - Drop reference taken in bus_add_device(). 527 */ 528 void bus_remove_device(struct device *dev) 529 { 530 if (dev->bus) { 531 sysfs_remove_link(&dev->kobj, "subsystem"); 532 remove_deprecated_bus_links(dev); 533 sysfs_remove_link(&dev->bus->p->devices_kset->kobj, 534 dev_name(dev)); 535 device_remove_attrs(dev->bus, dev); 536 if (klist_node_attached(&dev->p->knode_bus)) 537 klist_del(&dev->p->knode_bus); 538 539 pr_debug("bus: '%s': remove device %s\n", 540 dev->bus->name, dev_name(dev)); 541 device_release_driver(dev); 542 bus_put(dev->bus); 543 } 544 } 545 546 static int driver_add_attrs(struct bus_type *bus, struct device_driver *drv) 547 { 548 int error = 0; 549 int i; 550 551 if (bus->drv_attrs) { 552 for (i = 0; attr_name(bus->drv_attrs[i]); i++) { 553 error = driver_create_file(drv, &bus->drv_attrs[i]); 554 if (error) 555 goto err; 556 } 557 } 558 done: 559 return error; 560 err: 561 while (--i >= 0) 562 driver_remove_file(drv, &bus->drv_attrs[i]); 563 goto done; 564 } 565 566 static void driver_remove_attrs(struct bus_type *bus, 567 struct device_driver *drv) 568 { 569 int i; 570 571 if (bus->drv_attrs) { 572 for (i = 0; attr_name(bus->drv_attrs[i]); i++) 573 driver_remove_file(drv, &bus->drv_attrs[i]); 574 } 575 } 576 577 #ifdef CONFIG_HOTPLUG 578 /* 579 * Thanks to drivers making their tables __devinit, we can't allow manual 580 * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled. 581 */ 582 static int __must_check add_bind_files(struct device_driver *drv) 583 { 584 int ret; 585 586 ret = driver_create_file(drv, &driver_attr_unbind); 587 if (ret == 0) { 588 ret = driver_create_file(drv, &driver_attr_bind); 589 if (ret) 590 driver_remove_file(drv, &driver_attr_unbind); 591 } 592 return ret; 593 } 594 595 static void remove_bind_files(struct device_driver *drv) 596 { 597 driver_remove_file(drv, &driver_attr_bind); 598 driver_remove_file(drv, &driver_attr_unbind); 599 } 600 601 static BUS_ATTR(drivers_probe, S_IWUSR, NULL, store_drivers_probe); 602 static BUS_ATTR(drivers_autoprobe, S_IWUSR | S_IRUGO, 603 show_drivers_autoprobe, store_drivers_autoprobe); 604 605 static int add_probe_files(struct bus_type *bus) 606 { 607 int retval; 608 609 retval = bus_create_file(bus, &bus_attr_drivers_probe); 610 if (retval) 611 goto out; 612 613 retval = bus_create_file(bus, &bus_attr_drivers_autoprobe); 614 if (retval) 615 bus_remove_file(bus, &bus_attr_drivers_probe); 616 out: 617 return retval; 618 } 619 620 static void remove_probe_files(struct bus_type *bus) 621 { 622 bus_remove_file(bus, &bus_attr_drivers_autoprobe); 623 bus_remove_file(bus, &bus_attr_drivers_probe); 624 } 625 #else 626 static inline int add_bind_files(struct device_driver *drv) { return 0; } 627 static inline void remove_bind_files(struct device_driver *drv) {} 628 static inline int add_probe_files(struct bus_type *bus) { return 0; } 629 static inline void remove_probe_files(struct bus_type *bus) {} 630 #endif 631 632 static ssize_t driver_uevent_store(struct device_driver *drv, 633 const char *buf, size_t count) 634 { 635 enum kobject_action action; 636 637 if (kobject_action_type(buf, count, &action) == 0) 638 kobject_uevent(&drv->p->kobj, action); 639 return count; 640 } 641 static DRIVER_ATTR(uevent, S_IWUSR, NULL, driver_uevent_store); 642 643 /** 644 * bus_add_driver - Add a driver to the bus. 645 * @drv: driver. 646 */ 647 int bus_add_driver(struct device_driver *drv) 648 { 649 struct bus_type *bus; 650 struct driver_private *priv; 651 int error = 0; 652 653 bus = bus_get(drv->bus); 654 if (!bus) 655 return -EINVAL; 656 657 pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name); 658 659 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 660 if (!priv) { 661 error = -ENOMEM; 662 goto out_put_bus; 663 } 664 klist_init(&priv->klist_devices, NULL, NULL); 665 priv->driver = drv; 666 drv->p = priv; 667 priv->kobj.kset = bus->p->drivers_kset; 668 error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL, 669 "%s", drv->name); 670 if (error) 671 goto out_unregister; 672 673 if (drv->bus->p->drivers_autoprobe) { 674 error = driver_attach(drv); 675 if (error) 676 goto out_unregister; 677 } 678 klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers); 679 module_add_driver(drv->owner, drv); 680 681 error = driver_create_file(drv, &driver_attr_uevent); 682 if (error) { 683 printk(KERN_ERR "%s: uevent attr (%s) failed\n", 684 __func__, drv->name); 685 } 686 error = driver_add_attrs(bus, drv); 687 if (error) { 688 /* How the hell do we get out of this pickle? Give up */ 689 printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n", 690 __func__, drv->name); 691 } 692 693 if (!drv->suppress_bind_attrs) { 694 error = add_bind_files(drv); 695 if (error) { 696 /* Ditto */ 697 printk(KERN_ERR "%s: add_bind_files(%s) failed\n", 698 __func__, drv->name); 699 } 700 } 701 702 kobject_uevent(&priv->kobj, KOBJ_ADD); 703 return 0; 704 705 out_unregister: 706 kobject_put(&priv->kobj); 707 kfree(drv->p); 708 drv->p = NULL; 709 out_put_bus: 710 bus_put(bus); 711 return error; 712 } 713 714 /** 715 * bus_remove_driver - delete driver from bus's knowledge. 716 * @drv: driver. 717 * 718 * Detach the driver from the devices it controls, and remove 719 * it from its bus's list of drivers. Finally, we drop the reference 720 * to the bus we took in bus_add_driver(). 721 */ 722 void bus_remove_driver(struct device_driver *drv) 723 { 724 if (!drv->bus) 725 return; 726 727 if (!drv->suppress_bind_attrs) 728 remove_bind_files(drv); 729 driver_remove_attrs(drv->bus, drv); 730 driver_remove_file(drv, &driver_attr_uevent); 731 klist_remove(&drv->p->knode_bus); 732 pr_debug("bus: '%s': remove driver %s\n", drv->bus->name, drv->name); 733 driver_detach(drv); 734 module_remove_driver(drv); 735 kobject_put(&drv->p->kobj); 736 bus_put(drv->bus); 737 } 738 739 /* Helper for bus_rescan_devices's iter */ 740 static int __must_check bus_rescan_devices_helper(struct device *dev, 741 void *data) 742 { 743 int ret = 0; 744 745 if (!dev->driver) { 746 if (dev->parent) /* Needed for USB */ 747 down(&dev->parent->sem); 748 ret = device_attach(dev); 749 if (dev->parent) 750 up(&dev->parent->sem); 751 } 752 return ret < 0 ? ret : 0; 753 } 754 755 /** 756 * bus_rescan_devices - rescan devices on the bus for possible drivers 757 * @bus: the bus to scan. 758 * 759 * This function will look for devices on the bus with no driver 760 * attached and rescan it against existing drivers to see if it matches 761 * any by calling device_attach() for the unbound devices. 762 */ 763 int bus_rescan_devices(struct bus_type *bus) 764 { 765 return bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper); 766 } 767 EXPORT_SYMBOL_GPL(bus_rescan_devices); 768 769 /** 770 * device_reprobe - remove driver for a device and probe for a new driver 771 * @dev: the device to reprobe 772 * 773 * This function detaches the attached driver (if any) for the given 774 * device and restarts the driver probing process. It is intended 775 * to use if probing criteria changed during a devices lifetime and 776 * driver attachment should change accordingly. 777 */ 778 int device_reprobe(struct device *dev) 779 { 780 if (dev->driver) { 781 if (dev->parent) /* Needed for USB */ 782 down(&dev->parent->sem); 783 device_release_driver(dev); 784 if (dev->parent) 785 up(&dev->parent->sem); 786 } 787 return bus_rescan_devices_helper(dev, NULL); 788 } 789 EXPORT_SYMBOL_GPL(device_reprobe); 790 791 /** 792 * find_bus - locate bus by name. 793 * @name: name of bus. 794 * 795 * Call kset_find_obj() to iterate over list of buses to 796 * find a bus by name. Return bus if found. 797 * 798 * Note that kset_find_obj increments bus' reference count. 799 */ 800 #if 0 801 struct bus_type *find_bus(char *name) 802 { 803 struct kobject *k = kset_find_obj(bus_kset, name); 804 return k ? to_bus(k) : NULL; 805 } 806 #endif /* 0 */ 807 808 809 /** 810 * bus_add_attrs - Add default attributes for this bus. 811 * @bus: Bus that has just been registered. 812 */ 813 814 static int bus_add_attrs(struct bus_type *bus) 815 { 816 int error = 0; 817 int i; 818 819 if (bus->bus_attrs) { 820 for (i = 0; attr_name(bus->bus_attrs[i]); i++) { 821 error = bus_create_file(bus, &bus->bus_attrs[i]); 822 if (error) 823 goto err; 824 } 825 } 826 done: 827 return error; 828 err: 829 while (--i >= 0) 830 bus_remove_file(bus, &bus->bus_attrs[i]); 831 goto done; 832 } 833 834 static void bus_remove_attrs(struct bus_type *bus) 835 { 836 int i; 837 838 if (bus->bus_attrs) { 839 for (i = 0; attr_name(bus->bus_attrs[i]); i++) 840 bus_remove_file(bus, &bus->bus_attrs[i]); 841 } 842 } 843 844 static void klist_devices_get(struct klist_node *n) 845 { 846 struct device_private *dev_prv = to_device_private_bus(n); 847 struct device *dev = dev_prv->device; 848 849 get_device(dev); 850 } 851 852 static void klist_devices_put(struct klist_node *n) 853 { 854 struct device_private *dev_prv = to_device_private_bus(n); 855 struct device *dev = dev_prv->device; 856 857 put_device(dev); 858 } 859 860 static ssize_t bus_uevent_store(struct bus_type *bus, 861 const char *buf, size_t count) 862 { 863 enum kobject_action action; 864 865 if (kobject_action_type(buf, count, &action) == 0) 866 kobject_uevent(&bus->p->subsys.kobj, action); 867 return count; 868 } 869 static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store); 870 871 /** 872 * bus_register - register a bus with the system. 873 * @bus: bus. 874 * 875 * Once we have that, we registered the bus with the kobject 876 * infrastructure, then register the children subsystems it has: 877 * the devices and drivers that belong to the bus. 878 */ 879 int bus_register(struct bus_type *bus) 880 { 881 int retval; 882 struct bus_type_private *priv; 883 884 priv = kzalloc(sizeof(struct bus_type_private), GFP_KERNEL); 885 if (!priv) 886 return -ENOMEM; 887 888 priv->bus = bus; 889 bus->p = priv; 890 891 BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier); 892 893 retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name); 894 if (retval) 895 goto out; 896 897 priv->subsys.kobj.kset = bus_kset; 898 priv->subsys.kobj.ktype = &bus_ktype; 899 priv->drivers_autoprobe = 1; 900 901 retval = kset_register(&priv->subsys); 902 if (retval) 903 goto out; 904 905 retval = bus_create_file(bus, &bus_attr_uevent); 906 if (retval) 907 goto bus_uevent_fail; 908 909 priv->devices_kset = kset_create_and_add("devices", NULL, 910 &priv->subsys.kobj); 911 if (!priv->devices_kset) { 912 retval = -ENOMEM; 913 goto bus_devices_fail; 914 } 915 916 priv->drivers_kset = kset_create_and_add("drivers", NULL, 917 &priv->subsys.kobj); 918 if (!priv->drivers_kset) { 919 retval = -ENOMEM; 920 goto bus_drivers_fail; 921 } 922 923 klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put); 924 klist_init(&priv->klist_drivers, NULL, NULL); 925 926 retval = add_probe_files(bus); 927 if (retval) 928 goto bus_probe_files_fail; 929 930 retval = bus_add_attrs(bus); 931 if (retval) 932 goto bus_attrs_fail; 933 934 pr_debug("bus: '%s': registered\n", bus->name); 935 return 0; 936 937 bus_attrs_fail: 938 remove_probe_files(bus); 939 bus_probe_files_fail: 940 kset_unregister(bus->p->drivers_kset); 941 bus_drivers_fail: 942 kset_unregister(bus->p->devices_kset); 943 bus_devices_fail: 944 bus_remove_file(bus, &bus_attr_uevent); 945 bus_uevent_fail: 946 kset_unregister(&bus->p->subsys); 947 kfree(bus->p); 948 out: 949 bus->p = NULL; 950 return retval; 951 } 952 EXPORT_SYMBOL_GPL(bus_register); 953 954 /** 955 * bus_unregister - remove a bus from the system 956 * @bus: bus. 957 * 958 * Unregister the child subsystems and the bus itself. 959 * Finally, we call bus_put() to release the refcount 960 */ 961 void bus_unregister(struct bus_type *bus) 962 { 963 pr_debug("bus: '%s': unregistering\n", bus->name); 964 bus_remove_attrs(bus); 965 remove_probe_files(bus); 966 kset_unregister(bus->p->drivers_kset); 967 kset_unregister(bus->p->devices_kset); 968 bus_remove_file(bus, &bus_attr_uevent); 969 kset_unregister(&bus->p->subsys); 970 kfree(bus->p); 971 bus->p = NULL; 972 } 973 EXPORT_SYMBOL_GPL(bus_unregister); 974 975 int bus_register_notifier(struct bus_type *bus, struct notifier_block *nb) 976 { 977 return blocking_notifier_chain_register(&bus->p->bus_notifier, nb); 978 } 979 EXPORT_SYMBOL_GPL(bus_register_notifier); 980 981 int bus_unregister_notifier(struct bus_type *bus, struct notifier_block *nb) 982 { 983 return blocking_notifier_chain_unregister(&bus->p->bus_notifier, nb); 984 } 985 EXPORT_SYMBOL_GPL(bus_unregister_notifier); 986 987 struct kset *bus_get_kset(struct bus_type *bus) 988 { 989 return &bus->p->subsys; 990 } 991 EXPORT_SYMBOL_GPL(bus_get_kset); 992 993 struct klist *bus_get_device_klist(struct bus_type *bus) 994 { 995 return &bus->p->klist_devices; 996 } 997 EXPORT_SYMBOL_GPL(bus_get_device_klist); 998 999 /* 1000 * Yes, this forcably breaks the klist abstraction temporarily. It 1001 * just wants to sort the klist, not change reference counts and 1002 * take/drop locks rapidly in the process. It does all this while 1003 * holding the lock for the list, so objects can't otherwise be 1004 * added/removed while we're swizzling. 1005 */ 1006 static void device_insertion_sort_klist(struct device *a, struct list_head *list, 1007 int (*compare)(const struct device *a, 1008 const struct device *b)) 1009 { 1010 struct list_head *pos; 1011 struct klist_node *n; 1012 struct device_private *dev_prv; 1013 struct device *b; 1014 1015 list_for_each(pos, list) { 1016 n = container_of(pos, struct klist_node, n_node); 1017 dev_prv = to_device_private_bus(n); 1018 b = dev_prv->device; 1019 if (compare(a, b) <= 0) { 1020 list_move_tail(&a->p->knode_bus.n_node, 1021 &b->p->knode_bus.n_node); 1022 return; 1023 } 1024 } 1025 list_move_tail(&a->p->knode_bus.n_node, list); 1026 } 1027 1028 void bus_sort_breadthfirst(struct bus_type *bus, 1029 int (*compare)(const struct device *a, 1030 const struct device *b)) 1031 { 1032 LIST_HEAD(sorted_devices); 1033 struct list_head *pos, *tmp; 1034 struct klist_node *n; 1035 struct device_private *dev_prv; 1036 struct device *dev; 1037 struct klist *device_klist; 1038 1039 device_klist = bus_get_device_klist(bus); 1040 1041 spin_lock(&device_klist->k_lock); 1042 list_for_each_safe(pos, tmp, &device_klist->k_list) { 1043 n = container_of(pos, struct klist_node, n_node); 1044 dev_prv = to_device_private_bus(n); 1045 dev = dev_prv->device; 1046 device_insertion_sort_klist(dev, &sorted_devices, compare); 1047 } 1048 list_splice(&sorted_devices, &device_klist->k_list); 1049 spin_unlock(&device_klist->k_lock); 1050 } 1051 EXPORT_SYMBOL_GPL(bus_sort_breadthfirst); 1052 1053 int __init buses_init(void) 1054 { 1055 bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL); 1056 if (!bus_kset) 1057 return -ENOMEM; 1058 return 0; 1059 } 1060