1
2
3
4
5
6
7
8
9
10
11
12#ifndef _DEVICE_H_
13#define _DEVICE_H_
14
15#include <linux/dev_printk.h>
16#include <linux/energy_model.h>
17#include <linux/ioport.h>
18#include <linux/kobject.h>
19#include <linux/klist.h>
20#include <linux/list.h>
21#include <linux/lockdep.h>
22#include <linux/compiler.h>
23#include <linux/types.h>
24#include <linux/mutex.h>
25#include <linux/pm.h>
26#include <linux/atomic.h>
27#include <linux/uidgid.h>
28#include <linux/gfp.h>
29#include <linux/overflow.h>
30#include <linux/device/bus.h>
31#include <linux/device/class.h>
32#include <linux/device/driver.h>
33#include <asm/device.h>
34
35struct device;
36struct device_private;
37struct device_driver;
38struct driver_private;
39struct module;
40struct class;
41struct subsys_private;
42struct device_node;
43struct fwnode_handle;
44struct iommu_ops;
45struct iommu_group;
46struct dev_pin_info;
47struct dev_iommu;
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62struct subsys_interface {
63 const char *name;
64 struct bus_type *subsys;
65 struct list_head node;
66 int (*add_dev)(struct device *dev, struct subsys_interface *sif);
67 void (*remove_dev)(struct device *dev, struct subsys_interface *sif);
68};
69
70int subsys_interface_register(struct subsys_interface *sif);
71void subsys_interface_unregister(struct subsys_interface *sif);
72
73int subsys_system_register(struct bus_type *subsys,
74 const struct attribute_group **groups);
75int subsys_virtual_register(struct bus_type *subsys,
76 const struct attribute_group **groups);
77
78
79
80
81
82
83
84
85
86
87struct device_type {
88 const char *name;
89 const struct attribute_group **groups;
90 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
91 char *(*devnode)(struct device *dev, umode_t *mode,
92 kuid_t *uid, kgid_t *gid);
93 void (*release)(struct device *dev);
94
95 const struct dev_pm_ops *pm;
96};
97
98
99struct device_attribute {
100 struct attribute attr;
101 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
102 char *buf);
103 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
104 const char *buf, size_t count);
105};
106
107struct dev_ext_attribute {
108 struct device_attribute attr;
109 void *var;
110};
111
112ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr,
113 char *buf);
114ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr,
115 const char *buf, size_t count);
116ssize_t device_show_int(struct device *dev, struct device_attribute *attr,
117 char *buf);
118ssize_t device_store_int(struct device *dev, struct device_attribute *attr,
119 const char *buf, size_t count);
120ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
121 char *buf);
122ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
123 const char *buf, size_t count);
124
125#define DEVICE_ATTR(_name, _mode, _show, _store) \
126 struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
127#define DEVICE_ATTR_PREALLOC(_name, _mode, _show, _store) \
128 struct device_attribute dev_attr_##_name = \
129 __ATTR_PREALLOC(_name, _mode, _show, _store)
130#define DEVICE_ATTR_RW(_name) \
131 struct device_attribute dev_attr_##_name = __ATTR_RW(_name)
132#define DEVICE_ATTR_ADMIN_RW(_name) \
133 struct device_attribute dev_attr_##_name = __ATTR_RW_MODE(_name, 0600)
134#define DEVICE_ATTR_RO(_name) \
135 struct device_attribute dev_attr_##_name = __ATTR_RO(_name)
136#define DEVICE_ATTR_ADMIN_RO(_name) \
137 struct device_attribute dev_attr_##_name = __ATTR_RO_MODE(_name, 0400)
138#define DEVICE_ATTR_WO(_name) \
139 struct device_attribute dev_attr_##_name = __ATTR_WO(_name)
140#define DEVICE_ULONG_ATTR(_name, _mode, _var) \
141 struct dev_ext_attribute dev_attr_##_name = \
142 { __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) }
143#define DEVICE_INT_ATTR(_name, _mode, _var) \
144 struct dev_ext_attribute dev_attr_##_name = \
145 { __ATTR(_name, _mode, device_show_int, device_store_int), &(_var) }
146#define DEVICE_BOOL_ATTR(_name, _mode, _var) \
147 struct dev_ext_attribute dev_attr_##_name = \
148 { __ATTR(_name, _mode, device_show_bool, device_store_bool), &(_var) }
149#define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \
150 struct device_attribute dev_attr_##_name = \
151 __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store)
152
153int device_create_file(struct device *device,
154 const struct device_attribute *entry);
155void device_remove_file(struct device *dev,
156 const struct device_attribute *attr);
157bool device_remove_file_self(struct device *dev,
158 const struct device_attribute *attr);
159int __must_check device_create_bin_file(struct device *dev,
160 const struct bin_attribute *attr);
161void device_remove_bin_file(struct device *dev,
162 const struct bin_attribute *attr);
163
164
165typedef void (*dr_release_t)(struct device *dev, void *res);
166typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
167
168#ifdef CONFIG_DEBUG_DEVRES
169void *__devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp,
170 int nid, const char *name) __malloc;
171#define devres_alloc(release, size, gfp) \
172 __devres_alloc_node(release, size, gfp, NUMA_NO_NODE, #release)
173#define devres_alloc_node(release, size, gfp, nid) \
174 __devres_alloc_node(release, size, gfp, nid, #release)
175#else
176void *devres_alloc_node(dr_release_t release, size_t size,
177 gfp_t gfp, int nid) __malloc;
178static inline void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp)
179{
180 return devres_alloc_node(release, size, gfp, NUMA_NO_NODE);
181}
182#endif
183
184void devres_for_each_res(struct device *dev, dr_release_t release,
185 dr_match_t match, void *match_data,
186 void (*fn)(struct device *, void *, void *),
187 void *data);
188void devres_free(void *res);
189void devres_add(struct device *dev, void *res);
190void *devres_find(struct device *dev, dr_release_t release,
191 dr_match_t match, void *match_data);
192void *devres_get(struct device *dev, void *new_res,
193 dr_match_t match, void *match_data);
194void *devres_remove(struct device *dev, dr_release_t release,
195 dr_match_t match, void *match_data);
196int devres_destroy(struct device *dev, dr_release_t release,
197 dr_match_t match, void *match_data);
198int devres_release(struct device *dev, dr_release_t release,
199 dr_match_t match, void *match_data);
200
201
202void * __must_check devres_open_group(struct device *dev, void *id, gfp_t gfp);
203void devres_close_group(struct device *dev, void *id);
204void devres_remove_group(struct device *dev, void *id);
205int devres_release_group(struct device *dev, void *id);
206
207
208void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp) __malloc;
209void *devm_krealloc(struct device *dev, void *ptr, size_t size,
210 gfp_t gfp) __must_check;
211__printf(3, 0) char *devm_kvasprintf(struct device *dev, gfp_t gfp,
212 const char *fmt, va_list ap) __malloc;
213__printf(3, 4) char *devm_kasprintf(struct device *dev, gfp_t gfp,
214 const char *fmt, ...) __malloc;
215static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
216{
217 return devm_kmalloc(dev, size, gfp | __GFP_ZERO);
218}
219static inline void *devm_kmalloc_array(struct device *dev,
220 size_t n, size_t size, gfp_t flags)
221{
222 size_t bytes;
223
224 if (unlikely(check_mul_overflow(n, size, &bytes)))
225 return NULL;
226
227 return devm_kmalloc(dev, bytes, flags);
228}
229static inline void *devm_kcalloc(struct device *dev,
230 size_t n, size_t size, gfp_t flags)
231{
232 return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO);
233}
234void devm_kfree(struct device *dev, const void *p);
235char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp) __malloc;
236const char *devm_kstrdup_const(struct device *dev, const char *s, gfp_t gfp);
237void *devm_kmemdup(struct device *dev, const void *src, size_t len, gfp_t gfp);
238
239unsigned long devm_get_free_pages(struct device *dev,
240 gfp_t gfp_mask, unsigned int order);
241void devm_free_pages(struct device *dev, unsigned long addr);
242
243void __iomem *devm_ioremap_resource(struct device *dev,
244 const struct resource *res);
245void __iomem *devm_ioremap_resource_wc(struct device *dev,
246 const struct resource *res);
247
248void __iomem *devm_of_iomap(struct device *dev,
249 struct device_node *node, int index,
250 resource_size_t *size);
251
252
253int devm_add_action(struct device *dev, void (*action)(void *), void *data);
254void devm_remove_action(struct device *dev, void (*action)(void *), void *data);
255void devm_release_action(struct device *dev, void (*action)(void *), void *data);
256
257static inline int devm_add_action_or_reset(struct device *dev,
258 void (*action)(void *), void *data)
259{
260 int ret;
261
262 ret = devm_add_action(dev, action, data);
263 if (ret)
264 action(data);
265
266 return ret;
267}
268
269
270
271
272
273
274
275
276
277
278
279
280#define devm_alloc_percpu(dev, type) \
281 ((typeof(type) __percpu *)__devm_alloc_percpu((dev), sizeof(type), \
282 __alignof__(type)))
283
284void __percpu *__devm_alloc_percpu(struct device *dev, size_t size,
285 size_t align);
286void devm_free_percpu(struct device *dev, void __percpu *pdata);
287
288struct device_dma_parameters {
289
290
291
292
293 unsigned int max_segment_size;
294 unsigned long segment_boundary_mask;
295};
296
297
298
299
300
301
302
303
304
305
306enum device_link_state {
307 DL_STATE_NONE = -1,
308 DL_STATE_DORMANT = 0,
309 DL_STATE_AVAILABLE,
310 DL_STATE_CONSUMER_PROBE,
311 DL_STATE_ACTIVE,
312 DL_STATE_SUPPLIER_UNBIND,
313};
314
315
316
317
318
319
320
321
322
323
324
325
326
327#define DL_FLAG_STATELESS BIT(0)
328#define DL_FLAG_AUTOREMOVE_CONSUMER BIT(1)
329#define DL_FLAG_PM_RUNTIME BIT(2)
330#define DL_FLAG_RPM_ACTIVE BIT(3)
331#define DL_FLAG_AUTOREMOVE_SUPPLIER BIT(4)
332#define DL_FLAG_AUTOPROBE_CONSUMER BIT(5)
333#define DL_FLAG_MANAGED BIT(6)
334#define DL_FLAG_SYNC_STATE_ONLY BIT(7)
335
336
337
338
339
340
341
342
343enum dl_dev_state {
344 DL_DEV_NO_DRIVER = 0,
345 DL_DEV_PROBING,
346 DL_DEV_DRIVER_BOUND,
347 DL_DEV_UNBINDING,
348};
349
350
351
352
353
354
355
356
357struct dev_links_info {
358 struct list_head suppliers;
359 struct list_head consumers;
360 struct list_head defer_sync;
361 enum dl_dev_state status;
362};
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455struct device {
456 struct kobject kobj;
457 struct device *parent;
458
459 struct device_private *p;
460
461 const char *init_name;
462 const struct device_type *type;
463
464 struct bus_type *bus;
465 struct device_driver *driver;
466
467 void *platform_data;
468
469 void *driver_data;
470
471#ifdef CONFIG_PROVE_LOCKING
472 struct mutex lockdep_mutex;
473#endif
474 struct mutex mutex;
475
476
477
478 struct dev_links_info links;
479 struct dev_pm_info power;
480 struct dev_pm_domain *pm_domain;
481
482#ifdef CONFIG_ENERGY_MODEL
483 struct em_perf_domain *em_pd;
484#endif
485
486#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
487 struct irq_domain *msi_domain;
488#endif
489#ifdef CONFIG_PINCTRL
490 struct dev_pin_info *pins;
491#endif
492#ifdef CONFIG_GENERIC_MSI_IRQ
493 struct list_head msi_list;
494#endif
495#ifdef CONFIG_DMA_OPS
496 const struct dma_map_ops *dma_ops;
497#endif
498 u64 *dma_mask;
499 u64 coherent_dma_mask;
500
501
502
503
504 u64 bus_dma_limit;
505 const struct bus_dma_region *dma_range_map;
506
507 struct device_dma_parameters *dma_parms;
508
509 struct list_head dma_pools;
510
511#ifdef CONFIG_DMA_DECLARE_COHERENT
512 struct dma_coherent_mem *dma_mem;
513
514#endif
515#ifdef CONFIG_DMA_CMA
516 struct cma *cma_area;
517
518#endif
519
520 struct dev_archdata archdata;
521
522 struct device_node *of_node;
523 struct fwnode_handle *fwnode;
524
525#ifdef CONFIG_NUMA
526 int numa_node;
527#endif
528 dev_t devt;
529 u32 id;
530
531 spinlock_t devres_lock;
532 struct list_head devres_head;
533
534 struct class *class;
535 const struct attribute_group **groups;
536
537 void (*release)(struct device *dev);
538 struct iommu_group *iommu_group;
539 struct dev_iommu *iommu;
540
541 bool offline_disabled:1;
542 bool offline:1;
543 bool of_node_reused:1;
544 bool state_synced:1;
545#if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \
546 defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
547 defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL)
548 bool dma_coherent:1;
549#endif
550#ifdef CONFIG_DMA_OPS_BYPASS
551 bool dma_ops_bypass : 1;
552#endif
553};
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569struct device_link {
570 struct device *supplier;
571 struct list_head s_node;
572 struct device *consumer;
573 struct list_head c_node;
574 struct device link_dev;
575 enum device_link_state status;
576 u32 flags;
577 refcount_t rpm_active;
578 struct kref kref;
579#ifdef CONFIG_SRCU
580 struct rcu_head rcu_head;
581#endif
582 bool supplier_preactivated;
583};
584
585static inline struct device *kobj_to_dev(struct kobject *kobj)
586{
587 return container_of(kobj, struct device, kobj);
588}
589
590
591
592
593
594
595static inline bool device_iommu_mapped(struct device *dev)
596{
597 return (dev->iommu_group != NULL);
598}
599
600
601#include <linux/pm_wakeup.h>
602
603static inline const char *dev_name(const struct device *dev)
604{
605
606 if (dev->init_name)
607 return dev->init_name;
608
609 return kobject_name(&dev->kobj);
610}
611
612
613
614
615
616
617
618
619static inline const char *dev_bus_name(const struct device *dev)
620{
621 return dev->bus ? dev->bus->name : (dev->class ? dev->class->name : "");
622}
623
624__printf(2, 3) int dev_set_name(struct device *dev, const char *name, ...);
625
626#ifdef CONFIG_NUMA
627static inline int dev_to_node(struct device *dev)
628{
629 return dev->numa_node;
630}
631static inline void set_dev_node(struct device *dev, int node)
632{
633 dev->numa_node = node;
634}
635#else
636static inline int dev_to_node(struct device *dev)
637{
638 return NUMA_NO_NODE;
639}
640static inline void set_dev_node(struct device *dev, int node)
641{
642}
643#endif
644
645static inline struct irq_domain *dev_get_msi_domain(const struct device *dev)
646{
647#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
648 return dev->msi_domain;
649#else
650 return NULL;
651#endif
652}
653
654static inline void dev_set_msi_domain(struct device *dev, struct irq_domain *d)
655{
656#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
657 dev->msi_domain = d;
658#endif
659}
660
661static inline void *dev_get_drvdata(const struct device *dev)
662{
663 return dev->driver_data;
664}
665
666static inline void dev_set_drvdata(struct device *dev, void *data)
667{
668 dev->driver_data = data;
669}
670
671static inline struct pm_subsys_data *dev_to_psd(struct device *dev)
672{
673 return dev ? dev->power.subsys_data : NULL;
674}
675
676static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
677{
678 return dev->kobj.uevent_suppress;
679}
680
681static inline void dev_set_uevent_suppress(struct device *dev, int val)
682{
683 dev->kobj.uevent_suppress = val;
684}
685
686static inline int device_is_registered(struct device *dev)
687{
688 return dev->kobj.state_in_sysfs;
689}
690
691static inline void device_enable_async_suspend(struct device *dev)
692{
693 if (!dev->power.is_prepared)
694 dev->power.async_suspend = true;
695}
696
697static inline void device_disable_async_suspend(struct device *dev)
698{
699 if (!dev->power.is_prepared)
700 dev->power.async_suspend = false;
701}
702
703static inline bool device_async_suspend_enabled(struct device *dev)
704{
705 return !!dev->power.async_suspend;
706}
707
708static inline bool device_pm_not_required(struct device *dev)
709{
710 return dev->power.no_pm;
711}
712
713static inline void device_set_pm_not_required(struct device *dev)
714{
715 dev->power.no_pm = true;
716}
717
718static inline void dev_pm_syscore_device(struct device *dev, bool val)
719{
720#ifdef CONFIG_PM_SLEEP
721 dev->power.syscore = val;
722#endif
723}
724
725static inline void dev_pm_set_driver_flags(struct device *dev, u32 flags)
726{
727 dev->power.driver_flags = flags;
728}
729
730static inline bool dev_pm_test_driver_flags(struct device *dev, u32 flags)
731{
732 return !!(dev->power.driver_flags & flags);
733}
734
735static inline void device_lock(struct device *dev)
736{
737 mutex_lock(&dev->mutex);
738}
739
740static inline int device_lock_interruptible(struct device *dev)
741{
742 return mutex_lock_interruptible(&dev->mutex);
743}
744
745static inline int device_trylock(struct device *dev)
746{
747 return mutex_trylock(&dev->mutex);
748}
749
750static inline void device_unlock(struct device *dev)
751{
752 mutex_unlock(&dev->mutex);
753}
754
755static inline void device_lock_assert(struct device *dev)
756{
757 lockdep_assert_held(&dev->mutex);
758}
759
760static inline struct device_node *dev_of_node(struct device *dev)
761{
762 if (!IS_ENABLED(CONFIG_OF) || !dev)
763 return NULL;
764 return dev->of_node;
765}
766
767static inline bool dev_has_sync_state(struct device *dev)
768{
769 if (!dev)
770 return false;
771 if (dev->driver && dev->driver->sync_state)
772 return true;
773 if (dev->bus && dev->bus->sync_state)
774 return true;
775 return false;
776}
777
778
779
780
781int __must_check device_register(struct device *dev);
782void device_unregister(struct device *dev);
783void device_initialize(struct device *dev);
784int __must_check device_add(struct device *dev);
785void device_del(struct device *dev);
786int device_for_each_child(struct device *dev, void *data,
787 int (*fn)(struct device *dev, void *data));
788int device_for_each_child_reverse(struct device *dev, void *data,
789 int (*fn)(struct device *dev, void *data));
790struct device *device_find_child(struct device *dev, void *data,
791 int (*match)(struct device *dev, void *data));
792struct device *device_find_child_by_name(struct device *parent,
793 const char *name);
794int device_rename(struct device *dev, const char *new_name);
795int device_move(struct device *dev, struct device *new_parent,
796 enum dpm_order dpm_order);
797int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid);
798const char *device_get_devnode(struct device *dev, umode_t *mode, kuid_t *uid,
799 kgid_t *gid, const char **tmp);
800int device_is_dependent(struct device *dev, void *target);
801
802static inline bool device_supports_offline(struct device *dev)
803{
804 return dev->bus && dev->bus->offline && dev->bus->online;
805}
806
807void lock_device_hotplug(void);
808void unlock_device_hotplug(void);
809int lock_device_hotplug_sysfs(void);
810int device_offline(struct device *dev);
811int device_online(struct device *dev);
812void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
813void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
814void device_set_of_node_from_dev(struct device *dev, const struct device *dev2);
815
816static inline int dev_num_vf(struct device *dev)
817{
818 if (dev->bus && dev->bus->num_vf)
819 return dev->bus->num_vf(dev);
820 return 0;
821}
822
823
824
825
826struct device *__root_device_register(const char *name, struct module *owner);
827
828
829#define root_device_register(name) \
830 __root_device_register(name, THIS_MODULE)
831
832void root_device_unregister(struct device *root);
833
834static inline void *dev_get_platdata(const struct device *dev)
835{
836 return dev->platform_data;
837}
838
839
840
841
842
843int __must_check device_bind_driver(struct device *dev);
844void device_release_driver(struct device *dev);
845int __must_check device_attach(struct device *dev);
846int __must_check driver_attach(struct device_driver *drv);
847void device_initial_probe(struct device *dev);
848int __must_check device_reprobe(struct device *dev);
849
850bool device_is_bound(struct device *dev);
851
852
853
854
855__printf(5, 6) struct device *
856device_create(struct class *cls, struct device *parent, dev_t devt,
857 void *drvdata, const char *fmt, ...);
858__printf(6, 7) struct device *
859device_create_with_groups(struct class *cls, struct device *parent, dev_t devt,
860 void *drvdata, const struct attribute_group **groups,
861 const char *fmt, ...);
862void device_destroy(struct class *cls, dev_t devt);
863
864int __must_check device_add_groups(struct device *dev,
865 const struct attribute_group **groups);
866void device_remove_groups(struct device *dev,
867 const struct attribute_group **groups);
868
869static inline int __must_check device_add_group(struct device *dev,
870 const struct attribute_group *grp)
871{
872 const struct attribute_group *groups[] = { grp, NULL };
873
874 return device_add_groups(dev, groups);
875}
876
877static inline void device_remove_group(struct device *dev,
878 const struct attribute_group *grp)
879{
880 const struct attribute_group *groups[] = { grp, NULL };
881
882 return device_remove_groups(dev, groups);
883}
884
885int __must_check devm_device_add_groups(struct device *dev,
886 const struct attribute_group **groups);
887void devm_device_remove_groups(struct device *dev,
888 const struct attribute_group **groups);
889int __must_check devm_device_add_group(struct device *dev,
890 const struct attribute_group *grp);
891void devm_device_remove_group(struct device *dev,
892 const struct attribute_group *grp);
893
894
895
896
897
898
899
900extern int (*platform_notify)(struct device *dev);
901
902extern int (*platform_notify_remove)(struct device *dev);
903
904
905
906
907
908
909struct device *get_device(struct device *dev);
910void put_device(struct device *dev);
911bool kill_device(struct device *dev);
912
913#ifdef CONFIG_DEVTMPFS
914int devtmpfs_mount(void);
915#else
916static inline int devtmpfs_mount(void) { return 0; }
917#endif
918
919
920void device_shutdown(void);
921
922
923const char *dev_driver_string(const struct device *dev);
924
925
926struct device_link *device_link_add(struct device *consumer,
927 struct device *supplier, u32 flags);
928void device_link_del(struct device_link *link);
929void device_link_remove(void *consumer, struct device *supplier);
930void device_links_supplier_sync_state_pause(void);
931void device_links_supplier_sync_state_resume(void);
932
933extern __printf(3, 4)
934int dev_err_probe(const struct device *dev, int err, const char *fmt, ...);
935
936
937#define MODULE_ALIAS_CHARDEV(major,minor) \
938 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
939#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
940 MODULE_ALIAS("char-major-" __stringify(major) "-*")
941
942#ifdef CONFIG_SYSFS_DEPRECATED
943extern long sysfs_deprecated;
944#else
945#define sysfs_deprecated 0
946#endif
947
948#endif
949