LCOV - code coverage report
Current view: top level - drivers/base - bus.c (source / functions) Hit Total Coverage
Test: Real Lines: 205 383 53.5 %
Date: 2020-10-17 15:46:16 Functions: 3 52 5.8 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14