2 * device.h - generic, centralized driver model
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.
8 * This file is released under the GPLv2
10 * See Documentation/driver-model/ for more information.
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/module.h>
25 #include <linux/atomic.h>
26 #include <asm/device.h>
29 struct device_private;
31 struct driver_private;
33 struct subsys_private;
38 struct bus_attribute {
39 struct attribute attr;
40 ssize_t (*show)(struct bus_type *bus, char *buf);
41 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
44 #define BUS_ATTR(_name, _mode, _show, _store) \
45 struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
47 extern int __must_check bus_create_file(struct bus_type *,
48 struct bus_attribute *);
49 extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
52 * struct bus_type - The bus type of the device
54 * @name: The name of the bus.
55 * @bus_attrs: Default attributes of the bus.
56 * @dev_attrs: Default attributes of the devices on the bus.
57 * @drv_attrs: Default attributes of the device drivers on the bus.
58 * @match: Called, perhaps multiple times, whenever a new device or driver
59 * is added for this bus. It should return a nonzero value if the
60 * given device can be handled by the given driver.
61 * @uevent: Called when a device is added, removed, or a few other things
62 * that generate uevents to add the environment variables.
63 * @probe: Called when a new device or driver add to this bus, and callback
64 * the specific driver's probe to initial the matched device.
65 * @remove: Called when a device removed from this bus.
66 * @shutdown: Called at shut-down time to quiesce the device.
67 * @suspend: Called when a device on this bus wants to go to sleep mode.
68 * @resume: Called to bring a device on this bus out of sleep mode.
69 * @pm: Power management operations of this bus, callback the specific
70 * device driver's pm-ops.
71 * @iommu_ops IOMMU specific operations for this bus, used to attach IOMMU
72 * driver implementations to a bus and allow the driver to do
74 * @p: The private data of the driver core, only the driver core can
77 * A bus is a channel between the processor and one or more devices. For the
78 * purposes of the device model, all devices are connected via a bus, even if
79 * it is an internal, virtual, "platform" bus. Buses can plug into each other.
80 * A USB controller is usually a PCI device, for example. The device model
81 * represents the actual connections between buses and the devices they control.
82 * A bus is represented by the bus_type structure. It contains the name, the
83 * default attributes, the bus' methods, PM operations, and the driver core's
88 struct bus_attribute *bus_attrs;
89 struct device_attribute *dev_attrs;
90 struct driver_attribute *drv_attrs;
92 int (*match)(struct device *dev, struct device_driver *drv);
93 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
94 int (*probe)(struct device *dev);
95 int (*remove)(struct device *dev);
96 void (*shutdown)(struct device *dev);
98 int (*suspend)(struct device *dev, pm_message_t state);
99 int (*resume)(struct device *dev);
101 const struct dev_pm_ops *pm;
103 struct iommu_ops *iommu_ops;
105 struct subsys_private *p;
108 extern int __must_check bus_register(struct bus_type *bus);
109 extern void bus_unregister(struct bus_type *bus);
111 extern int __must_check bus_rescan_devices(struct bus_type *bus);
113 /* iterator helpers for buses */
115 int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
116 int (*fn)(struct device *dev, void *data));
117 struct device *bus_find_device(struct bus_type *bus, struct device *start,
119 int (*match)(struct device *dev, void *data));
120 struct device *bus_find_device_by_name(struct bus_type *bus,
121 struct device *start,
124 int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
125 void *data, int (*fn)(struct device_driver *, void *));
127 void bus_sort_breadthfirst(struct bus_type *bus,
128 int (*compare)(const struct device *a,
129 const struct device *b));
131 * Bus notifiers: Get notified of addition/removal of devices
132 * and binding/unbinding of drivers to devices.
133 * In the long run, it should be a replacement for the platform
136 struct notifier_block;
138 extern int bus_register_notifier(struct bus_type *bus,
139 struct notifier_block *nb);
140 extern int bus_unregister_notifier(struct bus_type *bus,
141 struct notifier_block *nb);
143 /* All 4 notifers below get called with the target struct device *
144 * as an argument. Note that those functions are likely to be called
145 * with the device lock held in the core, so be careful.
147 #define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */
148 #define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */
149 #define BUS_NOTIFY_BIND_DRIVER 0x00000003 /* driver about to be
151 #define BUS_NOTIFY_BOUND_DRIVER 0x00000004 /* driver bound to device */
152 #define BUS_NOTIFY_UNBIND_DRIVER 0x00000005 /* driver about to be
154 #define BUS_NOTIFY_UNBOUND_DRIVER 0x00000006 /* driver is unbound
157 extern struct kset *bus_get_kset(struct bus_type *bus);
158 extern struct klist *bus_get_device_klist(struct bus_type *bus);
161 * struct device_driver - The basic device driver structure
162 * @name: Name of the device driver.
163 * @bus: The bus which the device of this driver belongs to.
164 * @owner: The module owner.
165 * @mod_name: Used for built-in modules.
166 * @suppress_bind_attrs: Disables bind/unbind via sysfs.
167 * @of_match_table: The open firmware table.
168 * @probe: Called to query the existence of a specific device,
169 * whether this driver can work with it, and bind the driver
170 * to a specific device.
171 * @remove: Called when the device is removed from the system to
172 * unbind a device from this driver.
173 * @shutdown: Called at shut-down time to quiesce the device.
174 * @suspend: Called to put the device to sleep mode. Usually to a
176 * @resume: Called to bring a device from sleep mode.
177 * @groups: Default attributes that get created by the driver core
179 * @pm: Power management operations of the device which matched
181 * @p: Driver core's private data, no one other than the driver
182 * core can touch this.
184 * The device driver-model tracks all of the drivers known to the system.
185 * The main reason for this tracking is to enable the driver core to match
186 * up drivers with new devices. Once drivers are known objects within the
187 * system, however, a number of other things become possible. Device drivers
188 * can export information and configuration variables that are independent
189 * of any specific device.
191 struct device_driver {
193 struct bus_type *bus;
195 struct module *owner;
196 const char *mod_name; /* used for built-in modules */
198 bool suppress_bind_attrs; /* disables bind/unbind via sysfs */
200 const struct of_device_id *of_match_table;
202 int (*probe) (struct device *dev);
203 int (*remove) (struct device *dev);
204 void (*shutdown) (struct device *dev);
205 int (*suspend) (struct device *dev, pm_message_t state);
206 int (*resume) (struct device *dev);
207 const struct attribute_group **groups;
209 const struct dev_pm_ops *pm;
211 struct driver_private *p;
215 extern int __must_check driver_register(struct device_driver *drv);
216 extern void driver_unregister(struct device_driver *drv);
218 extern struct device_driver *get_driver(struct device_driver *drv);
219 extern void put_driver(struct device_driver *drv);
220 extern struct device_driver *driver_find(const char *name,
221 struct bus_type *bus);
222 extern int driver_probe_done(void);
223 extern void wait_for_device_probe(void);
226 /* sysfs interface for exporting driver attributes */
228 struct driver_attribute {
229 struct attribute attr;
230 ssize_t (*show)(struct device_driver *driver, char *buf);
231 ssize_t (*store)(struct device_driver *driver, const char *buf,
235 #define DRIVER_ATTR(_name, _mode, _show, _store) \
236 struct driver_attribute driver_attr_##_name = \
237 __ATTR(_name, _mode, _show, _store)
239 extern int __must_check driver_create_file(struct device_driver *driver,
240 const struct driver_attribute *attr);
241 extern void driver_remove_file(struct device_driver *driver,
242 const struct driver_attribute *attr);
244 extern int __must_check driver_add_kobj(struct device_driver *drv,
245 struct kobject *kobj,
246 const char *fmt, ...);
248 extern int __must_check driver_for_each_device(struct device_driver *drv,
249 struct device *start,
251 int (*fn)(struct device *dev,
253 struct device *driver_find_device(struct device_driver *drv,
254 struct device *start, void *data,
255 int (*match)(struct device *dev, void *data));
258 * struct class - device classes
259 * @name: Name of the class.
260 * @owner: The module owner.
261 * @class_attrs: Default attributes of this class.
262 * @dev_attrs: Default attributes of the devices belong to the class.
263 * @dev_bin_attrs: Default binary attributes of the devices belong to the class.
264 * @dev_kobj: The kobject that represents this class and links it into the hierarchy.
265 * @dev_uevent: Called when a device is added, removed from this class, or a
266 * few other things that generate uevents to add the environment
268 * @devnode: Callback to provide the devtmpfs.
269 * @class_release: Called to release this class.
270 * @dev_release: Called to release the device.
271 * @suspend: Used to put the device to sleep mode, usually to a low power
273 * @resume: Used to bring the device from the sleep mode.
274 * @ns_type: Callbacks so sysfs can detemine namespaces.
275 * @namespace: Namespace of the device belongs to this class.
276 * @pm: The default device power management operations of this class.
277 * @p: The private data of the driver core, no one other than the
278 * driver core can touch this.
280 * A class is a higher-level view of a device that abstracts out low-level
281 * implementation details. Drivers may see a SCSI disk or an ATA disk, but,
282 * at the class level, they are all simply disks. Classes allow user space
283 * to work with devices based on what they do, rather than how they are
284 * connected or how they work.
288 struct module *owner;
290 struct class_attribute *class_attrs;
291 struct device_attribute *dev_attrs;
292 struct bin_attribute *dev_bin_attrs;
293 struct kobject *dev_kobj;
295 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
296 char *(*devnode)(struct device *dev, mode_t *mode);
298 void (*class_release)(struct class *class);
299 void (*dev_release)(struct device *dev);
301 int (*suspend)(struct device *dev, pm_message_t state);
302 int (*resume)(struct device *dev);
304 const struct kobj_ns_type_operations *ns_type;
305 const void *(*namespace)(struct device *dev);
307 const struct dev_pm_ops *pm;
309 struct subsys_private *p;
312 struct class_dev_iter {
313 struct klist_iter ki;
314 const struct device_type *type;
317 extern struct kobject *sysfs_dev_block_kobj;
318 extern struct kobject *sysfs_dev_char_kobj;
319 extern int __must_check __class_register(struct class *class,
320 struct lock_class_key *key);
321 extern void class_unregister(struct class *class);
323 /* This is a #define to keep the compiler from merging different
324 * instances of the __key variable */
325 #define class_register(class) \
327 static struct lock_class_key __key; \
328 __class_register(class, &__key); \
332 struct class_compat *class_compat_register(const char *name);
333 void class_compat_unregister(struct class_compat *cls);
334 int class_compat_create_link(struct class_compat *cls, struct device *dev,
335 struct device *device_link);
336 void class_compat_remove_link(struct class_compat *cls, struct device *dev,
337 struct device *device_link);
339 extern void class_dev_iter_init(struct class_dev_iter *iter,
341 struct device *start,
342 const struct device_type *type);
343 extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
344 extern void class_dev_iter_exit(struct class_dev_iter *iter);
346 extern int class_for_each_device(struct class *class, struct device *start,
348 int (*fn)(struct device *dev, void *data));
349 extern struct device *class_find_device(struct class *class,
350 struct device *start, void *data,
351 int (*match)(struct device *, void *));
353 struct class_attribute {
354 struct attribute attr;
355 ssize_t (*show)(struct class *class, struct class_attribute *attr,
357 ssize_t (*store)(struct class *class, struct class_attribute *attr,
358 const char *buf, size_t count);
361 #define CLASS_ATTR(_name, _mode, _show, _store) \
362 struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
364 extern int __must_check class_create_file(struct class *class,
365 const struct class_attribute *attr);
366 extern void class_remove_file(struct class *class,
367 const struct class_attribute *attr);
369 /* Simple class attribute that is just a static string */
371 struct class_attribute_string {
372 struct class_attribute attr;
376 /* Currently read-only only */
377 #define _CLASS_ATTR_STRING(_name, _mode, _str) \
378 { __ATTR(_name, _mode, show_class_attr_string, NULL), _str }
379 #define CLASS_ATTR_STRING(_name, _mode, _str) \
380 struct class_attribute_string class_attr_##_name = \
381 _CLASS_ATTR_STRING(_name, _mode, _str)
383 extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
386 struct class_interface {
387 struct list_head node;
390 int (*add_dev) (struct device *, struct class_interface *);
391 void (*remove_dev) (struct device *, struct class_interface *);
394 extern int __must_check class_interface_register(struct class_interface *);
395 extern void class_interface_unregister(struct class_interface *);
397 extern struct class * __must_check __class_create(struct module *owner,
399 struct lock_class_key *key);
400 extern void class_destroy(struct class *cls);
402 /* This is a #define to keep the compiler from merging different
403 * instances of the __key variable */
404 #define class_create(owner, name) \
406 static struct lock_class_key __key; \
407 __class_create(owner, name, &__key); \
411 * The type of device, "struct device" is embedded in. A class
412 * or bus can contain devices of different types
413 * like "partitions" and "disks", "mouse" and "event".
414 * This identifies the device type and carries type-specific
415 * information, equivalent to the kobj_type of a kobject.
416 * If "name" is specified, the uevent will contain it in
417 * the DEVTYPE variable.
421 const struct attribute_group **groups;
422 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
423 char *(*devnode)(struct device *dev, mode_t *mode);
424 void (*release)(struct device *dev);
426 const struct dev_pm_ops *pm;
429 /* interface for exporting device attributes */
430 struct device_attribute {
431 struct attribute attr;
432 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
434 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
435 const char *buf, size_t count);
438 #define DEVICE_ATTR(_name, _mode, _show, _store) \
439 struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
441 extern int __must_check device_create_file(struct device *device,
442 const struct device_attribute *entry);
443 extern void device_remove_file(struct device *dev,
444 const struct device_attribute *attr);
445 extern int __must_check device_create_bin_file(struct device *dev,
446 const struct bin_attribute *attr);
447 extern void device_remove_bin_file(struct device *dev,
448 const struct bin_attribute *attr);
449 extern int device_schedule_callback_owner(struct device *dev,
450 void (*func)(struct device *dev), struct module *owner);
452 /* This is a macro to avoid include problems with THIS_MODULE */
453 #define device_schedule_callback(dev, func) \
454 device_schedule_callback_owner(dev, func, THIS_MODULE)
456 /* device resource management */
457 typedef void (*dr_release_t)(struct device *dev, void *res);
458 typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
460 #ifdef CONFIG_DEBUG_DEVRES
461 extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
463 #define devres_alloc(release, size, gfp) \
464 __devres_alloc(release, size, gfp, #release)
466 extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
468 extern void devres_free(void *res);
469 extern void devres_add(struct device *dev, void *res);
470 extern void *devres_find(struct device *dev, dr_release_t release,
471 dr_match_t match, void *match_data);
472 extern void *devres_get(struct device *dev, void *new_res,
473 dr_match_t match, void *match_data);
474 extern void *devres_remove(struct device *dev, dr_release_t release,
475 dr_match_t match, void *match_data);
476 extern int devres_destroy(struct device *dev, dr_release_t release,
477 dr_match_t match, void *match_data);
480 extern void * __must_check devres_open_group(struct device *dev, void *id,
482 extern void devres_close_group(struct device *dev, void *id);
483 extern void devres_remove_group(struct device *dev, void *id);
484 extern int devres_release_group(struct device *dev, void *id);
486 /* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
487 extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
488 extern void devm_kfree(struct device *dev, void *p);
490 struct device_dma_parameters {
492 * a low level driver may set these to teach IOMMU code about
495 unsigned int max_segment_size;
496 unsigned long segment_boundary_mask;
500 * struct device - The basic device structure
501 * @parent: The device's "parent" device, the device to which it is attached.
502 * In most cases, a parent device is some sort of bus or host
503 * controller. If parent is NULL, the device, is a top-level device,
504 * which is not usually what you want.
505 * @p: Holds the private data of the driver core portions of the device.
506 * See the comment of the struct device_private for detail.
507 * @kobj: A top-level, abstract class from which other classes are derived.
508 * @init_name: Initial name of the device.
509 * @type: The type of device.
510 * This identifies the device type and carries type-specific
512 * @mutex: Mutex to synchronize calls to its driver.
513 * @bus: Type of bus device is on.
514 * @driver: Which driver has allocated this
515 * @platform_data: Platform data specific to the device.
516 * Example: For devices on custom boards, as typical of embedded
517 * and SOC based hardware, Linux often uses platform_data to point
518 * to board-specific structures describing devices and how they
519 * are wired. That can include what ports are available, chip
520 * variants, which GPIO pins act in what additional roles, and so
521 * on. This shrinks the "Board Support Packages" (BSPs) and
522 * minimizes board-specific #ifdefs in drivers.
523 * @power: For device power management.
524 * See Documentation/power/devices.txt for details.
525 * @pm_domain: Provide callbacks that are executed during system suspend,
526 * hibernation, system resume and during runtime PM transitions
527 * along with subsystem-level and driver-level callbacks.
528 * @numa_node: NUMA node this device is close to.
529 * @dma_mask: Dma mask (if dma'ble device).
530 * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all
531 * hardware supports 64-bit addresses for consistent allocations
533 * @dma_parms: A low level driver may set these to teach IOMMU code about
534 * segment limitations.
535 * @dma_pools: Dma pools (if dma'ble device).
536 * @dma_mem: Internal for coherent mem override.
537 * @archdata: For arch-specific additions.
538 * @of_node: Associated device tree node.
539 * @devt: For creating the sysfs "dev".
540 * @devres_lock: Spinlock to protect the resource of the device.
541 * @devres_head: The resources list of the device.
542 * @knode_class: The node used to add the device to the class list.
543 * @class: The class of the device.
544 * @groups: Optional attribute groups.
545 * @release: Callback to free the device after all references have
546 * gone away. This should be set by the allocator of the
547 * device (i.e. the bus driver that discovered the device).
549 * At the lowest level, every device in a Linux system is represented by an
550 * instance of struct device. The device structure contains the information
551 * that the device model core needs to model the system. Most subsystems,
552 * however, track additional information about the devices they host. As a
553 * result, it is rare for devices to be represented by bare device structures;
554 * instead, that structure, like kobject structures, is usually embedded within
555 * a higher-level representation of the device.
558 struct device *parent;
560 struct device_private *p;
563 const char *init_name; /* initial name of the device */
564 const struct device_type *type;
566 struct mutex mutex; /* mutex to synchronize calls to
570 struct bus_type *bus; /* type of bus device is on */
571 struct device_driver *driver; /* which driver has allocated this
573 void *platform_data; /* Platform specific data, device
574 core doesn't touch it */
575 struct dev_pm_info power;
576 struct dev_pm_domain *pm_domain;
579 int numa_node; /* NUMA node this device is close to */
581 u64 *dma_mask; /* dma mask (if dma'able device) */
582 u64 coherent_dma_mask;/* Like dma_mask, but for
583 alloc_coherent mappings as
584 not all hardware supports
585 64 bit addresses for consistent
586 allocations such descriptors. */
588 struct device_dma_parameters *dma_parms;
590 struct list_head dma_pools; /* dma pools (if dma'ble) */
592 struct dma_coherent_mem *dma_mem; /* internal for coherent mem
594 /* arch specific additions */
595 struct dev_archdata archdata;
597 struct device_node *of_node; /* associated device tree node */
599 dev_t devt; /* dev_t, creates the sysfs "dev" */
601 spinlock_t devres_lock;
602 struct list_head devres_head;
604 struct klist_node knode_class;
606 const struct attribute_group **groups; /* optional groups */
608 void (*release)(struct device *dev);
611 /* Get the wakeup routines, which depend on struct device */
612 #include <linux/pm_wakeup.h>
614 static inline const char *dev_name(const struct device *dev)
616 /* Use the init name until the kobject becomes available */
618 return dev->init_name;
620 return kobject_name(&dev->kobj);
623 extern int dev_set_name(struct device *dev, const char *name, ...)
624 __attribute__((format(printf, 2, 3)));
627 static inline int dev_to_node(struct device *dev)
629 return dev->numa_node;
631 static inline void set_dev_node(struct device *dev, int node)
633 dev->numa_node = node;
636 static inline int dev_to_node(struct device *dev)
640 static inline void set_dev_node(struct device *dev, int node)
645 static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
647 return dev->kobj.uevent_suppress;
650 static inline void dev_set_uevent_suppress(struct device *dev, int val)
652 dev->kobj.uevent_suppress = val;
655 static inline int device_is_registered(struct device *dev)
657 return dev->kobj.state_in_sysfs;
660 static inline void device_enable_async_suspend(struct device *dev)
662 if (!dev->power.is_prepared)
663 dev->power.async_suspend = true;
666 static inline void device_disable_async_suspend(struct device *dev)
668 if (!dev->power.is_prepared)
669 dev->power.async_suspend = false;
672 static inline bool device_async_suspend_enabled(struct device *dev)
674 return !!dev->power.async_suspend;
677 static inline void device_lock(struct device *dev)
679 mutex_lock(&dev->mutex);
682 static inline int device_trylock(struct device *dev)
684 return mutex_trylock(&dev->mutex);
687 static inline void device_unlock(struct device *dev)
689 mutex_unlock(&dev->mutex);
692 void driver_init(void);
695 * High level routines for use by the bus drivers
697 extern int __must_check device_register(struct device *dev);
698 extern void device_unregister(struct device *dev);
699 extern void device_initialize(struct device *dev);
700 extern int __must_check device_add(struct device *dev);
701 extern void device_del(struct device *dev);
702 extern int device_for_each_child(struct device *dev, void *data,
703 int (*fn)(struct device *dev, void *data));
704 extern struct device *device_find_child(struct device *dev, void *data,
705 int (*match)(struct device *dev, void *data));
706 extern int device_rename(struct device *dev, const char *new_name);
707 extern int device_move(struct device *dev, struct device *new_parent,
708 enum dpm_order dpm_order);
709 extern const char *device_get_devnode(struct device *dev,
710 mode_t *mode, const char **tmp);
711 extern void *dev_get_drvdata(const struct device *dev);
712 extern int dev_set_drvdata(struct device *dev, void *data);
715 * Root device objects for grouping under /sys/devices
717 extern struct device *__root_device_register(const char *name,
718 struct module *owner);
719 static inline struct device *root_device_register(const char *name)
721 return __root_device_register(name, THIS_MODULE);
723 extern void root_device_unregister(struct device *root);
725 static inline void *dev_get_platdata(const struct device *dev)
727 return dev->platform_data;
731 * Manual binding of a device to driver. See drivers/base/bus.c
732 * for information on use.
734 extern int __must_check device_bind_driver(struct device *dev);
735 extern void device_release_driver(struct device *dev);
736 extern int __must_check device_attach(struct device *dev);
737 extern int __must_check driver_attach(struct device_driver *drv);
738 extern int __must_check device_reprobe(struct device *dev);
741 * Easy functions for dynamically creating devices on the fly
743 extern struct device *device_create_vargs(struct class *cls,
744 struct device *parent,
749 extern struct device *device_create(struct class *cls, struct device *parent,
750 dev_t devt, void *drvdata,
751 const char *fmt, ...)
752 __attribute__((format(printf, 5, 6)));
753 extern void device_destroy(struct class *cls, dev_t devt);
756 * Platform "fixup" functions - allow the platform to have their say
757 * about devices and actions that the general device layer doesn't
760 /* Notify platform of device discovery */
761 extern int (*platform_notify)(struct device *dev);
763 extern int (*platform_notify_remove)(struct device *dev);
767 * get_device - atomically increment the reference count for the device.
770 extern struct device *get_device(struct device *dev);
771 extern void put_device(struct device *dev);
773 extern void wait_for_device_probe(void);
775 #ifdef CONFIG_DEVTMPFS
776 extern int devtmpfs_create_node(struct device *dev);
777 extern int devtmpfs_delete_node(struct device *dev);
778 extern int devtmpfs_mount(const char *mntdir);
780 static inline int devtmpfs_create_node(struct device *dev) { return 0; }
781 static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
782 static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
785 /* drivers/base/power/shutdown.c */
786 extern void device_shutdown(void);
788 /* debugging and troubleshooting/diagnostic helpers. */
789 extern const char *dev_driver_string(const struct device *dev);
794 extern int dev_printk(const char *level, const struct device *dev,
795 const char *fmt, ...)
796 __attribute__ ((format (printf, 3, 4)));
797 extern int dev_emerg(const struct device *dev, const char *fmt, ...)
798 __attribute__ ((format (printf, 2, 3)));
799 extern int dev_alert(const struct device *dev, const char *fmt, ...)
800 __attribute__ ((format (printf, 2, 3)));
801 extern int dev_crit(const struct device *dev, const char *fmt, ...)
802 __attribute__ ((format (printf, 2, 3)));
803 extern int dev_err(const struct device *dev, const char *fmt, ...)
804 __attribute__ ((format (printf, 2, 3)));
805 extern int dev_warn(const struct device *dev, const char *fmt, ...)
806 __attribute__ ((format (printf, 2, 3)));
807 extern int dev_notice(const struct device *dev, const char *fmt, ...)
808 __attribute__ ((format (printf, 2, 3)));
809 extern int _dev_info(const struct device *dev, const char *fmt, ...)
810 __attribute__ ((format (printf, 2, 3)));
814 static inline int dev_printk(const char *level, const struct device *dev,
815 const char *fmt, ...)
816 __attribute__ ((format (printf, 3, 4)));
817 static inline int dev_printk(const char *level, const struct device *dev,
818 const char *fmt, ...)
821 static inline int dev_emerg(const struct device *dev, const char *fmt, ...)
822 __attribute__ ((format (printf, 2, 3)));
823 static inline int dev_emerg(const struct device *dev, const char *fmt, ...)
825 static inline int dev_crit(const struct device *dev, const char *fmt, ...)
826 __attribute__ ((format (printf, 2, 3)));
827 static inline int dev_crit(const struct device *dev, const char *fmt, ...)
829 static inline int dev_alert(const struct device *dev, const char *fmt, ...)
830 __attribute__ ((format (printf, 2, 3)));
831 static inline int dev_alert(const struct device *dev, const char *fmt, ...)
833 static inline int dev_err(const struct device *dev, const char *fmt, ...)
834 __attribute__ ((format (printf, 2, 3)));
835 static inline int dev_err(const struct device *dev, const char *fmt, ...)
837 static inline int dev_warn(const struct device *dev, const char *fmt, ...)
838 __attribute__ ((format (printf, 2, 3)));
839 static inline int dev_warn(const struct device *dev, const char *fmt, ...)
841 static inline int dev_notice(const struct device *dev, const char *fmt, ...)
842 __attribute__ ((format (printf, 2, 3)));
843 static inline int dev_notice(const struct device *dev, const char *fmt, ...)
845 static inline int _dev_info(const struct device *dev, const char *fmt, ...)
846 __attribute__ ((format (printf, 2, 3)));
847 static inline int _dev_info(const struct device *dev, const char *fmt, ...)
853 * Stupid hackaround for existing uses of non-printk uses dev_info
855 * Note that the definition of dev_info below is actually _dev_info
856 * and a macro is used to avoid redefining dev_info
859 #define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
862 #define dev_dbg(dev, format, arg...) \
863 dev_printk(KERN_DEBUG, dev, format, ##arg)
864 #elif defined(CONFIG_DYNAMIC_DEBUG)
865 #define dev_dbg(dev, format, ...) \
867 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
870 #define dev_dbg(dev, format, arg...) \
873 dev_printk(KERN_DEBUG, dev, format, ##arg); \
879 #define dev_vdbg dev_dbg
881 #define dev_vdbg(dev, format, arg...) \
884 dev_printk(KERN_DEBUG, dev, format, ##arg); \
890 * dev_WARN*() acts like dev_printk(), but with the key difference
891 * of using a WARN/WARN_ON to get the message out, including the
892 * file/line information and a backtrace.
894 #define dev_WARN(dev, format, arg...) \
895 WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg);
897 #define dev_WARN_ONCE(dev, condition, format, arg...) \
898 WARN_ONCE(condition, "Device %s\n" format, \
899 dev_driver_string(dev), ## arg)
901 /* Create alias, so I can be autoloaded. */
902 #define MODULE_ALIAS_CHARDEV(major,minor) \
903 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
904 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \
905 MODULE_ALIAS("char-major-" __stringify(major) "-*")
907 #ifdef CONFIG_SYSFS_DEPRECATED
908 extern long sysfs_deprecated;
910 #define sysfs_deprecated 0
913 #endif /* _DEVICE_H_ */