1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * device.h - generic, centralized driver model 4 * 5 * Copyright (c) 2001-2003 Patrick Mochel <[email protected]> 6 * Copyright (c) 2004-2009 Greg Kroah-Hartman <[email protected]> 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/dev_printk.h> 16 #include <linux/energy_model.h> 17 #include <linux/ioport.h> 18 #include <linux/kobject.h> 19 #include <linux/klist.h> 20 #include <linux/list.h> 21 #include <linux/lockdep.h> 22 #include <linux/compiler.h> 23 #include <linux/types.h> 24 #include <linux/mutex.h> 25 #include <linux/pm.h> 26 #include <linux/atomic.h> 27 #include <linux/uidgid.h> 28 #include <linux/gfp.h> 29 #include <linux/overflow.h> 30 #include <linux/device/bus.h> 31 #include <linux/device/class.h> 32 #include <linux/device/driver.h> 33 #include <asm/device.h> 34 35 struct device; 36 struct device_private; 37 struct device_driver; 38 struct driver_private; 39 struct module; 40 struct class; 41 struct subsys_private; 42 struct device_node; 43 struct fwnode_handle; 44 struct iommu_ops; 45 struct iommu_group; 46 struct dev_pin_info; 47 struct dev_iommu; 48 49 /** 50 * struct subsys_interface - interfaces to device functions 51 * @name: name of the device function 52 * @subsys: subsytem of the devices to attach to 53 * @node: the list of functions registered at the subsystem 54 * @add_dev: device hookup to device function handler 55 * @remove_dev: device hookup to device function handler 56 * 57 * Simple interfaces attached to a subsystem. Multiple interfaces can 58 * attach to a subsystem and its devices. Unlike drivers, they do not 59 * exclusively claim or control devices. Interfaces usually represent 60 * a specific functionality of a subsystem/class of devices. 61 */ 62 struct subsys_interface { 63 const char *name; 64 struct bus_type *subsys; 65 struct list_head node; 66 int (*add_dev)(struct device *dev, struct subsys_interface *sif); 67 void (*remove_dev)(struct device *dev, struct subsys_interface *sif); 68 }; 69 70 int subsys_interface_register(struct subsys_interface *sif); 71 void subsys_interface_unregister(struct subsys_interface *sif); 72 73 int subsys_system_register(struct bus_type *subsys, 74 const struct attribute_group **groups); 75 int subsys_virtual_register(struct bus_type *subsys, 76 const struct attribute_group **groups); 77 78 /* 79 * The type of device, "struct device" is embedded in. A class 80 * or bus can contain devices of different types 81 * like "partitions" and "disks", "mouse" and "event". 82 * This identifies the device type and carries type-specific 83 * information, equivalent to the kobj_type of a kobject. 84 * If "name" is specified, the uevent will contain it in 85 * the DEVTYPE variable. 86 */ 87 struct device_type { 88 const char *name; 89 const struct attribute_group **groups; 90 int (*uevent)(struct device *dev, struct kobj_uevent_env *env); 91 char *(*devnode)(struct device *dev, umode_t *mode, 92 kuid_t *uid, kgid_t *gid); 93 void (*release)(struct device *dev); 94 95 const struct dev_pm_ops *pm; 96 }; 97 98 /* interface for exporting device attributes */ 99 struct device_attribute { 100 struct attribute attr; 101 ssize_t (*show)(struct device *dev, struct device_attribute *attr, 102 char *buf); 103 ssize_t (*store)(struct device *dev, struct device_attribute *attr, 104 const char *buf, size_t count); 105 }; 106 107 struct dev_ext_attribute { 108 struct device_attribute attr; 109 void *var; 110 }; 111 112 ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr, 113 char *buf); 114 ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr, 115 const char *buf, size_t count); 116 ssize_t device_show_int(struct device *dev, struct device_attribute *attr, 117 char *buf); 118 ssize_t device_store_int(struct device *dev, struct device_attribute *attr, 119 const char *buf, size_t count); 120 ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 121 char *buf); 122 ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 123 const char *buf, size_t count); 124 125 #define DEVICE_ATTR(_name, _mode, _show, _store) \ 126 struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store) 127 #define DEVICE_ATTR_PREALLOC(_name, _mode, _show, _store) \ 128 struct device_attribute dev_attr_##_name = \ 129 __ATTR_PREALLOC(_name, _mode, _show, _store) 130 #define DEVICE_ATTR_RW(_name) \ 131 struct device_attribute dev_attr_##_name = __ATTR_RW(_name) 132 #define DEVICE_ATTR_ADMIN_RW(_name) \ 133 struct device_attribute dev_attr_##_name = __ATTR_RW_MODE(_name, 0600) 134 #define DEVICE_ATTR_RO(_name) \ 135 struct device_attribute dev_attr_##_name = __ATTR_RO(_name) 136 #define DEVICE_ATTR_ADMIN_RO(_name) \ 137 struct device_attribute dev_attr_##_name = __ATTR_RO_MODE(_name, 0400) 138 #define DEVICE_ATTR_WO(_name) \ 139 struct device_attribute dev_attr_##_name = __ATTR_WO(_name) 140 #define DEVICE_ULONG_ATTR(_name, _mode, _var) \ 141 struct dev_ext_attribute dev_attr_##_name = \ 142 { __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) } 143 #define DEVICE_INT_ATTR(_name, _mode, _var) \ 144 struct dev_ext_attribute dev_attr_##_name = \ 145 { __ATTR(_name, _mode, device_show_int, device_store_int), &(_var) } 146 #define DEVICE_BOOL_ATTR(_name, _mode, _var) \ 147 struct dev_ext_attribute dev_attr_##_name = \ 148 { __ATTR(_name, _mode, device_show_bool, device_store_bool), &(_var) } 149 #define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \ 150 struct device_attribute dev_attr_##_name = \ 151 __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) 152 153 int device_create_file(struct device *device, 154 const struct device_attribute *entry); 155 void device_remove_file(struct device *dev, 156 const struct device_attribute *attr); 157 bool device_remove_file_self(struct device *dev, 158 const struct device_attribute *attr); 159 int __must_check device_create_bin_file(struct device *dev, 160 const struct bin_attribute *attr); 161 void device_remove_bin_file(struct device *dev, 162 const struct bin_attribute *attr); 163 164 /* device resource management */ 165 typedef void (*dr_release_t)(struct device *dev, void *res); 166 typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data); 167 168 #ifdef CONFIG_DEBUG_DEVRES 169 void *__devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp, 170 int nid, const char *name) __malloc; 171 #define devres_alloc(release, size, gfp) \ 172 __devres_alloc_node(release, size, gfp, NUMA_NO_NODE, #release) 173 #define devres_alloc_node(release, size, gfp, nid) \ 174 __devres_alloc_node(release, size, gfp, nid, #release) 175 #else 176 void *devres_alloc_node(dr_release_t release, size_t size, 177 gfp_t gfp, int nid) __malloc; 178 static inline void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp) 179 { 180 return devres_alloc_node(release, size, gfp, NUMA_NO_NODE); 181 } 182 #endif 183 184 void devres_for_each_res(struct device *dev, dr_release_t release, 185 dr_match_t match, void *match_data, 186 void (*fn)(struct device *, void *, void *), 187 void *data); 188 void devres_free(void *res); 189 void devres_add(struct device *dev, void *res); 190 void *devres_find(struct device *dev, dr_release_t release, 191 dr_match_t match, void *match_data); 192 void *devres_get(struct device *dev, void *new_res, 193 dr_match_t match, void *match_data); 194 void *devres_remove(struct device *dev, dr_release_t release, 195 dr_match_t match, void *match_data); 196 int devres_destroy(struct device *dev, dr_release_t release, 197 dr_match_t match, void *match_data); 198 int devres_release(struct device *dev, dr_release_t release, 199 dr_match_t match, void *match_data); 200 201 /* devres group */ 202 void * __must_check devres_open_group(struct device *dev, void *id, gfp_t gfp); 203 void devres_close_group(struct device *dev, void *id); 204 void devres_remove_group(struct device *dev, void *id); 205 int devres_release_group(struct device *dev, void *id); 206 207 /* managed devm_k.alloc/kfree for device drivers */ 208 void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp) __malloc; 209 __printf(3, 0) char *devm_kvasprintf(struct device *dev, gfp_t gfp, 210 const char *fmt, va_list ap) __malloc; 211 __printf(3, 4) char *devm_kasprintf(struct device *dev, gfp_t gfp, 212 const char *fmt, ...) __malloc; 213 static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp) 214 { 215 return devm_kmalloc(dev, size, gfp | __GFP_ZERO); 216 } 217 static inline void *devm_kmalloc_array(struct device *dev, 218 size_t n, size_t size, gfp_t flags) 219 { 220 size_t bytes; 221 222 if (unlikely(check_mul_overflow(n, size, &bytes))) 223 return NULL; 224 225 return devm_kmalloc(dev, bytes, flags); 226 } 227 static inline void *devm_kcalloc(struct device *dev, 228 size_t n, size_t size, gfp_t flags) 229 { 230 return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO); 231 } 232 void devm_kfree(struct device *dev, const void *p); 233 char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp) __malloc; 234 const char *devm_kstrdup_const(struct device *dev, const char *s, gfp_t gfp); 235 void *devm_kmemdup(struct device *dev, const void *src, size_t len, gfp_t gfp); 236 237 unsigned long devm_get_free_pages(struct device *dev, 238 gfp_t gfp_mask, unsigned int order); 239 void devm_free_pages(struct device *dev, unsigned long addr); 240 241 void __iomem *devm_ioremap_resource(struct device *dev, 242 const struct resource *res); 243 void __iomem *devm_ioremap_resource_wc(struct device *dev, 244 const struct resource *res); 245 246 void __iomem *devm_of_iomap(struct device *dev, 247 struct device_node *node, int index, 248 resource_size_t *size); 249 250 /* allows to add/remove a custom action to devres stack */ 251 int devm_add_action(struct device *dev, void (*action)(void *), void *data); 252 void devm_remove_action(struct device *dev, void (*action)(void *), void *data); 253 void devm_release_action(struct device *dev, void (*action)(void *), void *data); 254 255 static inline int devm_add_action_or_reset(struct device *dev, 256 void (*action)(void *), void *data) 257 { 258 int ret; 259 260 ret = devm_add_action(dev, action, data); 261 if (ret) 262 action(data); 263 264 return ret; 265 } 266 267 /** 268 * devm_alloc_percpu - Resource-managed alloc_percpu 269 * @dev: Device to allocate per-cpu memory for 270 * @type: Type to allocate per-cpu memory for 271 * 272 * Managed alloc_percpu. Per-cpu memory allocated with this function is 273 * automatically freed on driver detach. 274 * 275 * RETURNS: 276 * Pointer to allocated memory on success, NULL on failure. 277 */ 278 #define devm_alloc_percpu(dev, type) \ 279 ((typeof(type) __percpu *)__devm_alloc_percpu((dev), sizeof(type), \ 280 __alignof__(type))) 281 282 void __percpu *__devm_alloc_percpu(struct device *dev, size_t size, 283 size_t align); 284 void devm_free_percpu(struct device *dev, void __percpu *pdata); 285 286 struct device_dma_parameters { 287 /* 288 * a low level driver may set these to teach IOMMU code about 289 * sg limitations. 290 */ 291 unsigned int max_segment_size; 292 unsigned long segment_boundary_mask; 293 }; 294 295 /** 296 * enum device_link_state - Device link states. 297 * @DL_STATE_NONE: The presence of the drivers is not being tracked. 298 * @DL_STATE_DORMANT: None of the supplier/consumer drivers is present. 299 * @DL_STATE_AVAILABLE: The supplier driver is present, but the consumer is not. 300 * @DL_STATE_CONSUMER_PROBE: The consumer is probing (supplier driver present). 301 * @DL_STATE_ACTIVE: Both the supplier and consumer drivers are present. 302 * @DL_STATE_SUPPLIER_UNBIND: The supplier driver is unbinding. 303 */ 304 enum device_link_state { 305 DL_STATE_NONE = -1, 306 DL_STATE_DORMANT = 0, 307 DL_STATE_AVAILABLE, 308 DL_STATE_CONSUMER_PROBE, 309 DL_STATE_ACTIVE, 310 DL_STATE_SUPPLIER_UNBIND, 311 }; 312 313 /* 314 * Device link flags. 315 * 316 * STATELESS: The core will not remove this link automatically. 317 * AUTOREMOVE_CONSUMER: Remove the link automatically on consumer driver unbind. 318 * PM_RUNTIME: If set, the runtime PM framework will use this link. 319 * RPM_ACTIVE: Run pm_runtime_get_sync() on the supplier during link creation. 320 * AUTOREMOVE_SUPPLIER: Remove the link automatically on supplier driver unbind. 321 * AUTOPROBE_CONSUMER: Probe consumer driver automatically after supplier binds. 322 * MANAGED: The core tracks presence of supplier/consumer drivers (internal). 323 * SYNC_STATE_ONLY: Link only affects sync_state() behavior. 324 */ 325 #define DL_FLAG_STATELESS BIT(0) 326 #define DL_FLAG_AUTOREMOVE_CONSUMER BIT(1) 327 #define DL_FLAG_PM_RUNTIME BIT(2) 328 #define DL_FLAG_RPM_ACTIVE BIT(3) 329 #define DL_FLAG_AUTOREMOVE_SUPPLIER BIT(4) 330 #define DL_FLAG_AUTOPROBE_CONSUMER BIT(5) 331 #define DL_FLAG_MANAGED BIT(6) 332 #define DL_FLAG_SYNC_STATE_ONLY BIT(7) 333 334 /** 335 * enum dl_dev_state - Device driver presence tracking information. 336 * @DL_DEV_NO_DRIVER: There is no driver attached to the device. 337 * @DL_DEV_PROBING: A driver is probing. 338 * @DL_DEV_DRIVER_BOUND: The driver has been bound to the device. 339 * @DL_DEV_UNBINDING: The driver is unbinding from the device. 340 */ 341 enum dl_dev_state { 342 DL_DEV_NO_DRIVER = 0, 343 DL_DEV_PROBING, 344 DL_DEV_DRIVER_BOUND, 345 DL_DEV_UNBINDING, 346 }; 347 348 /** 349 * struct dev_links_info - Device data related to device links. 350 * @suppliers: List of links to supplier devices. 351 * @consumers: List of links to consumer devices. 352 * @needs_suppliers: Hook to global list of devices waiting for suppliers. 353 * @defer_hook: Hook to global list of devices that have deferred sync_state or 354 * deferred fw_devlink. 355 * @need_for_probe: If needs_suppliers is on a list, this indicates if the 356 * suppliers are needed for probe or not. 357 * @status: Driver status information. 358 */ 359 struct dev_links_info { 360 struct list_head suppliers; 361 struct list_head consumers; 362 struct list_head needs_suppliers; 363 struct list_head defer_hook; 364 bool need_for_probe; 365 enum dl_dev_state status; 366 }; 367 368 /** 369 * struct device - The basic device structure 370 * @parent: The device's "parent" device, the device to which it is attached. 371 * In most cases, a parent device is some sort of bus or host 372 * controller. If parent is NULL, the device, is a top-level device, 373 * which is not usually what you want. 374 * @p: Holds the private data of the driver core portions of the device. 375 * See the comment of the struct device_private for detail. 376 * @kobj: A top-level, abstract class from which other classes are derived. 377 * @init_name: Initial name of the device. 378 * @type: The type of device. 379 * This identifies the device type and carries type-specific 380 * information. 381 * @mutex: Mutex to synchronize calls to its driver. 382 * @lockdep_mutex: An optional debug lock that a subsystem can use as a 383 * peer lock to gain localized lockdep coverage of the device_lock. 384 * @bus: Type of bus device is on. 385 * @driver: Which driver has allocated this 386 * @platform_data: Platform data specific to the device. 387 * Example: For devices on custom boards, as typical of embedded 388 * and SOC based hardware, Linux often uses platform_data to point 389 * to board-specific structures describing devices and how they 390 * are wired. That can include what ports are available, chip 391 * variants, which GPIO pins act in what additional roles, and so 392 * on. This shrinks the "Board Support Packages" (BSPs) and 393 * minimizes board-specific #ifdefs in drivers. 394 * @driver_data: Private pointer for driver specific info. 395 * @links: Links to suppliers and consumers of this device. 396 * @power: For device power management. 397 * See Documentation/driver-api/pm/devices.rst for details. 398 * @pm_domain: Provide callbacks that are executed during system suspend, 399 * hibernation, system resume and during runtime PM transitions 400 * along with subsystem-level and driver-level callbacks. 401 * @pins: For device pin management. 402 * See Documentation/driver-api/pinctl.rst for details. 403 * @msi_list: Hosts MSI descriptors 404 * @msi_domain: The generic MSI domain this device is using. 405 * @numa_node: NUMA node this device is close to. 406 * @dma_ops: DMA mapping operations for this device. 407 * @dma_mask: Dma mask (if dma'ble device). 408 * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all 409 * hardware supports 64-bit addresses for consistent allocations 410 * such descriptors. 411 * @bus_dma_limit: Limit of an upstream bridge or bus which imposes a smaller 412 * DMA limit than the device itself supports. 413 * @dma_pfn_offset: offset of DMA memory range relatively of RAM 414 * @dma_parms: A low level driver may set these to teach IOMMU code about 415 * segment limitations. 416 * @dma_pools: Dma pools (if dma'ble device). 417 * @dma_mem: Internal for coherent mem override. 418 * @cma_area: Contiguous memory area for dma allocations 419 * @archdata: For arch-specific additions. 420 * @of_node: Associated device tree node. 421 * @fwnode: Associated device node supplied by platform firmware. 422 * @devt: For creating the sysfs "dev". 423 * @id: device instance 424 * @devres_lock: Spinlock to protect the resource of the device. 425 * @devres_head: The resources list of the device. 426 * @knode_class: The node used to add the device to the class list. 427 * @class: The class of the device. 428 * @groups: Optional attribute groups. 429 * @release: Callback to free the device after all references have 430 * gone away. This should be set by the allocator of the 431 * device (i.e. the bus driver that discovered the device). 432 * @iommu_group: IOMMU group the device belongs to. 433 * @iommu: Per device generic IOMMU runtime data 434 * 435 * @offline_disabled: If set, the device is permanently online. 436 * @offline: Set after successful invocation of bus type's .offline(). 437 * @of_node_reused: Set if the device-tree node is shared with an ancestor 438 * device. 439 * @state_synced: The hardware state of this device has been synced to match 440 * the software state of this device by calling the driver/bus 441 * sync_state() callback. 442 * @dma_coherent: this particular device is dma coherent, even if the 443 * architecture supports non-coherent devices. 444 * @dma_ops_bypass: If set to %true then the dma_ops are bypassed for the 445 * streaming DMA operations (->map_* / ->unmap_* / ->sync_*), 446 * and optionall (if the coherent mask is large enough) also 447 * for dma allocations. This flag is managed by the dma ops 448 * instance from ->dma_supported. 449 * 450 * At the lowest level, every device in a Linux system is represented by an 451 * instance of struct device. The device structure contains the information 452 * that the device model core needs to model the system. Most subsystems, 453 * however, track additional information about the devices they host. As a 454 * result, it is rare for devices to be represented by bare device structures; 455 * instead, that structure, like kobject structures, is usually embedded within 456 * a higher-level representation of the device. 457 */ 458 struct device { 459 struct kobject kobj; 460 struct device *parent; 461 462 struct device_private *p; 463 464 const char *init_name; /* initial name of the device */ 465 const struct device_type *type; 466 467 struct bus_type *bus; /* type of bus device is on */ 468 struct device_driver *driver; /* which driver has allocated this 469 device */ 470 void *platform_data; /* Platform specific data, device 471 core doesn't touch it */ 472 void *driver_data; /* Driver data, set and get with 473 dev_set_drvdata/dev_get_drvdata */ 474 #ifdef CONFIG_PROVE_LOCKING 475 struct mutex lockdep_mutex; 476 #endif 477 struct mutex mutex; /* mutex to synchronize calls to 478 * its driver. 479 */ 480 481 struct dev_links_info links; 482 struct dev_pm_info power; 483 struct dev_pm_domain *pm_domain; 484 485 #ifdef CONFIG_ENERGY_MODEL 486 struct em_perf_domain *em_pd; 487 #endif 488 489 #ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN 490 struct irq_domain *msi_domain; 491 #endif 492 #ifdef CONFIG_PINCTRL 493 struct dev_pin_info *pins; 494 #endif 495 #ifdef CONFIG_GENERIC_MSI_IRQ 496 struct list_head msi_list; 497 #endif 498 #ifdef CONFIG_DMA_OPS 499 const struct dma_map_ops *dma_ops; 500 #endif 501 u64 *dma_mask; /* dma mask (if dma'able device) */ 502 u64 coherent_dma_mask;/* Like dma_mask, but for 503 alloc_coherent mappings as 504 not all hardware supports 505 64 bit addresses for consistent 506 allocations such descriptors. */ 507 u64 bus_dma_limit; /* upstream dma constraint */ 508 unsigned long dma_pfn_offset; 509 510 struct device_dma_parameters *dma_parms; 511 512 struct list_head dma_pools; /* dma pools (if dma'ble) */ 513 514 #ifdef CONFIG_DMA_DECLARE_COHERENT 515 struct dma_coherent_mem *dma_mem; /* internal for coherent mem 516 override */ 517 #endif 518 #ifdef CONFIG_DMA_CMA 519 struct cma *cma_area; /* contiguous memory area for dma 520 allocations */ 521 #endif 522 /* arch specific additions */ 523 struct dev_archdata archdata; 524 525 struct device_node *of_node; /* associated device tree node */ 526 struct fwnode_handle *fwnode; /* firmware device node */ 527 528 #ifdef CONFIG_NUMA 529 int numa_node; /* NUMA node this device is close to */ 530 #endif 531 dev_t devt; /* dev_t, creates the sysfs "dev" */ 532 u32 id; /* device instance */ 533 534 spinlock_t devres_lock; 535 struct list_head devres_head; 536 537 struct class *class; 538 const struct attribute_group **groups; /* optional groups */ 539 540 void (*release)(struct device *dev); 541 struct iommu_group *iommu_group; 542 struct dev_iommu *iommu; 543 544 bool offline_disabled:1; 545 bool offline:1; 546 bool of_node_reused:1; 547 bool state_synced:1; 548 #if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \ 549 defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \ 550 defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL) 551 bool dma_coherent:1; 552 #endif 553 #ifdef CONFIG_DMA_OPS_BYPASS 554 bool dma_ops_bypass : 1; 555 #endif 556 }; 557 558 /** 559 * struct device_link - Device link representation. 560 * @supplier: The device on the supplier end of the link. 561 * @s_node: Hook to the supplier device's list of links to consumers. 562 * @consumer: The device on the consumer end of the link. 563 * @c_node: Hook to the consumer device's list of links to suppliers. 564 * @link_dev: device used to expose link details in sysfs 565 * @status: The state of the link (with respect to the presence of drivers). 566 * @flags: Link flags. 567 * @rpm_active: Whether or not the consumer device is runtime-PM-active. 568 * @kref: Count repeated addition of the same link. 569 * @rcu_head: An RCU head to use for deferred execution of SRCU callbacks. 570 * @supplier_preactivated: Supplier has been made active before consumer probe. 571 */ 572 struct device_link { 573 struct device *supplier; 574 struct list_head s_node; 575 struct device *consumer; 576 struct list_head c_node; 577 struct device link_dev; 578 enum device_link_state status; 579 u32 flags; 580 refcount_t rpm_active; 581 struct kref kref; 582 #ifdef CONFIG_SRCU 583 struct rcu_head rcu_head; 584 #endif 585 bool supplier_preactivated; /* Owned by consumer probe. */ 586 }; 587 588 static inline struct device *kobj_to_dev(struct kobject *kobj) 589 { 590 return container_of(kobj, struct device, kobj); 591 } 592 593 /** 594 * device_iommu_mapped - Returns true when the device DMA is translated 595 * by an IOMMU 596 * @dev: Device to perform the check on 597 */ 598 static inline bool device_iommu_mapped(struct device *dev) 599 { 600 return (dev->iommu_group != NULL); 601 } 602 603 /* Get the wakeup routines, which depend on struct device */ 604 #include <linux/pm_wakeup.h> 605 606 static inline const char *dev_name(const struct device *dev) 607 { 608 /* Use the init name until the kobject becomes available */ 609 if (dev->init_name) 610 return dev->init_name; 611 612 return kobject_name(&dev->kobj); 613 } 614 615 __printf(2, 3) int dev_set_name(struct device *dev, const char *name, ...); 616 617 #ifdef CONFIG_NUMA 618 static inline int dev_to_node(struct device *dev) 619 { 620 return dev->numa_node; 621 } 622 static inline void set_dev_node(struct device *dev, int node) 623 { 624 dev->numa_node = node; 625 } 626 #else 627 static inline int dev_to_node(struct device *dev) 628 { 629 return NUMA_NO_NODE; 630 } 631 static inline void set_dev_node(struct device *dev, int node) 632 { 633 } 634 #endif 635 636 static inline struct irq_domain *dev_get_msi_domain(const struct device *dev) 637 { 638 #ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN 639 return dev->msi_domain; 640 #else 641 return NULL; 642 #endif 643 } 644 645 static inline void dev_set_msi_domain(struct device *dev, struct irq_domain *d) 646 { 647 #ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN 648 dev->msi_domain = d; 649 #endif 650 } 651 652 static inline void *dev_get_drvdata(const struct device *dev) 653 { 654 return dev->driver_data; 655 } 656 657 static inline void dev_set_drvdata(struct device *dev, void *data) 658 { 659 dev->driver_data = data; 660 } 661 662 static inline struct pm_subsys_data *dev_to_psd(struct device *dev) 663 { 664 return dev ? dev->power.subsys_data : NULL; 665 } 666 667 static inline unsigned int dev_get_uevent_suppress(const struct device *dev) 668 { 669 return dev->kobj.uevent_suppress; 670 } 671 672 static inline void dev_set_uevent_suppress(struct device *dev, int val) 673 { 674 dev->kobj.uevent_suppress = val; 675 } 676 677 static inline int device_is_registered(struct device *dev) 678 { 679 return dev->kobj.state_in_sysfs; 680 } 681 682 static inline void device_enable_async_suspend(struct device *dev) 683 { 684 if (!dev->power.is_prepared) 685 dev->power.async_suspend = true; 686 } 687 688 static inline void device_disable_async_suspend(struct device *dev) 689 { 690 if (!dev->power.is_prepared) 691 dev->power.async_suspend = false; 692 } 693 694 static inline bool device_async_suspend_enabled(struct device *dev) 695 { 696 return !!dev->power.async_suspend; 697 } 698 699 static inline bool device_pm_not_required(struct device *dev) 700 { 701 return dev->power.no_pm; 702 } 703 704 static inline void device_set_pm_not_required(struct device *dev) 705 { 706 dev->power.no_pm = true; 707 } 708 709 static inline void dev_pm_syscore_device(struct device *dev, bool val) 710 { 711 #ifdef CONFIG_PM_SLEEP 712 dev->power.syscore = val; 713 #endif 714 } 715 716 static inline void dev_pm_set_driver_flags(struct device *dev, u32 flags) 717 { 718 dev->power.driver_flags = flags; 719 } 720 721 static inline bool dev_pm_test_driver_flags(struct device *dev, u32 flags) 722 { 723 return !!(dev->power.driver_flags & flags); 724 } 725 726 static inline void device_lock(struct device *dev) 727 { 728 mutex_lock(&dev->mutex); 729 } 730 731 static inline int device_lock_interruptible(struct device *dev) 732 { 733 return mutex_lock_interruptible(&dev->mutex); 734 } 735 736 static inline int device_trylock(struct device *dev) 737 { 738 return mutex_trylock(&dev->mutex); 739 } 740 741 static inline void device_unlock(struct device *dev) 742 { 743 mutex_unlock(&dev->mutex); 744 } 745 746 static inline void device_lock_assert(struct device *dev) 747 { 748 lockdep_assert_held(&dev->mutex); 749 } 750 751 static inline struct device_node *dev_of_node(struct device *dev) 752 { 753 if (!IS_ENABLED(CONFIG_OF) || !dev) 754 return NULL; 755 return dev->of_node; 756 } 757 758 static inline bool dev_has_sync_state(struct device *dev) 759 { 760 if (!dev) 761 return false; 762 if (dev->driver && dev->driver->sync_state) 763 return true; 764 if (dev->bus && dev->bus->sync_state) 765 return true; 766 return false; 767 } 768 769 /* 770 * High level routines for use by the bus drivers 771 */ 772 int __must_check device_register(struct device *dev); 773 void device_unregister(struct device *dev); 774 void device_initialize(struct device *dev); 775 int __must_check device_add(struct device *dev); 776 void device_del(struct device *dev); 777 int device_for_each_child(struct device *dev, void *data, 778 int (*fn)(struct device *dev, void *data)); 779 int device_for_each_child_reverse(struct device *dev, void *data, 780 int (*fn)(struct device *dev, void *data)); 781 struct device *device_find_child(struct device *dev, void *data, 782 int (*match)(struct device *dev, void *data)); 783 struct device *device_find_child_by_name(struct device *parent, 784 const char *name); 785 int device_rename(struct device *dev, const char *new_name); 786 int device_move(struct device *dev, struct device *new_parent, 787 enum dpm_order dpm_order); 788 int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid); 789 const char *device_get_devnode(struct device *dev, umode_t *mode, kuid_t *uid, 790 kgid_t *gid, const char **tmp); 791 int device_is_dependent(struct device *dev, void *target); 792 793 static inline bool device_supports_offline(struct device *dev) 794 { 795 return dev->bus && dev->bus->offline && dev->bus->online; 796 } 797 798 void lock_device_hotplug(void); 799 void unlock_device_hotplug(void); 800 int lock_device_hotplug_sysfs(void); 801 int device_offline(struct device *dev); 802 int device_online(struct device *dev); 803 void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode); 804 void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode); 805 void device_set_of_node_from_dev(struct device *dev, const struct device *dev2); 806 807 static inline int dev_num_vf(struct device *dev) 808 { 809 if (dev->bus && dev->bus->num_vf) 810 return dev->bus->num_vf(dev); 811 return 0; 812 } 813 814 /* 815 * Root device objects for grouping under /sys/devices 816 */ 817 struct device *__root_device_register(const char *name, struct module *owner); 818 819 /* This is a macro to avoid include problems with THIS_MODULE */ 820 #define root_device_register(name) \ 821 __root_device_register(name, THIS_MODULE) 822 823 void root_device_unregister(struct device *root); 824 825 static inline void *dev_get_platdata(const struct device *dev) 826 { 827 return dev->platform_data; 828 } 829 830 /* 831 * Manual binding of a device to driver. See drivers/base/bus.c 832 * for information on use. 833 */ 834 int __must_check device_bind_driver(struct device *dev); 835 void device_release_driver(struct device *dev); 836 int __must_check device_attach(struct device *dev); 837 int __must_check driver_attach(struct device_driver *drv); 838 void device_initial_probe(struct device *dev); 839 int __must_check device_reprobe(struct device *dev); 840 841 bool device_is_bound(struct device *dev); 842 843 /* 844 * Easy functions for dynamically creating devices on the fly 845 */ 846 __printf(5, 6) struct device * 847 device_create(struct class *cls, struct device *parent, dev_t devt, 848 void *drvdata, const char *fmt, ...); 849 __printf(6, 7) struct device * 850 device_create_with_groups(struct class *cls, struct device *parent, dev_t devt, 851 void *drvdata, const struct attribute_group **groups, 852 const char *fmt, ...); 853 void device_destroy(struct class *cls, dev_t devt); 854 855 int __must_check device_add_groups(struct device *dev, 856 const struct attribute_group **groups); 857 void device_remove_groups(struct device *dev, 858 const struct attribute_group **groups); 859 860 static inline int __must_check device_add_group(struct device *dev, 861 const struct attribute_group *grp) 862 { 863 const struct attribute_group *groups[] = { grp, NULL }; 864 865 return device_add_groups(dev, groups); 866 } 867 868 static inline void device_remove_group(struct device *dev, 869 const struct attribute_group *grp) 870 { 871 const struct attribute_group *groups[] = { grp, NULL }; 872 873 return device_remove_groups(dev, groups); 874 } 875 876 int __must_check devm_device_add_groups(struct device *dev, 877 const struct attribute_group **groups); 878 void devm_device_remove_groups(struct device *dev, 879 const struct attribute_group **groups); 880 int __must_check devm_device_add_group(struct device *dev, 881 const struct attribute_group *grp); 882 void devm_device_remove_group(struct device *dev, 883 const struct attribute_group *grp); 884 885 /* 886 * Platform "fixup" functions - allow the platform to have their say 887 * about devices and actions that the general device layer doesn't 888 * know about. 889 */ 890 /* Notify platform of device discovery */ 891 extern int (*platform_notify)(struct device *dev); 892 893 extern int (*platform_notify_remove)(struct device *dev); 894 895 896 /* 897 * get_device - atomically increment the reference count for the device. 898 * 899 */ 900 struct device *get_device(struct device *dev); 901 void put_device(struct device *dev); 902 bool kill_device(struct device *dev); 903 904 #ifdef CONFIG_DEVTMPFS 905 int devtmpfs_mount(void); 906 #else 907 static inline int devtmpfs_mount(void) { return 0; } 908 #endif 909 910 /* drivers/base/power/shutdown.c */ 911 void device_shutdown(void); 912 913 /* debugging and troubleshooting/diagnostic helpers. */ 914 const char *dev_driver_string(const struct device *dev); 915 916 /* Device links interface. */ 917 struct device_link *device_link_add(struct device *consumer, 918 struct device *supplier, u32 flags); 919 void device_link_del(struct device_link *link); 920 void device_link_remove(void *consumer, struct device *supplier); 921 void device_links_supplier_sync_state_pause(void); 922 void device_links_supplier_sync_state_resume(void); 923 924 extern __printf(3, 4) 925 int __must_check dev_err_probe(const struct device *dev, int err, const char *fmt, ...); 926 927 /* Create alias, so I can be autoloaded. */ 928 #define MODULE_ALIAS_CHARDEV(major,minor) \ 929 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor)) 930 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \ 931 MODULE_ALIAS("char-major-" __stringify(major) "-*") 932 933 #ifdef CONFIG_SYSFS_DEPRECATED 934 extern long sysfs_deprecated; 935 #else 936 #define sysfs_deprecated 0 937 #endif 938 939 #endif /* _DEVICE_H_ */ 940