drivers/base/bus.c

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