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
168void *__devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp,
169 int nid, const char *name) __malloc;
170#define devres_alloc(release, size, gfp) \
171 __devres_alloc_node(release, size, gfp, NUMA_NO_NODE, #release)
172#define devres_alloc_node(release, size, gfp, nid) \
173 __devres_alloc_node(release, size, gfp, nid, #release)
174
175void devres_for_each_res(struct device *dev, dr_release_t release,
176 dr_match_t match, void *match_data,
177 void (*fn)(struct device *, void *, void *),
178 void *data);
179void devres_free(void *res);
180void devres_add(struct device *dev, void *res);
181void *devres_find(struct device *dev, dr_release_t release,
182 dr_match_t match, void *match_data);
183void *devres_get(struct device *dev, void *new_res,
184 dr_match_t match, void *match_data);
185void *devres_remove(struct device *dev, dr_release_t release,
186 dr_match_t match, void *match_data);
187int devres_destroy(struct device *dev, dr_release_t release,
188 dr_match_t match, void *match_data);
189int devres_release(struct device *dev, dr_release_t release,
190 dr_match_t match, void *match_data);
191
192
193void * __must_check devres_open_group(struct device *dev, void *id, gfp_t gfp);
194void devres_close_group(struct device *dev, void *id);
195void devres_remove_group(struct device *dev, void *id);
196int devres_release_group(struct device *dev, void *id);
197
198
199void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp) __malloc;
200void *devm_krealloc(struct device *dev, void *ptr, size_t size,
201 gfp_t gfp) __must_check;
202__printf(3, 0) char *devm_kvasprintf(struct device *dev, gfp_t gfp,
203 const char *fmt, va_list ap) __malloc;
204__printf(3, 4) char *devm_kasprintf(struct device *dev, gfp_t gfp,
205 const char *fmt, ...) __malloc;
206static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
207{
208 return devm_kmalloc(dev, size, gfp | __GFP_ZERO);
209}
210static inline void *devm_kmalloc_array(struct device *dev,
211 size_t n, size_t size, gfp_t flags)
212{
213 size_t bytes;
214
215 if (unlikely(check_mul_overflow(n, size, &bytes)))
216 return NULL;
217
218 return devm_kmalloc(dev, bytes, flags);
219}
220static inline void *devm_kcalloc(struct device *dev,
221 size_t n, size_t size, gfp_t flags)
222{
223 return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO);
224}
225void devm_kfree(struct device *dev, const void *p);
226char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp) __malloc;
227const char *devm_kstrdup_const(struct device *dev, const char *s, gfp_t gfp);
228void *devm_kmemdup(struct device *dev, const void *src, size_t len, gfp_t gfp);
229
230unsigned long devm_get_free_pages(struct device *dev,
231 gfp_t gfp_mask, unsigned int order);
232void devm_free_pages(struct device *dev, unsigned long addr);
233
234void __iomem *devm_ioremap_resource(struct device *dev,
235 const struct resource *res);
236void __iomem *devm_ioremap_resource_wc(struct device *dev,
237 const struct resource *res);
238
239void __iomem *devm_of_iomap(struct device *dev,
240 struct device_node *node, int index,
241 resource_size_t *size);
242
243
244int devm_add_action(struct device *dev, void (*action)(void *), void *data);
245void devm_remove_action(struct device *dev, void (*action)(void *), void *data);
246void devm_release_action(struct device *dev, void (*action)(void *), void *data);
247
248static inline int devm_add_action_or_reset(struct device *dev,
249 void (*action)(void *), void *data)
250{
251 int ret;
252
253 ret = devm_add_action(dev, action, data);
254 if (ret)
255 action(data);
256
257 return ret;
258}
259
260
261
262
263
264
265
266
267
268
269
270
271#define devm_alloc_percpu(dev, type) \
272 ((typeof(type) __percpu *)__devm_alloc_percpu((dev), sizeof(type), \
273 __alignof__(type)))
274
275void __percpu *__devm_alloc_percpu(struct device *dev, size_t size,
276 size_t align);
277void devm_free_percpu(struct device *dev, void __percpu *pdata);
278
279struct device_dma_parameters {
280
281
282
283
284 unsigned int max_segment_size;
285 unsigned int min_align_mask;
286 unsigned long segment_boundary_mask;
287};
288
289
290
291
292
293
294
295
296
297
298enum device_link_state {
299 DL_STATE_NONE = -1,
300 DL_STATE_DORMANT = 0,
301 DL_STATE_AVAILABLE,
302 DL_STATE_CONSUMER_PROBE,
303 DL_STATE_ACTIVE,
304 DL_STATE_SUPPLIER_UNBIND,
305};
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320#define DL_FLAG_STATELESS BIT(0)
321#define DL_FLAG_AUTOREMOVE_CONSUMER BIT(1)
322#define DL_FLAG_PM_RUNTIME BIT(2)
323#define DL_FLAG_RPM_ACTIVE BIT(3)
324#define DL_FLAG_AUTOREMOVE_SUPPLIER BIT(4)
325#define DL_FLAG_AUTOPROBE_CONSUMER BIT(5)
326#define DL_FLAG_MANAGED BIT(6)
327#define DL_FLAG_SYNC_STATE_ONLY BIT(7)
328#define DL_FLAG_INFERRED BIT(8)
329
330
331
332
333
334
335
336
337enum dl_dev_state {
338 DL_DEV_NO_DRIVER = 0,
339 DL_DEV_PROBING,
340 DL_DEV_DRIVER_BOUND,
341 DL_DEV_UNBINDING,
342};
343
344
345
346
347
348
349
350
351
352
353enum device_removable {
354 DEVICE_REMOVABLE_NOT_SUPPORTED = 0,
355 DEVICE_REMOVABLE_UNKNOWN,
356 DEVICE_FIXED,
357 DEVICE_REMOVABLE,
358};
359
360
361
362
363
364
365
366
367struct dev_links_info {
368 struct list_head suppliers;
369 struct list_head consumers;
370 struct list_head defer_sync;
371 enum dl_dev_state status;
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
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473struct device {
474 struct kobject kobj;
475 struct device *parent;
476
477 struct device_private *p;
478
479 const char *init_name;
480 const struct device_type *type;
481
482 struct bus_type *bus;
483 struct device_driver *driver;
484
485 void *platform_data;
486
487 void *driver_data;
488
489#ifdef CONFIG_PROVE_LOCKING
490 struct mutex lockdep_mutex;
491#endif
492 struct mutex mutex;
493
494
495
496 struct dev_links_info links;
497 struct dev_pm_info power;
498 struct dev_pm_domain *pm_domain;
499
500#ifdef CONFIG_ENERGY_MODEL
501 struct em_perf_domain *em_pd;
502#endif
503
504#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
505 struct irq_domain *msi_domain;
506#endif
507#ifdef CONFIG_PINCTRL
508 struct dev_pin_info *pins;
509#endif
510#ifdef CONFIG_GENERIC_MSI_IRQ
511 raw_spinlock_t msi_lock;
512 struct list_head msi_list;
513#endif
514#ifdef CONFIG_DMA_OPS
515 const struct dma_map_ops *dma_ops;
516#endif
517 u64 *dma_mask;
518 u64 coherent_dma_mask;
519
520
521
522
523 u64 bus_dma_limit;
524 const struct bus_dma_region *dma_range_map;
525
526 struct device_dma_parameters *dma_parms;
527
528 struct list_head dma_pools;
529
530#ifdef CONFIG_DMA_DECLARE_COHERENT
531 struct dma_coherent_mem *dma_mem;
532
533#endif
534#ifdef CONFIG_DMA_CMA
535 struct cma *cma_area;
536
537#endif
538#ifdef CONFIG_SWIOTLB
539 struct io_tlb_mem *dma_io_tlb_mem;
540#endif
541
542 struct dev_archdata archdata;
543
544 struct device_node *of_node;
545 struct fwnode_handle *fwnode;
546
547#ifdef CONFIG_NUMA
548 int numa_node;
549#endif
550 dev_t devt;
551 u32 id;
552
553 spinlock_t devres_lock;
554 struct list_head devres_head;
555
556 struct class *class;
557 const struct attribute_group **groups;
558
559 void (*release)(struct device *dev);
560 struct iommu_group *iommu_group;
561 struct dev_iommu *iommu;
562
563 enum device_removable removable;
564
565 bool offline_disabled:1;
566 bool offline:1;
567 bool of_node_reused:1;
568 bool state_synced:1;
569 bool can_match:1;
570#if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \
571 defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
572 defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL)
573 bool dma_coherent:1;
574#endif
575#ifdef CONFIG_DMA_OPS_BYPASS
576 bool dma_ops_bypass : 1;
577#endif
578};
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594struct device_link {
595 struct device *supplier;
596 struct list_head s_node;
597 struct device *consumer;
598 struct list_head c_node;
599 struct device link_dev;
600 enum device_link_state status;
601 u32 flags;
602 refcount_t rpm_active;
603 struct kref kref;
604 struct work_struct rm_work;
605 bool supplier_preactivated;
606};
607
608static inline struct device *kobj_to_dev(struct kobject *kobj)
609{
610 return container_of(kobj, struct device, kobj);
611}
612
613
614
615
616
617
618static inline bool device_iommu_mapped(struct device *dev)
619{
620 return (dev->iommu_group != NULL);
621}
622
623
624#include <linux/pm_wakeup.h>
625
626static inline const char *dev_name(const struct device *dev)
627{
628
629 if (dev->init_name)
630 return dev->init_name;
631
632 return kobject_name(&dev->kobj);
633}
634
635
636
637
638
639
640
641
642static inline const char *dev_bus_name(const struct device *dev)
643{
644 return dev->bus ? dev->bus->name : (dev->class ? dev->class->name : "");
645}
646
647__printf(2, 3) int dev_set_name(struct device *dev, const char *name, ...);
648
649#ifdef CONFIG_NUMA
650static inline int dev_to_node(struct device *dev)
651{
652 return dev->numa_node;
653}
654static inline void set_dev_node(struct device *dev, int node)
655{
656 dev->numa_node = node;
657}
658#else
659static inline int dev_to_node(struct device *dev)
660{
661 return NUMA_NO_NODE;
662}
663static inline void set_dev_node(struct device *dev, int node)
664{
665}
666#endif
667
668static inline struct irq_domain *dev_get_msi_domain(const struct device *dev)
669{
670#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
671 return dev->msi_domain;
672#else
673 return NULL;
674#endif
675}
676
677static inline void dev_set_msi_domain(struct device *dev, struct irq_domain *d)
678{
679#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
680 dev->msi_domain = d;
681#endif
682}
683
684static inline void *dev_get_drvdata(const struct device *dev)
685{
686 return dev->driver_data;
687}
688
689static inline void dev_set_drvdata(struct device *dev, void *data)
690{
691 dev->driver_data = data;
692}
693
694static inline struct pm_subsys_data *dev_to_psd(struct device *dev)
695{
696 return dev ? dev->power.subsys_data : NULL;
697}
698
699static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
700{
701 return dev->kobj.uevent_suppress;
702}
703
704static inline void dev_set_uevent_suppress(struct device *dev, int val)
705{
706 dev->kobj.uevent_suppress = val;
707}
708
709static inline int device_is_registered(struct device *dev)
710{
711 return dev->kobj.state_in_sysfs;
712}
713
714static inline void device_enable_async_suspend(struct device *dev)
715{
716 if (!dev->power.is_prepared)
717 dev->power.async_suspend = true;
718}
719
720static inline void device_disable_async_suspend(struct device *dev)
721{
722 if (!dev->power.is_prepared)
723 dev->power.async_suspend = false;
724}
725
726static inline bool device_async_suspend_enabled(struct device *dev)
727{
728 return !!dev->power.async_suspend;
729}
730
731static inline bool device_pm_not_required(struct device *dev)
732{
733 return dev->power.no_pm;
734}
735
736static inline void device_set_pm_not_required(struct device *dev)
737{
738 dev->power.no_pm = true;
739}
740
741static inline void dev_pm_syscore_device(struct device *dev, bool val)
742{
743#ifdef CONFIG_PM_SLEEP
744 dev->power.syscore = val;
745#endif
746}
747
748static inline void dev_pm_set_driver_flags(struct device *dev, u32 flags)
749{
750 dev->power.driver_flags = flags;
751}
752
753static inline bool dev_pm_test_driver_flags(struct device *dev, u32 flags)
754{
755 return !!(dev->power.driver_flags & flags);
756}
757
758static inline void device_lock(struct device *dev)
759{
760 mutex_lock(&dev->mutex);
761}
762
763static inline int device_lock_interruptible(struct device *dev)
764{
765 return mutex_lock_interruptible(&dev->mutex);
766}
767
768static inline int device_trylock(struct device *dev)
769{
770 return mutex_trylock(&dev->mutex);
771}
772
773static inline void device_unlock(struct device *dev)
774{
775 mutex_unlock(&dev->mutex);
776}
777
778static inline void device_lock_assert(struct device *dev)
779{
780 lockdep_assert_held(&dev->mutex);
781}
782
783static inline struct device_node *dev_of_node(struct device *dev)
784{
785 if (!IS_ENABLED(CONFIG_OF) || !dev)
786 return NULL;
787 return dev->of_node;
788}
789
790static inline bool dev_has_sync_state(struct device *dev)
791{
792 if (!dev)
793 return false;
794 if (dev->driver && dev->driver->sync_state)
795 return true;
796 if (dev->bus && dev->bus->sync_state)
797 return true;
798 return false;
799}
800
801static inline void dev_set_removable(struct device *dev,
802 enum device_removable removable)
803{
804 dev->removable = removable;
805}
806
807static inline bool dev_is_removable(struct device *dev)
808{
809 return dev->removable == DEVICE_REMOVABLE;
810}
811
812static inline bool dev_removable_is_valid(struct device *dev)
813{
814 return dev->removable != DEVICE_REMOVABLE_NOT_SUPPORTED;
815}
816
817
818
819
820int __must_check device_register(struct device *dev);
821void device_unregister(struct device *dev);
822void device_initialize(struct device *dev);
823int __must_check device_add(struct device *dev);
824void device_del(struct device *dev);
825int device_for_each_child(struct device *dev, void *data,
826 int (*fn)(struct device *dev, void *data));
827int device_for_each_child_reverse(struct device *dev, void *data,
828 int (*fn)(struct device *dev, void *data));
829struct device *device_find_child(struct device *dev, void *data,
830 int (*match)(struct device *dev, void *data));
831struct device *device_find_child_by_name(struct device *parent,
832 const char *name);
833int device_rename(struct device *dev, const char *new_name);
834int device_move(struct device *dev, struct device *new_parent,
835 enum dpm_order dpm_order);
836int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid);
837const char *device_get_devnode(struct device *dev, umode_t *mode, kuid_t *uid,
838 kgid_t *gid, const char **tmp);
839int device_is_dependent(struct device *dev, void *target);
840
841static inline bool device_supports_offline(struct device *dev)
842{
843 return dev->bus && dev->bus->offline && dev->bus->online;
844}
845
846void lock_device_hotplug(void);
847void unlock_device_hotplug(void);
848int lock_device_hotplug_sysfs(void);
849int device_offline(struct device *dev);
850int device_online(struct device *dev);
851void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
852void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
853void device_set_of_node_from_dev(struct device *dev, const struct device *dev2);
854void device_set_node(struct device *dev, struct fwnode_handle *fwnode);
855
856static inline int dev_num_vf(struct device *dev)
857{
858 if (dev->bus && dev->bus->num_vf)
859 return dev->bus->num_vf(dev);
860 return 0;
861}
862
863
864
865
866struct device *__root_device_register(const char *name, struct module *owner);
867
868
869#define root_device_register(name) \
870 __root_device_register(name, THIS_MODULE)
871
872void root_device_unregister(struct device *root);
873
874static inline void *dev_get_platdata(const struct device *dev)
875{
876 return dev->platform_data;
877}
878
879
880
881
882
883int __must_check device_driver_attach(struct device_driver *drv,
884 struct device *dev);
885int __must_check device_bind_driver(struct device *dev);
886void device_release_driver(struct device *dev);
887int __must_check device_attach(struct device *dev);
888int __must_check driver_attach(struct device_driver *drv);
889void device_initial_probe(struct device *dev);
890int __must_check device_reprobe(struct device *dev);
891
892bool device_is_bound(struct device *dev);
893
894
895
896
897__printf(5, 6) struct device *
898device_create(struct class *cls, struct device *parent, dev_t devt,
899 void *drvdata, const char *fmt, ...);
900__printf(6, 7) struct device *
901device_create_with_groups(struct class *cls, struct device *parent, dev_t devt,
902 void *drvdata, const struct attribute_group **groups,
903 const char *fmt, ...);
904void device_destroy(struct class *cls, dev_t devt);
905
906int __must_check device_add_groups(struct device *dev,
907 const struct attribute_group **groups);
908void device_remove_groups(struct device *dev,
909 const struct attribute_group **groups);
910
911static inline int __must_check device_add_group(struct device *dev,
912 const struct attribute_group *grp)
913{
914 const struct attribute_group *groups[] = { grp, NULL };
915
916 return device_add_groups(dev, groups);
917}
918
919static inline void device_remove_group(struct device *dev,
920 const struct attribute_group *grp)
921{
922 const struct attribute_group *groups[] = { grp, NULL };
923
924 return device_remove_groups(dev, groups);
925}
926
927int __must_check devm_device_add_groups(struct device *dev,
928 const struct attribute_group **groups);
929void devm_device_remove_groups(struct device *dev,
930 const struct attribute_group **groups);
931int __must_check devm_device_add_group(struct device *dev,
932 const struct attribute_group *grp);
933void devm_device_remove_group(struct device *dev,
934 const struct attribute_group *grp);
935
936
937
938
939
940
941
942extern int (*platform_notify)(struct device *dev);
943
944extern int (*platform_notify_remove)(struct device *dev);
945
946
947
948
949
950
951struct device *get_device(struct device *dev);
952void put_device(struct device *dev);
953bool kill_device(struct device *dev);
954
955#ifdef CONFIG_DEVTMPFS
956int devtmpfs_mount(void);
957#else
958static inline int devtmpfs_mount(void) { return 0; }
959#endif
960
961
962void device_shutdown(void);
963
964
965const char *dev_driver_string(const struct device *dev);
966
967
968struct device_link *device_link_add(struct device *consumer,
969 struct device *supplier, u32 flags);
970void device_link_del(struct device_link *link);
971void device_link_remove(void *consumer, struct device *supplier);
972void device_links_supplier_sync_state_pause(void);
973void device_links_supplier_sync_state_resume(void);
974
975extern __printf(3, 4)
976int dev_err_probe(const struct device *dev, int err, const char *fmt, ...);
977
978
979#define MODULE_ALIAS_CHARDEV(major,minor) \
980 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
981#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
982 MODULE_ALIAS("char-major-" __stringify(major) "-*")
983
984#ifdef CONFIG_SYSFS_DEPRECATED
985extern long sysfs_deprecated;
986#else
987#define sysfs_deprecated 0
988#endif
989
990#endif
991