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