LCOV - code coverage report
Current view: top level - include/linux - device.h (source / functions) Hit Total Coverage
Test: Real Lines: 27 42 64.3 %
Date: 2020-10-17 15:46:16 Functions: 0 2 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * device.h - generic, centralized driver model
       4                 :            :  *
       5                 :            :  * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
       6                 :            :  * Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de>
       7                 :            :  * Copyright (c) 2008-2009 Novell Inc.
       8                 :            :  *
       9                 :            :  * See Documentation/driver-api/driver-model/ for more information.
      10                 :            :  */
      11                 :            : 
      12                 :            : #ifndef _DEVICE_H_
      13                 :            : #define _DEVICE_H_
      14                 :            : 
      15                 :            : #include <linux/ioport.h>
      16                 :            : #include <linux/kobject.h>
      17                 :            : #include <linux/klist.h>
      18                 :            : #include <linux/list.h>
      19                 :            : #include <linux/lockdep.h>
      20                 :            : #include <linux/compiler.h>
      21                 :            : #include <linux/types.h>
      22                 :            : #include <linux/mutex.h>
      23                 :            : #include <linux/pm.h>
      24                 :            : #include <linux/atomic.h>
      25                 :            : #include <linux/ratelimit.h>
      26                 :            : #include <linux/uidgid.h>
      27                 :            : #include <linux/gfp.h>
      28                 :            : #include <linux/overflow.h>
      29                 :            : #include <asm/device.h>
      30                 :            : 
      31                 :            : struct device;
      32                 :            : struct device_private;
      33                 :            : struct device_driver;
      34                 :            : struct driver_private;
      35                 :            : struct module;
      36                 :            : struct class;
      37                 :            : struct subsys_private;
      38                 :            : struct bus_type;
      39                 :            : struct device_node;
      40                 :            : struct fwnode_handle;
      41                 :            : struct iommu_ops;
      42                 :            : struct iommu_group;
      43                 :            : struct iommu_fwspec;
      44                 :            : struct dev_pin_info;
      45                 :            : struct iommu_param;
      46                 :            : 
      47                 :            : struct bus_attribute {
      48                 :            :         struct attribute        attr;
      49                 :            :         ssize_t (*show)(struct bus_type *bus, char *buf);
      50                 :            :         ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
      51                 :            : };
      52                 :            : 
      53                 :            : #define BUS_ATTR_RW(_name) \
      54                 :            :         struct bus_attribute bus_attr_##_name = __ATTR_RW(_name)
      55                 :            : #define BUS_ATTR_RO(_name) \
      56                 :            :         struct bus_attribute bus_attr_##_name = __ATTR_RO(_name)
      57                 :            : #define BUS_ATTR_WO(_name) \
      58                 :            :         struct bus_attribute bus_attr_##_name = __ATTR_WO(_name)
      59                 :            : 
      60                 :            : extern int __must_check bus_create_file(struct bus_type *,
      61                 :            :                                         struct bus_attribute *);
      62                 :            : extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
      63                 :            : 
      64                 :            : /**
      65                 :            :  * struct bus_type - The bus type of the device
      66                 :            :  *
      67                 :            :  * @name:       The name of the bus.
      68                 :            :  * @dev_name:   Used for subsystems to enumerate devices like ("foo%u", dev->id).
      69                 :            :  * @dev_root:   Default device to use as the parent.
      70                 :            :  * @bus_groups: Default attributes of the bus.
      71                 :            :  * @dev_groups: Default attributes of the devices on the bus.
      72                 :            :  * @drv_groups: Default attributes of the device drivers on the bus.
      73                 :            :  * @match:      Called, perhaps multiple times, whenever a new device or driver
      74                 :            :  *              is added for this bus. It should return a positive value if the
      75                 :            :  *              given device can be handled by the given driver and zero
      76                 :            :  *              otherwise. It may also return error code if determining that
      77                 :            :  *              the driver supports the device is not possible. In case of
      78                 :            :  *              -EPROBE_DEFER it will queue the device for deferred probing.
      79                 :            :  * @uevent:     Called when a device is added, removed, or a few other things
      80                 :            :  *              that generate uevents to add the environment variables.
      81                 :            :  * @probe:      Called when a new device or driver add to this bus, and callback
      82                 :            :  *              the specific driver's probe to initial the matched device.
      83                 :            :  * @remove:     Called when a device removed from this bus.
      84                 :            :  * @shutdown:   Called at shut-down time to quiesce the device.
      85                 :            :  *
      86                 :            :  * @online:     Called to put the device back online (after offlining it).
      87                 :            :  * @offline:    Called to put the device offline for hot-removal. May fail.
      88                 :            :  *
      89                 :            :  * @suspend:    Called when a device on this bus wants to go to sleep mode.
      90                 :            :  * @resume:     Called to bring a device on this bus out of sleep mode.
      91                 :            :  * @num_vf:     Called to find out how many virtual functions a device on this
      92                 :            :  *              bus supports.
      93                 :            :  * @dma_configure:      Called to setup DMA configuration on a device on
      94                 :            :  *                      this bus.
      95                 :            :  * @pm:         Power management operations of this bus, callback the specific
      96                 :            :  *              device driver's pm-ops.
      97                 :            :  * @iommu_ops:  IOMMU specific operations for this bus, used to attach IOMMU
      98                 :            :  *              driver implementations to a bus and allow the driver to do
      99                 :            :  *              bus-specific setup
     100                 :            :  * @p:          The private data of the driver core, only the driver core can
     101                 :            :  *              touch this.
     102                 :            :  * @lock_key:   Lock class key for use by the lock validator
     103                 :            :  * @need_parent_lock:   When probing or removing a device on this bus, the
     104                 :            :  *                      device core should lock the device's parent.
     105                 :            :  *
     106                 :            :  * A bus is a channel between the processor and one or more devices. For the
     107                 :            :  * purposes of the device model, all devices are connected via a bus, even if
     108                 :            :  * it is an internal, virtual, "platform" bus. Buses can plug into each other.
     109                 :            :  * A USB controller is usually a PCI device, for example. The device model
     110                 :            :  * represents the actual connections between buses and the devices they control.
     111                 :            :  * A bus is represented by the bus_type structure. It contains the name, the
     112                 :            :  * default attributes, the bus' methods, PM operations, and the driver core's
     113                 :            :  * private data.
     114                 :            :  */
     115                 :            : struct bus_type {
     116                 :            :         const char              *name;
     117                 :            :         const char              *dev_name;
     118                 :            :         struct device           *dev_root;
     119                 :            :         const struct attribute_group **bus_groups;
     120                 :            :         const struct attribute_group **dev_groups;
     121                 :            :         const struct attribute_group **drv_groups;
     122                 :            : 
     123                 :            :         int (*match)(struct device *dev, struct device_driver *drv);
     124                 :            :         int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
     125                 :            :         int (*probe)(struct device *dev);
     126                 :            :         int (*remove)(struct device *dev);
     127                 :            :         void (*shutdown)(struct device *dev);
     128                 :            : 
     129                 :            :         int (*online)(struct device *dev);
     130                 :            :         int (*offline)(struct device *dev);
     131                 :            : 
     132                 :            :         int (*suspend)(struct device *dev, pm_message_t state);
     133                 :            :         int (*resume)(struct device *dev);
     134                 :            : 
     135                 :            :         int (*num_vf)(struct device *dev);
     136                 :            : 
     137                 :            :         int (*dma_configure)(struct device *dev);
     138                 :            : 
     139                 :            :         const struct dev_pm_ops *pm;
     140                 :            : 
     141                 :            :         const struct iommu_ops *iommu_ops;
     142                 :            : 
     143                 :            :         struct subsys_private *p;
     144                 :            :         struct lock_class_key lock_key;
     145                 :            : 
     146                 :            :         bool need_parent_lock;
     147                 :            : };
     148                 :            : 
     149                 :            : extern int __must_check bus_register(struct bus_type *bus);
     150                 :            : 
     151                 :            : extern void bus_unregister(struct bus_type *bus);
     152                 :            : 
     153                 :            : extern int __must_check bus_rescan_devices(struct bus_type *bus);
     154                 :            : 
     155                 :            : /* iterator helpers for buses */
     156                 :            : struct subsys_dev_iter {
     157                 :            :         struct klist_iter               ki;
     158                 :            :         const struct device_type        *type;
     159                 :            : };
     160                 :            : void subsys_dev_iter_init(struct subsys_dev_iter *iter,
     161                 :            :                          struct bus_type *subsys,
     162                 :            :                          struct device *start,
     163                 :            :                          const struct device_type *type);
     164                 :            : struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter);
     165                 :            : void subsys_dev_iter_exit(struct subsys_dev_iter *iter);
     166                 :            : 
     167                 :            : int device_match_name(struct device *dev, const void *name);
     168                 :            : int device_match_of_node(struct device *dev, const void *np);
     169                 :            : int device_match_fwnode(struct device *dev, const void *fwnode);
     170                 :            : int device_match_devt(struct device *dev, const void *pdevt);
     171                 :            : int device_match_acpi_dev(struct device *dev, const void *adev);
     172                 :            : int device_match_any(struct device *dev, const void *unused);
     173                 :            : 
     174                 :            : int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
     175                 :            :                      int (*fn)(struct device *dev, void *data));
     176                 :            : struct device *bus_find_device(struct bus_type *bus, struct device *start,
     177                 :            :                                const void *data,
     178                 :            :                                int (*match)(struct device *dev, const void *data));
     179                 :            : /**
     180                 :            :  * bus_find_device_by_name - device iterator for locating a particular device
     181                 :            :  * of a specific name.
     182                 :            :  * @bus: bus type
     183                 :            :  * @start: Device to begin with
     184                 :            :  * @name: name of the device to match
     185                 :            :  */
     186                 :            : static inline struct device *bus_find_device_by_name(struct bus_type *bus,
     187                 :            :                                                      struct device *start,
     188                 :            :                                                      const char *name)
     189                 :            : {
     190                 :          0 :         return bus_find_device(bus, start, name, device_match_name);
     191                 :            : }
     192                 :            : 
     193                 :            : /**
     194                 :            :  * bus_find_device_by_of_node : device iterator for locating a particular device
     195                 :            :  * matching the of_node.
     196                 :            :  * @bus: bus type
     197                 :            :  * @np: of_node of the device to match.
     198                 :            :  */
     199                 :            : static inline struct device *
     200                 :            : bus_find_device_by_of_node(struct bus_type *bus, const struct device_node *np)
     201                 :            : {
     202                 :          0 :         return bus_find_device(bus, NULL, np, device_match_of_node);
     203                 :            : }
     204                 :            : 
     205                 :            : /**
     206                 :            :  * bus_find_device_by_fwnode : device iterator for locating a particular device
     207                 :            :  * matching the fwnode.
     208                 :            :  * @bus: bus type
     209                 :            :  * @fwnode: fwnode of the device to match.
     210                 :            :  */
     211                 :            : static inline struct device *
     212                 :            : bus_find_device_by_fwnode(struct bus_type *bus, const struct fwnode_handle *fwnode)
     213                 :            : {
     214                 :          0 :         return bus_find_device(bus, NULL, fwnode, device_match_fwnode);
     215                 :            : }
     216                 :            : 
     217                 :            : /**
     218                 :            :  * bus_find_device_by_devt : device iterator for locating a particular device
     219                 :            :  * matching the device type.
     220                 :            :  * @bus: bus type
     221                 :            :  * @devt: device type of the device to match.
     222                 :            :  */
     223                 :            : static inline struct device *bus_find_device_by_devt(struct bus_type *bus,
     224                 :            :                                                      dev_t devt)
     225                 :            : {
     226                 :          2 :         return bus_find_device(bus, NULL, &devt, device_match_devt);
     227                 :            : }
     228                 :            : 
     229                 :            : /**
     230                 :            :  * bus_find_next_device - Find the next device after a given device in a
     231                 :            :  * given bus.
     232                 :            :  * @bus: bus type
     233                 :            :  * @cur: device to begin the search with.
     234                 :            :  */
     235                 :            : static inline struct device *
     236                 :            : bus_find_next_device(struct bus_type *bus,struct device *cur)
     237                 :            : {
     238                 :            :         return bus_find_device(bus, cur, NULL, device_match_any);
     239                 :            : }
     240                 :            : 
     241                 :            : #ifdef CONFIG_ACPI
     242                 :            : struct acpi_device;
     243                 :            : 
     244                 :            : /**
     245                 :            :  * bus_find_device_by_acpi_dev : device iterator for locating a particular device
     246                 :            :  * matching the ACPI COMPANION device.
     247                 :            :  * @bus: bus type
     248                 :            :  * @adev: ACPI COMPANION device to match.
     249                 :            :  */
     250                 :            : static inline struct device *
     251                 :            : bus_find_device_by_acpi_dev(struct bus_type *bus, const struct acpi_device *adev)
     252                 :            : {
     253                 :            :         return bus_find_device(bus, NULL, adev, device_match_acpi_dev);
     254                 :            : }
     255                 :            : #else
     256                 :            : static inline struct device *
     257                 :            : bus_find_device_by_acpi_dev(struct bus_type *bus, const void *adev)
     258                 :            : {
     259                 :            :         return NULL;
     260                 :            : }
     261                 :            : #endif
     262                 :            : 
     263                 :            : struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id,
     264                 :            :                                         struct device *hint);
     265                 :            : int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
     266                 :            :                      void *data, int (*fn)(struct device_driver *, void *));
     267                 :            : void bus_sort_breadthfirst(struct bus_type *bus,
     268                 :            :                            int (*compare)(const struct device *a,
     269                 :            :                                           const struct device *b));
     270                 :            : /*
     271                 :            :  * Bus notifiers: Get notified of addition/removal of devices
     272                 :            :  * and binding/unbinding of drivers to devices.
     273                 :            :  * In the long run, it should be a replacement for the platform
     274                 :            :  * notify hooks.
     275                 :            :  */
     276                 :            : struct notifier_block;
     277                 :            : 
     278                 :            : extern int bus_register_notifier(struct bus_type *bus,
     279                 :            :                                  struct notifier_block *nb);
     280                 :            : extern int bus_unregister_notifier(struct bus_type *bus,
     281                 :            :                                    struct notifier_block *nb);
     282                 :            : 
     283                 :            : /* All 4 notifers below get called with the target struct device *
     284                 :            :  * as an argument. Note that those functions are likely to be called
     285                 :            :  * with the device lock held in the core, so be careful.
     286                 :            :  */
     287                 :            : #define BUS_NOTIFY_ADD_DEVICE           0x00000001 /* device added */
     288                 :            : #define BUS_NOTIFY_DEL_DEVICE           0x00000002 /* device to be removed */
     289                 :            : #define BUS_NOTIFY_REMOVED_DEVICE       0x00000003 /* device removed */
     290                 :            : #define BUS_NOTIFY_BIND_DRIVER          0x00000004 /* driver about to be
     291                 :            :                                                       bound */
     292                 :            : #define BUS_NOTIFY_BOUND_DRIVER         0x00000005 /* driver bound to device */
     293                 :            : #define BUS_NOTIFY_UNBIND_DRIVER        0x00000006 /* driver about to be
     294                 :            :                                                       unbound */
     295                 :            : #define BUS_NOTIFY_UNBOUND_DRIVER       0x00000007 /* driver is unbound
     296                 :            :                                                       from the device */
     297                 :            : #define BUS_NOTIFY_DRIVER_NOT_BOUND     0x00000008 /* driver fails to be bound */
     298                 :            : 
     299                 :            : extern struct kset *bus_get_kset(struct bus_type *bus);
     300                 :            : extern struct klist *bus_get_device_klist(struct bus_type *bus);
     301                 :            : 
     302                 :            : /**
     303                 :            :  * enum probe_type - device driver probe type to try
     304                 :            :  *      Device drivers may opt in for special handling of their
     305                 :            :  *      respective probe routines. This tells the core what to
     306                 :            :  *      expect and prefer.
     307                 :            :  *
     308                 :            :  * @PROBE_DEFAULT_STRATEGY: Used by drivers that work equally well
     309                 :            :  *      whether probed synchronously or asynchronously.
     310                 :            :  * @PROBE_PREFER_ASYNCHRONOUS: Drivers for "slow" devices which
     311                 :            :  *      probing order is not essential for booting the system may
     312                 :            :  *      opt into executing their probes asynchronously.
     313                 :            :  * @PROBE_FORCE_SYNCHRONOUS: Use this to annotate drivers that need
     314                 :            :  *      their probe routines to run synchronously with driver and
     315                 :            :  *      device registration (with the exception of -EPROBE_DEFER
     316                 :            :  *      handling - re-probing always ends up being done asynchronously).
     317                 :            :  *
     318                 :            :  * Note that the end goal is to switch the kernel to use asynchronous
     319                 :            :  * probing by default, so annotating drivers with
     320                 :            :  * %PROBE_PREFER_ASYNCHRONOUS is a temporary measure that allows us
     321                 :            :  * to speed up boot process while we are validating the rest of the
     322                 :            :  * drivers.
     323                 :            :  */
     324                 :            : enum probe_type {
     325                 :            :         PROBE_DEFAULT_STRATEGY,
     326                 :            :         PROBE_PREFER_ASYNCHRONOUS,
     327                 :            :         PROBE_FORCE_SYNCHRONOUS,
     328                 :            : };
     329                 :            : 
     330                 :            : /**
     331                 :            :  * struct device_driver - The basic device driver structure
     332                 :            :  * @name:       Name of the device driver.
     333                 :            :  * @bus:        The bus which the device of this driver belongs to.
     334                 :            :  * @owner:      The module owner.
     335                 :            :  * @mod_name:   Used for built-in modules.
     336                 :            :  * @suppress_bind_attrs: Disables bind/unbind via sysfs.
     337                 :            :  * @probe_type: Type of the probe (synchronous or asynchronous) to use.
     338                 :            :  * @of_match_table: The open firmware table.
     339                 :            :  * @acpi_match_table: The ACPI match table.
     340                 :            :  * @probe:      Called to query the existence of a specific device,
     341                 :            :  *              whether this driver can work with it, and bind the driver
     342                 :            :  *              to a specific device.
     343                 :            :  * @remove:     Called when the device is removed from the system to
     344                 :            :  *              unbind a device from this driver.
     345                 :            :  * @shutdown:   Called at shut-down time to quiesce the device.
     346                 :            :  * @suspend:    Called to put the device to sleep mode. Usually to a
     347                 :            :  *              low power state.
     348                 :            :  * @resume:     Called to bring a device from sleep mode.
     349                 :            :  * @groups:     Default attributes that get created by the driver core
     350                 :            :  *              automatically.
     351                 :            :  * @dev_groups: Additional attributes attached to device instance once the
     352                 :            :  *              it is bound to the driver.
     353                 :            :  * @pm:         Power management operations of the device which matched
     354                 :            :  *              this driver.
     355                 :            :  * @coredump:   Called when sysfs entry is written to. The device driver
     356                 :            :  *              is expected to call the dev_coredump API resulting in a
     357                 :            :  *              uevent.
     358                 :            :  * @p:          Driver core's private data, no one other than the driver
     359                 :            :  *              core can touch this.
     360                 :            :  *
     361                 :            :  * The device driver-model tracks all of the drivers known to the system.
     362                 :            :  * The main reason for this tracking is to enable the driver core to match
     363                 :            :  * up drivers with new devices. Once drivers are known objects within the
     364                 :            :  * system, however, a number of other things become possible. Device drivers
     365                 :            :  * can export information and configuration variables that are independent
     366                 :            :  * of any specific device.
     367                 :            :  */
     368                 :            : struct device_driver {
     369                 :            :         const char              *name;
     370                 :            :         struct bus_type         *bus;
     371                 :            : 
     372                 :            :         struct module           *owner;
     373                 :            :         const char              *mod_name;      /* used for built-in modules */
     374                 :            : 
     375                 :            :         bool suppress_bind_attrs;       /* disables bind/unbind via sysfs */
     376                 :            :         enum probe_type probe_type;
     377                 :            : 
     378                 :            :         const struct of_device_id       *of_match_table;
     379                 :            :         const struct acpi_device_id     *acpi_match_table;
     380                 :            : 
     381                 :            :         int (*probe) (struct device *dev);
     382                 :            :         int (*remove) (struct device *dev);
     383                 :            :         void (*shutdown) (struct device *dev);
     384                 :            :         int (*suspend) (struct device *dev, pm_message_t state);
     385                 :            :         int (*resume) (struct device *dev);
     386                 :            :         const struct attribute_group **groups;
     387                 :            :         const struct attribute_group **dev_groups;
     388                 :            : 
     389                 :            :         const struct dev_pm_ops *pm;
     390                 :            :         void (*coredump) (struct device *dev);
     391                 :            : 
     392                 :            :         struct driver_private *p;
     393                 :            : };
     394                 :            : 
     395                 :            : 
     396                 :            : extern int __must_check driver_register(struct device_driver *drv);
     397                 :            : extern void driver_unregister(struct device_driver *drv);
     398                 :            : 
     399                 :            : extern struct device_driver *driver_find(const char *name,
     400                 :            :                                          struct bus_type *bus);
     401                 :            : extern int driver_probe_done(void);
     402                 :            : extern void wait_for_device_probe(void);
     403                 :            : 
     404                 :            : /* sysfs interface for exporting driver attributes */
     405                 :            : 
     406                 :            : struct driver_attribute {
     407                 :            :         struct attribute attr;
     408                 :            :         ssize_t (*show)(struct device_driver *driver, char *buf);
     409                 :            :         ssize_t (*store)(struct device_driver *driver, const char *buf,
     410                 :            :                          size_t count);
     411                 :            : };
     412                 :            : 
     413                 :            : #define DRIVER_ATTR_RW(_name) \
     414                 :            :         struct driver_attribute driver_attr_##_name = __ATTR_RW(_name)
     415                 :            : #define DRIVER_ATTR_RO(_name) \
     416                 :            :         struct driver_attribute driver_attr_##_name = __ATTR_RO(_name)
     417                 :            : #define DRIVER_ATTR_WO(_name) \
     418                 :            :         struct driver_attribute driver_attr_##_name = __ATTR_WO(_name)
     419                 :            : 
     420                 :            : extern int __must_check driver_create_file(struct device_driver *driver,
     421                 :            :                                         const struct driver_attribute *attr);
     422                 :            : extern void driver_remove_file(struct device_driver *driver,
     423                 :            :                                const struct driver_attribute *attr);
     424                 :            : 
     425                 :            : extern int __must_check driver_for_each_device(struct device_driver *drv,
     426                 :            :                                                struct device *start,
     427                 :            :                                                void *data,
     428                 :            :                                                int (*fn)(struct device *dev,
     429                 :            :                                                          void *));
     430                 :            : struct device *driver_find_device(struct device_driver *drv,
     431                 :            :                                   struct device *start, const void *data,
     432                 :            :                                   int (*match)(struct device *dev, const void *data));
     433                 :            : 
     434                 :            : /**
     435                 :            :  * driver_find_device_by_name - device iterator for locating a particular device
     436                 :            :  * of a specific name.
     437                 :            :  * @drv: the driver we're iterating
     438                 :            :  * @name: name of the device to match
     439                 :            :  */
     440                 :            : static inline struct device *driver_find_device_by_name(struct device_driver *drv,
     441                 :            :                                                         const char *name)
     442                 :            : {
     443                 :            :         return driver_find_device(drv, NULL, name, device_match_name);
     444                 :            : }
     445                 :            : 
     446                 :            : /**
     447                 :            :  * driver_find_device_by_of_node- device iterator for locating a particular device
     448                 :            :  * by of_node pointer.
     449                 :            :  * @drv: the driver we're iterating
     450                 :            :  * @np: of_node pointer to match.
     451                 :            :  */
     452                 :            : static inline struct device *
     453                 :            : driver_find_device_by_of_node(struct device_driver *drv,
     454                 :            :                               const struct device_node *np)
     455                 :            : {
     456                 :            :         return driver_find_device(drv, NULL, np, device_match_of_node);
     457                 :            : }
     458                 :            : 
     459                 :            : /**
     460                 :            :  * driver_find_device_by_fwnode- device iterator for locating a particular device
     461                 :            :  * by fwnode pointer.
     462                 :            :  * @drv: the driver we're iterating
     463                 :            :  * @fwnode: fwnode pointer to match.
     464                 :            :  */
     465                 :            : static inline struct device *
     466                 :            : driver_find_device_by_fwnode(struct device_driver *drv,
     467                 :            :                              const struct fwnode_handle *fwnode)
     468                 :            : {
     469                 :            :         return driver_find_device(drv, NULL, fwnode, device_match_fwnode);
     470                 :            : }
     471                 :            : 
     472                 :            : /**
     473                 :            :  * driver_find_device_by_devt- device iterator for locating a particular device
     474                 :            :  * by devt.
     475                 :            :  * @drv: the driver we're iterating
     476                 :            :  * @devt: devt pointer to match.
     477                 :            :  */
     478                 :            : static inline struct device *driver_find_device_by_devt(struct device_driver *drv,
     479                 :            :                                                         dev_t devt)
     480                 :            : {
     481                 :            :         return driver_find_device(drv, NULL, &devt, device_match_devt);
     482                 :            : }
     483                 :            : 
     484                 :            : static inline struct device *driver_find_next_device(struct device_driver *drv,
     485                 :            :                                                      struct device *start)
     486                 :            : {
     487                 :            :         return driver_find_device(drv, start, NULL, device_match_any);
     488                 :            : }
     489                 :            : 
     490                 :            : #ifdef CONFIG_ACPI
     491                 :            : /**
     492                 :            :  * driver_find_device_by_acpi_dev : device iterator for locating a particular
     493                 :            :  * device matching the ACPI_COMPANION device.
     494                 :            :  * @drv: the driver we're iterating
     495                 :            :  * @adev: ACPI_COMPANION device to match.
     496                 :            :  */
     497                 :            : static inline struct device *
     498                 :            : driver_find_device_by_acpi_dev(struct device_driver *drv,
     499                 :            :                                const struct acpi_device *adev)
     500                 :            : {
     501                 :            :         return driver_find_device(drv, NULL, adev, device_match_acpi_dev);
     502                 :            : }
     503                 :            : #else
     504                 :            : static inline struct device *
     505                 :            : driver_find_device_by_acpi_dev(struct device_driver *drv, const void *adev)
     506                 :            : {
     507                 :            :         return NULL;
     508                 :            : }
     509                 :            : #endif
     510                 :            : 
     511                 :            : void driver_deferred_probe_add(struct device *dev);
     512                 :            : int driver_deferred_probe_check_state(struct device *dev);
     513                 :            : int driver_deferred_probe_check_state_continue(struct device *dev);
     514                 :            : 
     515                 :            : /**
     516                 :            :  * struct subsys_interface - interfaces to device functions
     517                 :            :  * @name:       name of the device function
     518                 :            :  * @subsys:     subsytem of the devices to attach to
     519                 :            :  * @node:       the list of functions registered at the subsystem
     520                 :            :  * @add_dev:    device hookup to device function handler
     521                 :            :  * @remove_dev: device hookup to device function handler
     522                 :            :  *
     523                 :            :  * Simple interfaces attached to a subsystem. Multiple interfaces can
     524                 :            :  * attach to a subsystem and its devices. Unlike drivers, they do not
     525                 :            :  * exclusively claim or control devices. Interfaces usually represent
     526                 :            :  * a specific functionality of a subsystem/class of devices.
     527                 :            :  */
     528                 :            : struct subsys_interface {
     529                 :            :         const char *name;
     530                 :            :         struct bus_type *subsys;
     531                 :            :         struct list_head node;
     532                 :            :         int (*add_dev)(struct device *dev, struct subsys_interface *sif);
     533                 :            :         void (*remove_dev)(struct device *dev, struct subsys_interface *sif);
     534                 :            : };
     535                 :            : 
     536                 :            : int subsys_interface_register(struct subsys_interface *sif);
     537                 :            : void subsys_interface_unregister(struct subsys_interface *sif);
     538                 :            : 
     539                 :            : int subsys_system_register(struct bus_type *subsys,
     540                 :            :                            const struct attribute_group **groups);
     541                 :            : int subsys_virtual_register(struct bus_type *subsys,
     542                 :            :                             const struct attribute_group **groups);
     543                 :            : 
     544                 :            : /**
     545                 :            :  * struct class - device classes
     546                 :            :  * @name:       Name of the class.
     547                 :            :  * @owner:      The module owner.
     548                 :            :  * @class_groups: Default attributes of this class.
     549                 :            :  * @dev_groups: Default attributes of the devices that belong to the class.
     550                 :            :  * @dev_kobj:   The kobject that represents this class and links it into the hierarchy.
     551                 :            :  * @dev_uevent: Called when a device is added, removed from this class, or a
     552                 :            :  *              few other things that generate uevents to add the environment
     553                 :            :  *              variables.
     554                 :            :  * @devnode:    Callback to provide the devtmpfs.
     555                 :            :  * @class_release: Called to release this class.
     556                 :            :  * @dev_release: Called to release the device.
     557                 :            :  * @shutdown_pre: Called at shut-down time before driver shutdown.
     558                 :            :  * @ns_type:    Callbacks so sysfs can detemine namespaces.
     559                 :            :  * @namespace:  Namespace of the device belongs to this class.
     560                 :            :  * @get_ownership: Allows class to specify uid/gid of the sysfs directories
     561                 :            :  *              for the devices belonging to the class. Usually tied to
     562                 :            :  *              device's namespace.
     563                 :            :  * @pm:         The default device power management operations of this class.
     564                 :            :  * @p:          The private data of the driver core, no one other than the
     565                 :            :  *              driver core can touch this.
     566                 :            :  *
     567                 :            :  * A class is a higher-level view of a device that abstracts out low-level
     568                 :            :  * implementation details. Drivers may see a SCSI disk or an ATA disk, but,
     569                 :            :  * at the class level, they are all simply disks. Classes allow user space
     570                 :            :  * to work with devices based on what they do, rather than how they are
     571                 :            :  * connected or how they work.
     572                 :            :  */
     573                 :            : struct class {
     574                 :            :         const char              *name;
     575                 :            :         struct module           *owner;
     576                 :            : 
     577                 :            :         const struct attribute_group    **class_groups;
     578                 :            :         const struct attribute_group    **dev_groups;
     579                 :            :         struct kobject                  *dev_kobj;
     580                 :            : 
     581                 :            :         int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
     582                 :            :         char *(*devnode)(struct device *dev, umode_t *mode);
     583                 :            : 
     584                 :            :         void (*class_release)(struct class *class);
     585                 :            :         void (*dev_release)(struct device *dev);
     586                 :            : 
     587                 :            :         int (*shutdown_pre)(struct device *dev);
     588                 :            : 
     589                 :            :         const struct kobj_ns_type_operations *ns_type;
     590                 :            :         const void *(*namespace)(struct device *dev);
     591                 :            : 
     592                 :            :         void (*get_ownership)(struct device *dev, kuid_t *uid, kgid_t *gid);
     593                 :            : 
     594                 :            :         const struct dev_pm_ops *pm;
     595                 :            : 
     596                 :            :         struct subsys_private *p;
     597                 :            : };
     598                 :            : 
     599                 :            : struct class_dev_iter {
     600                 :            :         struct klist_iter               ki;
     601                 :            :         const struct device_type        *type;
     602                 :            : };
     603                 :            : 
     604                 :            : extern struct kobject *sysfs_dev_block_kobj;
     605                 :            : extern struct kobject *sysfs_dev_char_kobj;
     606                 :            : extern int __must_check __class_register(struct class *class,
     607                 :            :                                          struct lock_class_key *key);
     608                 :            : extern void class_unregister(struct class *class);
     609                 :            : 
     610                 :            : /* This is a #define to keep the compiler from merging different
     611                 :            :  * instances of the __key variable */
     612                 :            : #define class_register(class)                   \
     613                 :            : ({                                              \
     614                 :            :         static struct lock_class_key __key;     \
     615                 :            :         __class_register(class, &__key);    \
     616                 :            : })
     617                 :            : 
     618                 :            : struct class_compat;
     619                 :            : struct class_compat *class_compat_register(const char *name);
     620                 :            : void class_compat_unregister(struct class_compat *cls);
     621                 :            : int class_compat_create_link(struct class_compat *cls, struct device *dev,
     622                 :            :                              struct device *device_link);
     623                 :            : void class_compat_remove_link(struct class_compat *cls, struct device *dev,
     624                 :            :                               struct device *device_link);
     625                 :            : 
     626                 :            : extern void class_dev_iter_init(struct class_dev_iter *iter,
     627                 :            :                                 struct class *class,
     628                 :            :                                 struct device *start,
     629                 :            :                                 const struct device_type *type);
     630                 :            : extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
     631                 :            : extern void class_dev_iter_exit(struct class_dev_iter *iter);
     632                 :            : 
     633                 :            : extern int class_for_each_device(struct class *class, struct device *start,
     634                 :            :                                  void *data,
     635                 :            :                                  int (*fn)(struct device *dev, void *data));
     636                 :            : extern struct device *class_find_device(struct class *class,
     637                 :            :                                         struct device *start, const void *data,
     638                 :            :                                         int (*match)(struct device *, const void *));
     639                 :            : 
     640                 :            : /**
     641                 :            :  * class_find_device_by_name - device iterator for locating a particular device
     642                 :            :  * of a specific name.
     643                 :            :  * @class: class type
     644                 :            :  * @name: name of the device to match
     645                 :            :  */
     646                 :            : static inline struct device *class_find_device_by_name(struct class *class,
     647                 :            :                                                        const char *name)
     648                 :            : {
     649                 :          3 :         return class_find_device(class, NULL, name, device_match_name);
     650                 :            : }
     651                 :            : 
     652                 :            : /**
     653                 :            :  * class_find_device_by_of_node : device iterator for locating a particular device
     654                 :            :  * matching the of_node.
     655                 :            :  * @class: class type
     656                 :            :  * @np: of_node of the device to match.
     657                 :            :  */
     658                 :            : static inline struct device *
     659                 :            : class_find_device_by_of_node(struct class *class, const struct device_node *np)
     660                 :            : {
     661                 :          0 :         return class_find_device(class, NULL, np, device_match_of_node);
     662                 :            : }
     663                 :            : 
     664                 :            : /**
     665                 :            :  * class_find_device_by_fwnode : device iterator for locating a particular device
     666                 :            :  * matching the fwnode.
     667                 :            :  * @class: class type
     668                 :            :  * @fwnode: fwnode of the device to match.
     669                 :            :  */
     670                 :            : static inline struct device *
     671                 :            : class_find_device_by_fwnode(struct class *class,
     672                 :            :                             const struct fwnode_handle *fwnode)
     673                 :            : {
     674                 :            :         return class_find_device(class, NULL, fwnode, device_match_fwnode);
     675                 :            : }
     676                 :            : 
     677                 :            : /**
     678                 :            :  * class_find_device_by_devt : device iterator for locating a particular device
     679                 :            :  * matching the device type.
     680                 :            :  * @class: class type
     681                 :            :  * @devt: device type of the device to match.
     682                 :            :  */
     683                 :            : static inline struct device *class_find_device_by_devt(struct class *class,
     684                 :            :                                                        dev_t devt)
     685                 :            : {
     686                 :          3 :         return class_find_device(class, NULL, &devt, device_match_devt);
     687                 :            : }
     688                 :            : 
     689                 :            : #ifdef CONFIG_ACPI
     690                 :            : struct acpi_device;
     691                 :            : /**
     692                 :            :  * class_find_device_by_acpi_dev : device iterator for locating a particular
     693                 :            :  * device matching the ACPI_COMPANION device.
     694                 :            :  * @class: class type
     695                 :            :  * @adev: ACPI_COMPANION device to match.
     696                 :            :  */
     697                 :            : static inline struct device *
     698                 :            : class_find_device_by_acpi_dev(struct class *class, const struct acpi_device *adev)
     699                 :            : {
     700                 :            :         return class_find_device(class, NULL, adev, device_match_acpi_dev);
     701                 :            : }
     702                 :            : #else
     703                 :            : static inline struct device *
     704                 :            : class_find_device_by_acpi_dev(struct class *class, const void *adev)
     705                 :            : {
     706                 :            :         return NULL;
     707                 :            : }
     708                 :            : #endif
     709                 :            : 
     710                 :            : struct class_attribute {
     711                 :            :         struct attribute attr;
     712                 :            :         ssize_t (*show)(struct class *class, struct class_attribute *attr,
     713                 :            :                         char *buf);
     714                 :            :         ssize_t (*store)(struct class *class, struct class_attribute *attr,
     715                 :            :                         const char *buf, size_t count);
     716                 :            : };
     717                 :            : 
     718                 :            : #define CLASS_ATTR_RW(_name) \
     719                 :            :         struct class_attribute class_attr_##_name = __ATTR_RW(_name)
     720                 :            : #define CLASS_ATTR_RO(_name) \
     721                 :            :         struct class_attribute class_attr_##_name = __ATTR_RO(_name)
     722                 :            : #define CLASS_ATTR_WO(_name) \
     723                 :            :         struct class_attribute class_attr_##_name = __ATTR_WO(_name)
     724                 :            : 
     725                 :            : extern int __must_check class_create_file_ns(struct class *class,
     726                 :            :                                              const struct class_attribute *attr,
     727                 :            :                                              const void *ns);
     728                 :            : extern void class_remove_file_ns(struct class *class,
     729                 :            :                                  const struct class_attribute *attr,
     730                 :            :                                  const void *ns);
     731                 :            : 
     732                 :            : static inline int __must_check class_create_file(struct class *class,
     733                 :            :                                         const struct class_attribute *attr)
     734                 :            : {
     735                 :            :         return class_create_file_ns(class, attr, NULL);
     736                 :            : }
     737                 :            : 
     738                 :            : static inline void class_remove_file(struct class *class,
     739                 :            :                                      const struct class_attribute *attr)
     740                 :            : {
     741                 :            :         return class_remove_file_ns(class, attr, NULL);
     742                 :            : }
     743                 :            : 
     744                 :            : /* Simple class attribute that is just a static string */
     745                 :            : struct class_attribute_string {
     746                 :            :         struct class_attribute attr;
     747                 :            :         char *str;
     748                 :            : };
     749                 :            : 
     750                 :            : /* Currently read-only only */
     751                 :            : #define _CLASS_ATTR_STRING(_name, _mode, _str) \
     752                 :            :         { __ATTR(_name, _mode, show_class_attr_string, NULL), _str }
     753                 :            : #define CLASS_ATTR_STRING(_name, _mode, _str) \
     754                 :            :         struct class_attribute_string class_attr_##_name = \
     755                 :            :                 _CLASS_ATTR_STRING(_name, _mode, _str)
     756                 :            : 
     757                 :            : extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
     758                 :            :                         char *buf);
     759                 :            : 
     760                 :            : struct class_interface {
     761                 :            :         struct list_head        node;
     762                 :            :         struct class            *class;
     763                 :            : 
     764                 :            :         int (*add_dev)          (struct device *, struct class_interface *);
     765                 :            :         void (*remove_dev)      (struct device *, struct class_interface *);
     766                 :            : };
     767                 :            : 
     768                 :            : extern int __must_check class_interface_register(struct class_interface *);
     769                 :            : extern void class_interface_unregister(struct class_interface *);
     770                 :            : 
     771                 :            : extern struct class * __must_check __class_create(struct module *owner,
     772                 :            :                                                   const char *name,
     773                 :            :                                                   struct lock_class_key *key);
     774                 :            : extern void class_destroy(struct class *cls);
     775                 :            : 
     776                 :            : /* This is a #define to keep the compiler from merging different
     777                 :            :  * instances of the __key variable */
     778                 :            : #define class_create(owner, name)               \
     779                 :            : ({                                              \
     780                 :            :         static struct lock_class_key __key;     \
     781                 :            :         __class_create(owner, name, &__key);        \
     782                 :            : })
     783                 :            : 
     784                 :            : /*
     785                 :            :  * The type of device, "struct device" is embedded in. A class
     786                 :            :  * or bus can contain devices of different types
     787                 :            :  * like "partitions" and "disks", "mouse" and "event".
     788                 :            :  * This identifies the device type and carries type-specific
     789                 :            :  * information, equivalent to the kobj_type of a kobject.
     790                 :            :  * If "name" is specified, the uevent will contain it in
     791                 :            :  * the DEVTYPE variable.
     792                 :            :  */
     793                 :            : struct device_type {
     794                 :            :         const char *name;
     795                 :            :         const struct attribute_group **groups;
     796                 :            :         int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
     797                 :            :         char *(*devnode)(struct device *dev, umode_t *mode,
     798                 :            :                          kuid_t *uid, kgid_t *gid);
     799                 :            :         void (*release)(struct device *dev);
     800                 :            : 
     801                 :            :         const struct dev_pm_ops *pm;
     802                 :            : };
     803                 :            : 
     804                 :            : /* interface for exporting device attributes */
     805                 :            : struct device_attribute {
     806                 :            :         struct attribute        attr;
     807                 :            :         ssize_t (*show)(struct device *dev, struct device_attribute *attr,
     808                 :            :                         char *buf);
     809                 :            :         ssize_t (*store)(struct device *dev, struct device_attribute *attr,
     810                 :            :                          const char *buf, size_t count);
     811                 :            : };
     812                 :            : 
     813                 :            : struct dev_ext_attribute {
     814                 :            :         struct device_attribute attr;
     815                 :            :         void *var;
     816                 :            : };
     817                 :            : 
     818                 :            : ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr,
     819                 :            :                           char *buf);
     820                 :            : ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr,
     821                 :            :                            const char *buf, size_t count);
     822                 :            : ssize_t device_show_int(struct device *dev, struct device_attribute *attr,
     823                 :            :                         char *buf);
     824                 :            : ssize_t device_store_int(struct device *dev, struct device_attribute *attr,
     825                 :            :                          const char *buf, size_t count);
     826                 :            : ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
     827                 :            :                         char *buf);
     828                 :            : ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
     829                 :            :                          const char *buf, size_t count);
     830                 :            : 
     831                 :            : #define DEVICE_ATTR(_name, _mode, _show, _store) \
     832                 :            :         struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
     833                 :            : #define DEVICE_ATTR_PREALLOC(_name, _mode, _show, _store) \
     834                 :            :         struct device_attribute dev_attr_##_name = \
     835                 :            :                 __ATTR_PREALLOC(_name, _mode, _show, _store)
     836                 :            : #define DEVICE_ATTR_RW(_name) \
     837                 :            :         struct device_attribute dev_attr_##_name = __ATTR_RW(_name)
     838                 :            : #define DEVICE_ATTR_RO(_name) \
     839                 :            :         struct device_attribute dev_attr_##_name = __ATTR_RO(_name)
     840                 :            : #define DEVICE_ATTR_WO(_name) \
     841                 :            :         struct device_attribute dev_attr_##_name = __ATTR_WO(_name)
     842                 :            : #define DEVICE_ULONG_ATTR(_name, _mode, _var) \
     843                 :            :         struct dev_ext_attribute dev_attr_##_name = \
     844                 :            :                 { __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) }
     845                 :            : #define DEVICE_INT_ATTR(_name, _mode, _var) \
     846                 :            :         struct dev_ext_attribute dev_attr_##_name = \
     847                 :            :                 { __ATTR(_name, _mode, device_show_int, device_store_int), &(_var) }
     848                 :            : #define DEVICE_BOOL_ATTR(_name, _mode, _var) \
     849                 :            :         struct dev_ext_attribute dev_attr_##_name = \
     850                 :            :                 { __ATTR(_name, _mode, device_show_bool, device_store_bool), &(_var) }
     851                 :            : #define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \
     852                 :            :         struct device_attribute dev_attr_##_name =              \
     853                 :            :                 __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store)
     854                 :            : 
     855                 :            : extern int device_create_file(struct device *device,
     856                 :            :                               const struct device_attribute *entry);
     857                 :            : extern void device_remove_file(struct device *dev,
     858                 :            :                                const struct device_attribute *attr);
     859                 :            : extern bool device_remove_file_self(struct device *dev,
     860                 :            :                                     const struct device_attribute *attr);
     861                 :            : extern int __must_check device_create_bin_file(struct device *dev,
     862                 :            :                                         const struct bin_attribute *attr);
     863                 :            : extern void device_remove_bin_file(struct device *dev,
     864                 :            :                                    const struct bin_attribute *attr);
     865                 :            : 
     866                 :            : /* device resource management */
     867                 :            : typedef void (*dr_release_t)(struct device *dev, void *res);
     868                 :            : typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
     869                 :            : 
     870                 :            : #ifdef CONFIG_DEBUG_DEVRES
     871                 :            : extern void *__devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp,
     872                 :            :                                  int nid, const char *name) __malloc;
     873                 :            : #define devres_alloc(release, size, gfp) \
     874                 :            :         __devres_alloc_node(release, size, gfp, NUMA_NO_NODE, #release)
     875                 :            : #define devres_alloc_node(release, size, gfp, nid) \
     876                 :            :         __devres_alloc_node(release, size, gfp, nid, #release)
     877                 :            : #else
     878                 :            : extern void *devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp,
     879                 :            :                                int nid) __malloc;
     880                 :            : static inline void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp)
     881                 :            : {
     882                 :          3 :         return devres_alloc_node(release, size, gfp, NUMA_NO_NODE);
     883                 :            : }
     884                 :            : #endif
     885                 :            : 
     886                 :            : extern void devres_for_each_res(struct device *dev, dr_release_t release,
     887                 :            :                                 dr_match_t match, void *match_data,
     888                 :            :                                 void (*fn)(struct device *, void *, void *),
     889                 :            :                                 void *data);
     890                 :            : extern void devres_free(void *res);
     891                 :            : extern void devres_add(struct device *dev, void *res);
     892                 :            : extern void *devres_find(struct device *dev, dr_release_t release,
     893                 :            :                          dr_match_t match, void *match_data);
     894                 :            : extern void *devres_get(struct device *dev, void *new_res,
     895                 :            :                         dr_match_t match, void *match_data);
     896                 :            : extern void *devres_remove(struct device *dev, dr_release_t release,
     897                 :            :                            dr_match_t match, void *match_data);
     898                 :            : extern int devres_destroy(struct device *dev, dr_release_t release,
     899                 :            :                           dr_match_t match, void *match_data);
     900                 :            : extern int devres_release(struct device *dev, dr_release_t release,
     901                 :            :                           dr_match_t match, void *match_data);
     902                 :            : 
     903                 :            : /* devres group */
     904                 :            : extern void * __must_check devres_open_group(struct device *dev, void *id,
     905                 :            :                                              gfp_t gfp);
     906                 :            : extern void devres_close_group(struct device *dev, void *id);
     907                 :            : extern void devres_remove_group(struct device *dev, void *id);
     908                 :            : extern int devres_release_group(struct device *dev, void *id);
     909                 :            : 
     910                 :            : /* managed devm_k.alloc/kfree for device drivers */
     911                 :            : extern void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp) __malloc;
     912                 :            : extern __printf(3, 0)
     913                 :            : char *devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt,
     914                 :            :                       va_list ap) __malloc;
     915                 :            : extern __printf(3, 4)
     916                 :            : char *devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...) __malloc;
     917                 :            : static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
     918                 :            : {
     919                 :          3 :         return devm_kmalloc(dev, size, gfp | __GFP_ZERO);
     920                 :            : }
     921                 :          3 : static inline void *devm_kmalloc_array(struct device *dev,
     922                 :            :                                        size_t n, size_t size, gfp_t flags)
     923                 :            : {
     924                 :            :         size_t bytes;
     925                 :            : 
     926                 :          3 :         if (unlikely(check_mul_overflow(n, size, &bytes)))
     927                 :            :                 return NULL;
     928                 :            : 
     929                 :          3 :         return devm_kmalloc(dev, bytes, flags);
     930                 :            : }
     931                 :            : static inline void *devm_kcalloc(struct device *dev,
     932                 :            :                                  size_t n, size_t size, gfp_t flags)
     933                 :            : {
     934                 :          3 :         return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO);
     935                 :            : }
     936                 :            : extern void devm_kfree(struct device *dev, const void *p);
     937                 :            : extern char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp) __malloc;
     938                 :            : extern const char *devm_kstrdup_const(struct device *dev,
     939                 :            :                                       const char *s, gfp_t gfp);
     940                 :            : extern void *devm_kmemdup(struct device *dev, const void *src, size_t len,
     941                 :            :                           gfp_t gfp);
     942                 :            : 
     943                 :            : extern unsigned long devm_get_free_pages(struct device *dev,
     944                 :            :                                          gfp_t gfp_mask, unsigned int order);
     945                 :            : extern void devm_free_pages(struct device *dev, unsigned long addr);
     946                 :            : 
     947                 :            : void __iomem *devm_ioremap_resource(struct device *dev,
     948                 :            :                                     const struct resource *res);
     949                 :            : 
     950                 :            : void __iomem *devm_of_iomap(struct device *dev,
     951                 :            :                             struct device_node *node, int index,
     952                 :            :                             resource_size_t *size);
     953                 :            : 
     954                 :            : /* allows to add/remove a custom action to devres stack */
     955                 :            : int devm_add_action(struct device *dev, void (*action)(void *), void *data);
     956                 :            : void devm_remove_action(struct device *dev, void (*action)(void *), void *data);
     957                 :            : void devm_release_action(struct device *dev, void (*action)(void *), void *data);
     958                 :            : 
     959                 :          0 : static inline int devm_add_action_or_reset(struct device *dev,
     960                 :            :                                            void (*action)(void *), void *data)
     961                 :            : {
     962                 :            :         int ret;
     963                 :            : 
     964                 :          0 :         ret = devm_add_action(dev, action, data);
     965                 :          0 :         if (ret)
     966                 :          0 :                 action(data);
     967                 :            : 
     968                 :          0 :         return ret;
     969                 :            : }
     970                 :            : 
     971                 :            : /**
     972                 :            :  * devm_alloc_percpu - Resource-managed alloc_percpu
     973                 :            :  * @dev: Device to allocate per-cpu memory for
     974                 :            :  * @type: Type to allocate per-cpu memory for
     975                 :            :  *
     976                 :            :  * Managed alloc_percpu. Per-cpu memory allocated with this function is
     977                 :            :  * automatically freed on driver detach.
     978                 :            :  *
     979                 :            :  * RETURNS:
     980                 :            :  * Pointer to allocated memory on success, NULL on failure.
     981                 :            :  */
     982                 :            : #define devm_alloc_percpu(dev, type)      \
     983                 :            :         ((typeof(type) __percpu *)__devm_alloc_percpu((dev), sizeof(type), \
     984                 :            :                                                       __alignof__(type)))
     985                 :            : 
     986                 :            : void __percpu *__devm_alloc_percpu(struct device *dev, size_t size,
     987                 :            :                                    size_t align);
     988                 :            : void devm_free_percpu(struct device *dev, void __percpu *pdata);
     989                 :            : 
     990                 :            : struct device_dma_parameters {
     991                 :            :         /*
     992                 :            :          * a low level driver may set these to teach IOMMU code about
     993                 :            :          * sg limitations.
     994                 :            :          */
     995                 :            :         unsigned int max_segment_size;
     996                 :            :         unsigned long segment_boundary_mask;
     997                 :            : };
     998                 :            : 
     999                 :            : /**
    1000                 :            :  * struct device_connection - Device Connection Descriptor
    1001                 :            :  * @fwnode: The device node of the connected device
    1002                 :            :  * @endpoint: The names of the two devices connected together
    1003                 :            :  * @id: Unique identifier for the connection
    1004                 :            :  * @list: List head, private, for internal use only
    1005                 :            :  *
    1006                 :            :  * NOTE: @fwnode is not used together with @endpoint. @fwnode is used when
    1007                 :            :  * platform firmware defines the connection. When the connection is registered
    1008                 :            :  * with device_connection_add() @endpoint is used instead.
    1009                 :            :  */
    1010                 :            : struct device_connection {
    1011                 :            :         struct fwnode_handle    *fwnode;
    1012                 :            :         const char              *endpoint[2];
    1013                 :            :         const char              *id;
    1014                 :            :         struct list_head        list;
    1015                 :            : };
    1016                 :            : 
    1017                 :            : typedef void *(*devcon_match_fn_t)(struct device_connection *con, int ep,
    1018                 :            :                                    void *data);
    1019                 :            : 
    1020                 :            : void *fwnode_connection_find_match(struct fwnode_handle *fwnode,
    1021                 :            :                                    const char *con_id, void *data,
    1022                 :            :                                    devcon_match_fn_t match);
    1023                 :            : void *device_connection_find_match(struct device *dev, const char *con_id,
    1024                 :            :                                    void *data, devcon_match_fn_t match);
    1025                 :            : 
    1026                 :            : struct device *device_connection_find(struct device *dev, const char *con_id);
    1027                 :            : 
    1028                 :            : void device_connection_add(struct device_connection *con);
    1029                 :            : void device_connection_remove(struct device_connection *con);
    1030                 :            : 
    1031                 :            : /**
    1032                 :            :  * device_connections_add - Add multiple device connections at once
    1033                 :            :  * @cons: Zero terminated array of device connection descriptors
    1034                 :            :  */
    1035                 :            : static inline void device_connections_add(struct device_connection *cons)
    1036                 :            : {
    1037                 :            :         struct device_connection *c;
    1038                 :            : 
    1039                 :            :         for (c = cons; c->endpoint[0]; c++)
    1040                 :            :                 device_connection_add(c);
    1041                 :            : }
    1042                 :            : 
    1043                 :            : /**
    1044                 :            :  * device_connections_remove - Remove multiple device connections at once
    1045                 :            :  * @cons: Zero terminated array of device connection descriptors
    1046                 :            :  */
    1047                 :            : static inline void device_connections_remove(struct device_connection *cons)
    1048                 :            : {
    1049                 :            :         struct device_connection *c;
    1050                 :            : 
    1051                 :            :         for (c = cons; c->endpoint[0]; c++)
    1052                 :            :                 device_connection_remove(c);
    1053                 :            : }
    1054                 :            : 
    1055                 :            : /**
    1056                 :            :  * enum device_link_state - Device link states.
    1057                 :            :  * @DL_STATE_NONE: The presence of the drivers is not being tracked.
    1058                 :            :  * @DL_STATE_DORMANT: None of the supplier/consumer drivers is present.
    1059                 :            :  * @DL_STATE_AVAILABLE: The supplier driver is present, but the consumer is not.
    1060                 :            :  * @DL_STATE_CONSUMER_PROBE: The consumer is probing (supplier driver present).
    1061                 :            :  * @DL_STATE_ACTIVE: Both the supplier and consumer drivers are present.
    1062                 :            :  * @DL_STATE_SUPPLIER_UNBIND: The supplier driver is unbinding.
    1063                 :            :  */
    1064                 :            : enum device_link_state {
    1065                 :            :         DL_STATE_NONE = -1,
    1066                 :            :         DL_STATE_DORMANT = 0,
    1067                 :            :         DL_STATE_AVAILABLE,
    1068                 :            :         DL_STATE_CONSUMER_PROBE,
    1069                 :            :         DL_STATE_ACTIVE,
    1070                 :            :         DL_STATE_SUPPLIER_UNBIND,
    1071                 :            : };
    1072                 :            : 
    1073                 :            : /*
    1074                 :            :  * Device link flags.
    1075                 :            :  *
    1076                 :            :  * STATELESS: The core will not remove this link automatically.
    1077                 :            :  * AUTOREMOVE_CONSUMER: Remove the link automatically on consumer driver unbind.
    1078                 :            :  * PM_RUNTIME: If set, the runtime PM framework will use this link.
    1079                 :            :  * RPM_ACTIVE: Run pm_runtime_get_sync() on the supplier during link creation.
    1080                 :            :  * AUTOREMOVE_SUPPLIER: Remove the link automatically on supplier driver unbind.
    1081                 :            :  * AUTOPROBE_CONSUMER: Probe consumer driver automatically after supplier binds.
    1082                 :            :  * MANAGED: The core tracks presence of supplier/consumer drivers (internal).
    1083                 :            :  */
    1084                 :            : #define DL_FLAG_STATELESS               BIT(0)
    1085                 :            : #define DL_FLAG_AUTOREMOVE_CONSUMER     BIT(1)
    1086                 :            : #define DL_FLAG_PM_RUNTIME              BIT(2)
    1087                 :            : #define DL_FLAG_RPM_ACTIVE              BIT(3)
    1088                 :            : #define DL_FLAG_AUTOREMOVE_SUPPLIER     BIT(4)
    1089                 :            : #define DL_FLAG_AUTOPROBE_CONSUMER      BIT(5)
    1090                 :            : #define DL_FLAG_MANAGED                 BIT(6)
    1091                 :            : 
    1092                 :            : /**
    1093                 :            :  * struct device_link - Device link representation.
    1094                 :            :  * @supplier: The device on the supplier end of the link.
    1095                 :            :  * @s_node: Hook to the supplier device's list of links to consumers.
    1096                 :            :  * @consumer: The device on the consumer end of the link.
    1097                 :            :  * @c_node: Hook to the consumer device's list of links to suppliers.
    1098                 :            :  * @status: The state of the link (with respect to the presence of drivers).
    1099                 :            :  * @flags: Link flags.
    1100                 :            :  * @rpm_active: Whether or not the consumer device is runtime-PM-active.
    1101                 :            :  * @kref: Count repeated addition of the same link.
    1102                 :            :  * @rcu_head: An RCU head to use for deferred execution of SRCU callbacks.
    1103                 :            :  * @supplier_preactivated: Supplier has been made active before consumer probe.
    1104                 :            :  */
    1105                 :            : struct device_link {
    1106                 :            :         struct device *supplier;
    1107                 :            :         struct list_head s_node;
    1108                 :            :         struct device *consumer;
    1109                 :            :         struct list_head c_node;
    1110                 :            :         enum device_link_state status;
    1111                 :            :         u32 flags;
    1112                 :            :         refcount_t rpm_active;
    1113                 :            :         struct kref kref;
    1114                 :            : #ifdef CONFIG_SRCU
    1115                 :            :         struct rcu_head rcu_head;
    1116                 :            : #endif
    1117                 :            :         bool supplier_preactivated; /* Owned by consumer probe. */
    1118                 :            : };
    1119                 :            : 
    1120                 :            : /**
    1121                 :            :  * enum dl_dev_state - Device driver presence tracking information.
    1122                 :            :  * @DL_DEV_NO_DRIVER: There is no driver attached to the device.
    1123                 :            :  * @DL_DEV_PROBING: A driver is probing.
    1124                 :            :  * @DL_DEV_DRIVER_BOUND: The driver has been bound to the device.
    1125                 :            :  * @DL_DEV_UNBINDING: The driver is unbinding from the device.
    1126                 :            :  */
    1127                 :            : enum dl_dev_state {
    1128                 :            :         DL_DEV_NO_DRIVER = 0,
    1129                 :            :         DL_DEV_PROBING,
    1130                 :            :         DL_DEV_DRIVER_BOUND,
    1131                 :            :         DL_DEV_UNBINDING,
    1132                 :            : };
    1133                 :            : 
    1134                 :            : /**
    1135                 :            :  * struct dev_links_info - Device data related to device links.
    1136                 :            :  * @suppliers: List of links to supplier devices.
    1137                 :            :  * @consumers: List of links to consumer devices.
    1138                 :            :  * @status: Driver status information.
    1139                 :            :  */
    1140                 :            : struct dev_links_info {
    1141                 :            :         struct list_head suppliers;
    1142                 :            :         struct list_head consumers;
    1143                 :            :         enum dl_dev_state status;
    1144                 :            : };
    1145                 :            : 
    1146                 :            : /**
    1147                 :            :  * struct device - The basic device structure
    1148                 :            :  * @parent:     The device's "parent" device, the device to which it is attached.
    1149                 :            :  *              In most cases, a parent device is some sort of bus or host
    1150                 :            :  *              controller. If parent is NULL, the device, is a top-level device,
    1151                 :            :  *              which is not usually what you want.
    1152                 :            :  * @p:          Holds the private data of the driver core portions of the device.
    1153                 :            :  *              See the comment of the struct device_private for detail.
    1154                 :            :  * @kobj:       A top-level, abstract class from which other classes are derived.
    1155                 :            :  * @init_name:  Initial name of the device.
    1156                 :            :  * @type:       The type of device.
    1157                 :            :  *              This identifies the device type and carries type-specific
    1158                 :            :  *              information.
    1159                 :            :  * @mutex:      Mutex to synchronize calls to its driver.
    1160                 :            :  * @lockdep_mutex: An optional debug lock that a subsystem can use as a
    1161                 :            :  *              peer lock to gain localized lockdep coverage of the device_lock.
    1162                 :            :  * @bus:        Type of bus device is on.
    1163                 :            :  * @driver:     Which driver has allocated this
    1164                 :            :  * @platform_data: Platform data specific to the device.
    1165                 :            :  *              Example: For devices on custom boards, as typical of embedded
    1166                 :            :  *              and SOC based hardware, Linux often uses platform_data to point
    1167                 :            :  *              to board-specific structures describing devices and how they
    1168                 :            :  *              are wired.  That can include what ports are available, chip
    1169                 :            :  *              variants, which GPIO pins act in what additional roles, and so
    1170                 :            :  *              on.  This shrinks the "Board Support Packages" (BSPs) and
    1171                 :            :  *              minimizes board-specific #ifdefs in drivers.
    1172                 :            :  * @driver_data: Private pointer for driver specific info.
    1173                 :            :  * @links:      Links to suppliers and consumers of this device.
    1174                 :            :  * @power:      For device power management.
    1175                 :            :  *              See Documentation/driver-api/pm/devices.rst for details.
    1176                 :            :  * @pm_domain:  Provide callbacks that are executed during system suspend,
    1177                 :            :  *              hibernation, system resume and during runtime PM transitions
    1178                 :            :  *              along with subsystem-level and driver-level callbacks.
    1179                 :            :  * @pins:       For device pin management.
    1180                 :            :  *              See Documentation/driver-api/pinctl.rst for details.
    1181                 :            :  * @msi_list:   Hosts MSI descriptors
    1182                 :            :  * @msi_domain: The generic MSI domain this device is using.
    1183                 :            :  * @numa_node:  NUMA node this device is close to.
    1184                 :            :  * @dma_ops:    DMA mapping operations for this device.
    1185                 :            :  * @dma_mask:   Dma mask (if dma'ble device).
    1186                 :            :  * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all
    1187                 :            :  *              hardware supports 64-bit addresses for consistent allocations
    1188                 :            :  *              such descriptors.
    1189                 :            :  * @bus_dma_limit: Limit of an upstream bridge or bus which imposes a smaller
    1190                 :            :  *              DMA limit than the device itself supports.
    1191                 :            :  * @dma_pfn_offset: offset of DMA memory range relatively of RAM
    1192                 :            :  * @dma_parms:  A low level driver may set these to teach IOMMU code about
    1193                 :            :  *              segment limitations.
    1194                 :            :  * @dma_pools:  Dma pools (if dma'ble device).
    1195                 :            :  * @dma_mem:    Internal for coherent mem override.
    1196                 :            :  * @cma_area:   Contiguous memory area for dma allocations
    1197                 :            :  * @archdata:   For arch-specific additions.
    1198                 :            :  * @of_node:    Associated device tree node.
    1199                 :            :  * @fwnode:     Associated device node supplied by platform firmware.
    1200                 :            :  * @devt:       For creating the sysfs "dev".
    1201                 :            :  * @id:         device instance
    1202                 :            :  * @devres_lock: Spinlock to protect the resource of the device.
    1203                 :            :  * @devres_head: The resources list of the device.
    1204                 :            :  * @knode_class: The node used to add the device to the class list.
    1205                 :            :  * @class:      The class of the device.
    1206                 :            :  * @groups:     Optional attribute groups.
    1207                 :            :  * @release:    Callback to free the device after all references have
    1208                 :            :  *              gone away. This should be set by the allocator of the
    1209                 :            :  *              device (i.e. the bus driver that discovered the device).
    1210                 :            :  * @iommu_group: IOMMU group the device belongs to.
    1211                 :            :  * @iommu_fwspec: IOMMU-specific properties supplied by firmware.
    1212                 :            :  * @iommu_param: Per device generic IOMMU runtime data
    1213                 :            :  *
    1214                 :            :  * @offline_disabled: If set, the device is permanently online.
    1215                 :            :  * @offline:    Set after successful invocation of bus type's .offline().
    1216                 :            :  * @of_node_reused: Set if the device-tree node is shared with an ancestor
    1217                 :            :  *              device.
    1218                 :            :  * @dma_coherent: this particular device is dma coherent, even if the
    1219                 :            :  *              architecture supports non-coherent devices.
    1220                 :            :  *
    1221                 :            :  * At the lowest level, every device in a Linux system is represented by an
    1222                 :            :  * instance of struct device. The device structure contains the information
    1223                 :            :  * that the device model core needs to model the system. Most subsystems,
    1224                 :            :  * however, track additional information about the devices they host. As a
    1225                 :            :  * result, it is rare for devices to be represented by bare device structures;
    1226                 :            :  * instead, that structure, like kobject structures, is usually embedded within
    1227                 :            :  * a higher-level representation of the device.
    1228                 :            :  */
    1229                 :            : struct device {
    1230                 :            :         struct kobject kobj;
    1231                 :            :         struct device           *parent;
    1232                 :            : 
    1233                 :            :         struct device_private   *p;
    1234                 :            : 
    1235                 :            :         const char              *init_name; /* initial name of the device */
    1236                 :            :         const struct device_type *type;
    1237                 :            : 
    1238                 :            :         struct bus_type *bus;           /* type of bus device is on */
    1239                 :            :         struct device_driver *driver;   /* which driver has allocated this
    1240                 :            :                                            device */
    1241                 :            :         void            *platform_data; /* Platform specific data, device
    1242                 :            :                                            core doesn't touch it */
    1243                 :            :         void            *driver_data;   /* Driver data, set and get with
    1244                 :            :                                            dev_set_drvdata/dev_get_drvdata */
    1245                 :            : #ifdef CONFIG_PROVE_LOCKING
    1246                 :            :         struct mutex            lockdep_mutex;
    1247                 :            : #endif
    1248                 :            :         struct mutex            mutex;  /* mutex to synchronize calls to
    1249                 :            :                                          * its driver.
    1250                 :            :                                          */
    1251                 :            : 
    1252                 :            :         struct dev_links_info   links;
    1253                 :            :         struct dev_pm_info      power;
    1254                 :            :         struct dev_pm_domain    *pm_domain;
    1255                 :            : 
    1256                 :            : #ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
    1257                 :            :         struct irq_domain       *msi_domain;
    1258                 :            : #endif
    1259                 :            : #ifdef CONFIG_PINCTRL
    1260                 :            :         struct dev_pin_info     *pins;
    1261                 :            : #endif
    1262                 :            : #ifdef CONFIG_GENERIC_MSI_IRQ
    1263                 :            :         struct list_head        msi_list;
    1264                 :            : #endif
    1265                 :            : 
    1266                 :            :         const struct dma_map_ops *dma_ops;
    1267                 :            :         u64             *dma_mask;      /* dma mask (if dma'able device) */
    1268                 :            :         u64             coherent_dma_mask;/* Like dma_mask, but for
    1269                 :            :                                              alloc_coherent mappings as
    1270                 :            :                                              not all hardware supports
    1271                 :            :                                              64 bit addresses for consistent
    1272                 :            :                                              allocations such descriptors. */
    1273                 :            :         u64             bus_dma_limit;  /* upstream dma constraint */
    1274                 :            :         unsigned long   dma_pfn_offset;
    1275                 :            : 
    1276                 :            :         struct device_dma_parameters *dma_parms;
    1277                 :            : 
    1278                 :            :         struct list_head        dma_pools;      /* dma pools (if dma'ble) */
    1279                 :            : 
    1280                 :            : #ifdef CONFIG_DMA_DECLARE_COHERENT
    1281                 :            :         struct dma_coherent_mem *dma_mem; /* internal for coherent mem
    1282                 :            :                                              override */
    1283                 :            : #endif
    1284                 :            : #ifdef CONFIG_DMA_CMA
    1285                 :            :         struct cma *cma_area;           /* contiguous memory area for dma
    1286                 :            :                                            allocations */
    1287                 :            : #endif
    1288                 :            :         /* arch specific additions */
    1289                 :            :         struct dev_archdata     archdata;
    1290                 :            : 
    1291                 :            :         struct device_node      *of_node; /* associated device tree node */
    1292                 :            :         struct fwnode_handle    *fwnode; /* firmware device node */
    1293                 :            : 
    1294                 :            : #ifdef CONFIG_NUMA
    1295                 :            :         int             numa_node;      /* NUMA node this device is close to */
    1296                 :            : #endif
    1297                 :            :         dev_t                   devt;   /* dev_t, creates the sysfs "dev" */
    1298                 :            :         u32                     id;     /* device instance */
    1299                 :            : 
    1300                 :            :         spinlock_t              devres_lock;
    1301                 :            :         struct list_head        devres_head;
    1302                 :            : 
    1303                 :            :         struct class            *class;
    1304                 :            :         const struct attribute_group **groups;  /* optional groups */
    1305                 :            : 
    1306                 :            :         void    (*release)(struct device *dev);
    1307                 :            :         struct iommu_group      *iommu_group;
    1308                 :            :         struct iommu_fwspec     *iommu_fwspec;
    1309                 :            :         struct iommu_param      *iommu_param;
    1310                 :            : 
    1311                 :            :         bool                    offline_disabled:1;
    1312                 :            :         bool                    offline:1;
    1313                 :            :         bool                    of_node_reused:1;
    1314                 :            : #if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \
    1315                 :            :     defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
    1316                 :            :     defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL)
    1317                 :            :         bool                    dma_coherent:1;
    1318                 :            : #endif
    1319                 :            : };
    1320                 :            : 
    1321                 :            : static inline struct device *kobj_to_dev(struct kobject *kobj)
    1322                 :            : {
    1323                 :            :         return container_of(kobj, struct device, kobj);
    1324                 :            : }
    1325                 :            : 
    1326                 :            : /**
    1327                 :            :  * device_iommu_mapped - Returns true when the device DMA is translated
    1328                 :            :  *                       by an IOMMU
    1329                 :            :  * @dev: Device to perform the check on
    1330                 :            :  */
    1331                 :            : static inline bool device_iommu_mapped(struct device *dev)
    1332                 :            : {
    1333                 :            :         return (dev->iommu_group != NULL);
    1334                 :            : }
    1335                 :            : 
    1336                 :            : /* Get the wakeup routines, which depend on struct device */
    1337                 :            : #include <linux/pm_wakeup.h>
    1338                 :            : 
    1339                 :            : static inline const char *dev_name(const struct device *dev)
    1340                 :            : {
    1341                 :            :         /* Use the init name until the kobject becomes available */
    1342                 :          3 :         if (dev->init_name)
    1343                 :            :                 return dev->init_name;
    1344                 :            : 
    1345                 :            :         return kobject_name(&dev->kobj);
    1346                 :            : }
    1347                 :            : 
    1348                 :            : extern __printf(2, 3)
    1349                 :            : int dev_set_name(struct device *dev, const char *name, ...);
    1350                 :            : 
    1351                 :            : #ifdef CONFIG_NUMA
    1352                 :            : static inline int dev_to_node(struct device *dev)
    1353                 :            : {
    1354                 :            :         return dev->numa_node;
    1355                 :            : }
    1356                 :            : static inline void set_dev_node(struct device *dev, int node)
    1357                 :            : {
    1358                 :            :         dev->numa_node = node;
    1359                 :            : }
    1360                 :            : #else
    1361                 :            : static inline int dev_to_node(struct device *dev)
    1362                 :            : {
    1363                 :            :         return NUMA_NO_NODE;
    1364                 :            : }
    1365                 :            : static inline void set_dev_node(struct device *dev, int node)
    1366                 :            : {
    1367                 :            : }
    1368                 :            : #endif
    1369                 :            : 
    1370                 :            : static inline struct irq_domain *dev_get_msi_domain(const struct device *dev)
    1371                 :            : {
    1372                 :            : #ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
    1373                 :            :         return dev->msi_domain;
    1374                 :            : #else
    1375                 :            :         return NULL;
    1376                 :            : #endif
    1377                 :            : }
    1378                 :            : 
    1379                 :            : static inline void dev_set_msi_domain(struct device *dev, struct irq_domain *d)
    1380                 :            : {
    1381                 :            : #ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
    1382                 :            :         dev->msi_domain = d;
    1383                 :            : #endif
    1384                 :            : }
    1385                 :            : 
    1386                 :            : static inline void *dev_get_drvdata(const struct device *dev)
    1387                 :            : {
    1388                 :          3 :         return dev->driver_data;
    1389                 :            : }
    1390                 :            : 
    1391                 :            : static inline void dev_set_drvdata(struct device *dev, void *data)
    1392                 :            : {
    1393                 :          3 :         dev->driver_data = data;
    1394                 :            : }
    1395                 :            : 
    1396                 :            : static inline struct pm_subsys_data *dev_to_psd(struct device *dev)
    1397                 :            : {
    1398                 :          3 :         return dev ? dev->power.subsys_data : NULL;
    1399                 :            : }
    1400                 :            : 
    1401                 :            : static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
    1402                 :            : {
    1403                 :          3 :         return dev->kobj.uevent_suppress;
    1404                 :            : }
    1405                 :            : 
    1406                 :            : static inline void dev_set_uevent_suppress(struct device *dev, int val)
    1407                 :            : {
    1408                 :          3 :         dev->kobj.uevent_suppress = val;
    1409                 :            : }
    1410                 :            : 
    1411                 :            : static inline int device_is_registered(struct device *dev)
    1412                 :            : {
    1413                 :          3 :         return dev->kobj.state_in_sysfs;
    1414                 :            : }
    1415                 :            : 
    1416                 :            : static inline void device_enable_async_suspend(struct device *dev)
    1417                 :            : {
    1418                 :          3 :         if (!dev->power.is_prepared)
    1419                 :          3 :                 dev->power.async_suspend = true;
    1420                 :            : }
    1421                 :            : 
    1422                 :            : static inline void device_disable_async_suspend(struct device *dev)
    1423                 :            : {
    1424                 :          0 :         if (!dev->power.is_prepared)
    1425                 :          0 :                 dev->power.async_suspend = false;
    1426                 :            : }
    1427                 :            : 
    1428                 :            : static inline bool device_async_suspend_enabled(struct device *dev)
    1429                 :            : {
    1430                 :            :         return !!dev->power.async_suspend;
    1431                 :            : }
    1432                 :            : 
    1433                 :            : static inline bool device_pm_not_required(struct device *dev)
    1434                 :            : {
    1435                 :          3 :         return dev->power.no_pm;
    1436                 :            : }
    1437                 :            : 
    1438                 :            : static inline void device_set_pm_not_required(struct device *dev)
    1439                 :            : {
    1440                 :          0 :         dev->power.no_pm = true;
    1441                 :            : }
    1442                 :            : 
    1443                 :            : static inline void dev_pm_syscore_device(struct device *dev, bool val)
    1444                 :            : {
    1445                 :            : #ifdef CONFIG_PM_SLEEP
    1446                 :            :         dev->power.syscore = val;
    1447                 :            : #endif
    1448                 :            : }
    1449                 :            : 
    1450                 :            : static inline void dev_pm_set_driver_flags(struct device *dev, u32 flags)
    1451                 :            : {
    1452                 :          3 :         dev->power.driver_flags = flags;
    1453                 :            : }
    1454                 :            : 
    1455                 :            : static inline bool dev_pm_test_driver_flags(struct device *dev, u32 flags)
    1456                 :            : {
    1457                 :            :         return !!(dev->power.driver_flags & flags);
    1458                 :            : }
    1459                 :            : 
    1460                 :            : static inline void device_lock(struct device *dev)
    1461                 :            : {
    1462                 :          3 :         mutex_lock(&dev->mutex);
    1463                 :            : }
    1464                 :            : 
    1465                 :            : static inline int device_lock_interruptible(struct device *dev)
    1466                 :            : {
    1467                 :          3 :         return mutex_lock_interruptible(&dev->mutex);
    1468                 :            : }
    1469                 :            : 
    1470                 :            : static inline int device_trylock(struct device *dev)
    1471                 :            : {
    1472                 :          0 :         return mutex_trylock(&dev->mutex);
    1473                 :            : }
    1474                 :            : 
    1475                 :            : static inline void device_unlock(struct device *dev)
    1476                 :            : {
    1477                 :          3 :         mutex_unlock(&dev->mutex);
    1478                 :            : }
    1479                 :            : 
    1480                 :            : static inline void device_lock_assert(struct device *dev)
    1481                 :            : {
    1482                 :            :         lockdep_assert_held(&dev->mutex);
    1483                 :            : }
    1484                 :            : 
    1485                 :            : static inline struct device_node *dev_of_node(struct device *dev)
    1486                 :            : {
    1487                 :          3 :         if (!IS_ENABLED(CONFIG_OF) || !dev)
    1488                 :            :                 return NULL;
    1489                 :          3 :         return dev->of_node;
    1490                 :            : }
    1491                 :            : 
    1492                 :            : void driver_init(void);
    1493                 :            : 
    1494                 :            : /*
    1495                 :            :  * High level routines for use by the bus drivers
    1496                 :            :  */
    1497                 :            : extern int __must_check device_register(struct device *dev);
    1498                 :            : extern void device_unregister(struct device *dev);
    1499                 :            : extern void device_initialize(struct device *dev);
    1500                 :            : extern int __must_check device_add(struct device *dev);
    1501                 :            : extern void device_del(struct device *dev);
    1502                 :            : extern int device_for_each_child(struct device *dev, void *data,
    1503                 :            :                      int (*fn)(struct device *dev, void *data));
    1504                 :            : extern int device_for_each_child_reverse(struct device *dev, void *data,
    1505                 :            :                      int (*fn)(struct device *dev, void *data));
    1506                 :            : extern struct device *device_find_child(struct device *dev, void *data,
    1507                 :            :                                 int (*match)(struct device *dev, void *data));
    1508                 :            : extern struct device *device_find_child_by_name(struct device *parent,
    1509                 :            :                                                 const char *name);
    1510                 :            : extern int device_rename(struct device *dev, const char *new_name);
    1511                 :            : extern int device_move(struct device *dev, struct device *new_parent,
    1512                 :            :                        enum dpm_order dpm_order);
    1513                 :            : extern const char *device_get_devnode(struct device *dev,
    1514                 :            :                                       umode_t *mode, kuid_t *uid, kgid_t *gid,
    1515                 :            :                                       const char **tmp);
    1516                 :            : 
    1517                 :            : static inline bool device_supports_offline(struct device *dev)
    1518                 :            : {
    1519                 :          3 :         return dev->bus && dev->bus->offline && dev->bus->online;
    1520                 :            : }
    1521                 :            : 
    1522                 :            : extern void lock_device_hotplug(void);
    1523                 :            : extern void unlock_device_hotplug(void);
    1524                 :            : extern int lock_device_hotplug_sysfs(void);
    1525                 :            : extern int device_offline(struct device *dev);
    1526                 :            : extern int device_online(struct device *dev);
    1527                 :            : extern void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
    1528                 :            : extern void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
    1529                 :            : void device_set_of_node_from_dev(struct device *dev, const struct device *dev2);
    1530                 :            : 
    1531                 :            : static inline int dev_num_vf(struct device *dev)
    1532                 :            : {
    1533                 :          0 :         if (dev->bus && dev->bus->num_vf)
    1534                 :          0 :                 return dev->bus->num_vf(dev);
    1535                 :            :         return 0;
    1536                 :            : }
    1537                 :            : 
    1538                 :            : /*
    1539                 :            :  * Root device objects for grouping under /sys/devices
    1540                 :            :  */
    1541                 :            : extern struct device *__root_device_register(const char *name,
    1542                 :            :                                              struct module *owner);
    1543                 :            : 
    1544                 :            : /* This is a macro to avoid include problems with THIS_MODULE */
    1545                 :            : #define root_device_register(name) \
    1546                 :            :         __root_device_register(name, THIS_MODULE)
    1547                 :            : 
    1548                 :            : extern void root_device_unregister(struct device *root);
    1549                 :            : 
    1550                 :            : static inline void *dev_get_platdata(const struct device *dev)
    1551                 :            : {
    1552                 :          3 :         return dev->platform_data;
    1553                 :            : }
    1554                 :            : 
    1555                 :            : /*
    1556                 :            :  * Manual binding of a device to driver. See drivers/base/bus.c
    1557                 :            :  * for information on use.
    1558                 :            :  */
    1559                 :            : extern int __must_check device_bind_driver(struct device *dev);
    1560                 :            : extern void device_release_driver(struct device *dev);
    1561                 :            : extern int  __must_check device_attach(struct device *dev);
    1562                 :            : extern int __must_check driver_attach(struct device_driver *drv);
    1563                 :            : extern void device_initial_probe(struct device *dev);
    1564                 :            : extern int __must_check device_reprobe(struct device *dev);
    1565                 :            : 
    1566                 :            : extern bool device_is_bound(struct device *dev);
    1567                 :            : 
    1568                 :            : /*
    1569                 :            :  * Easy functions for dynamically creating devices on the fly
    1570                 :            :  */
    1571                 :            : extern __printf(5, 0)
    1572                 :            : struct device *device_create_vargs(struct class *cls, struct device *parent,
    1573                 :            :                                    dev_t devt, void *drvdata,
    1574                 :            :                                    const char *fmt, va_list vargs);
    1575                 :            : extern __printf(5, 6)
    1576                 :            : struct device *device_create(struct class *cls, struct device *parent,
    1577                 :            :                              dev_t devt, void *drvdata,
    1578                 :            :                              const char *fmt, ...);
    1579                 :            : extern __printf(6, 7)
    1580                 :            : struct device *device_create_with_groups(struct class *cls,
    1581                 :            :                              struct device *parent, dev_t devt, void *drvdata,
    1582                 :            :                              const struct attribute_group **groups,
    1583                 :            :                              const char *fmt, ...);
    1584                 :            : extern void device_destroy(struct class *cls, dev_t devt);
    1585                 :            : 
    1586                 :            : extern int __must_check device_add_groups(struct device *dev,
    1587                 :            :                                         const struct attribute_group **groups);
    1588                 :            : extern void device_remove_groups(struct device *dev,
    1589                 :            :                                  const struct attribute_group **groups);
    1590                 :            : 
    1591                 :            : static inline int __must_check device_add_group(struct device *dev,
    1592                 :            :                                         const struct attribute_group *grp)
    1593                 :            : {
    1594                 :            :         const struct attribute_group *groups[] = { grp, NULL };
    1595                 :            : 
    1596                 :            :         return device_add_groups(dev, groups);
    1597                 :            : }
    1598                 :            : 
    1599                 :            : static inline void device_remove_group(struct device *dev,
    1600                 :            :                                        const struct attribute_group *grp)
    1601                 :            : {
    1602                 :            :         const struct attribute_group *groups[] = { grp, NULL };
    1603                 :            : 
    1604                 :            :         return device_remove_groups(dev, groups);
    1605                 :            : }
    1606                 :            : 
    1607                 :            : extern int __must_check devm_device_add_groups(struct device *dev,
    1608                 :            :                                         const struct attribute_group **groups);
    1609                 :            : extern void devm_device_remove_groups(struct device *dev,
    1610                 :            :                                       const struct attribute_group **groups);
    1611                 :            : extern int __must_check devm_device_add_group(struct device *dev,
    1612                 :            :                                         const struct attribute_group *grp);
    1613                 :            : extern void devm_device_remove_group(struct device *dev,
    1614                 :            :                                      const struct attribute_group *grp);
    1615                 :            : 
    1616                 :            : /*
    1617                 :            :  * Platform "fixup" functions - allow the platform to have their say
    1618                 :            :  * about devices and actions that the general device layer doesn't
    1619                 :            :  * know about.
    1620                 :            :  */
    1621                 :            : /* Notify platform of device discovery */
    1622                 :            : extern int (*platform_notify)(struct device *dev);
    1623                 :            : 
    1624                 :            : extern int (*platform_notify_remove)(struct device *dev);
    1625                 :            : 
    1626                 :            : 
    1627                 :            : /*
    1628                 :            :  * get_device - atomically increment the reference count for the device.
    1629                 :            :  *
    1630                 :            :  */
    1631                 :            : extern struct device *get_device(struct device *dev);
    1632                 :            : extern void put_device(struct device *dev);
    1633                 :            : extern bool kill_device(struct device *dev);
    1634                 :            : 
    1635                 :            : #ifdef CONFIG_DEVTMPFS
    1636                 :            : extern int devtmpfs_create_node(struct device *dev);
    1637                 :            : extern int devtmpfs_delete_node(struct device *dev);
    1638                 :            : extern int devtmpfs_mount(const char *mntdir);
    1639                 :            : #else
    1640                 :            : static inline int devtmpfs_create_node(struct device *dev) { return 0; }
    1641                 :            : static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
    1642                 :            : static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
    1643                 :            : #endif
    1644                 :            : 
    1645                 :            : /* drivers/base/power/shutdown.c */
    1646                 :            : extern void device_shutdown(void);
    1647                 :            : 
    1648                 :            : /* debugging and troubleshooting/diagnostic helpers. */
    1649                 :            : extern const char *dev_driver_string(const struct device *dev);
    1650                 :            : 
    1651                 :            : /* Device links interface. */
    1652                 :            : struct device_link *device_link_add(struct device *consumer,
    1653                 :            :                                     struct device *supplier, u32 flags);
    1654                 :            : void device_link_del(struct device_link *link);
    1655                 :            : void device_link_remove(void *consumer, struct device *supplier);
    1656                 :            : 
    1657                 :            : #ifndef dev_fmt
    1658                 :            : #define dev_fmt(fmt) fmt
    1659                 :            : #endif
    1660                 :            : 
    1661                 :            : #ifdef CONFIG_PRINTK
    1662                 :            : 
    1663                 :            : __printf(3, 0) __cold
    1664                 :            : int dev_vprintk_emit(int level, const struct device *dev,
    1665                 :            :                      const char *fmt, va_list args);
    1666                 :            : __printf(3, 4) __cold
    1667                 :            : int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
    1668                 :            : 
    1669                 :            : __printf(3, 4) __cold
    1670                 :            : void dev_printk(const char *level, const struct device *dev,
    1671                 :            :                 const char *fmt, ...);
    1672                 :            : __printf(2, 3) __cold
    1673                 :            : void _dev_emerg(const struct device *dev, const char *fmt, ...);
    1674                 :            : __printf(2, 3) __cold
    1675                 :            : void _dev_alert(const struct device *dev, const char *fmt, ...);
    1676                 :            : __printf(2, 3) __cold
    1677                 :            : void _dev_crit(const struct device *dev, const char *fmt, ...);
    1678                 :            : __printf(2, 3) __cold
    1679                 :            : void _dev_err(const struct device *dev, const char *fmt, ...);
    1680                 :            : __printf(2, 3) __cold
    1681                 :            : void _dev_warn(const struct device *dev, const char *fmt, ...);
    1682                 :            : __printf(2, 3) __cold
    1683                 :            : void _dev_notice(const struct device *dev, const char *fmt, ...);
    1684                 :            : __printf(2, 3) __cold
    1685                 :            : void _dev_info(const struct device *dev, const char *fmt, ...);
    1686                 :            : 
    1687                 :            : #else
    1688                 :            : 
    1689                 :            : static inline __printf(3, 0)
    1690                 :            : int dev_vprintk_emit(int level, const struct device *dev,
    1691                 :            :                      const char *fmt, va_list args)
    1692                 :            : { return 0; }
    1693                 :            : static inline __printf(3, 4)
    1694                 :            : int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
    1695                 :            : { return 0; }
    1696                 :            : 
    1697                 :            : static inline void __dev_printk(const char *level, const struct device *dev,
    1698                 :            :                                 struct va_format *vaf)
    1699                 :            : {}
    1700                 :            : static inline __printf(3, 4)
    1701                 :            : void dev_printk(const char *level, const struct device *dev,
    1702                 :            :                  const char *fmt, ...)
    1703                 :            : {}
    1704                 :            : 
    1705                 :            : static inline __printf(2, 3)
    1706                 :            : void _dev_emerg(const struct device *dev, const char *fmt, ...)
    1707                 :            : {}
    1708                 :            : static inline __printf(2, 3)
    1709                 :            : void _dev_crit(const struct device *dev, const char *fmt, ...)
    1710                 :            : {}
    1711                 :            : static inline __printf(2, 3)
    1712                 :            : void _dev_alert(const struct device *dev, const char *fmt, ...)
    1713                 :            : {}
    1714                 :            : static inline __printf(2, 3)
    1715                 :            : void _dev_err(const struct device *dev, const char *fmt, ...)
    1716                 :            : {}
    1717                 :            : static inline __printf(2, 3)
    1718                 :            : void _dev_warn(const struct device *dev, const char *fmt, ...)
    1719                 :            : {}
    1720                 :            : static inline __printf(2, 3)
    1721                 :            : void _dev_notice(const struct device *dev, const char *fmt, ...)
    1722                 :            : {}
    1723                 :            : static inline __printf(2, 3)
    1724                 :            : void _dev_info(const struct device *dev, const char *fmt, ...)
    1725                 :            : {}
    1726                 :            : 
    1727                 :            : #endif
    1728                 :            : 
    1729                 :            : /*
    1730                 :            :  * #defines for all the dev_<level> macros to prefix with whatever
    1731                 :            :  * possible use of #define dev_fmt(fmt) ...
    1732                 :            :  */
    1733                 :            : 
    1734                 :            : #define dev_emerg(dev, fmt, ...)                                        \
    1735                 :            :         _dev_emerg(dev, dev_fmt(fmt), ##__VA_ARGS__)
    1736                 :            : #define dev_crit(dev, fmt, ...)                                         \
    1737                 :            :         _dev_crit(dev, dev_fmt(fmt), ##__VA_ARGS__)
    1738                 :            : #define dev_alert(dev, fmt, ...)                                        \
    1739                 :            :         _dev_alert(dev, dev_fmt(fmt), ##__VA_ARGS__)
    1740                 :            : #define dev_err(dev, fmt, ...)                                          \
    1741                 :            :         _dev_err(dev, dev_fmt(fmt), ##__VA_ARGS__)
    1742                 :            : #define dev_warn(dev, fmt, ...)                                         \
    1743                 :            :         _dev_warn(dev, dev_fmt(fmt), ##__VA_ARGS__)
    1744                 :            : #define dev_notice(dev, fmt, ...)                                       \
    1745                 :            :         _dev_notice(dev, dev_fmt(fmt), ##__VA_ARGS__)
    1746                 :            : #define dev_info(dev, fmt, ...)                                         \
    1747                 :            :         _dev_info(dev, dev_fmt(fmt), ##__VA_ARGS__)
    1748                 :            : 
    1749                 :            : #if defined(CONFIG_DYNAMIC_DEBUG)
    1750                 :            : #define dev_dbg(dev, fmt, ...)                                          \
    1751                 :            :         dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__)
    1752                 :            : #elif defined(DEBUG)
    1753                 :            : #define dev_dbg(dev, fmt, ...)                                          \
    1754                 :            :         dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__)
    1755                 :            : #else
    1756                 :            : #define dev_dbg(dev, fmt, ...)                                          \
    1757                 :            : ({                                                                      \
    1758                 :            :         if (0)                                                          \
    1759                 :            :                 dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
    1760                 :            : })
    1761                 :            : #endif
    1762                 :            : 
    1763                 :            : #ifdef CONFIG_PRINTK
    1764                 :            : #define dev_level_once(dev_level, dev, fmt, ...)                        \
    1765                 :            : do {                                                                    \
    1766                 :            :         static bool __print_once __read_mostly;                         \
    1767                 :            :                                                                         \
    1768                 :            :         if (!__print_once) {                                            \
    1769                 :            :                 __print_once = true;                                    \
    1770                 :            :                 dev_level(dev, fmt, ##__VA_ARGS__);                     \
    1771                 :            :         }                                                               \
    1772                 :            : } while (0)
    1773                 :            : #else
    1774                 :            : #define dev_level_once(dev_level, dev, fmt, ...)                        \
    1775                 :            : do {                                                                    \
    1776                 :            :         if (0)                                                          \
    1777                 :            :                 dev_level(dev, fmt, ##__VA_ARGS__);                     \
    1778                 :            : } while (0)
    1779                 :            : #endif
    1780                 :            : 
    1781                 :            : #define dev_emerg_once(dev, fmt, ...)                                   \
    1782                 :            :         dev_level_once(dev_emerg, dev, fmt, ##__VA_ARGS__)
    1783                 :            : #define dev_alert_once(dev, fmt, ...)                                   \
    1784                 :            :         dev_level_once(dev_alert, dev, fmt, ##__VA_ARGS__)
    1785                 :            : #define dev_crit_once(dev, fmt, ...)                                    \
    1786                 :            :         dev_level_once(dev_crit, dev, fmt, ##__VA_ARGS__)
    1787                 :            : #define dev_err_once(dev, fmt, ...)                                     \
    1788                 :            :         dev_level_once(dev_err, dev, fmt, ##__VA_ARGS__)
    1789                 :            : #define dev_warn_once(dev, fmt, ...)                                    \
    1790                 :            :         dev_level_once(dev_warn, dev, fmt, ##__VA_ARGS__)
    1791                 :            : #define dev_notice_once(dev, fmt, ...)                                  \
    1792                 :            :         dev_level_once(dev_notice, dev, fmt, ##__VA_ARGS__)
    1793                 :            : #define dev_info_once(dev, fmt, ...)                                    \
    1794                 :            :         dev_level_once(dev_info, dev, fmt, ##__VA_ARGS__)
    1795                 :            : #define dev_dbg_once(dev, fmt, ...)                                     \
    1796                 :            :         dev_level_once(dev_dbg, dev, fmt, ##__VA_ARGS__)
    1797                 :            : 
    1798                 :            : #define dev_level_ratelimited(dev_level, dev, fmt, ...)                 \
    1799                 :            : do {                                                                    \
    1800                 :            :         static DEFINE_RATELIMIT_STATE(_rs,                              \
    1801                 :            :                                       DEFAULT_RATELIMIT_INTERVAL,       \
    1802                 :            :                                       DEFAULT_RATELIMIT_BURST);         \
    1803                 :            :         if (__ratelimit(&_rs))                                              \
    1804                 :            :                 dev_level(dev, fmt, ##__VA_ARGS__);                     \
    1805                 :            : } while (0)
    1806                 :            : 
    1807                 :            : #define dev_emerg_ratelimited(dev, fmt, ...)                            \
    1808                 :            :         dev_level_ratelimited(dev_emerg, dev, fmt, ##__VA_ARGS__)
    1809                 :            : #define dev_alert_ratelimited(dev, fmt, ...)                            \
    1810                 :            :         dev_level_ratelimited(dev_alert, dev, fmt, ##__VA_ARGS__)
    1811                 :            : #define dev_crit_ratelimited(dev, fmt, ...)                             \
    1812                 :            :         dev_level_ratelimited(dev_crit, dev, fmt, ##__VA_ARGS__)
    1813                 :            : #define dev_err_ratelimited(dev, fmt, ...)                              \
    1814                 :            :         dev_level_ratelimited(dev_err, dev, fmt, ##__VA_ARGS__)
    1815                 :            : #define dev_warn_ratelimited(dev, fmt, ...)                             \
    1816                 :            :         dev_level_ratelimited(dev_warn, dev, fmt, ##__VA_ARGS__)
    1817                 :            : #define dev_notice_ratelimited(dev, fmt, ...)                           \
    1818                 :            :         dev_level_ratelimited(dev_notice, dev, fmt, ##__VA_ARGS__)
    1819                 :            : #define dev_info_ratelimited(dev, fmt, ...)                             \
    1820                 :            :         dev_level_ratelimited(dev_info, dev, fmt, ##__VA_ARGS__)
    1821                 :            : #if defined(CONFIG_DYNAMIC_DEBUG)
    1822                 :            : /* descriptor check is first to prevent flooding with "callbacks suppressed" */
    1823                 :            : #define dev_dbg_ratelimited(dev, fmt, ...)                              \
    1824                 :            : do {                                                                    \
    1825                 :            :         static DEFINE_RATELIMIT_STATE(_rs,                              \
    1826                 :            :                                       DEFAULT_RATELIMIT_INTERVAL,       \
    1827                 :            :                                       DEFAULT_RATELIMIT_BURST);         \
    1828                 :            :         DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);                 \
    1829                 :            :         if (DYNAMIC_DEBUG_BRANCH(descriptor) &&                         \
    1830                 :            :             __ratelimit(&_rs))                                              \
    1831                 :            :                 __dynamic_dev_dbg(&descriptor, dev, dev_fmt(fmt),   \
    1832                 :            :                                   ##__VA_ARGS__);                       \
    1833                 :            : } while (0)
    1834                 :            : #elif defined(DEBUG)
    1835                 :            : #define dev_dbg_ratelimited(dev, fmt, ...)                              \
    1836                 :            : do {                                                                    \
    1837                 :            :         static DEFINE_RATELIMIT_STATE(_rs,                              \
    1838                 :            :                                       DEFAULT_RATELIMIT_INTERVAL,       \
    1839                 :            :                                       DEFAULT_RATELIMIT_BURST);         \
    1840                 :            :         if (__ratelimit(&_rs))                                              \
    1841                 :            :                 dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
    1842                 :            : } while (0)
    1843                 :            : #else
    1844                 :            : #define dev_dbg_ratelimited(dev, fmt, ...)                              \
    1845                 :            : do {                                                                    \
    1846                 :            :         if (0)                                                          \
    1847                 :            :                 dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
    1848                 :            : } while (0)
    1849                 :            : #endif
    1850                 :            : 
    1851                 :            : #ifdef VERBOSE_DEBUG
    1852                 :            : #define dev_vdbg        dev_dbg
    1853                 :            : #else
    1854                 :            : #define dev_vdbg(dev, fmt, ...)                                         \
    1855                 :            : ({                                                                      \
    1856                 :            :         if (0)                                                          \
    1857                 :            :                 dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
    1858                 :            : })
    1859                 :            : #endif
    1860                 :            : 
    1861                 :            : /*
    1862                 :            :  * dev_WARN*() acts like dev_printk(), but with the key difference of
    1863                 :            :  * using WARN/WARN_ONCE to include file/line information and a backtrace.
    1864                 :            :  */
    1865                 :            : #define dev_WARN(dev, format, arg...) \
    1866                 :            :         WARN(1, "%s %s: " format, dev_driver_string(dev), dev_name(dev), ## arg);
    1867                 :            : 
    1868                 :            : #define dev_WARN_ONCE(dev, condition, format, arg...) \
    1869                 :            :         WARN_ONCE(condition, "%s %s: " format, \
    1870                 :            :                         dev_driver_string(dev), dev_name(dev), ## arg)
    1871                 :            : 
    1872                 :            : /* Create alias, so I can be autoloaded. */
    1873                 :            : #define MODULE_ALIAS_CHARDEV(major,minor) \
    1874                 :            :         MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
    1875                 :            : #define MODULE_ALIAS_CHARDEV_MAJOR(major) \
    1876                 :            :         MODULE_ALIAS("char-major-" __stringify(major) "-*")
    1877                 :            : 
    1878                 :            : #ifdef CONFIG_SYSFS_DEPRECATED
    1879                 :            : extern long sysfs_deprecated;
    1880                 :            : #else
    1881                 :            : #define sysfs_deprecated 0
    1882                 :            : #endif
    1883                 :            : 
    1884                 :            : /**
    1885                 :            :  * module_driver() - Helper macro for drivers that don't do anything
    1886                 :            :  * special in module init/exit. This eliminates a lot of boilerplate.
    1887                 :            :  * Each module may only use this macro once, and calling it replaces
    1888                 :            :  * module_init() and module_exit().
    1889                 :            :  *
    1890                 :            :  * @__driver: driver name
    1891                 :            :  * @__register: register function for this driver type
    1892                 :            :  * @__unregister: unregister function for this driver type
    1893                 :            :  * @...: Additional arguments to be passed to __register and __unregister.
    1894                 :            :  *
    1895                 :            :  * Use this macro to construct bus specific macros for registering
    1896                 :            :  * drivers, and do not use it on its own.
    1897                 :            :  */
    1898                 :            : #define module_driver(__driver, __register, __unregister, ...) \
    1899                 :            : static int __init __driver##_init(void) \
    1900                 :            : { \
    1901                 :            :         return __register(&(__driver) , ##__VA_ARGS__); \
    1902                 :            : } \
    1903                 :            : module_init(__driver##_init); \
    1904                 :            : static void __exit __driver##_exit(void) \
    1905                 :            : { \
    1906                 :            :         __unregister(&(__driver) , ##__VA_ARGS__); \
    1907                 :            : } \
    1908                 :            : module_exit(__driver##_exit);
    1909                 :            : 
    1910                 :            : /**
    1911                 :            :  * builtin_driver() - Helper macro for drivers that don't do anything
    1912                 :            :  * special in init and have no exit. This eliminates some boilerplate.
    1913                 :            :  * Each driver may only use this macro once, and calling it replaces
    1914                 :            :  * device_initcall (or in some cases, the legacy __initcall).  This is
    1915                 :            :  * meant to be a direct parallel of module_driver() above but without
    1916                 :            :  * the __exit stuff that is not used for builtin cases.
    1917                 :            :  *
    1918                 :            :  * @__driver: driver name
    1919                 :            :  * @__register: register function for this driver type
    1920                 :            :  * @...: Additional arguments to be passed to __register
    1921                 :            :  *
    1922                 :            :  * Use this macro to construct bus specific macros for registering
    1923                 :            :  * drivers, and do not use it on its own.
    1924                 :            :  */
    1925                 :            : #define builtin_driver(__driver, __register, ...) \
    1926                 :            : static int __init __driver##_init(void) \
    1927                 :            : { \
    1928                 :            :         return __register(&(__driver) , ##__VA_ARGS__); \
    1929                 :            : } \
    1930                 :            : device_initcall(__driver##_init);
    1931                 :            : 
    1932                 :            : #endif /* _DEVICE_H_ */
    

Generated by: LCOV version 1.14