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 * 7 * This file is released under the GPLv2 8 * 9 */ 10 11 #include <linux/device.h> 12 #include <linux/module.h> 13 #include <linux/errno.h> 14 #include <linux/init.h> 15 #include <linux/string.h> 16 #include "base.h" 17 #include "power/power.h" 18 19 #define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr) 20 #define to_bus(obj) container_of(obj, struct bus_type, subsys.kset.kobj) 21 22 /* 23 * sysfs bindings for drivers 24 */ 25 26 #define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr) 27 #define to_driver(obj) container_of(obj, struct device_driver, kobj) 28 29 30 static ssize_t 31 drv_attr_show(struct kobject * kobj, struct attribute * attr, char * buf) 32 { 33 struct driver_attribute * drv_attr = to_drv_attr(attr); 34 struct device_driver * drv = to_driver(kobj); 35 ssize_t ret = -EIO; 36 37 if (drv_attr->show) 38 ret = drv_attr->show(drv, buf); 39 return ret; 40 } 41 42 static ssize_t 43 drv_attr_store(struct kobject * kobj, struct attribute * attr, 44 const char * buf, size_t count) 45 { 46 struct driver_attribute * drv_attr = to_drv_attr(attr); 47 struct device_driver * drv = to_driver(kobj); 48 ssize_t ret = -EIO; 49 50 if (drv_attr->store) 51 ret = drv_attr->store(drv, buf, count); 52 return ret; 53 } 54 55 static struct sysfs_ops driver_sysfs_ops = { 56 .show = drv_attr_show, 57 .store = drv_attr_store, 58 }; 59 60 61 static void driver_release(struct kobject * kobj) 62 { 63 struct device_driver * drv = to_driver(kobj); 64 complete(&drv->unloaded); 65 } 66 67 static struct kobj_type ktype_driver = { 68 .sysfs_ops = &driver_sysfs_ops, 69 .release = driver_release, 70 }; 71 72 73 /* 74 * sysfs bindings for buses 75 */ 76 77 78 static ssize_t 79 bus_attr_show(struct kobject * kobj, struct attribute * attr, char * buf) 80 { 81 struct bus_attribute * bus_attr = to_bus_attr(attr); 82 struct bus_type * bus = to_bus(kobj); 83 ssize_t ret = 0; 84 85 if (bus_attr->show) 86 ret = bus_attr->show(bus, buf); 87 return ret; 88 } 89 90 static ssize_t 91 bus_attr_store(struct kobject * kobj, struct attribute * attr, 92 const char * buf, size_t count) 93 { 94 struct bus_attribute * bus_attr = to_bus_attr(attr); 95 struct bus_type * bus = to_bus(kobj); 96 ssize_t ret = 0; 97 98 if (bus_attr->store) 99 ret = bus_attr->store(bus, buf, count); 100 return ret; 101 } 102 103 static struct sysfs_ops bus_sysfs_ops = { 104 .show = bus_attr_show, 105 .store = bus_attr_store, 106 }; 107 108 int bus_create_file(struct bus_type * bus, struct bus_attribute * attr) 109 { 110 int error; 111 if (get_bus(bus)) { 112 error = sysfs_create_file(&bus->subsys.kset.kobj, &attr->attr); 113 put_bus(bus); 114 } else 115 error = -EINVAL; 116 return error; 117 } 118 119 void bus_remove_file(struct bus_type * bus, struct bus_attribute * attr) 120 { 121 if (get_bus(bus)) { 122 sysfs_remove_file(&bus->subsys.kset.kobj, &attr->attr); 123 put_bus(bus); 124 } 125 } 126 127 static struct kobj_type ktype_bus = { 128 .sysfs_ops = &bus_sysfs_ops, 129 130 }; 131 132 static decl_subsys(bus, &ktype_bus, NULL); 133 134 135 #ifdef CONFIG_HOTPLUG 136 137 /* Manually detach a device from its associated driver. */ 138 static int driver_helper(struct device *dev, void *data) 139 { 140 const char *name = data; 141 142 if (strcmp(name, dev->bus_id) == 0) 143 return 1; 144 return 0; 145 } 146 147 static ssize_t driver_unbind(struct device_driver *drv, 148 const char *buf, size_t count) 149 { 150 struct bus_type *bus = get_bus(drv->bus); 151 struct device *dev; 152 int err = -ENODEV; 153 154 dev = bus_find_device(bus, NULL, (void *)buf, driver_helper); 155 if (dev && dev->driver == drv) { 156 if (dev->parent) /* Needed for USB */ 157 down(&dev->parent->sem); 158 device_release_driver(dev); 159 if (dev->parent) 160 up(&dev->parent->sem); 161 err = count; 162 } 163 put_device(dev); 164 put_bus(bus); 165 return err; 166 } 167 static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind); 168 169 /* 170 * Manually attach a device to a driver. 171 * Note: the driver must want to bind to the device, 172 * it is not possible to override the driver's id table. 173 */ 174 static ssize_t driver_bind(struct device_driver *drv, 175 const char *buf, size_t count) 176 { 177 struct bus_type *bus = get_bus(drv->bus); 178 struct device *dev; 179 int err = -ENODEV; 180 181 dev = bus_find_device(bus, NULL, (void *)buf, driver_helper); 182 if (dev && dev->driver == NULL) { 183 if (dev->parent) /* Needed for USB */ 184 down(&dev->parent->sem); 185 down(&dev->sem); 186 err = driver_probe_device(drv, dev); 187 up(&dev->sem); 188 if (dev->parent) 189 up(&dev->parent->sem); 190 191 if (err > 0) /* success */ 192 err = count; 193 else if (err == 0) /* driver didn't accept device */ 194 err = -ENODEV; 195 } 196 put_device(dev); 197 put_bus(bus); 198 return err; 199 } 200 static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind); 201 202 #endif 203 204 static struct device * next_device(struct klist_iter * i) 205 { 206 struct klist_node * n = klist_next(i); 207 return n ? container_of(n, struct device, knode_bus) : NULL; 208 } 209 210 /** 211 * bus_for_each_dev - device iterator. 212 * @bus: bus type. 213 * @start: device to start iterating from. 214 * @data: data for the callback. 215 * @fn: function to be called for each device. 216 * 217 * Iterate over @bus's list of devices, and call @fn for each, 218 * passing it @data. If @start is not NULL, we use that device to 219 * begin iterating from. 220 * 221 * We check the return of @fn each time. If it returns anything 222 * other than 0, we break out and return that value. 223 * 224 * NOTE: The device that returns a non-zero value is not retained 225 * in any way, nor is its refcount incremented. If the caller needs 226 * to retain this data, it should do, and increment the reference 227 * count in the supplied callback. 228 */ 229 230 int bus_for_each_dev(struct bus_type * bus, struct device * start, 231 void * data, int (*fn)(struct device *, void *)) 232 { 233 struct klist_iter i; 234 struct device * dev; 235 int error = 0; 236 237 if (!bus) 238 return -EINVAL; 239 240 klist_iter_init_node(&bus->klist_devices, &i, 241 (start ? &start->knode_bus : NULL)); 242 while ((dev = next_device(&i)) && !error) 243 error = fn(dev, data); 244 klist_iter_exit(&i); 245 return error; 246 } 247 248 /** 249 * bus_find_device - device iterator for locating a particular device. 250 * @bus: bus type 251 * @start: Device to begin with 252 * @data: Data to pass to match function 253 * @match: Callback function to check device 254 * 255 * This is similar to the bus_for_each_dev() function above, but it 256 * returns a reference to a device that is 'found' for later use, as 257 * determined by the @match callback. 258 * 259 * The callback should return 0 if the device doesn't match and non-zero 260 * if it does. If the callback returns non-zero, this function will 261 * return to the caller and not iterate over any more devices. 262 */ 263 struct device * bus_find_device(struct bus_type *bus, 264 struct device *start, void *data, 265 int (*match)(struct device *, void *)) 266 { 267 struct klist_iter i; 268 struct device *dev; 269 270 if (!bus) 271 return NULL; 272 273 klist_iter_init_node(&bus->klist_devices, &i, 274 (start ? &start->knode_bus : NULL)); 275 while ((dev = next_device(&i))) 276 if (match(dev, data) && get_device(dev)) 277 break; 278 klist_iter_exit(&i); 279 return dev; 280 } 281 282 283 static struct device_driver * next_driver(struct klist_iter * i) 284 { 285 struct klist_node * n = klist_next(i); 286 return n ? container_of(n, struct device_driver, knode_bus) : NULL; 287 } 288 289 /** 290 * bus_for_each_drv - driver iterator 291 * @bus: bus we're dealing with. 292 * @start: driver to start iterating on. 293 * @data: data to pass to the callback. 294 * @fn: function to call for each driver. 295 * 296 * This is nearly identical to the device iterator above. 297 * We iterate over each driver that belongs to @bus, and call 298 * @fn for each. If @fn returns anything but 0, we break out 299 * and return it. If @start is not NULL, we use it as the head 300 * of the list. 301 * 302 * NOTE: we don't return the driver that returns a non-zero 303 * value, nor do we leave the reference count incremented for that 304 * driver. If the caller needs to know that info, it must set it 305 * in the callback. It must also be sure to increment the refcount 306 * so it doesn't disappear before returning to the caller. 307 */ 308 309 int bus_for_each_drv(struct bus_type * bus, struct device_driver * start, 310 void * data, int (*fn)(struct device_driver *, void *)) 311 { 312 struct klist_iter i; 313 struct device_driver * drv; 314 int error = 0; 315 316 if (!bus) 317 return -EINVAL; 318 319 klist_iter_init_node(&bus->klist_drivers, &i, 320 start ? &start->knode_bus : NULL); 321 while ((drv = next_driver(&i)) && !error) 322 error = fn(drv, data); 323 klist_iter_exit(&i); 324 return error; 325 } 326 327 static int device_add_attrs(struct bus_type * bus, struct device * dev) 328 { 329 int error = 0; 330 int i; 331 332 if (bus->dev_attrs) { 333 for (i = 0; attr_name(bus->dev_attrs[i]); i++) { 334 error = device_create_file(dev,&bus->dev_attrs[i]); 335 if (error) 336 goto Err; 337 } 338 } 339 Done: 340 return error; 341 Err: 342 while (--i >= 0) 343 device_remove_file(dev,&bus->dev_attrs[i]); 344 goto Done; 345 } 346 347 348 static void device_remove_attrs(struct bus_type * bus, struct device * dev) 349 { 350 int i; 351 352 if (bus->dev_attrs) { 353 for (i = 0; attr_name(bus->dev_attrs[i]); i++) 354 device_remove_file(dev,&bus->dev_attrs[i]); 355 } 356 } 357 358 359 /** 360 * bus_add_device - add device to bus 361 * @dev: device being added 362 * 363 * - Add the device to its bus's list of devices. 364 * - Create link to device's bus. 365 */ 366 int bus_add_device(struct device * dev) 367 { 368 struct bus_type * bus = get_bus(dev->bus); 369 int error = 0; 370 371 if (bus) { 372 pr_debug("bus %s: add device %s\n", bus->name, dev->bus_id); 373 error = device_add_attrs(bus, dev); 374 if (!error) { 375 sysfs_create_link(&bus->devices.kobj, &dev->kobj, dev->bus_id); 376 sysfs_create_link(&dev->kobj, &dev->bus->subsys.kset.kobj, "subsystem"); 377 sysfs_create_link(&dev->kobj, &dev->bus->subsys.kset.kobj, "bus"); 378 } 379 } 380 return error; 381 } 382 383 /** 384 * bus_attach_device - add device to bus 385 * @dev: device tried to attach to a driver 386 * 387 * - Try to attach to driver. 388 */ 389 void bus_attach_device(struct device * dev) 390 { 391 struct bus_type * bus = dev->bus; 392 393 if (bus) { 394 device_attach(dev); 395 klist_add_tail(&dev->knode_bus, &bus->klist_devices); 396 } 397 } 398 399 /** 400 * bus_remove_device - remove device from bus 401 * @dev: device to be removed 402 * 403 * - Remove symlink from bus's directory. 404 * - Delete device from bus's list. 405 * - Detach from its driver. 406 * - Drop reference taken in bus_add_device(). 407 */ 408 void bus_remove_device(struct device * dev) 409 { 410 if (dev->bus) { 411 sysfs_remove_link(&dev->kobj, "subsystem"); 412 sysfs_remove_link(&dev->kobj, "bus"); 413 sysfs_remove_link(&dev->bus->devices.kobj, dev->bus_id); 414 device_remove_attrs(dev->bus, dev); 415 klist_remove(&dev->knode_bus); 416 pr_debug("bus %s: remove device %s\n", dev->bus->name, dev->bus_id); 417 device_release_driver(dev); 418 put_bus(dev->bus); 419 } 420 } 421 422 static int driver_add_attrs(struct bus_type * bus, struct device_driver * drv) 423 { 424 int error = 0; 425 int i; 426 427 if (bus->drv_attrs) { 428 for (i = 0; attr_name(bus->drv_attrs[i]); i++) { 429 error = driver_create_file(drv, &bus->drv_attrs[i]); 430 if (error) 431 goto Err; 432 } 433 } 434 Done: 435 return error; 436 Err: 437 while (--i >= 0) 438 driver_remove_file(drv, &bus->drv_attrs[i]); 439 goto Done; 440 } 441 442 443 static void driver_remove_attrs(struct bus_type * bus, struct device_driver * drv) 444 { 445 int i; 446 447 if (bus->drv_attrs) { 448 for (i = 0; attr_name(bus->drv_attrs[i]); i++) 449 driver_remove_file(drv, &bus->drv_attrs[i]); 450 } 451 } 452 453 #ifdef CONFIG_HOTPLUG 454 /* 455 * Thanks to drivers making their tables __devinit, we can't allow manual 456 * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled. 457 */ 458 static void add_bind_files(struct device_driver *drv) 459 { 460 driver_create_file(drv, &driver_attr_unbind); 461 driver_create_file(drv, &driver_attr_bind); 462 } 463 464 static void remove_bind_files(struct device_driver *drv) 465 { 466 driver_remove_file(drv, &driver_attr_bind); 467 driver_remove_file(drv, &driver_attr_unbind); 468 } 469 #else 470 static inline void add_bind_files(struct device_driver *drv) {} 471 static inline void remove_bind_files(struct device_driver *drv) {} 472 #endif 473 474 /** 475 * bus_add_driver - Add a driver to the bus. 476 * @drv: driver. 477 * 478 */ 479 int bus_add_driver(struct device_driver * drv) 480 { 481 struct bus_type * bus = get_bus(drv->bus); 482 int error = 0; 483 484 if (bus) { 485 pr_debug("bus %s: add driver %s\n", bus->name, drv->name); 486 error = kobject_set_name(&drv->kobj, "%s", drv->name); 487 if (error) { 488 put_bus(bus); 489 return error; 490 } 491 drv->kobj.kset = &bus->drivers; 492 if ((error = kobject_register(&drv->kobj))) { 493 put_bus(bus); 494 return error; 495 } 496 497 driver_attach(drv); 498 klist_add_tail(&drv->knode_bus, &bus->klist_drivers); 499 module_add_driver(drv->owner, drv); 500 501 driver_add_attrs(bus, drv); 502 add_bind_files(drv); 503 } 504 return error; 505 } 506 507 508 /** 509 * bus_remove_driver - delete driver from bus's knowledge. 510 * @drv: driver. 511 * 512 * Detach the driver from the devices it controls, and remove 513 * it from its bus's list of drivers. Finally, we drop the reference 514 * to the bus we took in bus_add_driver(). 515 */ 516 517 void bus_remove_driver(struct device_driver * drv) 518 { 519 if (drv->bus) { 520 remove_bind_files(drv); 521 driver_remove_attrs(drv->bus, drv); 522 klist_remove(&drv->knode_bus); 523 pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name); 524 driver_detach(drv); 525 module_remove_driver(drv); 526 kobject_unregister(&drv->kobj); 527 put_bus(drv->bus); 528 } 529 } 530 531 532 /* Helper for bus_rescan_devices's iter */ 533 static int bus_rescan_devices_helper(struct device *dev, void *data) 534 { 535 if (!dev->driver) { 536 if (dev->parent) /* Needed for USB */ 537 down(&dev->parent->sem); 538 device_attach(dev); 539 if (dev->parent) 540 up(&dev->parent->sem); 541 } 542 return 0; 543 } 544 545 /** 546 * bus_rescan_devices - rescan devices on the bus for possible drivers 547 * @bus: the bus to scan. 548 * 549 * This function will look for devices on the bus with no driver 550 * attached and rescan it against existing drivers to see if it matches 551 * any by calling device_attach() for the unbound devices. 552 */ 553 void bus_rescan_devices(struct bus_type * bus) 554 { 555 bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper); 556 } 557 558 /** 559 * device_reprobe - remove driver for a device and probe for a new driver 560 * @dev: the device to reprobe 561 * 562 * This function detaches the attached driver (if any) for the given 563 * device and restarts the driver probing process. It is intended 564 * to use if probing criteria changed during a devices lifetime and 565 * driver attachment should change accordingly. 566 */ 567 void device_reprobe(struct device *dev) 568 { 569 if (dev->driver) { 570 if (dev->parent) /* Needed for USB */ 571 down(&dev->parent->sem); 572 device_release_driver(dev); 573 if (dev->parent) 574 up(&dev->parent->sem); 575 } 576 577 bus_rescan_devices_helper(dev, NULL); 578 } 579 EXPORT_SYMBOL_GPL(device_reprobe); 580 581 struct bus_type * get_bus(struct bus_type * bus) 582 { 583 return bus ? container_of(subsys_get(&bus->subsys), struct bus_type, subsys) : NULL; 584 } 585 586 void put_bus(struct bus_type * bus) 587 { 588 subsys_put(&bus->subsys); 589 } 590 591 592 /** 593 * find_bus - locate bus by name. 594 * @name: name of bus. 595 * 596 * Call kset_find_obj() to iterate over list of buses to 597 * find a bus by name. Return bus if found. 598 * 599 * Note that kset_find_obj increments bus' reference count. 600 */ 601 #if 0 602 struct bus_type * find_bus(char * name) 603 { 604 struct kobject * k = kset_find_obj(&bus_subsys.kset, name); 605 return k ? to_bus(k) : NULL; 606 } 607 #endif /* 0 */ 608 609 610 /** 611 * bus_add_attrs - Add default attributes for this bus. 612 * @bus: Bus that has just been registered. 613 */ 614 615 static int bus_add_attrs(struct bus_type * bus) 616 { 617 int error = 0; 618 int i; 619 620 if (bus->bus_attrs) { 621 for (i = 0; attr_name(bus->bus_attrs[i]); i++) { 622 if ((error = bus_create_file(bus,&bus->bus_attrs[i]))) 623 goto Err; 624 } 625 } 626 Done: 627 return error; 628 Err: 629 while (--i >= 0) 630 bus_remove_file(bus,&bus->bus_attrs[i]); 631 goto Done; 632 } 633 634 static void bus_remove_attrs(struct bus_type * bus) 635 { 636 int i; 637 638 if (bus->bus_attrs) { 639 for (i = 0; attr_name(bus->bus_attrs[i]); i++) 640 bus_remove_file(bus,&bus->bus_attrs[i]); 641 } 642 } 643 644 static void klist_devices_get(struct klist_node *n) 645 { 646 struct device *dev = container_of(n, struct device, knode_bus); 647 648 get_device(dev); 649 } 650 651 static void klist_devices_put(struct klist_node *n) 652 { 653 struct device *dev = container_of(n, struct device, knode_bus); 654 655 put_device(dev); 656 } 657 658 static void klist_drivers_get(struct klist_node *n) 659 { 660 struct device_driver *drv = container_of(n, struct device_driver, 661 knode_bus); 662 663 get_driver(drv); 664 } 665 666 static void klist_drivers_put(struct klist_node *n) 667 { 668 struct device_driver *drv = container_of(n, struct device_driver, 669 knode_bus); 670 671 put_driver(drv); 672 } 673 674 /** 675 * bus_register - register a bus with the system. 676 * @bus: bus. 677 * 678 * Once we have that, we registered the bus with the kobject 679 * infrastructure, then register the children subsystems it has: 680 * the devices and drivers that belong to the bus. 681 */ 682 int bus_register(struct bus_type * bus) 683 { 684 int retval; 685 686 retval = kobject_set_name(&bus->subsys.kset.kobj, "%s", bus->name); 687 if (retval) 688 goto out; 689 690 subsys_set_kset(bus, bus_subsys); 691 retval = subsystem_register(&bus->subsys); 692 if (retval) 693 goto out; 694 695 kobject_set_name(&bus->devices.kobj, "devices"); 696 bus->devices.subsys = &bus->subsys; 697 retval = kset_register(&bus->devices); 698 if (retval) 699 goto bus_devices_fail; 700 701 kobject_set_name(&bus->drivers.kobj, "drivers"); 702 bus->drivers.subsys = &bus->subsys; 703 bus->drivers.ktype = &ktype_driver; 704 retval = kset_register(&bus->drivers); 705 if (retval) 706 goto bus_drivers_fail; 707 708 klist_init(&bus->klist_devices, klist_devices_get, klist_devices_put); 709 klist_init(&bus->klist_drivers, klist_drivers_get, klist_drivers_put); 710 bus_add_attrs(bus); 711 712 pr_debug("bus type '%s' registered\n", bus->name); 713 return 0; 714 715 bus_drivers_fail: 716 kset_unregister(&bus->devices); 717 bus_devices_fail: 718 subsystem_unregister(&bus->subsys); 719 out: 720 return retval; 721 } 722 723 724 /** 725 * bus_unregister - remove a bus from the system 726 * @bus: bus. 727 * 728 * Unregister the child subsystems and the bus itself. 729 * Finally, we call put_bus() to release the refcount 730 */ 731 void bus_unregister(struct bus_type * bus) 732 { 733 pr_debug("bus %s: unregistering\n", bus->name); 734 bus_remove_attrs(bus); 735 kset_unregister(&bus->drivers); 736 kset_unregister(&bus->devices); 737 subsystem_unregister(&bus->subsys); 738 } 739 740 int __init buses_init(void) 741 { 742 return subsystem_register(&bus_subsys); 743 } 744 745 746 EXPORT_SYMBOL_GPL(bus_for_each_dev); 747 EXPORT_SYMBOL_GPL(bus_find_device); 748 EXPORT_SYMBOL_GPL(bus_for_each_drv); 749 750 EXPORT_SYMBOL_GPL(bus_register); 751 EXPORT_SYMBOL_GPL(bus_unregister); 752 EXPORT_SYMBOL_GPL(bus_rescan_devices); 753 754 EXPORT_SYMBOL_GPL(bus_create_file); 755 EXPORT_SYMBOL_GPL(bus_remove_file); 756