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