Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
device.h
Go to the documentation of this file.
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/pm.h>
25 #include <linux/atomic.h>
26 #include <linux/ratelimit.h>
27 #include <asm/device.h>
28 
29 struct device;
30 struct device_private;
31 struct device_driver;
32 struct driver_private;
33 struct module;
34 struct class;
35 struct subsys_private;
36 struct bus_type;
37 struct device_node;
38 struct iommu_ops;
39 struct iommu_group;
40 
41 struct bus_attribute {
42  struct attribute attr;
43  ssize_t (*show)(struct bus_type *bus, char *buf);
44  ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
45 };
46 
47 #define BUS_ATTR(_name, _mode, _show, _store) \
48 struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
49 
50 extern int __must_check bus_create_file(struct bus_type *,
51  struct bus_attribute *);
52 extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
53 
91 struct bus_type {
92  const char *name;
93  const char *dev_name;
94  struct device *dev_root;
98 
99  int (*match)(struct device *dev, struct device_driver *drv);
100  int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
101  int (*probe)(struct device *dev);
102  int (*remove)(struct device *dev);
103  void (*shutdown)(struct device *dev);
104 
106  int (*resume)(struct device *dev);
107 
108  const struct dev_pm_ops *pm;
109 
111 
112  struct subsys_private *p;
113 };
114 
115 /* This is a #define to keep the compiler from merging different
116  * instances of the __key variable */
117 #define bus_register(subsys) \
118 ({ \
119  static struct lock_class_key __key; \
120  __bus_register(subsys, &__key); \
121 })
122 extern int __must_check __bus_register(struct bus_type *bus,
123  struct lock_class_key *key);
124 extern void bus_unregister(struct bus_type *bus);
125 
126 extern int __must_check bus_rescan_devices(struct bus_type *bus);
127 
128 /* iterator helpers for buses */
130  struct klist_iter ki;
131  const struct device_type *type;
132 };
133 void subsys_dev_iter_init(struct subsys_dev_iter *iter,
134  struct bus_type *subsys,
135  struct device *start,
136  const struct device_type *type);
137 struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter);
138 void subsys_dev_iter_exit(struct subsys_dev_iter *iter);
139 
140 int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
141  int (*fn)(struct device *dev, void *data));
142 struct device *bus_find_device(struct bus_type *bus, struct device *start,
143  void *data,
144  int (*match)(struct device *dev, void *data));
145 struct device *bus_find_device_by_name(struct bus_type *bus,
146  struct device *start,
147  const char *name);
148 struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id,
149  struct device *hint);
150 int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
151  void *data, int (*fn)(struct device_driver *, void *));
152 void bus_sort_breadthfirst(struct bus_type *bus,
153  int (*compare)(const struct device *a,
154  const struct device *b));
155 /*
156  * Bus notifiers: Get notified of addition/removal of devices
157  * and binding/unbinding of drivers to devices.
158  * In the long run, it should be a replacement for the platform
159  * notify hooks.
160  */
161 struct notifier_block;
162 
163 extern int bus_register_notifier(struct bus_type *bus,
164  struct notifier_block *nb);
165 extern int bus_unregister_notifier(struct bus_type *bus,
166  struct notifier_block *nb);
167 
168 /* All 4 notifers below get called with the target struct device *
169  * as an argument. Note that those functions are likely to be called
170  * with the device lock held in the core, so be careful.
171  */
172 #define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */
173 #define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */
174 #define BUS_NOTIFY_BIND_DRIVER 0x00000003 /* driver about to be
175  bound */
176 #define BUS_NOTIFY_BOUND_DRIVER 0x00000004 /* driver bound to device */
177 #define BUS_NOTIFY_UNBIND_DRIVER 0x00000005 /* driver about to be
178  unbound */
179 #define BUS_NOTIFY_UNBOUND_DRIVER 0x00000006 /* driver is unbound
180  from the device */
181 
182 extern struct kset *bus_get_kset(struct bus_type *bus);
183 extern struct klist *bus_get_device_klist(struct bus_type *bus);
184 
216 struct device_driver {
217  const char *name;
218  struct bus_type *bus;
219 
220  struct module *owner;
221  const char *mod_name; /* used for built-in modules */
223  bool suppress_bind_attrs; /* disables bind/unbind via sysfs */
227  int (*probe) (struct device *dev);
228  int (*remove) (struct device *dev);
229  void (*shutdown) (struct device *dev);
230  int (*suspend) (struct device *dev, pm_message_t state);
231  int (*resume) (struct device *dev);
232  const struct attribute_group **groups;
234  const struct dev_pm_ops *pm;
235 
236  struct driver_private *p;
237 };
238 
239 
240 extern int __must_check driver_register(struct device_driver *drv);
241 extern void driver_unregister(struct device_driver *drv);
242 
243 extern struct device_driver *driver_find(const char *name,
244  struct bus_type *bus);
245 extern int driver_probe_done(void);
246 extern void wait_for_device_probe(void);
247 
249 /* sysfs interface for exporting driver attributes */
252  struct attribute attr;
253  ssize_t (*show)(struct device_driver *driver, char *buf);
254  ssize_t (*store)(struct device_driver *driver, const char *buf,
255  size_t count);
256 };
257 
258 #define DRIVER_ATTR(_name, _mode, _show, _store) \
259 struct driver_attribute driver_attr_##_name = \
260  __ATTR(_name, _mode, _show, _store)
261 
263  const struct driver_attribute *attr);
264 extern void driver_remove_file(struct device_driver *driver,
265  const struct driver_attribute *attr);
266 
267 extern int __must_check driver_for_each_device(struct device_driver *drv,
268  struct device *start,
269  void *data,
270  int (*fn)(struct device *dev,
271  void *));
272 struct device *driver_find_device(struct device_driver *drv,
273  struct device *start, void *data,
274  int (*match)(struct device *dev, void *data));
275 
290  const char *name;
291  struct bus_type *subsys;
292  struct list_head node;
293  int (*add_dev)(struct device *dev, struct subsys_interface *sif);
294  int (*remove_dev)(struct device *dev, struct subsys_interface *sif);
295 };
296 
299 
301  const struct attribute_group **groups);
302 
332 struct class {
333  const char *name;
334  struct module *owner;
337  struct device_attribute *dev_attrs;
339  struct kobject *dev_kobj;
340 
341  int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
342  char *(*devnode)(struct device *dev, umode_t *mode);
343 
344  void (*class_release)(struct class *class);
345  void (*dev_release)(struct device *dev);
346 
348  int (*resume)(struct device *dev);
349 
351  const void *(*namespace)(struct device *dev);
353  const struct dev_pm_ops *pm;
354 
355  struct subsys_private *p;
356 };
358 struct class_dev_iter {
359  struct klist_iter ki;
360  const struct device_type *type;
361 };
362 
363 extern struct kobject *sysfs_dev_block_kobj;
364 extern struct kobject *sysfs_dev_char_kobj;
365 extern int __must_check __class_register(struct class *class,
366  struct lock_class_key *key);
367 extern void class_unregister(struct class *class);
369 /* This is a #define to keep the compiler from merging different
370  * instances of the __key variable */
371 #define class_register(class) \
372 ({ \
373  static struct lock_class_key __key; \
374  __class_register(class, &__key); \
375 })
376 
377 struct class_compat;
378 struct class_compat *class_compat_register(const char *name);
379 void class_compat_unregister(struct class_compat *cls);
380 int class_compat_create_link(struct class_compat *cls, struct device *dev,
381  struct device *device_link);
382 void class_compat_remove_link(struct class_compat *cls, struct device *dev,
383  struct device *device_link);
384 
385 extern void class_dev_iter_init(struct class_dev_iter *iter,
386  struct class *class,
387  struct device *start,
388  const struct device_type *type);
389 extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
390 extern void class_dev_iter_exit(struct class_dev_iter *iter);
391 
392 extern int class_for_each_device(struct class *class, struct device *start,
393  void *data,
394  int (*fn)(struct device *dev, void *data));
395 extern struct device *class_find_device(struct class *class,
396  struct device *start, void *data,
397  int (*match)(struct device *, void *));
399 struct class_attribute {
400  struct attribute attr;
401  ssize_t (*show)(struct class *class, struct class_attribute *attr,
402  char *buf);
403  ssize_t (*store)(struct class *class, struct class_attribute *attr,
404  const char *buf, size_t count);
405  const void *(*namespace)(struct class *class,
406  const struct class_attribute *attr);
407 };
408 
409 #define CLASS_ATTR(_name, _mode, _show, _store) \
410 struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
411 
412 extern int __must_check class_create_file(struct class *class,
413  const struct class_attribute *attr);
414 extern void class_remove_file(struct class *class,
415  const struct class_attribute *attr);
417 /* Simple class attribute that is just a static string */
419 struct class_attribute_string {
420  struct class_attribute attr;
421  char *str;
422 };
423 
424 /* Currently read-only only */
425 #define _CLASS_ATTR_STRING(_name, _mode, _str) \
426  { __ATTR(_name, _mode, show_class_attr_string, NULL), _str }
427 #define CLASS_ATTR_STRING(_name, _mode, _str) \
428  struct class_attribute_string class_attr_##_name = \
429  _CLASS_ATTR_STRING(_name, _mode, _str)
430 
431 extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
432  char *buf);
434 struct class_interface {
435  struct list_head node;
436  struct class *class;
437 
438  int (*add_dev) (struct device *, struct class_interface *);
439  void (*remove_dev) (struct device *, struct class_interface *);
440 };
441 
443 extern void class_interface_unregister(struct class_interface *);
444 
445 extern struct class * __must_check __class_create(struct module *owner,
446  const char *name,
447  struct lock_class_key *key);
448 extern void class_destroy(struct class *cls);
450 /* This is a #define to keep the compiler from merging different
451  * instances of the __key variable */
452 #define class_create(owner, name) \
453 ({ \
454  static struct lock_class_key __key; \
455  __class_create(owner, name, &__key); \
456 })
457 
458 /*
459  * The type of device, "struct device" is embedded in. A class
460  * or bus can contain devices of different types
461  * like "partitions" and "disks", "mouse" and "event".
462  * This identifies the device type and carries type-specific
463  * information, equivalent to the kobj_type of a kobject.
464  * If "name" is specified, the uevent will contain it in
465  * the DEVTYPE variable.
466  */
467 struct device_type {
468  const char *name;
469  const struct attribute_group **groups;
470  int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
471  char *(*devnode)(struct device *dev, umode_t *mode);
472  void (*release)(struct device *dev);
473 
474  const struct dev_pm_ops *pm;
475 };
477 /* interface for exporting device attributes */
478 struct device_attribute {
479  struct attribute attr;
480  ssize_t (*show)(struct device *dev, struct device_attribute *attr,
481  char *buf);
482  ssize_t (*store)(struct device *dev, struct device_attribute *attr,
483  const char *buf, size_t count);
484 };
486 struct dev_ext_attribute {
487  struct device_attribute attr;
488  void *var;
489 };
490 
492  char *buf);
494  const char *buf, size_t count);
496  char *buf);
498  const char *buf, size_t count);
500 #define DEVICE_ATTR(_name, _mode, _show, _store) \
501  struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
502 #define DEVICE_ULONG_ATTR(_name, _mode, _var) \
503  struct dev_ext_attribute dev_attr_##_name = \
504  { __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) }
505 #define DEVICE_INT_ATTR(_name, _mode, _var) \
506  struct dev_ext_attribute dev_attr_##_name = \
507  { __ATTR(_name, _mode, device_show_int, device_store_int), &(_var) }
508 #define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \
509  struct device_attribute dev_attr_##_name = \
510  __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store)
511 
512 extern int device_create_file(struct device *device,
513  const struct device_attribute *entry);
514 extern void device_remove_file(struct device *dev,
515  const struct device_attribute *attr);
516 extern int __must_check device_create_bin_file(struct device *dev,
517  const struct bin_attribute *attr);
518 extern void device_remove_bin_file(struct device *dev,
519  const struct bin_attribute *attr);
520 extern int device_schedule_callback_owner(struct device *dev,
521  void (*func)(struct device *dev), struct module *owner);
522 
523 /* This is a macro to avoid include problems with THIS_MODULE */
524 #define device_schedule_callback(dev, func) \
525  device_schedule_callback_owner(dev, func, THIS_MODULE)
527 /* device resource management */
528 typedef void (*dr_release_t)(struct device *dev, void *res);
529 typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
530 
531 #ifdef CONFIG_DEBUG_DEVRES
532 extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
533  const char *name);
534 #define devres_alloc(release, size, gfp) \
535  __devres_alloc(release, size, gfp, #release)
536 #else
537 extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
538 #endif
539 extern void devres_for_each_res(struct device *dev, dr_release_t release,
540  dr_match_t match, void *match_data,
541  void (*fn)(struct device *, void *, void *),
542  void *data);
543 extern void devres_free(void *res);
544 extern void devres_add(struct device *dev, void *res);
545 extern void *devres_find(struct device *dev, dr_release_t release,
546  dr_match_t match, void *match_data);
547 extern void *devres_get(struct device *dev, void *new_res,
548  dr_match_t match, void *match_data);
549 extern void *devres_remove(struct device *dev, dr_release_t release,
550  dr_match_t match, void *match_data);
551 extern int devres_destroy(struct device *dev, dr_release_t release,
552  dr_match_t match, void *match_data);
553 extern int devres_release(struct device *dev, dr_release_t release,
554  dr_match_t match, void *match_data);
555 
556 /* devres group */
557 extern void * __must_check devres_open_group(struct device *dev, void *id,
558  gfp_t gfp);
559 extern void devres_close_group(struct device *dev, void *id);
560 extern void devres_remove_group(struct device *dev, void *id);
561 extern int devres_release_group(struct device *dev, void *id);
562 
563 /* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
564 extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
565 extern void devm_kfree(struct device *dev, void *p);
566 
568  struct resource *res);
569 
570 struct device_dma_parameters {
571  /*
572  * a low level driver may set these to teach IOMMU code about
573  * sg limitations.
574  */
575  unsigned int max_segment_size;
576  unsigned long segment_boundary_mask;
577 };
578 
638 struct device {
639  struct device *parent;
641  struct device_private *p;
643  struct kobject kobj;
644  const char *init_name; /* initial name of the device */
645  const struct device_type *type;
646 
647  struct mutex mutex; /* mutex to synchronize calls to
648  * its driver.
649  */
650 
651  struct bus_type *bus; /* type of bus device is on */
652  struct device_driver *driver; /* which driver has allocated this
653  device */
654  void *platform_data; /* Platform specific data, device
655  core doesn't touch it */
656  struct dev_pm_info power;
657  struct dev_pm_domain *pm_domain;
658 
659 #ifdef CONFIG_NUMA
660  int numa_node; /* NUMA node this device is close to */
661 #endif
662  u64 *dma_mask; /* dma mask (if dma'able device) */
663  u64 coherent_dma_mask;/* Like dma_mask, but for
664  alloc_coherent mappings as
665  not all hardware supports
666  64 bit addresses for consistent
667  allocations such descriptors. */
671  struct list_head dma_pools; /* dma pools (if dma'ble) */
672 
673  struct dma_coherent_mem *dma_mem; /* internal for coherent mem
674  override */
675 #ifdef CONFIG_CMA
676  struct cma *cma_area; /* contiguous memory area for dma
677  allocations */
678 #endif
679  /* arch specific additions */
680  struct dev_archdata archdata;
682  struct device_node *of_node; /* associated device tree node */
683 
684  dev_t devt; /* dev_t, creates the sysfs "dev" */
685  u32 id; /* device instance */
686 
690  struct klist_node knode_class;
691  struct class *class;
692  const struct attribute_group **groups; /* optional groups */
693 
694  void (*release)(struct device *dev);
695  struct iommu_group *iommu_group;
696 };
697 
698 static inline struct device *kobj_to_dev(struct kobject *kobj)
699 {
700  return container_of(kobj, struct device, kobj);
701 }
702 
703 /* Get the wakeup routines, which depend on struct device */
704 #include <linux/pm_wakeup.h>
705 
706 static inline const char *dev_name(const struct device *dev)
707 {
708  /* Use the init name until the kobject becomes available */
709  if (dev->init_name)
710  return dev->init_name;
711 
712  return kobject_name(&dev->kobj);
713 }
714 
715 extern __printf(2, 3)
716 int dev_set_name(struct device *dev, const char *name, ...);
717 
718 #ifdef CONFIG_NUMA
719 static inline int dev_to_node(struct device *dev)
720 {
721  return dev->numa_node;
722 }
723 static inline void set_dev_node(struct device *dev, int node)
724 {
725  dev->numa_node = node;
726 }
727 #else
728 static inline int dev_to_node(struct device *dev)
729 {
730  return -1;
731 }
732 static inline void set_dev_node(struct device *dev, int node)
733 {
734 }
735 #endif
736 
737 static inline struct pm_subsys_data *dev_to_psd(struct device *dev)
738 {
739  return dev ? dev->power.subsys_data : NULL;
740 }
741 
742 static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
743 {
744  return dev->kobj.uevent_suppress;
745 }
746 
747 static inline void dev_set_uevent_suppress(struct device *dev, int val)
748 {
749  dev->kobj.uevent_suppress = val;
750 }
751 
752 static inline int device_is_registered(struct device *dev)
753 {
754  return dev->kobj.state_in_sysfs;
755 }
756 
757 static inline void device_enable_async_suspend(struct device *dev)
758 {
759  if (!dev->power.is_prepared)
760  dev->power.async_suspend = true;
761 }
762 
763 static inline void device_disable_async_suspend(struct device *dev)
764 {
765  if (!dev->power.is_prepared)
766  dev->power.async_suspend = false;
767 }
768 
769 static inline bool device_async_suspend_enabled(struct device *dev)
770 {
771  return !!dev->power.async_suspend;
772 }
773 
774 static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
775 {
776  dev->power.ignore_children = enable;
777 }
778 
779 static inline void dev_pm_syscore_device(struct device *dev, bool val)
780 {
781 #ifdef CONFIG_PM_SLEEP
782  dev->power.syscore = val;
783 #endif
784 }
785 
786 static inline void device_lock(struct device *dev)
787 {
788  mutex_lock(&dev->mutex);
789 }
790 
791 static inline int device_trylock(struct device *dev)
792 {
793  return mutex_trylock(&dev->mutex);
794 }
795 
796 static inline void device_unlock(struct device *dev)
797 {
798  mutex_unlock(&dev->mutex);
799 }
800 
801 void driver_init(void);
802 
803 /*
804  * High level routines for use by the bus drivers
805  */
806 extern int __must_check device_register(struct device *dev);
807 extern void device_unregister(struct device *dev);
808 extern void device_initialize(struct device *dev);
809 extern int __must_check device_add(struct device *dev);
810 extern void device_del(struct device *dev);
811 extern int device_for_each_child(struct device *dev, void *data,
812  int (*fn)(struct device *dev, void *data));
813 extern struct device *device_find_child(struct device *dev, void *data,
814  int (*match)(struct device *dev, void *data));
815 extern int device_rename(struct device *dev, const char *new_name);
816 extern int device_move(struct device *dev, struct device *new_parent,
817  enum dpm_order dpm_order);
818 extern const char *device_get_devnode(struct device *dev,
819  umode_t *mode, const char **tmp);
820 extern void *dev_get_drvdata(const struct device *dev);
821 extern int dev_set_drvdata(struct device *dev, void *data);
822 
823 /*
824  * Root device objects for grouping under /sys/devices
825  */
826 extern struct device *__root_device_register(const char *name,
827  struct module *owner);
828 
829 /*
830  * This is a macro to avoid include problems with THIS_MODULE,
831  * just as per what is done for device_schedule_callback() above.
832  */
833 #define root_device_register(name) \
834  __root_device_register(name, THIS_MODULE)
835 
836 extern void root_device_unregister(struct device *root);
837 
838 static inline void *dev_get_platdata(const struct device *dev)
839 {
840  return dev->platform_data;
841 }
842 
843 /*
844  * Manual binding of a device to driver. See drivers/base/bus.c
845  * for information on use.
846  */
847 extern int __must_check device_bind_driver(struct device *dev);
848 extern void device_release_driver(struct device *dev);
849 extern int __must_check device_attach(struct device *dev);
850 extern int __must_check driver_attach(struct device_driver *drv);
851 extern int __must_check device_reprobe(struct device *dev);
852 
853 /*
854  * Easy functions for dynamically creating devices on the fly
855  */
856 extern struct device *device_create_vargs(struct class *cls,
857  struct device *parent,
858  dev_t devt,
859  void *drvdata,
860  const char *fmt,
861  va_list vargs);
862 extern __printf(5, 6)
864  dev_t devt, void *drvdata,
865  const char *fmt, ...);
866 extern void device_destroy(struct class *cls, dev_t devt);
867 
868 /*
869  * Platform "fixup" functions - allow the platform to have their say
870  * about devices and actions that the general device layer doesn't
871  * know about.
872  */
873 /* Notify platform of device discovery */
874 extern int (*platform_notify)(struct device *dev);
875 
876 extern int (*platform_notify_remove)(struct device *dev);
877 
878 
879 /*
880  * get_device - atomically increment the reference count for the device.
881  *
882  */
883 extern struct device *get_device(struct device *dev);
884 extern void put_device(struct device *dev);
885 
886 #ifdef CONFIG_DEVTMPFS
887 extern int devtmpfs_create_node(struct device *dev);
888 extern int devtmpfs_delete_node(struct device *dev);
889 extern int devtmpfs_mount(const char *mntdir);
890 #else
891 static inline int devtmpfs_create_node(struct device *dev) { return 0; }
892 static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
893 static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
894 #endif
895 
896 /* drivers/base/power/shutdown.c */
897 extern void device_shutdown(void);
898 
899 /* debugging and troubleshooting/diagnostic helpers. */
900 extern const char *dev_driver_string(const struct device *dev);
901 
902 
903 #ifdef CONFIG_PRINTK
904 
905 extern __printf(3, 0)
906 int dev_vprintk_emit(int level, const struct device *dev,
907  const char *fmt, va_list args);
908 extern __printf(3, 4)
909 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
910 
911 extern __printf(3, 4)
912 int dev_printk(const char *level, const struct device *dev,
913  const char *fmt, ...);
914 extern __printf(2, 3)
915 int dev_emerg(const struct device *dev, const char *fmt, ...);
916 extern __printf(2, 3)
917 int dev_alert(const struct device *dev, const char *fmt, ...);
918 extern __printf(2, 3)
919 int dev_crit(const struct device *dev, const char *fmt, ...);
920 extern __printf(2, 3)
921 int dev_err(const struct device *dev, const char *fmt, ...);
922 extern __printf(2, 3)
923 int dev_warn(const struct device *dev, const char *fmt, ...);
924 extern __printf(2, 3)
925 int dev_notice(const struct device *dev, const char *fmt, ...);
926 extern __printf(2, 3)
927 int _dev_info(const struct device *dev, const char *fmt, ...);
928 
929 #else
930 
931 static inline __printf(3, 0)
932 int dev_vprintk_emit(int level, const struct device *dev,
933  const char *fmt, va_list args)
934 { return 0; }
935 static inline __printf(3, 4)
936 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
937 { return 0; }
938 
939 static inline int __dev_printk(const char *level, const struct device *dev,
940  struct va_format *vaf)
941 { return 0; }
942 static inline __printf(3, 4)
943 int dev_printk(const char *level, const struct device *dev,
944  const char *fmt, ...)
945 { return 0; }
946 
947 static inline __printf(2, 3)
948 int dev_emerg(const struct device *dev, const char *fmt, ...)
949 { return 0; }
950 static inline __printf(2, 3)
951 int dev_crit(const struct device *dev, const char *fmt, ...)
952 { return 0; }
953 static inline __printf(2, 3)
954 int dev_alert(const struct device *dev, const char *fmt, ...)
955 { return 0; }
956 static inline __printf(2, 3)
957 int dev_err(const struct device *dev, const char *fmt, ...)
958 { return 0; }
959 static inline __printf(2, 3)
960 int dev_warn(const struct device *dev, const char *fmt, ...)
961 { return 0; }
962 static inline __printf(2, 3)
963 int dev_notice(const struct device *dev, const char *fmt, ...)
964 { return 0; }
965 static inline __printf(2, 3)
966 int _dev_info(const struct device *dev, const char *fmt, ...)
967 { return 0; }
968 
969 #endif
970 
971 /*
972  * Stupid hackaround for existing uses of non-printk uses dev_info
973  *
974  * Note that the definition of dev_info below is actually _dev_info
975  * and a macro is used to avoid redefining dev_info
976  */
977 
978 #define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
979 
980 #if defined(CONFIG_DYNAMIC_DEBUG)
981 #define dev_dbg(dev, format, ...) \
982 do { \
983  dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
984 } while (0)
985 #elif defined(DEBUG)
986 #define dev_dbg(dev, format, arg...) \
987  dev_printk(KERN_DEBUG, dev, format, ##arg)
988 #else
989 #define dev_dbg(dev, format, arg...) \
990 ({ \
991  if (0) \
992  dev_printk(KERN_DEBUG, dev, format, ##arg); \
993  0; \
994 })
995 #endif
996 
997 #define dev_level_ratelimited(dev_level, dev, fmt, ...) \
998 do { \
999  static DEFINE_RATELIMIT_STATE(_rs, \
1000  DEFAULT_RATELIMIT_INTERVAL, \
1001  DEFAULT_RATELIMIT_BURST); \
1002  if (__ratelimit(&_rs)) \
1003  dev_level(dev, fmt, ##__VA_ARGS__); \
1004 } while (0)
1006 #define dev_emerg_ratelimited(dev, fmt, ...) \
1007  dev_level_ratelimited(dev_emerg, dev, fmt, ##__VA_ARGS__)
1008 #define dev_alert_ratelimited(dev, fmt, ...) \
1009  dev_level_ratelimited(dev_alert, dev, fmt, ##__VA_ARGS__)
1010 #define dev_crit_ratelimited(dev, fmt, ...) \
1011  dev_level_ratelimited(dev_crit, dev, fmt, ##__VA_ARGS__)
1012 #define dev_err_ratelimited(dev, fmt, ...) \
1013  dev_level_ratelimited(dev_err, dev, fmt, ##__VA_ARGS__)
1014 #define dev_warn_ratelimited(dev, fmt, ...) \
1015  dev_level_ratelimited(dev_warn, dev, fmt, ##__VA_ARGS__)
1016 #define dev_notice_ratelimited(dev, fmt, ...) \
1017  dev_level_ratelimited(dev_notice, dev, fmt, ##__VA_ARGS__)
1018 #define dev_info_ratelimited(dev, fmt, ...) \
1019  dev_level_ratelimited(dev_info, dev, fmt, ##__VA_ARGS__)
1020 #if defined(CONFIG_DYNAMIC_DEBUG) || defined(DEBUG)
1021 #define dev_dbg_ratelimited(dev, fmt, ...) \
1022 do { \
1023  static DEFINE_RATELIMIT_STATE(_rs, \
1024  DEFAULT_RATELIMIT_INTERVAL, \
1025  DEFAULT_RATELIMIT_BURST); \
1026  DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
1027  if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) && \
1028  __ratelimit(&_rs)) \
1029  __dynamic_pr_debug(&descriptor, pr_fmt(fmt), \
1030  ##__VA_ARGS__); \
1031 } while (0)
1032 #else
1033 #define dev_dbg_ratelimited(dev, fmt, ...) \
1034  no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
1035 #endif
1036 
1037 #ifdef VERBOSE_DEBUG
1038 #define dev_vdbg dev_dbg
1039 #else
1040 #define dev_vdbg(dev, format, arg...) \
1041 ({ \
1042  if (0) \
1043  dev_printk(KERN_DEBUG, dev, format, ##arg); \
1044  0; \
1045 })
1046 #endif
1047 
1048 /*
1049  * dev_WARN*() acts like dev_printk(), but with the key difference
1050  * of using a WARN/WARN_ON to get the message out, including the
1051  * file/line information and a backtrace.
1052  */
1053 #define dev_WARN(dev, format, arg...) \
1054  WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg);
1055 
1056 #define dev_WARN_ONCE(dev, condition, format, arg...) \
1057  WARN_ONCE(condition, "Device %s\n" format, \
1058  dev_driver_string(dev), ## arg)
1059 
1060 /* Create alias, so I can be autoloaded. */
1061 #define MODULE_ALIAS_CHARDEV(major,minor) \
1062  MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
1063 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \
1064  MODULE_ALIAS("char-major-" __stringify(major) "-*")
1065 
1066 #ifdef CONFIG_SYSFS_DEPRECATED
1067 extern long sysfs_deprecated;
1068 #else
1069 #define sysfs_deprecated 0
1070 #endif
1071 
1086 #define module_driver(__driver, __register, __unregister, ...) \
1087 static int __init __driver##_init(void) \
1088 { \
1089  return __register(&(__driver) , ##__VA_ARGS__); \
1090 } \
1091 module_init(__driver##_init); \
1092 static void __exit __driver##_exit(void) \
1093 { \
1094  __unregister(&(__driver) , ##__VA_ARGS__); \
1095 } \
1096 module_exit(__driver##_exit);
1097 
1098 #endif /* _DEVICE_H_ */