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             :  *
      31             :  * @glue_dirs - "glue" directory to put in-between the parent device to
      32             :  *              avoid namespace conflicts
      33             :  * @class - pointer back to the struct class that this structure is associated
      34             :  *          with.
      35             :  *
      36             :  * This structure is the one that is the actual kobject allowing struct
      37             :  * bus_type/class to be statically allocated safely.  Nothing outside of the
      38             :  * driver core should ever touch these fields.
      39             :  */
      40             : struct subsys_private {
      41             :         struct kset subsys;
      42             :         struct kset *devices_kset;
      43             :         struct list_head interfaces;
      44             :         struct mutex mutex;
      45             : 
      46             :         struct kset *drivers_kset;
      47             :         struct klist klist_devices;
      48             :         struct klist klist_drivers;
      49             :         struct blocking_notifier_head bus_notifier;
      50             :         unsigned int drivers_autoprobe:1;
      51             :         struct bus_type *bus;
      52             : 
      53             :         struct kset glue_dirs;
      54             :         struct class *class;
      55             : 
      56             :         struct lock_class_key lock_key;
      57             : };
      58             : #define to_subsys_private(obj) container_of_const(obj, struct subsys_private, subsys.kobj)
      59             : 
      60             : static inline struct subsys_private *subsys_get(struct subsys_private *sp)
      61             : {
      62         419 :         if (sp)
      63         419 :                 kset_get(&sp->subsys);
      64             :         return sp;
      65             : }
      66             : 
      67             : static inline void subsys_put(struct subsys_private *sp)
      68             : {
      69           0 :         if (sp)
      70         400 :                 kset_put(&sp->subsys);
      71             : }
      72             : 
      73             : struct driver_private {
      74             :         struct kobject kobj;
      75             :         struct klist klist_devices;
      76             :         struct klist_node knode_bus;
      77             :         struct module_kobject *mkobj;
      78             :         struct device_driver *driver;
      79             : };
      80             : #define to_driver(obj) container_of(obj, struct driver_private, kobj)
      81             : 
      82             : /**
      83             :  * struct device_private - structure to hold the private to the driver core portions of the device structure.
      84             :  *
      85             :  * @klist_children - klist containing all children of this device
      86             :  * @knode_parent - node in sibling list
      87             :  * @knode_driver - node in driver list
      88             :  * @knode_bus - node in bus list
      89             :  * @knode_class - node in class list
      90             :  * @deferred_probe - entry in deferred_probe_list which is used to retry the
      91             :  *      binding of drivers which were unable to get all the resources needed by
      92             :  *      the device; typically because it depends on another driver getting
      93             :  *      probed first.
      94             :  * @async_driver - pointer to device driver awaiting probe via async_probe
      95             :  * @device - pointer back to the struct device that this structure is
      96             :  * associated with.
      97             :  * @dead - This device is currently either in the process of or has been
      98             :  *      removed from the system. Any asynchronous events scheduled for this
      99             :  *      device should exit without taking any action.
     100             :  *
     101             :  * Nothing outside of the driver core should ever touch these fields.
     102             :  */
     103             : struct device_private {
     104             :         struct klist klist_children;
     105             :         struct klist_node knode_parent;
     106             :         struct klist_node knode_driver;
     107             :         struct klist_node knode_bus;
     108             :         struct klist_node knode_class;
     109             :         struct list_head deferred_probe;
     110             :         struct device_driver *async_driver;
     111             :         char *deferred_probe_reason;
     112             :         struct device *device;
     113             :         u8 dead:1;
     114             : };
     115             : #define to_device_private_parent(obj)   \
     116             :         container_of(obj, struct device_private, knode_parent)
     117             : #define to_device_private_driver(obj)   \
     118             :         container_of(obj, struct device_private, knode_driver)
     119             : #define to_device_private_bus(obj)      \
     120             :         container_of(obj, struct device_private, knode_bus)
     121             : #define to_device_private_class(obj)    \
     122             :         container_of(obj, struct device_private, knode_class)
     123             : 
     124             : /* initialisation functions */
     125             : extern int devices_init(void);
     126             : extern int buses_init(void);
     127             : extern int classes_init(void);
     128             : extern int firmware_init(void);
     129             : #ifdef CONFIG_SYS_HYPERVISOR
     130             : extern int hypervisor_init(void);
     131             : #else
     132             : static inline int hypervisor_init(void) { return 0; }
     133             : #endif
     134             : extern int platform_bus_init(void);
     135             : extern void cpu_dev_init(void);
     136             : extern void container_dev_init(void);
     137             : #ifdef CONFIG_AUXILIARY_BUS
     138             : extern void auxiliary_bus_init(void);
     139             : #else
     140             : static inline void auxiliary_bus_init(void) { }
     141             : #endif
     142             : 
     143             : struct kobject *virtual_device_parent(struct device *dev);
     144             : 
     145             : extern int bus_add_device(struct device *dev);
     146             : extern void bus_probe_device(struct device *dev);
     147             : extern void bus_remove_device(struct device *dev);
     148             : void bus_notify(struct device *dev, enum bus_notifier_event value);
     149             : bool bus_is_registered(const struct bus_type *bus);
     150             : 
     151             : extern int bus_add_driver(struct device_driver *drv);
     152             : extern void bus_remove_driver(struct device_driver *drv);
     153             : extern void device_release_driver_internal(struct device *dev,
     154             :                                            struct device_driver *drv,
     155             :                                            struct device *parent);
     156             : 
     157             : extern void driver_detach(struct device_driver *drv);
     158             : extern void driver_deferred_probe_del(struct device *dev);
     159             : extern void device_set_deferred_probe_reason(const struct device *dev,
     160             :                                              struct va_format *vaf);
     161             : static inline int driver_match_device(struct device_driver *drv,
     162             :                                       struct device *dev)
     163             : {
     164          51 :         return drv->bus->match ? drv->bus->match(dev, drv) : 1;
     165             : }
     166             : 
     167             : extern int driver_add_groups(struct device_driver *drv,
     168             :                              const struct attribute_group **groups);
     169             : extern void driver_remove_groups(struct device_driver *drv,
     170             :                                  const struct attribute_group **groups);
     171             : void device_driver_detach(struct device *dev);
     172             : 
     173             : extern int devres_release_all(struct device *dev);
     174             : extern void device_block_probing(void);
     175             : extern void device_unblock_probing(void);
     176             : extern void deferred_probe_extend_timeout(void);
     177             : extern void driver_deferred_probe_trigger(void);
     178             : const char *device_get_devnode(const struct device *dev, umode_t *mode,
     179             :                                kuid_t *uid, kgid_t *gid, const char **tmp);
     180             : 
     181             : /* /sys/devices directory */
     182             : extern struct kset *devices_kset;
     183             : extern void devices_kset_move_last(struct device *dev);
     184             : 
     185             : #if defined(CONFIG_MODULES) && defined(CONFIG_SYSFS)
     186             : extern void module_add_driver(struct module *mod, struct device_driver *drv);
     187             : extern void module_remove_driver(struct device_driver *drv);
     188             : #else
     189             : static inline void module_add_driver(struct module *mod,
     190             :                                      struct device_driver *drv) { }
     191             : static inline void module_remove_driver(struct device_driver *drv) { }
     192             : #endif
     193             : 
     194             : #ifdef CONFIG_DEVTMPFS
     195             : extern int devtmpfs_init(void);
     196             : #else
     197             : static inline int devtmpfs_init(void) { return 0; }
     198             : #endif
     199             : 
     200             : /* Device links support */
     201             : extern int device_links_read_lock(void);
     202             : extern void device_links_read_unlock(int idx);
     203             : extern int device_links_read_lock_held(void);
     204             : extern int device_links_check_suppliers(struct device *dev);
     205             : extern void device_links_force_bind(struct device *dev);
     206             : extern void device_links_driver_bound(struct device *dev);
     207             : extern void device_links_driver_cleanup(struct device *dev);
     208             : extern void device_links_no_driver(struct device *dev);
     209             : extern bool device_links_busy(struct device *dev);
     210             : extern void device_links_unbind_consumers(struct device *dev);
     211             : extern void fw_devlink_drivers_done(void);
     212             : 
     213             : /* device pm support */
     214             : void device_pm_move_to_tail(struct device *dev);
     215             : 
     216             : #ifdef CONFIG_DEVTMPFS
     217             : int devtmpfs_create_node(struct device *dev);
     218             : int devtmpfs_delete_node(struct device *dev);
     219             : #else
     220             : static inline int devtmpfs_create_node(struct device *dev) { return 0; }
     221             : static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
     222             : #endif
     223             : 
     224             : void software_node_notify(struct device *dev);
     225             : void software_node_notify_remove(struct device *dev);