Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : /*
       3             :  * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
       4             :  * Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de>
       5             :  * Copyright (c) 2008-2012 Novell Inc.
       6             :  * Copyright (c) 2012-2019 Greg Kroah-Hartman <gregkh@linuxfoundation.org>
       7             :  * Copyright (c) 2012-2019 Linux Foundation
       8             :  *
       9             :  * Core driver model functions and structures that should not be
      10             :  * shared outside of the drivers/base/ directory.
      11             :  *
      12             :  */
      13             : #include <linux/notifier.h>
      14             : 
      15             : /**
      16             :  * struct subsys_private - structure to hold the private to the driver core portions of the bus_type/class structure.
      17             :  *
      18             :  * @subsys - the struct kset that defines this subsystem
      19             :  * @devices_kset - the subsystem's 'devices' directory
      20             :  * @interfaces - list of subsystem interfaces associated
      21             :  * @mutex - protect the devices, and interfaces lists.
      22             :  *
      23             :  * @drivers_kset - the list of drivers associated
      24             :  * @klist_devices - the klist to iterate over the @devices_kset
      25             :  * @klist_drivers - the klist to iterate over the @drivers_kset
      26             :  * @bus_notifier - the bus notifier list for anything that cares about things
      27             :  *                 on this bus.
      28             :  * @bus - pointer back to the struct bus_type that this structure is associated
      29             :  *        with.
      30             :  * @dev_root: Default device to use as the parent.
      31             :  *
      32             :  * @glue_dirs - "glue" directory to put in-between the parent device to
      33             :  *              avoid namespace conflicts
      34             :  * @class - pointer back to the struct class that this structure is associated
      35             :  *          with.
      36             :  * @lock_key:   Lock class key for use by the lock validator
      37             :  *
      38             :  * This structure is the one that is the actual kobject allowing struct
      39             :  * bus_type/class to be statically allocated safely.  Nothing outside of the
      40             :  * driver core should ever touch these fields.
      41             :  */
      42             : struct subsys_private {
      43             :         struct kset subsys;
      44             :         struct kset *devices_kset;
      45             :         struct list_head interfaces;
      46             :         struct mutex mutex;
      47             : 
      48             :         struct kset *drivers_kset;
      49             :         struct klist klist_devices;
      50             :         struct klist klist_drivers;
      51             :         struct blocking_notifier_head bus_notifier;
      52             :         unsigned int drivers_autoprobe:1;
      53             :         const struct bus_type *bus;
      54             :         struct device *dev_root;
      55             : 
      56             :         struct kset glue_dirs;
      57             :         const struct class *class;
      58             : 
      59             :         struct lock_class_key lock_key;
      60             : };
      61             : #define to_subsys_private(obj) container_of_const(obj, struct subsys_private, subsys.kobj)
      62             : 
      63             : static inline struct subsys_private *subsys_get(struct subsys_private *sp)
      64             : {
      65        2100 :         if (sp)
      66        2100 :                 kset_get(&sp->subsys);
      67             :         return sp;
      68             : }
      69             : 
      70             : static inline void subsys_put(struct subsys_private *sp)
      71             : {
      72           3 :         if (sp)
      73        2080 :                 kset_put(&sp->subsys);
      74             : }
      75             : 
      76             : struct subsys_private *class_to_subsys(const struct class *class);
      77             : 
      78             : struct driver_private {
      79             :         struct kobject kobj;
      80             :         struct klist klist_devices;
      81             :         struct klist_node knode_bus;
      82             :         struct module_kobject *mkobj;
      83             :         struct device_driver *driver;
      84             : };
      85             : #define to_driver(obj) container_of(obj, struct driver_private, kobj)
      86             : 
      87             : /**
      88             :  * struct device_private - structure to hold the private to the driver core portions of the device structure.
      89             :  *
      90             :  * @klist_children - klist containing all children of this device
      91             :  * @knode_parent - node in sibling list
      92             :  * @knode_driver - node in driver list
      93             :  * @knode_bus - node in bus list
      94             :  * @knode_class - node in class list
      95             :  * @deferred_probe - entry in deferred_probe_list which is used to retry the
      96             :  *      binding of drivers which were unable to get all the resources needed by
      97             :  *      the device; typically because it depends on another driver getting
      98             :  *      probed first.
      99             :  * @async_driver - pointer to device driver awaiting probe via async_probe
     100             :  * @device - pointer back to the struct device that this structure is
     101             :  * associated with.
     102             :  * @dead - This device is currently either in the process of or has been
     103             :  *      removed from the system. Any asynchronous events scheduled for this
     104             :  *      device should exit without taking any action.
     105             :  *
     106             :  * Nothing outside of the driver core should ever touch these fields.
     107             :  */
     108             : struct device_private {
     109             :         struct klist klist_children;
     110             :         struct klist_node knode_parent;
     111             :         struct klist_node knode_driver;
     112             :         struct klist_node knode_bus;
     113             :         struct klist_node knode_class;
     114             :         struct list_head deferred_probe;
     115             :         struct device_driver *async_driver;
     116             :         char *deferred_probe_reason;
     117             :         struct device *device;
     118             :         u8 dead:1;
     119             : };
     120             : #define to_device_private_parent(obj)   \
     121             :         container_of(obj, struct device_private, knode_parent)
     122             : #define to_device_private_driver(obj)   \
     123             :         container_of(obj, struct device_private, knode_driver)
     124             : #define to_device_private_bus(obj)      \
     125             :         container_of(obj, struct device_private, knode_bus)
     126             : #define to_device_private_class(obj)    \
     127             :         container_of(obj, struct device_private, knode_class)
     128             : 
     129             : /* initialisation functions */
     130             : int devices_init(void);
     131             : int buses_init(void);
     132             : int classes_init(void);
     133             : int firmware_init(void);
     134             : #ifdef CONFIG_SYS_HYPERVISOR
     135             : int hypervisor_init(void);
     136             : #else
     137             : static inline int hypervisor_init(void) { return 0; }
     138             : #endif
     139             : int platform_bus_init(void);
     140             : void cpu_dev_init(void);
     141             : void container_dev_init(void);
     142             : #ifdef CONFIG_AUXILIARY_BUS
     143             : void auxiliary_bus_init(void);
     144             : #else
     145             : static inline void auxiliary_bus_init(void) { }
     146             : #endif
     147             : 
     148             : struct kobject *virtual_device_parent(struct device *dev);
     149             : 
     150             : int bus_add_device(struct device *dev);
     151             : void bus_probe_device(struct device *dev);
     152             : void bus_remove_device(struct device *dev);
     153             : void bus_notify(struct device *dev, enum bus_notifier_event value);
     154             : bool bus_is_registered(const struct bus_type *bus);
     155             : 
     156             : int bus_add_driver(struct device_driver *drv);
     157             : void bus_remove_driver(struct device_driver *drv);
     158             : void device_release_driver_internal(struct device *dev, struct device_driver *drv,
     159             :                                     struct device *parent);
     160             : 
     161             : void driver_detach(struct device_driver *drv);
     162             : void driver_deferred_probe_del(struct device *dev);
     163             : void device_set_deferred_probe_reason(const struct device *dev, struct va_format *vaf);
     164             : static inline int driver_match_device(struct device_driver *drv,
     165             :                                       struct device *dev)
     166             : {
     167          66 :         return drv->bus->match ? drv->bus->match(dev, drv) : 1;
     168             : }
     169             : 
     170           0 : static inline void dev_sync_state(struct device *dev)
     171             : {
     172           0 :         if (dev->bus->sync_state)
     173           0 :                 dev->bus->sync_state(dev);
     174           0 :         else if (dev->driver && dev->driver->sync_state)
     175           0 :                 dev->driver->sync_state(dev);
     176           0 : }
     177             : 
     178             : int driver_add_groups(struct device_driver *drv, const struct attribute_group **groups);
     179             : void driver_remove_groups(struct device_driver *drv, const struct attribute_group **groups);
     180             : void device_driver_detach(struct device *dev);
     181             : 
     182             : int devres_release_all(struct device *dev);
     183             : void device_block_probing(void);
     184             : void device_unblock_probing(void);
     185             : void deferred_probe_extend_timeout(void);
     186             : void driver_deferred_probe_trigger(void);
     187             : const char *device_get_devnode(const struct device *dev, umode_t *mode,
     188             :                                kuid_t *uid, kgid_t *gid, const char **tmp);
     189             : 
     190             : /* /sys/devices directory */
     191             : extern struct kset *devices_kset;
     192             : void devices_kset_move_last(struct device *dev);
     193             : 
     194             : #if defined(CONFIG_MODULES) && defined(CONFIG_SYSFS)
     195             : void module_add_driver(struct module *mod, struct device_driver *drv);
     196             : void module_remove_driver(struct device_driver *drv);
     197             : #else
     198             : static inline void module_add_driver(struct module *mod,
     199             :                                      struct device_driver *drv) { }
     200             : static inline void module_remove_driver(struct device_driver *drv) { }
     201             : #endif
     202             : 
     203             : #ifdef CONFIG_DEVTMPFS
     204             : int devtmpfs_init(void);
     205             : #else
     206             : static inline int devtmpfs_init(void) { return 0; }
     207             : #endif
     208             : 
     209             : #ifdef CONFIG_BLOCK
     210             : extern struct class block_class;
     211             : static inline bool is_blockdev(struct device *dev)
     212             : {
     213             :         return dev->class == &block_class;
     214             : }
     215             : #else
     216             : static inline bool is_blockdev(struct device *dev) { return false; }
     217             : #endif
     218             : 
     219             : /* Device links support */
     220             : int device_links_read_lock(void);
     221             : void device_links_read_unlock(int idx);
     222             : int device_links_read_lock_held(void);
     223             : int device_links_check_suppliers(struct device *dev);
     224             : void device_links_force_bind(struct device *dev);
     225             : void device_links_driver_bound(struct device *dev);
     226             : void device_links_driver_cleanup(struct device *dev);
     227             : void device_links_no_driver(struct device *dev);
     228             : bool device_links_busy(struct device *dev);
     229             : void device_links_unbind_consumers(struct device *dev);
     230             : void fw_devlink_drivers_done(void);
     231             : void fw_devlink_probing_done(void);
     232             : 
     233             : /* device pm support */
     234             : void device_pm_move_to_tail(struct device *dev);
     235             : 
     236             : #ifdef CONFIG_DEVTMPFS
     237             : int devtmpfs_create_node(struct device *dev);
     238             : int devtmpfs_delete_node(struct device *dev);
     239             : #else
     240             : static inline int devtmpfs_create_node(struct device *dev) { return 0; }
     241             : static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
     242             : #endif
     243             : 
     244             : void software_node_notify(struct device *dev);
     245             : void software_node_notify_remove(struct device *dev);