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