Linux Cross Reference
Free Electrons
Embedded Linux Experts
• Source Navigation • Diff Markup • Identifier Search • Freetext Search •
Version: 2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1
Linux/include/linux/device.h
1 /* 2 * device.h - generic, centralized driver model 3 * 4 * Copyright (c) 2001-2003 Patrick Mochel <[email protected]> 5 * Copyright (c) 2004-2009 Greg Kroah-Hartman <[email protected]> 6 * Copyright (c) 2008-2009 Novell Inc. 7 * 8 * This file is released under the GPLv2 9 * 10 * See Documentation/driver-model/ for more information. 11 */ 12 13 #ifndef _DEVICE_H_ 14 #define _DEVICE_H_ 15 16 #include <linux/ioport.h> 17 #include <linux/kobject.h> 18 #include <linux/klist.h> 19 #include <linux/list.h> 20 #include <linux/lockdep.h> 21 #include <linux/compiler.h> 22 #include <linux/types.h> 23 #include <linux/mutex.h> 24 #include <linux/pinctrl/devinfo.h> 25 #include <linux/pm.h> 26 #include <linux/atomic.h> 27 #include <linux/ratelimit.h> 28 #include <linux/uidgid.h> 29 #include <linux/gfp.h> 30 #include <asm/device.h> 31 32 struct device; 33 struct device_private; 34 struct device_driver; 35 struct driver_private; 36 struct module; 37 struct class; 38 struct subsys_private; 39 struct bus_type; 40 struct device_node; 41 struct fwnode_handle; 42 struct iommu_ops; 43 struct iommu_group; 44 45 struct bus_attribute { 46 struct attribute attr; 47 ssize_t (*show)(struct bus_type *bus, char *buf); 48 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count); 49 }; 50 51 #define BUS_ATTR(_name, _mode, _show, _store) 52 struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store) 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 58 extern int __must_check bus_create_file(struct bus_type *, 59 struct bus_attribute *); 60 extern void bus_remove_file(struct bus_type *, struct bus_attribute *); 61 62 /** 63 * struct bus_type - The bus type of the device 64 * 65 * @name: The name of the bus. 66 * @dev_name: Used for subsystems to enumerate devices like ("foo%u", dev->id). 67 * @dev_root: Default device to use as the parent. 68 * @dev_attrs: Default attributes of the devices on the bus. 69 * @bus_groups: Default attributes of the bus. 70 * @dev_groups: Default attributes of the devices on the bus. 71 * @drv_groups: Default attributes of the device drivers on the bus. 72 * @match: Called, perhaps multiple times, whenever a new device or driver 73 * is added for this bus. It should return a nonzero value if the 74 * given device can be handled by the given driver. 75 * @uevent: Called when a device is added, removed, or a few other things 76 * that generate uevents to add the environment variables. 77 * @probe: Called when a new device or driver add to this bus, and callback 78 * the specific driver‘s probe to initial the matched device. 79 * @remove: Called when a device removed from this bus. 80 * @shutdown: Called at shut-down time to quiesce the device. 81 * 82 * @online: Called to put the device back online (after offlining it). 83 * @offline: Called to put the device offline for hot-removal. May fail. 84 * 85 * @suspend: Called when a device on this bus wants to go to sleep mode. 86 * @resume: Called to bring a device on this bus out of sleep mode. 87 * @pm: Power management operations of this bus, callback the specific 88 * device driver‘s pm-ops. 89 * @iommu_ops: IOMMU specific operations for this bus, used to attach IOMMU 90 * driver implementations to a bus and allow the driver to do 91 * bus-specific setup 92 * @p: The private data of the driver core, only the driver core can 93 * touch this. 94 * @lock_key: Lock class key for use by the lock validator 95 * 96 * A bus is a channel between the processor and one or more devices. For the 97 * purposes of the device model, all devices are connected via a bus, even if 98 * it is an internal, virtual, "platform" bus. Buses can plug into each other. 99 * A USB controller is usually a PCI device, for example. The device model 100 * represents the actual connections between buses and the devices they control. 101 * A bus is represented by the bus_type structure. It contains the name, the 102 * default attributes, the bus‘ methods, PM operations, and the driver core‘s 103 * private data. 104 */ 105 struct bus_type { 106 const char *name; 107 const char *dev_name; 108 struct device *dev_root; 109 struct device_attribute *dev_attrs; /* use dev_groups instead */ 110 const struct attribute_group **bus_groups; 111 const struct attribute_group **dev_groups; 112 const struct attribute_group **drv_groups; 113 114 int (*match)(struct device *dev, struct device_driver *drv); 115 int (*uevent)(struct device *dev, struct kobj_uevent_env *env); 116 int (*probe)(struct device *dev); 117 int (*remove)(struct device *dev); 118 void (*shutdown)(struct device *dev); 119 120 int (*online)(struct device *dev); 121 int (*offline)(struct device *dev); 122 123 int (*suspend)(struct device *dev, pm_message_t state); 124 int (*resume)(struct device *dev); 125 126 const struct dev_pm_ops *pm; 127 128 const struct iommu_ops *iommu_ops; 129 130 struct subsys_private *p; 131 struct lock_class_key lock_key; 132 }; 133 134 extern int __must_check bus_register(struct bus_type *bus); 135 136 extern void bus_unregister(struct bus_type *bus); 137 138 extern int __must_check bus_rescan_devices(struct bus_type *bus); 139 140 /* iterator helpers for buses */ 141 struct subsys_dev_iter { 142 struct klist_iter ki; 143 const struct device_type *type; 144 }; 145 void subsys_dev_iter_init(struct subsys_dev_iter *iter, 146 struct bus_type *subsys, 147 struct device *start, 148 const struct device_type *type); 149 struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter); 150 void subsys_dev_iter_exit(struct subsys_dev_iter *iter); 151 152 int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data, 153 int (*fn)(struct device *dev, void *data)); 154 struct device *bus_find_device(struct bus_type *bus, struct device *start, 155 void *data, 156 int (*match)(struct device *dev, void *data)); 157 struct device *bus_find_device_by_name(struct bus_type *bus, 158 struct device *start, 159 const char *name); 160 struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id, 161 struct device *hint); 162 int bus_for_each_drv(struct bus_type *bus, struct device_driver *start, 163 void *data, int (*fn)(struct device_driver *, void *)); 164 void bus_sort_breadthfirst(struct bus_type *bus, 165 int (*compare)(const struct device *a, 166 const struct device *b)); 167 /* 168 * Bus notifiers: Get notified of addition/removal of devices 169 * and binding/unbinding of drivers to devices. 170 * In the long run, it should be a replacement for the platform 171 * notify hooks. 172 */ 173 struct notifier_block; 174 175 extern int bus_register_notifier(struct bus_type *bus, 176 struct notifier_block *nb); 177 extern int bus_unregister_notifier(struct bus_type *bus, 178 struct notifier_block *nb); 179 180 /* All 4 notifers below get called with the target struct device * 181 * as an argument. Note that those functions are likely to be called 182 * with the device lock held in the core, so be careful. 183 */ 184 #define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */ 185 #define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device to be removed */ 186 #define BUS_NOTIFY_REMOVED_DEVICE 0x00000003 /* device removed */ 187 #define BUS_NOTIFY_BIND_DRIVER 0x00000004 /* driver about to be 188 bound */ 189 #define BUS_NOTIFY_BOUND_DRIVER 0x00000005 /* driver bound to device */ 190 #define BUS_NOTIFY_UNBIND_DRIVER 0x00000006 /* driver about to be 191 unbound */ 192 #define BUS_NOTIFY_UNBOUND_DRIVER 0x00000007 /* driver is unbound 193 from the device */ 194 195 extern struct kset *bus_get_kset(struct bus_type *bus); 196 extern struct klist *bus_get_device_klist(struct bus_type *bus); 197 198 /** 199 * struct device_driver - The basic device driver structure 200 * @name: Name of the device driver. 201 * @bus: The bus which the device of this driver belongs to. 202 * @owner: The module owner. 203 * @mod_name: Used for built-in modules. 204 * @suppress_bind_attrs: Disables bind/unbind via sysfs. 205 * @of_match_table: The open firmware table. 206 * @acpi_match_table: The ACPI match table. 207 * @probe: Called to query the existence of a specific device, 208 * whether this driver can work with it, and bind the driver 209 * to a specific device. 210 * @remove: Called when the device is removed from the system to 211 * unbind a device from this driver. 212 * @shutdown: Called at shut-down time to quiesce the device. 213 * @suspend: Called to put the device to sleep mode. Usually to a 214 * low power state. 215 * @resume: Called to bring a device from sleep mode. 216 * @groups: Default attributes that get created by the driver core 217 * automatically. 218 * @pm: Power management operations of the device which matched 219 * this driver. 220 * @p: Driver core‘s private data, no one other than the driver 221 * core can touch this. 222 * 223 * The device driver-model tracks all of the drivers known to the system. 224 * The main reason for this tracking is to enable the driver core to match 225 * up drivers with new devices. Once drivers are known objects within the 226 * system, however, a number of other things become possible. Device drivers 227 * can export information and configuration variables that are independent 228 * of any specific device. 229 */ 230 struct device_driver { 231 const char *name; 232 struct bus_type *bus; 233 234 struct module *owner; 235 const char *mod_name; /* used for built-in modules */ 236 237 bool suppress_bind_attrs; /* disables bind/unbind via sysfs */ 238 239 const struct of_device_id *of_match_table; 240 const struct acpi_device_id *acpi_match_table; 241 242 int (*probe) (struct device *dev); 243 int (*remove) (struct device *dev); 244 void (*shutdown) (struct device *dev); 245 int (*suspend) (struct device *dev, pm_message_t state); 246 int (*resume) (struct device *dev); 247 const struct attribute_group **groups; 248 249 const struct dev_pm_ops *pm; 250 251 struct driver_private *p; 252 }; 253 254 255 extern int __must_check driver_register(struct device_driver *drv); 256 extern void driver_unregister(struct device_driver *drv); 257 258 extern struct device_driver *driver_find(const char *name, 259 struct bus_type *bus); 260 extern int driver_probe_done(void); 261 extern void wait_for_device_probe(void); 262 263 264 /* sysfs interface for exporting driver attributes */ 265 266 struct driver_attribute { 267 struct attribute attr; 268 ssize_t (*show)(struct device_driver *driver, char *buf); 269 ssize_t (*store)(struct device_driver *driver, const char *buf, 270 size_t count); 271 }; 272 273 #define DRIVER_ATTR(_name, _mode, _show, _store) 274 struct driver_attribute driver_attr_##_name = __ATTR(_name, _mode, _show, _store) 275 #define DRIVER_ATTR_RW(_name) 276 struct driver_attribute driver_attr_##_name = __ATTR_RW(_name) 277 #define DRIVER_ATTR_RO(_name) 278 struct driver_attribute driver_attr_##_name = __ATTR_RO(_name) 279 #define DRIVER_ATTR_WO(_name) 280 struct driver_attribute driver_attr_##_name = __ATTR_WO(_name) 281 282 extern int __must_check driver_create_file(struct device_driver *driver, 283 const struct driver_attribute *attr); 284 extern void driver_remove_file(struct device_driver *driver, 285 const struct driver_attribute *attr); 286 287 extern int __must_check driver_for_each_device(struct device_driver *drv, 288 struct device *start, 289 void *data, 290 int (*fn)(struct device *dev, 291 void *)); 292 struct device *driver_find_device(struct device_driver *drv, 293 struct device *start, void *data, 294 int (*match)(struct device *dev, void *data)); 295 296 /** 297 * struct subsys_interface - interfaces to device functions 298 * @name: name of the device function 299 * @subsys: subsytem of the devices to attach to 300 * @node: the list of functions registered at the subsystem 301 * @add_dev: device hookup to device function handler 302 * @remove_dev: device hookup to device function handler 303 * 304 * Simple interfaces attached to a subsystem. Multiple interfaces can 305 * attach to a subsystem and its devices. Unlike drivers, they do not 306 * exclusively claim or control devices. Interfaces usually represent 307 * a specific functionality of a subsystem/class of devices. 308 */ 309 struct subsys_interface { 310 const char *name; 311 struct bus_type *subsys; 312 struct list_head node; 313 int (*add_dev)(struct device *dev, struct subsys_interface *sif); 314 int (*remove_dev)(struct device *dev, struct subsys_interface *sif); 315 }; 316 317 int subsys_interface_register(struct subsys_interface *sif); 318 void subsys_interface_unregister(struct subsys_interface *sif); 319 320 int subsys_system_register(struct bus_type *subsys, 321 const struct attribute_group **groups); 322 int subsys_virtual_register(struct bus_type *subsys, 323 const struct attribute_group **groups); 324 325 /** 326 * struct class - device classes 327 * @name: Name of the class. 328 * @owner: The module owner. 329 * @class_attrs: Default attributes of this class. 330 * @dev_groups: Default attributes of the devices that belong to the class. 331 * @dev_kobj: The kobject that represents this class and links it into the hierarchy. 332 * @dev_uevent: Called when a device is added, removed from this class, or a 333 * few other things that generate uevents to add the environment 334 * variables. 335 * @devnode: Callback to provide the devtmpfs. 336 * @class_release: Called to release this class. 337 * @dev_release: Called to release the device. 338 * @suspend: Used to put the device to sleep mode, usually to a low power 339 * state. 340 * @resume: Used to bring the device from the sleep mode. 341 * @ns_type: Callbacks so sysfs can detemine namespaces. 342 * @namespace: Namespace of the device belongs to this class. 343 * @pm: The default device power management operations of this class. 344 * @p: The private data of the driver core, no one other than the 345 * driver core can touch this. 346 * 347 * A class is a higher-level view of a device that abstracts out low-level 348 * implementation details. Drivers may see a SCSI disk or an ATA disk, but, 349 * at the class level, they are all simply disks. Classes allow user space 350 * to work with devices based on what they do, rather than how they are 351 * connected or how they work. 352 */ 353 struct class { 354 const char *name; 355 struct module *owner; 356 357 struct class_attribute *class_attrs; 358 const struct attribute_group **dev_groups; 359 struct kobject *dev_kobj; 360 361 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env); 362 char *(*devnode)(struct device *dev, umode_t *mode); 363 364 void (*class_release)(struct class *class); 365 void (*dev_release)(struct device *dev); 366 367 int (*suspend)(struct device *dev, pm_message_t state); 368 int (*resume)(struct device *dev); 369 370 const struct kobj_ns_type_operations *ns_type; 371 const void *(*namespace)(struct device *dev); 372 373 const struct dev_pm_ops *pm; 374 375 struct subsys_private *p; 376 }; 377 378 struct class_dev_iter { 379 struct klist_iter ki; 380 const struct device_type *type; 381 }; 382 383 extern struct kobject *sysfs_dev_block_kobj; 384 extern struct kobject *sysfs_dev_char_kobj; 385 extern int __must_check __class_register(struct class *class, 386 struct lock_class_key *key); 387 extern void class_unregister(struct class *class); 388 389 /* This is a #define to keep the compiler from merging different 390 * instances of the __key variable */ 391 #define class_register(class) 392 ({ 393 static struct lock_class_key __key; 394 __class_register(class, &__key); 395 }) 396 397 struct class_compat; 398 struct class_compat *class_compat_register(const char *name); 399 void class_compat_unregister(struct class_compat *cls); 400 int class_compat_create_link(struct class_compat *cls, struct device *dev, 401 struct device *device_link); 402 void class_compat_remove_link(struct class_compat *cls, struct device *dev, 403 struct device *device_link); 404 405 extern void class_dev_iter_init(struct class_dev_iter *iter, 406 struct class *class, 407 struct device *start, 408 const struct device_type *type); 409 extern struct device *class_dev_iter_next(struct class_dev_iter *iter); 410 extern void class_dev_iter_exit(struct class_dev_iter *iter); 411 412 extern int class_for_each_device(struct class *class, struct device *start, 413 void *data, 414 int (*fn)(struct device *dev, void *data)); 415 extern struct device *class_find_device(struct class *class, 416 struct device *start, const void *data, 417 int (*match)(struct device *, const void *)); 418 419 struct class_attribute { 420 struct attribute attr; 421 ssize_t (*show)(struct class *class, struct class_attribute *attr, 422 char *buf); 423 ssize_t (*store)(struct class *class, struct class_attribute *attr, 424 const char *buf, size_t count); 425 }; 426 427 #define CLASS_ATTR(_name, _mode, _show, _store) 428 struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store) 429 #define CLASS_ATTR_RW(_name) 430 struct class_attribute class_attr_##_name = __ATTR_RW(_name) 431 #define CLASS_ATTR_RO(_name) 432 struct class_attribute class_attr_##_name = __ATTR_RO(_name) 433 434 extern int __must_check class_create_file_ns(struct class *class, 435 const struct class_attribute *attr, 436 const void *ns); 437 extern void class_remove_file_ns(struct class *class, 438 const struct class_attribute *attr, 439 const void *ns); 440 441 static inline int __must_check class_create_file(struct class *class, 442 const struct class_attribute *attr) 443 { 444 return class_create_file_ns(class, attr, NULL); 445 } 446 447 static inline void class_remove_file(struct class *class, 448 const struct class_attribute *attr) 449 { 450 return class_remove_file_ns(class, attr, NULL); 451 } 452 453 /* Simple class attribute that is just a static string */ 454 struct class_attribute_string { 455 struct class_attribute attr; 456 char *str; 457 }; 458 459 /* Currently read-only only */ 460 #define _CLASS_ATTR_STRING(_name, _mode, _str) 461 { __ATTR(_name, _mode, show_class_attr_string, NULL), _str } 462 #define CLASS_ATTR_STRING(_name, _mode, _str) 463 struct class_attribute_string class_attr_##_name = 464 _CLASS_ATTR_STRING(_name, _mode, _str) 465 466 extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr, 467 char *buf); 468 469 struct class_interface { 470 struct list_head node; 471 struct class *class; 472 473 int (*add_dev) (struct device *, struct class_interface *); 474 void (*remove_dev) (struct device *, struct class_interface *); 475 }; 476 477 extern int __must_check class_interface_register(struct class_interface *); 478 extern void class_interface_unregister(struct class_interface *); 479 480 extern struct class * __must_check __class_create(struct module *owner, 481 const char *name, 482 struct lock_class_key *key); 483 extern void class_destroy(struct class *cls); 484 485 /* This is a #define to keep the compiler from merging different 486 * instances of the __key variable */ 487 #define class_create(owner, name) 488 ({ 489 static struct lock_class_key __key; 490 __class_create(owner, name, &__key); 491 }) 492 493 /* 494 * The type of device, "struct device" is embedded in. A class 495 * or bus can contain devices of different types 496 * like "partitions" and "disks", "mouse" and "event". 497 * This identifies the device type and carries type-specific 498 * information, equivalent to the kobj_type of a kobject. 499 * If "name" is specified, the uevent will contain it in 500 * the DEVTYPE variable. 501 */ 502 struct device_type { 503 const char *name; 504 const struct attribute_group **groups; 505 int (*uevent)(struct device *dev, struct kobj_uevent_env *env); 506 char *(*devnode)(struct device *dev, umode_t *mode, 507 kuid_t *uid, kgid_t *gid); 508 void (*release)(struct device *dev); 509 510 const struct dev_pm_ops *pm; 511 }; 512 513 /* interface for exporting device attributes */ 514 struct device_attribute { 515 struct attribute attr; 516 ssize_t (*show)(struct device *dev, struct device_attribute *attr, 517 char *buf); 518 ssize_t (*store)(struct device *dev, struct device_attribute *attr, 519 const char *buf, size_t count); 520 }; 521 522 struct dev_ext_attribute { 523 struct device_attribute attr; 524 void *var; 525 }; 526 527 ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr, 528 char *buf); 529 ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr, 530 const char *buf, size_t count); 531 ssize_t device_show_int(struct device *dev, struct device_attribute *attr, 532 char *buf); 533 ssize_t device_store_int(struct device *dev, struct device_attribute *attr, 534 const char *buf, size_t count); 535 ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 536 char *buf); 537 ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 538 const char *buf, size_t count); 539 540 #define DEVICE_ATTR(_name, _mode, _show, _store) 541 struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store) 542 #define DEVICE_ATTR_RW(_name) 543 struct device_attribute dev_attr_##_name = __ATTR_RW(_name) 544 #define DEVICE_ATTR_RO(_name) 545 struct device_attribute dev_attr_##_name = __ATTR_RO(_name) 546 #define DEVICE_ATTR_WO(_name) 547 struct device_attribute dev_attr_##_name = __ATTR_WO(_name) 548 #define DEVICE_ULONG_ATTR(_name, _mode, _var) 549 struct dev_ext_attribute dev_attr_##_name = 550 { __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) } 551 #define DEVICE_INT_ATTR(_name, _mode, _var) 552 struct dev_ext_attribute dev_attr_##_name = 553 { __ATTR(_name, _mode, device_show_int, device_store_int), &(_var) } 554 #define DEVICE_BOOL_ATTR(_name, _mode, _var) 555 struct dev_ext_attribute dev_attr_##_name = 556 { __ATTR(_name, _mode, device_show_bool, device_store_bool), &(_var) } 557 #define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) 558 struct device_attribute dev_attr_##_name = 559 __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) 560 561 extern int device_create_file(struct device *device, 562 const struct device_attribute *entry); 563 extern void device_remove_file(struct device *dev, 564 const struct device_attribute *attr); 565 extern bool device_remove_file_self(struct device *dev, 566 const struct device_attribute *attr); 567 extern int __must_check device_create_bin_file(struct device *dev, 568 const struct bin_attribute *attr); 569 extern void device_remove_bin_file(struct device *dev, 570 const struct bin_attribute *attr); 571 572 /* device resource management */ 573 typedef void (*dr_release_t)(struct device *dev, void *res); 574 typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data); 575 576 #ifdef CONFIG_DEBUG_DEVRES 577 extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp, 578 const char *name); 579 #define devres_alloc(release, size, gfp) 580 __devres_alloc(release, size, gfp, #release) 581 #else 582 extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp); 583 #endif 584 extern void devres_for_each_res(struct device *dev, dr_release_t release, 585 dr_match_t match, void *match_data, 586 void (*fn)(struct device *, void *, void *), 587 void *data); 588 extern void devres_free(void *res); 589 extern void devres_add(struct device *dev, void *res); 590 extern void *devres_find(struct device *dev, dr_release_t release, 591 dr_match_t match, void *match_data); 592 extern void *devres_get(struct device *dev, void *new_res, 593 dr_match_t match, void *match_data); 594 extern void *devres_remove(struct device *dev, dr_release_t release, 595 dr_match_t match, void *match_data); 596 extern int devres_destroy(struct device *dev, dr_release_t release, 597 dr_match_t match, void *match_data); 598 extern int devres_release(struct device *dev, dr_release_t release, 599 dr_match_t match, void *match_data); 600 601 /* devres group */ 602 extern void * __must_check devres_open_group(struct device *dev, void *id, 603 gfp_t gfp); 604 extern void devres_close_group(struct device *dev, void *id); 605 extern void devres_remove_group(struct device *dev, void *id); 606 extern int devres_release_group(struct device *dev, void *id); 607 608 /* managed devm_k.alloc/kfree for device drivers */ 609 extern void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp); 610 extern char *devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt, 611 va_list ap); 612 extern __printf(3, 4) 613 char *devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...); 614 static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp) 615 { 616 return devm_kmalloc(dev, size, gfp | __GFP_ZERO); 617 } 618 static inline void *devm_kmalloc_array(struct device *dev, 619 size_t n, size_t size, gfp_t flags) 620 { 621 if (size != 0 && n > SIZE_MAX / size) 622 return NULL; 623 return devm_kmalloc(dev, n * size, flags); 624 } 625 static inline void *devm_kcalloc(struct device *dev, 626 size_t n, size_t size, gfp_t flags) 627 { 628 return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO); 629 } 630 extern void devm_kfree(struct device *dev, void *p); 631 extern char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp); 632 extern void *devm_kmemdup(struct device *dev, const void *src, size_t len, 633 gfp_t gfp); 634 635 extern unsigned long devm_get_free_pages(struct device *dev, 636 gfp_t gfp_mask, unsigned int order); 637 extern void devm_free_pages(struct device *dev, unsigned long addr); 638 639 void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res); 640 641 /* allows to add/remove a custom action to devres stack */ 642 int devm_add_action(struct device *dev, void (*action)(void *), void *data); 643 void devm_remove_action(struct device *dev, void (*action)(void *), void *data); 644 645 struct device_dma_parameters { 646 /* 647 * a low level driver may set these to teach IOMMU code about 648 * sg limitations. 649 */ 650 unsigned int max_segment_size; 651 unsigned long segment_boundary_mask; 652 }; 653 654 /** 655 * struct device - The basic device structure 656 * @parent: The device‘s "parent" device, the device to which it is attached. 657 * In most cases, a parent device is some sort of bus or host 658 * controller. If parent is NULL, the device, is a top-level device, 659 * which is not usually what you want. 660 * @p: Holds the private data of the driver core portions of the device. 661 * See the comment of the struct device_private for detail. 662 * @kobj: A top-level, abstract class from which other classes are derived. 663 * @init_name: Initial name of the device. 664 * @type: The type of device. 665 * This identifies the device type and carries type-specific 666 * information. 667 * @mutex: Mutex to synchronize calls to its driver. 668 * @bus: Type of bus device is on. 669 * @driver: Which driver has allocated this 670 * @platform_data: Platform data specific to the device. 671 * Example: For devices on custom boards, as typical of embedded 672 * and SOC based hardware, Linux often uses platform_data to point 673 * to board-specific structures describing devices and how they 674 * are wired. That can include what ports are available, chip 675 * variants, which GPIO pins act in what additional roles, and so 676 * on. This shrinks the "Board Support Packages" (BSPs) and 677 * minimizes board-specific #ifdefs in drivers. 678 * @driver_data: Private pointer for driver specific info. 679 * @power: For device power management. 680 * See Documentation/power/devices.txt for details. 681 * @pm_domain: Provide callbacks that are executed during system suspend, 682 * hibernation, system resume and during runtime PM transitions 683 * along with subsystem-level and driver-level callbacks. 684 * @pins: For device pin management. 685 * See Documentation/pinctrl.txt for details. 686 * @numa_node: NUMA node this device is close to. 687 * @dma_mask: Dma mask (if dma‘ble device). 688 * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all 689 * hardware supports 64-bit addresses for consistent allocations 690 * such descriptors. 691 * @dma_pfn_offset: offset of DMA memory range relatively of RAM 692 * @dma_parms: A low level driver may set these to teach IOMMU code about 693 * segment limitations. 694 * @dma_pools: Dma pools (if dma‘ble device). 695 * @dma_mem: Internal for coherent mem override. 696 * @cma_area: Contiguous memory area for dma allocations 697 * @archdata: For arch-specific additions. 698 * @of_node: Associated device tree node. 699 * @fwnode: Associated device node supplied by platform firmware. 700 * @devt: For creating the sysfs "dev". 701 * @id: device instance 702 * @devres_lock: Spinlock to protect the resource of the device. 703 * @devres_head: The resources list of the device. 704 * @knode_class: The node used to add the device to the class list. 705 * @class: The class of the device. 706 * @groups: Optional attribute groups. 707 * @release: Callback to free the device after all references have 708 * gone away. This should be set by the allocator of the 709 * device (i.e. the bus driver that discovered the device). 710 * @iommu_group: IOMMU group the device belongs to. 711 * 712 * @offline_disabled: If set, the device is permanently online. 713 * @offline: Set after successful invocation of bus type‘s .offline(). 714 * 715 * At the lowest level, every device in a Linux system is represented by an 716 * instance of struct device. The device structure contains the information 717 * that the device model core needs to model the system. Most subsystems, 718 * however, track additional information about the devices they host. As a 719 * result, it is rare for devices to be represented by bare device structures; 720 * instead, that structure, like kobject structures, is usually embedded within 721 * a higher-level representation of the device. 722 */ 723 struct device { 724 struct device *parent; 725 726 struct device_private *p; 727 728 struct kobject kobj; 729 const char *init_name; /* initial name of the device */ 730 const struct device_type *type; 731 732 struct mutex mutex; /* mutex to synchronize calls to 733 * its driver. 734 */ 735 736 struct bus_type *bus; /* type of bus device is on */ 737 struct device_driver *driver; /* which driver has allocated this 738 device */ 739 void *platform_data; /* Platform specific data, device 740 core doesn‘t touch it */ 741 void *driver_data; /* Driver data, set and get with 742 dev_set/get_drvdata */ 743 struct dev_pm_info power; 744 struct dev_pm_domain *pm_domain; 745 746 #ifdef CONFIG_PINCTRL 747 struct dev_pin_info *pins; 748 #endif 749 750 #ifdef CONFIG_NUMA 751 int numa_node; /* NUMA node this device is close to */ 752 #endif 753 u64 *dma_mask; /* dma mask (if dma‘able device) */ 754 u64 coherent_dma_mask;/* Like dma_mask, but for 755 alloc_coherent mappings as 756 not all hardware supports 757 64 bit addresses for consistent 758 allocations such descriptors. */ 759 unsigned long dma_pfn_offset; 760 761 struct device_dma_parameters *dma_parms; 762 763 struct list_head dma_pools; /* dma pools (if dma‘ble) */ 764 765 struct dma_coherent_mem *dma_mem; /* internal for coherent mem 766 override */ 767 #ifdef CONFIG_DMA_CMA 768 struct cma *cma_area; /* contiguous memory area for dma 769 allocations */ 770 #endif 771 /* arch specific additions */ 772 struct dev_archdata archdata; 773 774 struct device_node *of_node; /* associated device tree node */ 775 struct fwnode_handle *fwnode; /* firmware device node */ 776 777 dev_t devt; /* dev_t, creates the sysfs "dev" */ 778 u32 id; /* device instance */ 779 780 spinlock_t devres_lock; 781 struct list_head devres_head; 782 783 struct klist_node knode_class; 784 struct class *class; 785 const struct attribute_group **groups; /* optional groups */ 786 787 void (*release)(struct device *dev); 788 struct iommu_group *iommu_group; 789 790 bool offline_disabled:1; 791 bool offline:1; 792 }; 793 794 static inline struct device *kobj_to_dev(struct kobject *kobj) 795 { 796 return container_of(kobj, struct device, kobj); 797 } 798 799 /* Get the wakeup routines, which depend on struct device */ 800 #include <linux/pm_wakeup.h> 801 802 static inline const char *dev_name(const struct device *dev) 803 { 804 /* Use the init name until the kobject becomes available */ 805 if (dev->init_name) 806 return dev->init_name; 807 808 return kobject_name(&dev->kobj); 809 } 810 811 extern __printf(2, 3) 812 int dev_set_name(struct device *dev, const char *name, ...); 813 814 #ifdef CONFIG_NUMA 815 static inline int dev_to_node(struct device *dev) 816 { 817 return dev->numa_node; 818 } 819 static inline void set_dev_node(struct device *dev, int node) 820 { 821 dev->numa_node = node; 822 } 823 #else 824 static inline int dev_to_node(struct device *dev) 825 { 826 return -1; 827 } 828 static inline void set_dev_node(struct device *dev, int node) 829 { 830 } 831 #endif 832 833 static inline void *dev_get_drvdata(const struct device *dev) 834 { 835 return dev->driver_data; 836 } 837 838 static inline void dev_set_drvdata(struct device *dev, void *data) 839 { 840 dev->driver_data = data; 841 } 842 843 static inline struct pm_subsys_data *dev_to_psd(struct device *dev) 844 { 845 return dev ? dev->power.subsys_data : NULL; 846 } 847 848 static inline unsigned int dev_get_uevent_suppress(const struct device *dev) 849 { 850 return dev->kobj.uevent_suppress; 851 } 852 853 static inline void dev_set_uevent_suppress(struct device *dev, int val) 854 { 855 dev->kobj.uevent_suppress = val; 856 } 857 858 static inline int device_is_registered(struct device *dev) 859 { 860 return dev->kobj.state_in_sysfs; 861 } 862 863 static inline void device_enable_async_suspend(struct device *dev)
时间： 2024-11-08 19:45:59