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
472struct device {
473 struct kobject kobj;
474 struct device *parent;
475
476 struct device_private *p;
477
478 const char *init_name;
479 const struct device_type *type;
480
481 struct bus_type *bus;
482 struct device_driver *driver;
483
484 void *platform_data;
485
486 void *driver_data;
487
488#ifdef CONFIG_PROVE_LOCKING
489 struct mutex lockdep_mutex;
490#endif
491 struct mutex mutex;
492
493
494
495 struct dev_links_info links;
496 struct dev_pm_info power;
497 struct dev_pm_domain *pm_domain;
498
499#ifdef CONFIG_ENERGY_MODEL
500 struct em_perf_domain *em_pd;
501#endif
502
503#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
504 struct irq_domain *msi_domain;
505#endif
506#ifdef CONFIG_PINCTRL
507 struct dev_pin_info *pins;
508#endif
509#ifdef CONFIG_GENERIC_MSI_IRQ
510 raw_spinlock_t msi_lock;
511 struct list_head msi_list;
512#endif
513#ifdef CONFIG_DMA_OPS
514 const struct dma_map_ops *dma_ops;
515#endif
516 u64 *dma_mask;
517 u64 coherent_dma_mask;
518
519
520
521
522 u64 bus_dma_limit;
523 const struct bus_dma_region *dma_range_map;
524
525 struct device_dma_parameters *dma_parms;
526
527 struct list_head dma_pools;
528
529#ifdef CONFIG_DMA_DECLARE_COHERENT
530 struct dma_coherent_mem *dma_mem;
531
532#endif
533#ifdef CONFIG_DMA_CMA
534 struct cma *cma_area;
535
536#endif
537
538 struct dev_archdata archdata;
539
540 struct device_node *of_node;
541 struct fwnode_handle *fwnode;
542
543#ifdef CONFIG_NUMA
544 int numa_node;
545#endif
546 dev_t devt;
547 u32 id;
548
549 spinlock_t devres_lock;
550 struct list_head devres_head;
551
552 struct class *class;
553 const struct attribute_group **groups;
554
555 void (*release)(struct device *dev);
556 struct iommu_group *iommu_group;
557 struct dev_iommu *iommu;
558
559 enum device_removable removable;
560
561 bool offline_disabled:1;
562 bool offline:1;
563 bool of_node_reused:1;
564 bool state_synced:1;
565 bool can_match:1;
566#if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \
567 defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
568 defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL)
569 bool dma_coherent:1;
570#endif
571#ifdef CONFIG_DMA_OPS_BYPASS
572 bool dma_ops_bypass : 1;
573#endif
574};
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590struct device_link {
591 struct device *supplier;
592 struct list_head s_node;
593 struct device *consumer;
594 struct list_head c_node;
595 struct device link_dev;
596 enum device_link_state status;
597 u32 flags;
598 refcount_t rpm_active;
599 struct kref kref;
600 struct work_struct rm_work;
601 bool supplier_preactivated;
602};
603
604static inline struct device *kobj_to_dev(struct kobject *kobj)
605{
606 return container_of(kobj, struct device, kobj);
607}
608
609
610
611
612
613
614static inline bool device_iommu_mapped(struct device *dev)
615{
616 return (dev->iommu_group != NULL);
617}
618
619
620#include <linux/pm_wakeup.h>
621
622static inline const char *dev_name(const struct device *dev)
623{
624
625 if (dev->init_name)
626 return dev->init_name;
627
628 return kobject_name(&dev->kobj);
629}
630
631
632
633
634
635
636
637
638static inline const char *dev_bus_name(const struct device *dev)
639{
640 return dev->bus ? dev->bus->name : (dev->class ? dev->class->name : "");
641}
642
643__printf(2, 3) int dev_set_name(struct device *dev, const char *name, ...);
644
645#ifdef CONFIG_NUMA
646static inline int dev_to_node(struct device *dev)
647{
648 return dev->numa_node;
649}
650static inline void set_dev_node(struct device *dev, int node)
651{
652 dev->numa_node = node;
653}
654#else
655static inline int dev_to_node(struct device *dev)
656{
657 return NUMA_NO_NODE;
658}
659static inline void set_dev_node(struct device *dev, int node)
660{
661}
662#endif
663
664static inline struct irq_domain *dev_get_msi_domain(const struct device *dev)
665{
666#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
667 return dev->msi_domain;
668#else
669 return NULL;
670#endif
671}
672
673static inline void dev_set_msi_domain(struct device *dev, struct irq_domain *d)
674{
675#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
676 dev->msi_domain = d;
677#endif
678}
679
680static inline void *dev_get_drvdata(const struct device *dev)
681{
682 return dev->driver_data;
683}
684
685static inline void dev_set_drvdata(struct device *dev, void *data)
686{
687 dev->driver_data = data;
688}
689
690static inline struct pm_subsys_data *dev_to_psd(struct device *dev)
691{
692 return dev ? dev->power.subsys_data : NULL;
693}
694
695static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
696{
697 return dev->kobj.uevent_suppress;
698}
699
700static inline void dev_set_uevent_suppress(struct device *dev, int val)
701{
702 dev->kobj.uevent_suppress = val;
703}
704
705static inline int device_is_registered(struct device *dev)
706{
707 return dev->kobj.state_in_sysfs;
708}
709
710static inline void device_enable_async_suspend(struct device *dev)
711{
712 if (!dev->power.is_prepared)
713 dev->power.async_suspend = true;
714}
715
716static inline void device_disable_async_suspend(struct device *dev)
717{
718 if (!dev->power.is_prepared)
719 dev->power.async_suspend = false;
720}
721
722static inline bool device_async_suspend_enabled(struct device *dev)
723{
724 return !!dev->power.async_suspend;
725}
726
727static inline bool device_pm_not_required(struct device *dev)
728{
729 return dev->power.no_pm;
730}
731
732static inline void device_set_pm_not_required(struct device *dev)
733{
734 dev->power.no_pm = true;
735}
736
737static inline void dev_pm_syscore_device(struct device *dev, bool val)
738{
739#ifdef CONFIG_PM_SLEEP
740 dev->power.syscore = val;
741#endif
742}
743
744static inline void dev_pm_set_driver_flags(struct device *dev, u32 flags)
745{
746 dev->power.driver_flags = flags;
747}
748
749static inline bool dev_pm_test_driver_flags(struct device *dev, u32 flags)
750{
751 return !!(dev->power.driver_flags & flags);
752}
753
754static inline void device_lock(struct device *dev)
755{
756 mutex_lock(&dev->mutex);
757}
758
759static inline int device_lock_interruptible(struct device *dev)
760{
761 return mutex_lock_interruptible(&dev->mutex);
762}
763
764static inline int device_trylock(struct device *dev)
765{
766 return mutex_trylock(&dev->mutex);
767}
768
769static inline void device_unlock(struct device *dev)
770{
771 mutex_unlock(&dev->mutex);
772}
773
774static inline void device_lock_assert(struct device *dev)
775{
776 lockdep_assert_held(&dev->mutex);
777}
778
779static inline struct device_node *dev_of_node(struct device *dev)
780{
781 if (!IS_ENABLED(CONFIG_OF) || !dev)
782 return NULL;
783 return dev->of_node;
784}
785
786static inline bool dev_has_sync_state(struct device *dev)
787{
788 if (!dev)
789 return false;
790 if (dev->driver && dev->driver->sync_state)
791 return true;
792 if (dev->bus && dev->bus->sync_state)
793 return true;
794 return false;
795}
796
797static inline void dev_set_removable(struct device *dev,
798 enum device_removable removable)
799{
800 dev->removable = removable;
801}
802
803static inline bool dev_is_removable(struct device *dev)
804{
805 return dev->removable == DEVICE_REMOVABLE;
806}
807
808static inline bool dev_removable_is_valid(struct device *dev)
809{
810 return dev->removable != DEVICE_REMOVABLE_NOT_SUPPORTED;
811}
812
813
814
815
816int __must_check device_register(struct device *dev);
817void device_unregister(struct device *dev);
818void device_initialize(struct device *dev);
819int __must_check device_add(struct device *dev);
820void device_del(struct device *dev);
821int device_for_each_child(struct device *dev, void *data,
822 int (*fn)(struct device *dev, void *data));
823int device_for_each_child_reverse(struct device *dev, void *data,
824 int (*fn)(struct device *dev, void *data));
825struct device *device_find_child(struct device *dev, void *data,
826 int (*match)(struct device *dev, void *data));
827struct device *device_find_child_by_name(struct device *parent,
828 const char *name);
829int device_rename(struct device *dev, const char *new_name);
830int device_move(struct device *dev, struct device *new_parent,
831 enum dpm_order dpm_order);
832int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid);
833const char *device_get_devnode(struct device *dev, umode_t *mode, kuid_t *uid,
834 kgid_t *gid, const char **tmp);
835int device_is_dependent(struct device *dev, void *target);
836
837static inline bool device_supports_offline(struct device *dev)
838{
839 return dev->bus && dev->bus->offline && dev->bus->online;
840}
841
842void lock_device_hotplug(void);
843void unlock_device_hotplug(void);
844int lock_device_hotplug_sysfs(void);
845int device_offline(struct device *dev);
846int device_online(struct device *dev);
847void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
848void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
849void device_set_of_node_from_dev(struct device *dev, const struct device *dev2);
850void device_set_node(struct device *dev, struct fwnode_handle *fwnode);
851
852static inline int dev_num_vf(struct device *dev)
853{
854 if (dev->bus && dev->bus->num_vf)
855 return dev->bus->num_vf(dev);
856 return 0;
857}
858
859
860
861
862struct device *__root_device_register(const char *name, struct module *owner);
863
864
865#define root_device_register(name) \
866 __root_device_register(name, THIS_MODULE)
867
868void root_device_unregister(struct device *root);
869
870static inline void *dev_get_platdata(const struct device *dev)
871{
872 return dev->platform_data;
873}
874
875
876
877
878
879int __must_check device_driver_attach(struct device_driver *drv,
880 struct device *dev);
881int __must_check device_bind_driver(struct device *dev);
882void device_release_driver(struct device *dev);
883int __must_check device_attach(struct device *dev);
884int __must_check driver_attach(struct device_driver *drv);
885void device_initial_probe(struct device *dev);
886int __must_check device_reprobe(struct device *dev);
887
888bool device_is_bound(struct device *dev);
889
890
891
892
893__printf(5, 6) struct device *
894device_create(struct class *cls, struct device *parent, dev_t devt,
895 void *drvdata, const char *fmt, ...);
896__printf(6, 7) struct device *
897device_create_with_groups(struct class *cls, struct device *parent, dev_t devt,
898 void *drvdata, const struct attribute_group **groups,
899 const char *fmt, ...);
900void device_destroy(struct class *cls, dev_t devt);
901
902int __must_check device_add_groups(struct device *dev,
903 const struct attribute_group **groups);
904void device_remove_groups(struct device *dev,
905 const struct attribute_group **groups);
906
907static inline int __must_check device_add_group(struct device *dev,
908 const struct attribute_group *grp)
909{
910 const struct attribute_group *groups[] = { grp, NULL };
911
912 return device_add_groups(dev, groups);
913}
914
915static inline void device_remove_group(struct device *dev,
916 const struct attribute_group *grp)
917{
918 const struct attribute_group *groups[] = { grp, NULL };
919
920 return device_remove_groups(dev, groups);
921}
922
923int __must_check devm_device_add_groups(struct device *dev,
924 const struct attribute_group **groups);
925void devm_device_remove_groups(struct device *dev,
926 const struct attribute_group **groups);
927int __must_check devm_device_add_group(struct device *dev,
928 const struct attribute_group *grp);
929void devm_device_remove_group(struct device *dev,
930 const struct attribute_group *grp);
931
932
933
934
935
936
937
938extern int (*platform_notify)(struct device *dev);
939
940extern int (*platform_notify_remove)(struct device *dev);
941
942
943
944
945
946
947struct device *get_device(struct device *dev);
948void put_device(struct device *dev);
949bool kill_device(struct device *dev);
950
951#ifdef CONFIG_DEVTMPFS
952int devtmpfs_mount(void);
953#else
954static inline int devtmpfs_mount(void) { return 0; }
955#endif
956
957
958void device_shutdown(void);
959
960
961const char *dev_driver_string(const struct device *dev);
962
963
964struct device_link *device_link_add(struct device *consumer,
965 struct device *supplier, u32 flags);
966void device_link_del(struct device_link *link);
967void device_link_remove(void *consumer, struct device *supplier);
968void device_links_supplier_sync_state_pause(void);
969void device_links_supplier_sync_state_resume(void);
970
971extern __printf(3, 4)
972int dev_err_probe(const struct device *dev, int err, const char *fmt, ...);
973
974
975#define MODULE_ALIAS_CHARDEV(major,minor) \
976 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
977#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
978 MODULE_ALIAS("char-major-" __stringify(major) "-*")
979
980#ifdef CONFIG_SYSFS_DEPRECATED
981extern long sysfs_deprecated;
982#else
983#define sysfs_deprecated 0
984#endif
985
986#endif
987