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