LCOV - code coverage report
Current view: top level - include/linux - device.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 3 16 18.8 %
Date: 2014-02-18 Functions: 0 0 -
Branches: 7 160 4.4 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * device.h - generic, centralized driver model
       3                 :            :  *
       4                 :            :  * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
       5                 :            :  * Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de>
       6                 :            :  * Copyright (c) 2008-2009 Novell Inc.
       7                 :            :  *
       8                 :            :  * This file is released under the GPLv2
       9                 :            :  *
      10                 :            :  * See Documentation/driver-model/ for more information.
      11                 :            :  */
      12                 :            : 
      13                 :            : #ifndef _DEVICE_H_
      14                 :            : #define _DEVICE_H_
      15                 :            : 
      16                 :            : #include <linux/ioport.h>
      17                 :            : #include <linux/kobject.h>
      18                 :            : #include <linux/klist.h>
      19                 :            : #include <linux/list.h>
      20                 :            : #include <linux/lockdep.h>
      21                 :            : #include <linux/compiler.h>
      22                 :            : #include <linux/types.h>
      23                 :            : #include <linux/mutex.h>
      24                 :            : #include <linux/pinctrl/devinfo.h>
      25                 :            : #include <linux/pm.h>
      26                 :            : #include <linux/atomic.h>
      27                 :            : #include <linux/ratelimit.h>
      28                 :            : #include <linux/uidgid.h>
      29                 :            : #include <linux/gfp.h>
      30                 :            : #include <asm/device.h>
      31                 :            : 
      32                 :            : struct device;
      33                 :            : struct device_private;
      34                 :            : struct device_driver;
      35                 :            : struct driver_private;
      36                 :            : struct module;
      37                 :            : struct class;
      38                 :            : struct subsys_private;
      39                 :            : struct bus_type;
      40                 :            : struct device_node;
      41                 :            : struct iommu_ops;
      42                 :            : struct iommu_group;
      43                 :            : 
      44                 :            : struct bus_attribute {
      45                 :            :         struct attribute        attr;
      46                 :            :         ssize_t (*show)(struct bus_type *bus, char *buf);
      47                 :            :         ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
      48                 :            : };
      49                 :            : 
      50                 :            : #define BUS_ATTR(_name, _mode, _show, _store)   \
      51                 :            :         struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
      52                 :            : #define BUS_ATTR_RW(_name) \
      53                 :            :         struct bus_attribute bus_attr_##_name = __ATTR_RW(_name)
      54                 :            : #define BUS_ATTR_RO(_name) \
      55                 :            :         struct bus_attribute bus_attr_##_name = __ATTR_RO(_name)
      56                 :            : 
      57                 :            : extern int __must_check bus_create_file(struct bus_type *,
      58                 :            :                                         struct bus_attribute *);
      59                 :            : extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
      60                 :            : 
      61                 :            : /**
      62                 :            :  * struct bus_type - The bus type of the device
      63                 :            :  *
      64                 :            :  * @name:       The name of the bus.
      65                 :            :  * @dev_name:   Used for subsystems to enumerate devices like ("foo%u", dev->id).
      66                 :            :  * @dev_root:   Default device to use as the parent.
      67                 :            :  * @dev_attrs:  Default attributes of the devices on the bus.
      68                 :            :  * @bus_groups: Default attributes of the bus.
      69                 :            :  * @dev_groups: Default attributes of the devices on the bus.
      70                 :            :  * @drv_groups: Default attributes of the device drivers on the bus.
      71                 :            :  * @match:      Called, perhaps multiple times, whenever a new device or driver
      72                 :            :  *              is added for this bus. It should return a nonzero value if the
      73                 :            :  *              given device can be handled by the given driver.
      74                 :            :  * @uevent:     Called when a device is added, removed, or a few other things
      75                 :            :  *              that generate uevents to add the environment variables.
      76                 :            :  * @probe:      Called when a new device or driver add to this bus, and callback
      77                 :            :  *              the specific driver's probe to initial the matched device.
      78                 :            :  * @remove:     Called when a device removed from this bus.
      79                 :            :  * @shutdown:   Called at shut-down time to quiesce the device.
      80                 :            :  *
      81                 :            :  * @online:     Called to put the device back online (after offlining it).
      82                 :            :  * @offline:    Called to put the device offline for hot-removal. May fail.
      83                 :            :  *
      84                 :            :  * @suspend:    Called when a device on this bus wants to go to sleep mode.
      85                 :            :  * @resume:     Called to bring a device on this bus out of sleep mode.
      86                 :            :  * @pm:         Power management operations of this bus, callback the specific
      87                 :            :  *              device driver's pm-ops.
      88                 :            :  * @iommu_ops:  IOMMU specific operations for this bus, used to attach IOMMU
      89                 :            :  *              driver implementations to a bus and allow the driver to do
      90                 :            :  *              bus-specific setup
      91                 :            :  * @p:          The private data of the driver core, only the driver core can
      92                 :            :  *              touch this.
      93                 :            :  * @lock_key:   Lock class key for use by the lock validator
      94                 :            :  *
      95                 :            :  * A bus is a channel between the processor and one or more devices. For the
      96                 :            :  * purposes of the device model, all devices are connected via a bus, even if
      97                 :            :  * it is an internal, virtual, "platform" bus. Buses can plug into each other.
      98                 :            :  * A USB controller is usually a PCI device, for example. The device model
      99                 :            :  * represents the actual connections between buses and the devices they control.
     100                 :            :  * A bus is represented by the bus_type structure. It contains the name, the
     101                 :            :  * default attributes, the bus' methods, PM operations, and the driver core's
     102                 :            :  * private data.
     103                 :            :  */
     104                 :            : struct bus_type {
     105                 :            :         const char              *name;
     106                 :            :         const char              *dev_name;
     107                 :            :         struct device           *dev_root;
     108                 :            :         struct device_attribute *dev_attrs;     /* use dev_groups instead */
     109                 :            :         const struct attribute_group **bus_groups;
     110                 :            :         const struct attribute_group **dev_groups;
     111                 :            :         const struct attribute_group **drv_groups;
     112                 :            : 
     113                 :            :         int (*match)(struct device *dev, struct device_driver *drv);
     114                 :            :         int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
     115                 :            :         int (*probe)(struct device *dev);
     116                 :            :         int (*remove)(struct device *dev);
     117                 :            :         void (*shutdown)(struct device *dev);
     118                 :            : 
     119                 :            :         int (*online)(struct device *dev);
     120                 :            :         int (*offline)(struct device *dev);
     121                 :            : 
     122                 :            :         int (*suspend)(struct device *dev, pm_message_t state);
     123                 :            :         int (*resume)(struct device *dev);
     124                 :            : 
     125                 :            :         const struct dev_pm_ops *pm;
     126                 :            : 
     127                 :            :         struct iommu_ops *iommu_ops;
     128                 :            : 
     129                 :            :         struct subsys_private *p;
     130                 :            :         struct lock_class_key lock_key;
     131                 :            : };
     132                 :            : 
     133                 :            : extern int __must_check bus_register(struct bus_type *bus);
     134                 :            : 
     135                 :            : extern void bus_unregister(struct bus_type *bus);
     136                 :            : 
     137                 :            : extern int __must_check bus_rescan_devices(struct bus_type *bus);
     138                 :            : 
     139                 :            : /* iterator helpers for buses */
     140                 :            : struct subsys_dev_iter {
     141                 :            :         struct klist_iter               ki;
     142                 :            :         const struct device_type        *type;
     143                 :            : };
     144                 :            : void subsys_dev_iter_init(struct subsys_dev_iter *iter,
     145                 :            :                          struct bus_type *subsys,
     146                 :            :                          struct device *start,
     147                 :            :                          const struct device_type *type);
     148                 :            : struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter);
     149                 :            : void subsys_dev_iter_exit(struct subsys_dev_iter *iter);
     150                 :            : 
     151                 :            : int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
     152                 :            :                      int (*fn)(struct device *dev, void *data));
     153                 :            : struct device *bus_find_device(struct bus_type *bus, struct device *start,
     154                 :            :                                void *data,
     155                 :            :                                int (*match)(struct device *dev, void *data));
     156                 :            : struct device *bus_find_device_by_name(struct bus_type *bus,
     157                 :            :                                        struct device *start,
     158                 :            :                                        const char *name);
     159                 :            : struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id,
     160                 :            :                                         struct device *hint);
     161                 :            : int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
     162                 :            :                      void *data, int (*fn)(struct device_driver *, void *));
     163                 :            : void bus_sort_breadthfirst(struct bus_type *bus,
     164                 :            :                            int (*compare)(const struct device *a,
     165                 :            :                                           const struct device *b));
     166                 :            : /*
     167                 :            :  * Bus notifiers: Get notified of addition/removal of devices
     168                 :            :  * and binding/unbinding of drivers to devices.
     169                 :            :  * In the long run, it should be a replacement for the platform
     170                 :            :  * notify hooks.
     171                 :            :  */
     172                 :            : struct notifier_block;
     173                 :            : 
     174                 :            : extern int bus_register_notifier(struct bus_type *bus,
     175                 :            :                                  struct notifier_block *nb);
     176                 :            : extern int bus_unregister_notifier(struct bus_type *bus,
     177                 :            :                                    struct notifier_block *nb);
     178                 :            : 
     179                 :            : /* All 4 notifers below get called with the target struct device *
     180                 :            :  * as an argument. Note that those functions are likely to be called
     181                 :            :  * with the device lock held in the core, so be careful.
     182                 :            :  */
     183                 :            : #define BUS_NOTIFY_ADD_DEVICE           0x00000001 /* device added */
     184                 :            : #define BUS_NOTIFY_DEL_DEVICE           0x00000002 /* device removed */
     185                 :            : #define BUS_NOTIFY_BIND_DRIVER          0x00000003 /* driver about to be
     186                 :            :                                                       bound */
     187                 :            : #define BUS_NOTIFY_BOUND_DRIVER         0x00000004 /* driver bound to device */
     188                 :            : #define BUS_NOTIFY_UNBIND_DRIVER        0x00000005 /* driver about to be
     189                 :            :                                                       unbound */
     190                 :            : #define BUS_NOTIFY_UNBOUND_DRIVER       0x00000006 /* driver is unbound
     191                 :            :                                                       from the device */
     192                 :            : 
     193                 :            : extern struct kset *bus_get_kset(struct bus_type *bus);
     194                 :            : extern struct klist *bus_get_device_klist(struct bus_type *bus);
     195                 :            : 
     196                 :            : /**
     197                 :            :  * struct device_driver - The basic device driver structure
     198                 :            :  * @name:       Name of the device driver.
     199                 :            :  * @bus:        The bus which the device of this driver belongs to.
     200                 :            :  * @owner:      The module owner.
     201                 :            :  * @mod_name:   Used for built-in modules.
     202                 :            :  * @suppress_bind_attrs: Disables bind/unbind via sysfs.
     203                 :            :  * @of_match_table: The open firmware table.
     204                 :            :  * @acpi_match_table: The ACPI match table.
     205                 :            :  * @probe:      Called to query the existence of a specific device,
     206                 :            :  *              whether this driver can work with it, and bind the driver
     207                 :            :  *              to a specific device.
     208                 :            :  * @remove:     Called when the device is removed from the system to
     209                 :            :  *              unbind a device from this driver.
     210                 :            :  * @shutdown:   Called at shut-down time to quiesce the device.
     211                 :            :  * @suspend:    Called to put the device to sleep mode. Usually to a
     212                 :            :  *              low power state.
     213                 :            :  * @resume:     Called to bring a device from sleep mode.
     214                 :            :  * @groups:     Default attributes that get created by the driver core
     215                 :            :  *              automatically.
     216                 :            :  * @pm:         Power management operations of the device which matched
     217                 :            :  *              this driver.
     218                 :            :  * @p:          Driver core's private data, no one other than the driver
     219                 :            :  *              core can touch this.
     220                 :            :  *
     221                 :            :  * The device driver-model tracks all of the drivers known to the system.
     222                 :            :  * The main reason for this tracking is to enable the driver core to match
     223                 :            :  * up drivers with new devices. Once drivers are known objects within the
     224                 :            :  * system, however, a number of other things become possible. Device drivers
     225                 :            :  * can export information and configuration variables that are independent
     226                 :            :  * of any specific device.
     227                 :            :  */
     228                 :            : struct device_driver {
     229                 :            :         const char              *name;
     230                 :            :         struct bus_type         *bus;
     231                 :            : 
     232                 :            :         struct module           *owner;
     233                 :            :         const char              *mod_name;      /* used for built-in modules */
     234                 :            : 
     235                 :            :         bool suppress_bind_attrs;       /* disables bind/unbind via sysfs */
     236                 :            : 
     237                 :            :         const struct of_device_id       *of_match_table;
     238                 :            :         const struct acpi_device_id     *acpi_match_table;
     239                 :            : 
     240                 :            :         int (*probe) (struct device *dev);
     241                 :            :         int (*remove) (struct device *dev);
     242                 :            :         void (*shutdown) (struct device *dev);
     243                 :            :         int (*suspend) (struct device *dev, pm_message_t state);
     244                 :            :         int (*resume) (struct device *dev);
     245                 :            :         const struct attribute_group **groups;
     246                 :            : 
     247                 :            :         const struct dev_pm_ops *pm;
     248                 :            : 
     249                 :            :         struct driver_private *p;
     250                 :            : };
     251                 :            : 
     252                 :            : 
     253                 :            : extern int __must_check driver_register(struct device_driver *drv);
     254                 :            : extern void driver_unregister(struct device_driver *drv);
     255                 :            : 
     256                 :            : extern struct device_driver *driver_find(const char *name,
     257                 :            :                                          struct bus_type *bus);
     258                 :            : extern int driver_probe_done(void);
     259                 :            : extern void wait_for_device_probe(void);
     260                 :            : 
     261                 :            : 
     262                 :            : /* sysfs interface for exporting driver attributes */
     263                 :            : 
     264                 :            : struct driver_attribute {
     265                 :            :         struct attribute attr;
     266                 :            :         ssize_t (*show)(struct device_driver *driver, char *buf);
     267                 :            :         ssize_t (*store)(struct device_driver *driver, const char *buf,
     268                 :            :                          size_t count);
     269                 :            : };
     270                 :            : 
     271                 :            : #define DRIVER_ATTR(_name, _mode, _show, _store) \
     272                 :            :         struct driver_attribute driver_attr_##_name = __ATTR(_name, _mode, _show, _store)
     273                 :            : #define DRIVER_ATTR_RW(_name) \
     274                 :            :         struct driver_attribute driver_attr_##_name = __ATTR_RW(_name)
     275                 :            : #define DRIVER_ATTR_RO(_name) \
     276                 :            :         struct driver_attribute driver_attr_##_name = __ATTR_RO(_name)
     277                 :            : #define DRIVER_ATTR_WO(_name) \
     278                 :            :         struct driver_attribute driver_attr_##_name = __ATTR_WO(_name)
     279                 :            : 
     280                 :            : extern int __must_check driver_create_file(struct device_driver *driver,
     281                 :            :                                         const struct driver_attribute *attr);
     282                 :            : extern void driver_remove_file(struct device_driver *driver,
     283                 :            :                                const struct driver_attribute *attr);
     284                 :            : 
     285                 :            : extern int __must_check driver_for_each_device(struct device_driver *drv,
     286                 :            :                                                struct device *start,
     287                 :            :                                                void *data,
     288                 :            :                                                int (*fn)(struct device *dev,
     289                 :            :                                                          void *));
     290                 :            : struct device *driver_find_device(struct device_driver *drv,
     291                 :            :                                   struct device *start, void *data,
     292                 :            :                                   int (*match)(struct device *dev, void *data));
     293                 :            : 
     294                 :            : /**
     295                 :            :  * struct subsys_interface - interfaces to device functions
     296                 :            :  * @name:       name of the device function
     297                 :            :  * @subsys:     subsytem of the devices to attach to
     298                 :            :  * @node:       the list of functions registered at the subsystem
     299                 :            :  * @add_dev:    device hookup to device function handler
     300                 :            :  * @remove_dev: device hookup to device function handler
     301                 :            :  *
     302                 :            :  * Simple interfaces attached to a subsystem. Multiple interfaces can
     303                 :            :  * attach to a subsystem and its devices. Unlike drivers, they do not
     304                 :            :  * exclusively claim or control devices. Interfaces usually represent
     305                 :            :  * a specific functionality of a subsystem/class of devices.
     306                 :            :  */
     307                 :            : struct subsys_interface {
     308                 :            :         const char *name;
     309                 :            :         struct bus_type *subsys;
     310                 :            :         struct list_head node;
     311                 :            :         int (*add_dev)(struct device *dev, struct subsys_interface *sif);
     312                 :            :         int (*remove_dev)(struct device *dev, struct subsys_interface *sif);
     313                 :            : };
     314                 :            : 
     315                 :            : int subsys_interface_register(struct subsys_interface *sif);
     316                 :            : void subsys_interface_unregister(struct subsys_interface *sif);
     317                 :            : 
     318                 :            : int subsys_system_register(struct bus_type *subsys,
     319                 :            :                            const struct attribute_group **groups);
     320                 :            : int subsys_virtual_register(struct bus_type *subsys,
     321                 :            :                             const struct attribute_group **groups);
     322                 :            : 
     323                 :            : /**
     324                 :            :  * struct class - device classes
     325                 :            :  * @name:       Name of the class.
     326                 :            :  * @owner:      The module owner.
     327                 :            :  * @class_attrs: Default attributes of this class.
     328                 :            :  * @dev_groups: Default attributes of the devices that belong to the class.
     329                 :            :  * @dev_kobj:   The kobject that represents this class and links it into the hierarchy.
     330                 :            :  * @dev_uevent: Called when a device is added, removed from this class, or a
     331                 :            :  *              few other things that generate uevents to add the environment
     332                 :            :  *              variables.
     333                 :            :  * @devnode:    Callback to provide the devtmpfs.
     334                 :            :  * @class_release: Called to release this class.
     335                 :            :  * @dev_release: Called to release the device.
     336                 :            :  * @suspend:    Used to put the device to sleep mode, usually to a low power
     337                 :            :  *              state.
     338                 :            :  * @resume:     Used to bring the device from the sleep mode.
     339                 :            :  * @ns_type:    Callbacks so sysfs can detemine namespaces.
     340                 :            :  * @namespace:  Namespace of the device belongs to this class.
     341                 :            :  * @pm:         The default device power management operations of this class.
     342                 :            :  * @p:          The private data of the driver core, no one other than the
     343                 :            :  *              driver core can touch this.
     344                 :            :  *
     345                 :            :  * A class is a higher-level view of a device that abstracts out low-level
     346                 :            :  * implementation details. Drivers may see a SCSI disk or an ATA disk, but,
     347                 :            :  * at the class level, they are all simply disks. Classes allow user space
     348                 :            :  * to work with devices based on what they do, rather than how they are
     349                 :            :  * connected or how they work.
     350                 :            :  */
     351                 :            : struct class {
     352                 :            :         const char              *name;
     353                 :            :         struct module           *owner;
     354                 :            : 
     355                 :            :         struct class_attribute          *class_attrs;
     356                 :            :         const struct attribute_group    **dev_groups;
     357                 :            :         struct kobject                  *dev_kobj;
     358                 :            : 
     359                 :            :         int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
     360                 :            :         char *(*devnode)(struct device *dev, umode_t *mode);
     361                 :            : 
     362                 :            :         void (*class_release)(struct class *class);
     363                 :            :         void (*dev_release)(struct device *dev);
     364                 :            : 
     365                 :            :         int (*suspend)(struct device *dev, pm_message_t state);
     366                 :            :         int (*resume)(struct device *dev);
     367                 :            : 
     368                 :            :         const struct kobj_ns_type_operations *ns_type;
     369                 :            :         const void *(*namespace)(struct device *dev);
     370                 :            : 
     371                 :            :         const struct dev_pm_ops *pm;
     372                 :            : 
     373                 :            :         struct subsys_private *p;
     374                 :            : };
     375                 :            : 
     376                 :            : struct class_dev_iter {
     377                 :            :         struct klist_iter               ki;
     378                 :            :         const struct device_type        *type;
     379                 :            : };
     380                 :            : 
     381                 :            : extern struct kobject *sysfs_dev_block_kobj;
     382                 :            : extern struct kobject *sysfs_dev_char_kobj;
     383                 :            : extern int __must_check __class_register(struct class *class,
     384                 :            :                                          struct lock_class_key *key);
     385                 :            : extern void class_unregister(struct class *class);
     386                 :            : 
     387                 :            : /* This is a #define to keep the compiler from merging different
     388                 :            :  * instances of the __key variable */
     389                 :            : #define class_register(class)                   \
     390                 :            : ({                                              \
     391                 :            :         static struct lock_class_key __key;     \
     392                 :            :         __class_register(class, &__key);    \
     393                 :            : })
     394                 :            : 
     395                 :            : struct class_compat;
     396                 :            : struct class_compat *class_compat_register(const char *name);
     397                 :            : void class_compat_unregister(struct class_compat *cls);
     398                 :            : int class_compat_create_link(struct class_compat *cls, struct device *dev,
     399                 :            :                              struct device *device_link);
     400                 :            : void class_compat_remove_link(struct class_compat *cls, struct device *dev,
     401                 :            :                               struct device *device_link);
     402                 :            : 
     403                 :            : extern void class_dev_iter_init(struct class_dev_iter *iter,
     404                 :            :                                 struct class *class,
     405                 :            :                                 struct device *start,
     406                 :            :                                 const struct device_type *type);
     407                 :            : extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
     408                 :            : extern void class_dev_iter_exit(struct class_dev_iter *iter);
     409                 :            : 
     410                 :            : extern int class_for_each_device(struct class *class, struct device *start,
     411                 :            :                                  void *data,
     412                 :            :                                  int (*fn)(struct device *dev, void *data));
     413                 :            : extern struct device *class_find_device(struct class *class,
     414                 :            :                                         struct device *start, const void *data,
     415                 :            :                                         int (*match)(struct device *, const void *));
     416                 :            : 
     417                 :            : struct class_attribute {
     418                 :            :         struct attribute attr;
     419                 :            :         ssize_t (*show)(struct class *class, struct class_attribute *attr,
     420                 :            :                         char *buf);
     421                 :            :         ssize_t (*store)(struct class *class, struct class_attribute *attr,
     422                 :            :                         const char *buf, size_t count);
     423                 :            : };
     424                 :            : 
     425                 :            : #define CLASS_ATTR(_name, _mode, _show, _store) \
     426                 :            :         struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
     427                 :            : #define CLASS_ATTR_RW(_name) \
     428                 :            :         struct class_attribute class_attr_##_name = __ATTR_RW(_name)
     429                 :            : #define CLASS_ATTR_RO(_name) \
     430                 :            :         struct class_attribute class_attr_##_name = __ATTR_RO(_name)
     431                 :            : 
     432                 :            : extern int __must_check class_create_file_ns(struct class *class,
     433                 :            :                                              const struct class_attribute *attr,
     434                 :            :                                              const void *ns);
     435                 :            : extern void class_remove_file_ns(struct class *class,
     436                 :            :                                  const struct class_attribute *attr,
     437                 :            :                                  const void *ns);
     438                 :            : 
     439                 :            : static inline int __must_check class_create_file(struct class *class,
     440                 :            :                                         const struct class_attribute *attr)
     441                 :            : {
     442                 :          0 :         return class_create_file_ns(class, attr, NULL);
     443                 :            : }
     444                 :            : 
     445                 :            : static inline void class_remove_file(struct class *class,
     446                 :            :                                      const struct class_attribute *attr)
     447                 :            : {
     448                 :          0 :         return class_remove_file_ns(class, attr, NULL);
     449                 :            : }
     450                 :            : 
     451                 :            : /* Simple class attribute that is just a static string */
     452                 :            : struct class_attribute_string {
     453                 :            :         struct class_attribute attr;
     454                 :            :         char *str;
     455                 :            : };
     456                 :            : 
     457                 :            : /* Currently read-only only */
     458                 :            : #define _CLASS_ATTR_STRING(_name, _mode, _str) \
     459                 :            :         { __ATTR(_name, _mode, show_class_attr_string, NULL), _str }
     460                 :            : #define CLASS_ATTR_STRING(_name, _mode, _str) \
     461                 :            :         struct class_attribute_string class_attr_##_name = \
     462                 :            :                 _CLASS_ATTR_STRING(_name, _mode, _str)
     463                 :            : 
     464                 :            : extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
     465                 :            :                         char *buf);
     466                 :            : 
     467                 :            : struct class_interface {
     468                 :            :         struct list_head        node;
     469                 :            :         struct class            *class;
     470                 :            : 
     471                 :            :         int (*add_dev)          (struct device *, struct class_interface *);
     472                 :            :         void (*remove_dev)      (struct device *, struct class_interface *);
     473                 :            : };
     474                 :            : 
     475                 :            : extern int __must_check class_interface_register(struct class_interface *);
     476                 :            : extern void class_interface_unregister(struct class_interface *);
     477                 :            : 
     478                 :            : extern struct class * __must_check __class_create(struct module *owner,
     479                 :            :                                                   const char *name,
     480                 :            :                                                   struct lock_class_key *key);
     481                 :            : extern void class_destroy(struct class *cls);
     482                 :            : 
     483                 :            : /* This is a #define to keep the compiler from merging different
     484                 :            :  * instances of the __key variable */
     485                 :            : #define class_create(owner, name)               \
     486                 :            : ({                                              \
     487                 :            :         static struct lock_class_key __key;     \
     488                 :            :         __class_create(owner, name, &__key);        \
     489                 :            : })
     490                 :            : 
     491                 :            : /*
     492                 :            :  * The type of device, "struct device" is embedded in. A class
     493                 :            :  * or bus can contain devices of different types
     494                 :            :  * like "partitions" and "disks", "mouse" and "event".
     495                 :            :  * This identifies the device type and carries type-specific
     496                 :            :  * information, equivalent to the kobj_type of a kobject.
     497                 :            :  * If "name" is specified, the uevent will contain it in
     498                 :            :  * the DEVTYPE variable.
     499                 :            :  */
     500                 :            : struct device_type {
     501                 :            :         const char *name;
     502                 :            :         const struct attribute_group **groups;
     503                 :            :         int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
     504                 :            :         char *(*devnode)(struct device *dev, umode_t *mode,
     505                 :            :                          kuid_t *uid, kgid_t *gid);
     506                 :            :         void (*release)(struct device *dev);
     507                 :            : 
     508                 :            :         const struct dev_pm_ops *pm;
     509                 :            : };
     510                 :            : 
     511                 :            : /* interface for exporting device attributes */
     512                 :            : struct device_attribute {
     513                 :            :         struct attribute        attr;
     514                 :            :         ssize_t (*show)(struct device *dev, struct device_attribute *attr,
     515                 :            :                         char *buf);
     516                 :            :         ssize_t (*store)(struct device *dev, struct device_attribute *attr,
     517                 :            :                          const char *buf, size_t count);
     518                 :            : };
     519                 :            : 
     520                 :            : struct dev_ext_attribute {
     521                 :            :         struct device_attribute attr;
     522                 :            :         void *var;
     523                 :            : };
     524                 :            : 
     525                 :            : ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr,
     526                 :            :                           char *buf);
     527                 :            : ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr,
     528                 :            :                            const char *buf, size_t count);
     529                 :            : ssize_t device_show_int(struct device *dev, struct device_attribute *attr,
     530                 :            :                         char *buf);
     531                 :            : ssize_t device_store_int(struct device *dev, struct device_attribute *attr,
     532                 :            :                          const char *buf, size_t count);
     533                 :            : ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
     534                 :            :                         char *buf);
     535                 :            : ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
     536                 :            :                          const char *buf, size_t count);
     537                 :            : 
     538                 :            : #define DEVICE_ATTR(_name, _mode, _show, _store) \
     539                 :            :         struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
     540                 :            : #define DEVICE_ATTR_RW(_name) \
     541                 :            :         struct device_attribute dev_attr_##_name = __ATTR_RW(_name)
     542                 :            : #define DEVICE_ATTR_RO(_name) \
     543                 :            :         struct device_attribute dev_attr_##_name = __ATTR_RO(_name)
     544                 :            : #define DEVICE_ATTR_WO(_name) \
     545                 :            :         struct device_attribute dev_attr_##_name = __ATTR_WO(_name)
     546                 :            : #define DEVICE_ULONG_ATTR(_name, _mode, _var) \
     547                 :            :         struct dev_ext_attribute dev_attr_##_name = \
     548                 :            :                 { __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) }
     549                 :            : #define DEVICE_INT_ATTR(_name, _mode, _var) \
     550                 :            :         struct dev_ext_attribute dev_attr_##_name = \
     551                 :            :                 { __ATTR(_name, _mode, device_show_int, device_store_int), &(_var) }
     552                 :            : #define DEVICE_BOOL_ATTR(_name, _mode, _var) \
     553                 :            :         struct dev_ext_attribute dev_attr_##_name = \
     554                 :            :                 { __ATTR(_name, _mode, device_show_bool, device_store_bool), &(_var) }
     555                 :            : #define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \
     556                 :            :         struct device_attribute dev_attr_##_name =              \
     557                 :            :                 __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store)
     558                 :            : 
     559                 :            : extern int device_create_file(struct device *device,
     560                 :            :                               const struct device_attribute *entry);
     561                 :            : extern void device_remove_file(struct device *dev,
     562                 :            :                                const struct device_attribute *attr);
     563                 :            : extern int __must_check device_create_bin_file(struct device *dev,
     564                 :            :                                         const struct bin_attribute *attr);
     565                 :            : extern void device_remove_bin_file(struct device *dev,
     566                 :            :                                    const struct bin_attribute *attr);
     567                 :            : extern int device_schedule_callback_owner(struct device *dev,
     568                 :            :                 void (*func)(struct device *dev), struct module *owner);
     569                 :            : 
     570                 :            : /* This is a macro to avoid include problems with THIS_MODULE */
     571                 :            : #define device_schedule_callback(dev, func)                     \
     572                 :            :         device_schedule_callback_owner(dev, func, THIS_MODULE)
     573                 :            : 
     574                 :            : /* device resource management */
     575                 :            : typedef void (*dr_release_t)(struct device *dev, void *res);
     576                 :            : typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
     577                 :            : 
     578                 :            : #ifdef CONFIG_DEBUG_DEVRES
     579                 :            : extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
     580                 :            :                              const char *name);
     581                 :            : #define devres_alloc(release, size, gfp) \
     582                 :            :         __devres_alloc(release, size, gfp, #release)
     583                 :            : #else
     584                 :            : extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
     585                 :            : #endif
     586                 :            : extern void devres_for_each_res(struct device *dev, dr_release_t release,
     587                 :            :                                 dr_match_t match, void *match_data,
     588                 :            :                                 void (*fn)(struct device *, void *, void *),
     589                 :            :                                 void *data);
     590                 :            : extern void devres_free(void *res);
     591                 :            : extern void devres_add(struct device *dev, void *res);
     592                 :            : extern void *devres_find(struct device *dev, dr_release_t release,
     593                 :            :                          dr_match_t match, void *match_data);
     594                 :            : extern void *devres_get(struct device *dev, void *new_res,
     595                 :            :                         dr_match_t match, void *match_data);
     596                 :            : extern void *devres_remove(struct device *dev, dr_release_t release,
     597                 :            :                            dr_match_t match, void *match_data);
     598                 :            : extern int devres_destroy(struct device *dev, dr_release_t release,
     599                 :            :                           dr_match_t match, void *match_data);
     600                 :            : extern int devres_release(struct device *dev, dr_release_t release,
     601                 :            :                           dr_match_t match, void *match_data);
     602                 :            : 
     603                 :            : /* devres group */
     604                 :            : extern void * __must_check devres_open_group(struct device *dev, void *id,
     605                 :            :                                              gfp_t gfp);
     606                 :            : extern void devres_close_group(struct device *dev, void *id);
     607                 :            : extern void devres_remove_group(struct device *dev, void *id);
     608                 :            : extern int devres_release_group(struct device *dev, void *id);
     609                 :            : 
     610                 :            : /* managed devm_k.alloc/kfree for device drivers */
     611                 :            : extern void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp);
     612                 :            : static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
     613                 :            : {
     614                 :          0 :         return devm_kmalloc(dev, size, gfp | __GFP_ZERO);
     615                 :            : }
     616                 :            : static inline void *devm_kmalloc_array(struct device *dev,
     617                 :            :                                        size_t n, size_t size, gfp_t flags)
     618                 :            : {
     619                 :            :         if (size != 0 && n > SIZE_MAX / size)
     620                 :            :                 return NULL;
     621                 :            :         return devm_kmalloc(dev, n * size, flags);
     622                 :            : }
     623                 :            : static inline void *devm_kcalloc(struct device *dev,
     624                 :            :                                  size_t n, size_t size, gfp_t flags)
     625                 :            : {
     626                 :            :         return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO);
     627                 :            : }
     628                 :            : extern void devm_kfree(struct device *dev, void *p);
     629                 :            : 
     630                 :            : void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res);
     631                 :            : void __iomem *devm_request_and_ioremap(struct device *dev,
     632                 :            :                         struct resource *res);
     633                 :            : 
     634                 :            : /* allows to add/remove a custom action to devres stack */
     635                 :            : int devm_add_action(struct device *dev, void (*action)(void *), void *data);
     636                 :            : void devm_remove_action(struct device *dev, void (*action)(void *), void *data);
     637                 :            : 
     638                 :            : struct device_dma_parameters {
     639                 :            :         /*
     640                 :            :          * a low level driver may set these to teach IOMMU code about
     641                 :            :          * sg limitations.
     642                 :            :          */
     643                 :            :         unsigned int max_segment_size;
     644                 :            :         unsigned long segment_boundary_mask;
     645                 :            : };
     646                 :            : 
     647                 :            : struct acpi_device;
     648                 :            : 
     649                 :            : struct acpi_dev_node {
     650                 :            : #ifdef CONFIG_ACPI
     651                 :            :         struct acpi_device *companion;
     652                 :            : #endif
     653                 :            : };
     654                 :            : 
     655                 :            : /**
     656                 :            :  * struct device - The basic device structure
     657                 :            :  * @parent:     The device's "parent" device, the device to which it is attached.
     658                 :            :  *              In most cases, a parent device is some sort of bus or host
     659                 :            :  *              controller. If parent is NULL, the device, is a top-level device,
     660                 :            :  *              which is not usually what you want.
     661                 :            :  * @p:          Holds the private data of the driver core portions of the device.
     662                 :            :  *              See the comment of the struct device_private for detail.
     663                 :            :  * @kobj:       A top-level, abstract class from which other classes are derived.
     664                 :            :  * @init_name:  Initial name of the device.
     665                 :            :  * @type:       The type of device.
     666                 :            :  *              This identifies the device type and carries type-specific
     667                 :            :  *              information.
     668                 :            :  * @mutex:      Mutex to synchronize calls to its driver.
     669                 :            :  * @bus:        Type of bus device is on.
     670                 :            :  * @driver:     Which driver has allocated this
     671                 :            :  * @platform_data: Platform data specific to the device.
     672                 :            :  *              Example: For devices on custom boards, as typical of embedded
     673                 :            :  *              and SOC based hardware, Linux often uses platform_data to point
     674                 :            :  *              to board-specific structures describing devices and how they
     675                 :            :  *              are wired.  That can include what ports are available, chip
     676                 :            :  *              variants, which GPIO pins act in what additional roles, and so
     677                 :            :  *              on.  This shrinks the "Board Support Packages" (BSPs) and
     678                 :            :  *              minimizes board-specific #ifdefs in drivers.
     679                 :            :  * @power:      For device power management.
     680                 :            :  *              See Documentation/power/devices.txt for details.
     681                 :            :  * @pm_domain:  Provide callbacks that are executed during system suspend,
     682                 :            :  *              hibernation, system resume and during runtime PM transitions
     683                 :            :  *              along with subsystem-level and driver-level callbacks.
     684                 :            :  * @pins:       For device pin management.
     685                 :            :  *              See Documentation/pinctrl.txt for details.
     686                 :            :  * @numa_node:  NUMA node this device is close to.
     687                 :            :  * @dma_mask:   Dma mask (if dma'ble device).
     688                 :            :  * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all
     689                 :            :  *              hardware supports 64-bit addresses for consistent allocations
     690                 :            :  *              such descriptors.
     691                 :            :  * @dma_parms:  A low level driver may set these to teach IOMMU code about
     692                 :            :  *              segment limitations.
     693                 :            :  * @dma_pools:  Dma pools (if dma'ble device).
     694                 :            :  * @dma_mem:    Internal for coherent mem override.
     695                 :            :  * @cma_area:   Contiguous memory area for dma allocations
     696                 :            :  * @archdata:   For arch-specific additions.
     697                 :            :  * @of_node:    Associated device tree node.
     698                 :            :  * @acpi_node:  Associated ACPI device node.
     699                 :            :  * @devt:       For creating the sysfs "dev".
     700                 :            :  * @id:         device instance
     701                 :            :  * @devres_lock: Spinlock to protect the resource of the device.
     702                 :            :  * @devres_head: The resources list of the device.
     703                 :            :  * @knode_class: The node used to add the device to the class list.
     704                 :            :  * @class:      The class of the device.
     705                 :            :  * @groups:     Optional attribute groups.
     706                 :            :  * @release:    Callback to free the device after all references have
     707                 :            :  *              gone away. This should be set by the allocator of the
     708                 :            :  *              device (i.e. the bus driver that discovered the device).
     709                 :            :  * @iommu_group: IOMMU group the device belongs to.
     710                 :            :  *
     711                 :            :  * @offline_disabled: If set, the device is permanently online.
     712                 :            :  * @offline:    Set after successful invocation of bus type's .offline().
     713                 :            :  *
     714                 :            :  * At the lowest level, every device in a Linux system is represented by an
     715                 :            :  * instance of struct device. The device structure contains the information
     716                 :            :  * that the device model core needs to model the system. Most subsystems,
     717                 :            :  * however, track additional information about the devices they host. As a
     718                 :            :  * result, it is rare for devices to be represented by bare device structures;
     719                 :            :  * instead, that structure, like kobject structures, is usually embedded within
     720                 :            :  * a higher-level representation of the device.
     721                 :            :  */
     722                 :            : struct device {
     723                 :            :         struct device           *parent;
     724                 :            : 
     725                 :            :         struct device_private   *p;
     726                 :            : 
     727                 :            :         struct kobject kobj;
     728                 :            :         const char              *init_name; /* initial name of the device */
     729                 :            :         const struct device_type *type;
     730                 :            : 
     731                 :            :         struct mutex            mutex;  /* mutex to synchronize calls to
     732                 :            :                                          * its driver.
     733                 :            :                                          */
     734                 :            : 
     735                 :            :         struct bus_type *bus;           /* type of bus device is on */
     736                 :            :         struct device_driver *driver;   /* which driver has allocated this
     737                 :            :                                            device */
     738                 :            :         void            *platform_data; /* Platform specific data, device
     739                 :            :                                            core doesn't touch it */
     740                 :            :         struct dev_pm_info      power;
     741                 :            :         struct dev_pm_domain    *pm_domain;
     742                 :            : 
     743                 :            : #ifdef CONFIG_PINCTRL
     744                 :            :         struct dev_pin_info     *pins;
     745                 :            : #endif
     746                 :            : 
     747                 :            : #ifdef CONFIG_NUMA
     748                 :            :         int             numa_node;      /* NUMA node this device is close to */
     749                 :            : #endif
     750                 :            :         u64             *dma_mask;      /* dma mask (if dma'able device) */
     751                 :            :         u64             coherent_dma_mask;/* Like dma_mask, but for
     752                 :            :                                              alloc_coherent mappings as
     753                 :            :                                              not all hardware supports
     754                 :            :                                              64 bit addresses for consistent
     755                 :            :                                              allocations such descriptors. */
     756                 :            : 
     757                 :            :         struct device_dma_parameters *dma_parms;
     758                 :            : 
     759                 :            :         struct list_head        dma_pools;      /* dma pools (if dma'ble) */
     760                 :            : 
     761                 :            :         struct dma_coherent_mem *dma_mem; /* internal for coherent mem
     762                 :            :                                              override */
     763                 :            : #ifdef CONFIG_DMA_CMA
     764                 :            :         struct cma *cma_area;           /* contiguous memory area for dma
     765                 :            :                                            allocations */
     766                 :            : #endif
     767                 :            :         /* arch specific additions */
     768                 :            :         struct dev_archdata     archdata;
     769                 :            : 
     770                 :            :         struct device_node      *of_node; /* associated device tree node */
     771                 :            :         struct acpi_dev_node    acpi_node; /* associated ACPI device node */
     772                 :            : 
     773                 :            :         dev_t                   devt;   /* dev_t, creates the sysfs "dev" */
     774                 :            :         u32                     id;     /* device instance */
     775                 :            : 
     776                 :            :         spinlock_t              devres_lock;
     777                 :            :         struct list_head        devres_head;
     778                 :            : 
     779                 :            :         struct klist_node       knode_class;
     780                 :            :         struct class            *class;
     781                 :            :         const struct attribute_group **groups;  /* optional groups */
     782                 :            : 
     783                 :            :         void    (*release)(struct device *dev);
     784                 :            :         struct iommu_group      *iommu_group;
     785                 :            : 
     786                 :            :         bool                    offline_disabled:1;
     787                 :            :         bool                    offline:1;
     788                 :            : };
     789                 :            : 
     790                 :            : static inline struct device *kobj_to_dev(struct kobject *kobj)
     791                 :            : {
     792                 :            :         return container_of(kobj, struct device, kobj);
     793                 :            : }
     794                 :            : 
     795                 :            : /* Get the wakeup routines, which depend on struct device */
     796                 :            : #include <linux/pm_wakeup.h>
     797                 :            : 
     798                 :            : static inline const char *dev_name(const struct device *dev)
     799                 :            : {
     800                 :            :         /* Use the init name until the kobject becomes available */
     801 [ +  - ][ #  # ]:       6407 :         if (dev->init_name)
         [ #  # ][ +  - ]
         [ +  - ][ #  # ]
         [ +  - ][ +  - ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
           [ #  #  #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ +  - ]
           [ #  #  #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
           [ #  #  #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     802                 :            :                 return dev->init_name;
     803                 :            : 
     804                 :       5847 :         return kobject_name(&dev->kobj);
     805                 :            : }
     806                 :            : 
     807                 :            : extern __printf(2, 3)
     808                 :            : int dev_set_name(struct device *dev, const char *name, ...);
     809                 :            : 
     810                 :            : #ifdef CONFIG_NUMA
     811                 :            : static inline int dev_to_node(struct device *dev)
     812                 :            : {
     813                 :            :         return dev->numa_node;
     814                 :            : }
     815                 :            : static inline void set_dev_node(struct device *dev, int node)
     816                 :            : {
     817                 :            :         dev->numa_node = node;
     818                 :            : }
     819                 :            : #else
     820                 :            : static inline int dev_to_node(struct device *dev)
     821                 :            : {
     822                 :            :         return -1;
     823                 :            : }
     824                 :            : static inline void set_dev_node(struct device *dev, int node)
     825                 :            : {
     826                 :            : }
     827                 :            : #endif
     828                 :            : 
     829                 :            : static inline struct pm_subsys_data *dev_to_psd(struct device *dev)
     830                 :            : {
     831 [ #  # ][ #  # ]:          0 :         return dev ? dev->power.subsys_data : NULL;
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
     832                 :            : }
     833                 :            : 
     834                 :            : static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
     835                 :            : {
     836                 :          0 :         return dev->kobj.uevent_suppress;
     837                 :            : }
     838                 :            : 
     839                 :            : static inline void dev_set_uevent_suppress(struct device *dev, int val)
     840                 :            : {
     841                 :          0 :         dev->kobj.uevent_suppress = val;
     842                 :            : }
     843                 :            : 
     844                 :            : static inline int device_is_registered(struct device *dev)
     845                 :            : {
     846                 :          0 :         return dev->kobj.state_in_sysfs;
     847                 :            : }
     848                 :            : 
     849                 :            : static inline void device_enable_async_suspend(struct device *dev)
     850                 :            : {
     851   [ #  #  #  # ]:          0 :         if (!dev->power.is_prepared)
         [ #  # ][ #  # ]
     852                 :          0 :                 dev->power.async_suspend = true;
     853                 :            : }
     854                 :            : 
     855                 :            : static inline void device_disable_async_suspend(struct device *dev)
     856                 :            : {
     857                 :            :         if (!dev->power.is_prepared)
     858                 :            :                 dev->power.async_suspend = false;
     859                 :            : }
     860                 :            : 
     861                 :            : static inline bool device_async_suspend_enabled(struct device *dev)
     862                 :            : {
     863                 :            :         return !!dev->power.async_suspend;
     864                 :            : }
     865                 :            : 
     866                 :            : static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
     867                 :            : {
     868                 :          0 :         dev->power.ignore_children = enable;
     869                 :            : }
     870                 :            : 
     871                 :            : static inline void dev_pm_syscore_device(struct device *dev, bool val)
     872                 :            : {
     873                 :            : #ifdef CONFIG_PM_SLEEP
     874                 :            :         dev->power.syscore = val;
     875                 :            : #endif
     876                 :            : }
     877                 :            : 
     878                 :            : static inline void device_lock(struct device *dev)
     879                 :            : {
     880                 :          0 :         mutex_lock(&dev->mutex);
     881                 :            : }
     882                 :            : 
     883                 :            : static inline int device_trylock(struct device *dev)
     884                 :            : {
     885                 :          0 :         return mutex_trylock(&dev->mutex);
     886                 :            : }
     887                 :            : 
     888                 :            : static inline void device_unlock(struct device *dev)
     889                 :            : {
     890                 :          0 :         mutex_unlock(&dev->mutex);
     891                 :            : }
     892                 :            : 
     893                 :            : void driver_init(void);
     894                 :            : 
     895                 :            : /*
     896                 :            :  * High level routines for use by the bus drivers
     897                 :            :  */
     898                 :            : extern int __must_check device_register(struct device *dev);
     899                 :            : extern void device_unregister(struct device *dev);
     900                 :            : extern void device_initialize(struct device *dev);
     901                 :            : extern int __must_check device_add(struct device *dev);
     902                 :            : extern void device_del(struct device *dev);
     903                 :            : extern int device_for_each_child(struct device *dev, void *data,
     904                 :            :                      int (*fn)(struct device *dev, void *data));
     905                 :            : extern struct device *device_find_child(struct device *dev, void *data,
     906                 :            :                                 int (*match)(struct device *dev, void *data));
     907                 :            : extern int device_rename(struct device *dev, const char *new_name);
     908                 :            : extern int device_move(struct device *dev, struct device *new_parent,
     909                 :            :                        enum dpm_order dpm_order);
     910                 :            : extern const char *device_get_devnode(struct device *dev,
     911                 :            :                                       umode_t *mode, kuid_t *uid, kgid_t *gid,
     912                 :            :                                       const char **tmp);
     913                 :            : extern void *dev_get_drvdata(const struct device *dev);
     914                 :            : extern int dev_set_drvdata(struct device *dev, void *data);
     915                 :            : 
     916                 :            : static inline bool device_supports_offline(struct device *dev)
     917                 :            : {
     918 [ #  # ][ #  # ]:        112 :         return dev->bus && dev->bus->offline && dev->bus->online;
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ -  + ]
         [ #  # ][ #  # ]
     919                 :            : }
     920                 :            : 
     921                 :            : extern void lock_device_hotplug(void);
     922                 :            : extern void unlock_device_hotplug(void);
     923                 :            : extern int lock_device_hotplug_sysfs(void);
     924                 :            : extern int device_offline(struct device *dev);
     925                 :            : extern int device_online(struct device *dev);
     926                 :            : /*
     927                 :            :  * Root device objects for grouping under /sys/devices
     928                 :            :  */
     929                 :            : extern struct device *__root_device_register(const char *name,
     930                 :            :                                              struct module *owner);
     931                 :            : 
     932                 :            : /*
     933                 :            :  * This is a macro to avoid include problems with THIS_MODULE,
     934                 :            :  * just as per what is done for device_schedule_callback() above.
     935                 :            :  */
     936                 :            : #define root_device_register(name) \
     937                 :            :         __root_device_register(name, THIS_MODULE)
     938                 :            : 
     939                 :            : extern void root_device_unregister(struct device *root);
     940                 :            : 
     941                 :            : static inline void *dev_get_platdata(const struct device *dev)
     942                 :            : {
     943                 :            :         return dev->platform_data;
     944                 :            : }
     945                 :            : 
     946                 :            : /*
     947                 :            :  * Manual binding of a device to driver. See drivers/base/bus.c
     948                 :            :  * for information on use.
     949                 :            :  */
     950                 :            : extern int __must_check device_bind_driver(struct device *dev);
     951                 :            : extern void device_release_driver(struct device *dev);
     952                 :            : extern int  __must_check device_attach(struct device *dev);
     953                 :            : extern int __must_check driver_attach(struct device_driver *drv);
     954                 :            : extern int __must_check device_reprobe(struct device *dev);
     955                 :            : 
     956                 :            : /*
     957                 :            :  * Easy functions for dynamically creating devices on the fly
     958                 :            :  */
     959                 :            : extern struct device *device_create_vargs(struct class *cls,
     960                 :            :                                           struct device *parent,
     961                 :            :                                           dev_t devt,
     962                 :            :                                           void *drvdata,
     963                 :            :                                           const char *fmt,
     964                 :            :                                           va_list vargs);
     965                 :            : extern __printf(5, 6)
     966                 :            : struct device *device_create(struct class *cls, struct device *parent,
     967                 :            :                              dev_t devt, void *drvdata,
     968                 :            :                              const char *fmt, ...);
     969                 :            : extern __printf(6, 7)
     970                 :            : struct device *device_create_with_groups(struct class *cls,
     971                 :            :                              struct device *parent, dev_t devt, void *drvdata,
     972                 :            :                              const struct attribute_group **groups,
     973                 :            :                              const char *fmt, ...);
     974                 :            : extern void device_destroy(struct class *cls, dev_t devt);
     975                 :            : 
     976                 :            : /*
     977                 :            :  * Platform "fixup" functions - allow the platform to have their say
     978                 :            :  * about devices and actions that the general device layer doesn't
     979                 :            :  * know about.
     980                 :            :  */
     981                 :            : /* Notify platform of device discovery */
     982                 :            : extern int (*platform_notify)(struct device *dev);
     983                 :            : 
     984                 :            : extern int (*platform_notify_remove)(struct device *dev);
     985                 :            : 
     986                 :            : 
     987                 :            : /*
     988                 :            :  * get_device - atomically increment the reference count for the device.
     989                 :            :  *
     990                 :            :  */
     991                 :            : extern struct device *get_device(struct device *dev);
     992                 :            : extern void put_device(struct device *dev);
     993                 :            : 
     994                 :            : #ifdef CONFIG_DEVTMPFS
     995                 :            : extern int devtmpfs_create_node(struct device *dev);
     996                 :            : extern int devtmpfs_delete_node(struct device *dev);
     997                 :            : extern int devtmpfs_mount(const char *mntdir);
     998                 :            : #else
     999                 :            : static inline int devtmpfs_create_node(struct device *dev) { return 0; }
    1000                 :            : static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
    1001                 :            : static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
    1002                 :            : #endif
    1003                 :            : 
    1004                 :            : /* drivers/base/power/shutdown.c */
    1005                 :            : extern void device_shutdown(void);
    1006                 :            : 
    1007                 :            : /* debugging and troubleshooting/diagnostic helpers. */
    1008                 :            : extern const char *dev_driver_string(const struct device *dev);
    1009                 :            : 
    1010                 :            : 
    1011                 :            : #ifdef CONFIG_PRINTK
    1012                 :            : 
    1013                 :            : extern __printf(3, 0)
    1014                 :            : int dev_vprintk_emit(int level, const struct device *dev,
    1015                 :            :                      const char *fmt, va_list args);
    1016                 :            : extern __printf(3, 4)
    1017                 :            : int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
    1018                 :            : 
    1019                 :            : extern __printf(3, 4)
    1020                 :            : int dev_printk(const char *level, const struct device *dev,
    1021                 :            :                const char *fmt, ...);
    1022                 :            : extern __printf(2, 3)
    1023                 :            : int dev_emerg(const struct device *dev, const char *fmt, ...);
    1024                 :            : extern __printf(2, 3)
    1025                 :            : int dev_alert(const struct device *dev, const char *fmt, ...);
    1026                 :            : extern __printf(2, 3)
    1027                 :            : int dev_crit(const struct device *dev, const char *fmt, ...);
    1028                 :            : extern __printf(2, 3)
    1029                 :            : int dev_err(const struct device *dev, const char *fmt, ...);
    1030                 :            : extern __printf(2, 3)
    1031                 :            : int dev_warn(const struct device *dev, const char *fmt, ...);
    1032                 :            : extern __printf(2, 3)
    1033                 :            : int dev_notice(const struct device *dev, const char *fmt, ...);
    1034                 :            : extern __printf(2, 3)
    1035                 :            : int _dev_info(const struct device *dev, const char *fmt, ...);
    1036                 :            : 
    1037                 :            : #else
    1038                 :            : 
    1039                 :            : static inline __printf(3, 0)
    1040                 :            : int dev_vprintk_emit(int level, const struct device *dev,
    1041                 :            :                      const char *fmt, va_list args)
    1042                 :            : { return 0; }
    1043                 :            : static inline __printf(3, 4)
    1044                 :            : int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
    1045                 :            : { return 0; }
    1046                 :            : 
    1047                 :            : static inline int __dev_printk(const char *level, const struct device *dev,
    1048                 :            :                                struct va_format *vaf)
    1049                 :            : { return 0; }
    1050                 :            : static inline __printf(3, 4)
    1051                 :            : int dev_printk(const char *level, const struct device *dev,
    1052                 :            :                const char *fmt, ...)
    1053                 :            : { return 0; }
    1054                 :            : 
    1055                 :            : static inline __printf(2, 3)
    1056                 :            : int dev_emerg(const struct device *dev, const char *fmt, ...)
    1057                 :            : { return 0; }
    1058                 :            : static inline __printf(2, 3)
    1059                 :            : int dev_crit(const struct device *dev, const char *fmt, ...)
    1060                 :            : { return 0; }
    1061                 :            : static inline __printf(2, 3)
    1062                 :            : int dev_alert(const struct device *dev, const char *fmt, ...)
    1063                 :            : { return 0; }
    1064                 :            : static inline __printf(2, 3)
    1065                 :            : int dev_err(const struct device *dev, const char *fmt, ...)
    1066                 :            : { return 0; }
    1067                 :            : static inline __printf(2, 3)
    1068                 :            : int dev_warn(const struct device *dev, const char *fmt, ...)
    1069                 :            : { return 0; }
    1070                 :            : static inline __printf(2, 3)
    1071                 :            : int dev_notice(const struct device *dev, const char *fmt, ...)
    1072                 :            : { return 0; }
    1073                 :            : static inline __printf(2, 3)
    1074                 :            : int _dev_info(const struct device *dev, const char *fmt, ...)
    1075                 :            : { return 0; }
    1076                 :            : 
    1077                 :            : #endif
    1078                 :            : 
    1079                 :            : /*
    1080                 :            :  * Stupid hackaround for existing uses of non-printk uses dev_info
    1081                 :            :  *
    1082                 :            :  * Note that the definition of dev_info below is actually _dev_info
    1083                 :            :  * and a macro is used to avoid redefining dev_info
    1084                 :            :  */
    1085                 :            : 
    1086                 :            : #define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
    1087                 :            : 
    1088                 :            : #if defined(CONFIG_DYNAMIC_DEBUG)
    1089                 :            : #define dev_dbg(dev, format, ...)                    \
    1090                 :            : do {                                                 \
    1091                 :            :         dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
    1092                 :            : } while (0)
    1093                 :            : #elif defined(DEBUG)
    1094                 :            : #define dev_dbg(dev, format, arg...)            \
    1095                 :            :         dev_printk(KERN_DEBUG, dev, format, ##arg)
    1096                 :            : #else
    1097                 :            : #define dev_dbg(dev, format, arg...)                            \
    1098                 :            : ({                                                              \
    1099                 :            :         if (0)                                                  \
    1100                 :            :                 dev_printk(KERN_DEBUG, dev, format, ##arg);     \
    1101                 :            :         0;                                                      \
    1102                 :            : })
    1103                 :            : #endif
    1104                 :            : 
    1105                 :            : #define dev_level_ratelimited(dev_level, dev, fmt, ...)                 \
    1106                 :            : do {                                                                    \
    1107                 :            :         static DEFINE_RATELIMIT_STATE(_rs,                              \
    1108                 :            :                                       DEFAULT_RATELIMIT_INTERVAL,       \
    1109                 :            :                                       DEFAULT_RATELIMIT_BURST);         \
    1110                 :            :         if (__ratelimit(&_rs))                                              \
    1111                 :            :                 dev_level(dev, fmt, ##__VA_ARGS__);                     \
    1112                 :            : } while (0)
    1113                 :            : 
    1114                 :            : #define dev_emerg_ratelimited(dev, fmt, ...)                            \
    1115                 :            :         dev_level_ratelimited(dev_emerg, dev, fmt, ##__VA_ARGS__)
    1116                 :            : #define dev_alert_ratelimited(dev, fmt, ...)                            \
    1117                 :            :         dev_level_ratelimited(dev_alert, dev, fmt, ##__VA_ARGS__)
    1118                 :            : #define dev_crit_ratelimited(dev, fmt, ...)                             \
    1119                 :            :         dev_level_ratelimited(dev_crit, dev, fmt, ##__VA_ARGS__)
    1120                 :            : #define dev_err_ratelimited(dev, fmt, ...)                              \
    1121                 :            :         dev_level_ratelimited(dev_err, dev, fmt, ##__VA_ARGS__)
    1122                 :            : #define dev_warn_ratelimited(dev, fmt, ...)                             \
    1123                 :            :         dev_level_ratelimited(dev_warn, dev, fmt, ##__VA_ARGS__)
    1124                 :            : #define dev_notice_ratelimited(dev, fmt, ...)                           \
    1125                 :            :         dev_level_ratelimited(dev_notice, dev, fmt, ##__VA_ARGS__)
    1126                 :            : #define dev_info_ratelimited(dev, fmt, ...)                             \
    1127                 :            :         dev_level_ratelimited(dev_info, dev, fmt, ##__VA_ARGS__)
    1128                 :            : #if defined(CONFIG_DYNAMIC_DEBUG)
    1129                 :            : /* descriptor check is first to prevent flooding with "callbacks suppressed" */
    1130                 :            : #define dev_dbg_ratelimited(dev, fmt, ...)                              \
    1131                 :            : do {                                                                    \
    1132                 :            :         static DEFINE_RATELIMIT_STATE(_rs,                              \
    1133                 :            :                                       DEFAULT_RATELIMIT_INTERVAL,       \
    1134                 :            :                                       DEFAULT_RATELIMIT_BURST);         \
    1135                 :            :         DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);                 \
    1136                 :            :         if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) &&    \
    1137                 :            :             __ratelimit(&_rs))                                              \
    1138                 :            :                 __dynamic_dev_dbg(&descriptor, dev, fmt,            \
    1139                 :            :                                   ##__VA_ARGS__);                       \
    1140                 :            : } while (0)
    1141                 :            : #elif defined(DEBUG)
    1142                 :            : #define dev_dbg_ratelimited(dev, fmt, ...)                              \
    1143                 :            : do {                                                                    \
    1144                 :            :         static DEFINE_RATELIMIT_STATE(_rs,                              \
    1145                 :            :                                       DEFAULT_RATELIMIT_INTERVAL,       \
    1146                 :            :                                       DEFAULT_RATELIMIT_BURST);         \
    1147                 :            :         if (__ratelimit(&_rs))                                              \
    1148                 :            :                 dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__);        \
    1149                 :            : } while (0)
    1150                 :            : #else
    1151                 :            : #define dev_dbg_ratelimited(dev, fmt, ...)                      \
    1152                 :            :         no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
    1153                 :            : #endif
    1154                 :            : 
    1155                 :            : #ifdef VERBOSE_DEBUG
    1156                 :            : #define dev_vdbg        dev_dbg
    1157                 :            : #else
    1158                 :            : #define dev_vdbg(dev, format, arg...)                           \
    1159                 :            : ({                                                              \
    1160                 :            :         if (0)                                                  \
    1161                 :            :                 dev_printk(KERN_DEBUG, dev, format, ##arg);     \
    1162                 :            :         0;                                                      \
    1163                 :            : })
    1164                 :            : #endif
    1165                 :            : 
    1166                 :            : /*
    1167                 :            :  * dev_WARN*() acts like dev_printk(), but with the key difference of
    1168                 :            :  * using WARN/WARN_ONCE to include file/line information and a backtrace.
    1169                 :            :  */
    1170                 :            : #define dev_WARN(dev, format, arg...) \
    1171                 :            :         WARN(1, "%s %s: " format, dev_driver_string(dev), dev_name(dev), ## arg);
    1172                 :            : 
    1173                 :            : #define dev_WARN_ONCE(dev, condition, format, arg...) \
    1174                 :            :         WARN_ONCE(condition, "%s %s: " format, \
    1175                 :            :                         dev_driver_string(dev), dev_name(dev), ## arg)
    1176                 :            : 
    1177                 :            : /* Create alias, so I can be autoloaded. */
    1178                 :            : #define MODULE_ALIAS_CHARDEV(major,minor) \
    1179                 :            :         MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
    1180                 :            : #define MODULE_ALIAS_CHARDEV_MAJOR(major) \
    1181                 :            :         MODULE_ALIAS("char-major-" __stringify(major) "-*")
    1182                 :            : 
    1183                 :            : #ifdef CONFIG_SYSFS_DEPRECATED
    1184                 :            : extern long sysfs_deprecated;
    1185                 :            : #else
    1186                 :            : #define sysfs_deprecated 0
    1187                 :            : #endif
    1188                 :            : 
    1189                 :            : /**
    1190                 :            :  * module_driver() - Helper macro for drivers that don't do anything
    1191                 :            :  * special in module init/exit. This eliminates a lot of boilerplate.
    1192                 :            :  * Each module may only use this macro once, and calling it replaces
    1193                 :            :  * module_init() and module_exit().
    1194                 :            :  *
    1195                 :            :  * @__driver: driver name
    1196                 :            :  * @__register: register function for this driver type
    1197                 :            :  * @__unregister: unregister function for this driver type
    1198                 :            :  * @...: Additional arguments to be passed to __register and __unregister.
    1199                 :            :  *
    1200                 :            :  * Use this macro to construct bus specific macros for registering
    1201                 :            :  * drivers, and do not use it on its own.
    1202                 :            :  */
    1203                 :            : #define module_driver(__driver, __register, __unregister, ...) \
    1204                 :            : static int __init __driver##_init(void) \
    1205                 :            : { \
    1206                 :            :         return __register(&(__driver) , ##__VA_ARGS__); \
    1207                 :            : } \
    1208                 :            : module_init(__driver##_init); \
    1209                 :            : static void __exit __driver##_exit(void) \
    1210                 :            : { \
    1211                 :            :         __unregister(&(__driver) , ##__VA_ARGS__); \
    1212                 :            : } \
    1213                 :            : module_exit(__driver##_exit);
    1214                 :            : 
    1215                 :            : #endif /* _DEVICE_H_ */

Generated by: LCOV version 1.9