This source file includes following definitions.
- acpi_evaluate_dsm_typed
- to_acpi_hotplug_profile
- is_acpi_node
- is_acpi_static_node
- acpi_data_node_match
- acpi_fwnode_handle
- acpi_driver_data
- acpi_set_device_status
- acpi_set_hp_context
- acpi_bus_can_wakeup
- acpi_device_enumerated
- acpi_device_always_present
- acpi_pm_wakeup_event
- acpi_add_pm_notifier
- acpi_remove_pm_notifier
- acpi_pm_device_can_wakeup
- acpi_pm_device_sleep_state
- acpi_pm_set_device_wakeup
- acpi_pm_set_bridge_wakeup
- acpi_sleep_state_supported
- acpi_target_system_state
- acpi_device_power_manageable
- acpi_device_can_wakeup
- acpi_device_can_poweroff
- acpi_dev_put
- register_acpi_bus_type
- unregister_acpi_bus_type
1
2
3
4
5
6
7
8
9 #ifndef __ACPI_BUS_H__
10 #define __ACPI_BUS_H__
11
12 #include <linux/device.h>
13 #include <linux/property.h>
14
15
16 #define ACPI_MAX_HANDLES 10
17 struct acpi_handle_list {
18 u32 count;
19 acpi_handle handles[ACPI_MAX_HANDLES];
20 };
21
22
23 acpi_status
24 acpi_extract_package(union acpi_object *package,
25 struct acpi_buffer *format, struct acpi_buffer *buffer);
26 acpi_status
27 acpi_evaluate_integer(acpi_handle handle,
28 acpi_string pathname,
29 struct acpi_object_list *arguments, unsigned long long *data);
30 acpi_status
31 acpi_evaluate_reference(acpi_handle handle,
32 acpi_string pathname,
33 struct acpi_object_list *arguments,
34 struct acpi_handle_list *list);
35 acpi_status
36 acpi_evaluate_ost(acpi_handle handle, u32 source_event, u32 status_code,
37 struct acpi_buffer *status_buf);
38
39 acpi_status
40 acpi_get_physical_device_location(acpi_handle handle, struct acpi_pld_info **pld);
41
42 bool acpi_has_method(acpi_handle handle, char *name);
43 acpi_status acpi_execute_simple_method(acpi_handle handle, char *method,
44 u64 arg);
45 acpi_status acpi_evaluate_ej0(acpi_handle handle);
46 acpi_status acpi_evaluate_lck(acpi_handle handle, int lock);
47 bool acpi_ata_match(acpi_handle handle);
48 bool acpi_bay_match(acpi_handle handle);
49 bool acpi_dock_match(acpi_handle handle);
50
51 bool acpi_check_dsm(acpi_handle handle, const guid_t *guid, u64 rev, u64 funcs);
52 union acpi_object *acpi_evaluate_dsm(acpi_handle handle, const guid_t *guid,
53 u64 rev, u64 func, union acpi_object *argv4);
54
55 static inline union acpi_object *
56 acpi_evaluate_dsm_typed(acpi_handle handle, const guid_t *guid, u64 rev,
57 u64 func, union acpi_object *argv4,
58 acpi_object_type type)
59 {
60 union acpi_object *obj;
61
62 obj = acpi_evaluate_dsm(handle, guid, rev, func, argv4);
63 if (obj && obj->type != type) {
64 ACPI_FREE(obj);
65 obj = NULL;
66 }
67
68 return obj;
69 }
70
71 #define ACPI_INIT_DSM_ARGV4(cnt, eles) \
72 { \
73 .package.type = ACPI_TYPE_PACKAGE, \
74 .package.count = (cnt), \
75 .package.elements = (eles) \
76 }
77
78 bool acpi_dev_found(const char *hid);
79 bool acpi_dev_present(const char *hid, const char *uid, s64 hrv);
80
81 #ifdef CONFIG_ACPI
82
83 #include <linux/proc_fs.h>
84
85 #define ACPI_BUS_FILE_ROOT "acpi"
86 extern struct proc_dir_entry *acpi_root_dir;
87
88 enum acpi_bus_device_type {
89 ACPI_BUS_TYPE_DEVICE = 0,
90 ACPI_BUS_TYPE_POWER,
91 ACPI_BUS_TYPE_PROCESSOR,
92 ACPI_BUS_TYPE_THERMAL,
93 ACPI_BUS_TYPE_POWER_BUTTON,
94 ACPI_BUS_TYPE_SLEEP_BUTTON,
95 ACPI_BUS_TYPE_ECDT_EC,
96 ACPI_BUS_DEVICE_TYPE_COUNT
97 };
98
99 struct acpi_driver;
100 struct acpi_device;
101
102
103
104
105
106
107 struct acpi_hotplug_profile {
108 struct kobject kobj;
109 int (*scan_dependent)(struct acpi_device *adev);
110 void (*notify_online)(struct acpi_device *adev);
111 bool enabled:1;
112 bool demand_offline:1;
113 };
114
115 static inline struct acpi_hotplug_profile *to_acpi_hotplug_profile(
116 struct kobject *kobj)
117 {
118 return container_of(kobj, struct acpi_hotplug_profile, kobj);
119 }
120
121 struct acpi_scan_handler {
122 const struct acpi_device_id *ids;
123 struct list_head list_node;
124 bool (*match)(const char *idstr, const struct acpi_device_id **matchid);
125 int (*attach)(struct acpi_device *dev, const struct acpi_device_id *id);
126 void (*detach)(struct acpi_device *dev);
127 void (*bind)(struct device *phys_dev);
128 void (*unbind)(struct device *phys_dev);
129 struct acpi_hotplug_profile hotplug;
130 };
131
132
133
134
135
136
137 struct acpi_hotplug_context {
138 struct acpi_device *self;
139 int (*notify)(struct acpi_device *, u32);
140 void (*uevent)(struct acpi_device *, u32);
141 void (*fixup)(struct acpi_device *);
142 };
143
144
145
146
147
148
149 typedef int (*acpi_op_add) (struct acpi_device * device);
150 typedef int (*acpi_op_remove) (struct acpi_device * device);
151 typedef void (*acpi_op_notify) (struct acpi_device * device, u32 event);
152
153 struct acpi_device_ops {
154 acpi_op_add add;
155 acpi_op_remove remove;
156 acpi_op_notify notify;
157 };
158
159 #define ACPI_DRIVER_ALL_NOTIFY_EVENTS 0x1
160
161 struct acpi_driver {
162 char name[80];
163 char class[80];
164 const struct acpi_device_id *ids;
165 unsigned int flags;
166 struct acpi_device_ops ops;
167 struct device_driver drv;
168 struct module *owner;
169 };
170
171
172
173
174
175
176
177
178 struct acpi_device_status {
179 u32 present:1;
180 u32 enabled:1;
181 u32 show_in_ui:1;
182 u32 functional:1;
183 u32 battery_present:1;
184 u32 reserved:27;
185 };
186
187
188
189 struct acpi_device_flags {
190 u32 dynamic_status:1;
191 u32 removable:1;
192 u32 ejectable:1;
193 u32 power_manageable:1;
194 u32 match_driver:1;
195 u32 initialized:1;
196 u32 visited:1;
197 u32 hotplug_notify:1;
198 u32 is_dock_station:1;
199 u32 of_compatible_ok:1;
200 u32 coherent_dma:1;
201 u32 cca_seen:1;
202 u32 enumeration_by_parent:1;
203 u32 reserved:19;
204 };
205
206
207
208 struct acpi_device_dir {
209 struct proc_dir_entry *entry;
210 };
211
212 #define acpi_device_dir(d) ((d)->dir.entry)
213
214
215
216 typedef char acpi_bus_id[8];
217 typedef u64 acpi_bus_address;
218 typedef char acpi_device_name[40];
219 typedef char acpi_device_class[20];
220
221 struct acpi_hardware_id {
222 struct list_head list;
223 const char *id;
224 };
225
226 struct acpi_pnp_type {
227 u32 hardware_id:1;
228 u32 bus_address:1;
229 u32 platform_id:1;
230 u32 reserved:29;
231 };
232
233 struct acpi_device_pnp {
234 acpi_bus_id bus_id;
235 struct acpi_pnp_type type;
236 acpi_bus_address bus_address;
237 char *unique_id;
238 struct list_head ids;
239 acpi_device_name device_name;
240 acpi_device_class device_class;
241 union acpi_object *str_obj;
242 };
243
244 #define acpi_device_bid(d) ((d)->pnp.bus_id)
245 #define acpi_device_adr(d) ((d)->pnp.bus_address)
246 const char *acpi_device_hid(struct acpi_device *device);
247 #define acpi_device_uid(d) ((d)->pnp.unique_id)
248 #define acpi_device_name(d) ((d)->pnp.device_name)
249 #define acpi_device_class(d) ((d)->pnp.device_class)
250
251
252
253 struct acpi_device_power_flags {
254 u32 explicit_get:1;
255 u32 power_resources:1;
256 u32 inrush_current:1;
257 u32 power_removed:1;
258 u32 ignore_parent:1;
259 u32 dsw_present:1;
260 u32 reserved:26;
261 };
262
263 struct acpi_device_power_state {
264 struct {
265 u8 valid:1;
266 u8 explicit_set:1;
267 u8 reserved:6;
268 } flags;
269 int power;
270 int latency;
271 struct list_head resources;
272 };
273
274 struct acpi_device_power {
275 int state;
276 struct acpi_device_power_flags flags;
277 struct acpi_device_power_state states[ACPI_D_STATE_COUNT];
278 };
279
280
281
282 struct acpi_device_perf_flags {
283 u8 reserved:8;
284 };
285
286 struct acpi_device_perf_state {
287 struct {
288 u8 valid:1;
289 u8 reserved:7;
290 } flags;
291 u8 power;
292 u8 performance;
293 int latency;
294 };
295
296 struct acpi_device_perf {
297 int state;
298 struct acpi_device_perf_flags flags;
299 int state_count;
300 struct acpi_device_perf_state *states;
301 };
302
303
304 struct acpi_device_wakeup_flags {
305 u8 valid:1;
306 u8 notifier_present:1;
307 };
308
309 struct acpi_device_wakeup_context {
310 void (*func)(struct acpi_device_wakeup_context *context);
311 struct device *dev;
312 };
313
314 struct acpi_device_wakeup {
315 acpi_handle gpe_device;
316 u64 gpe_number;
317 u64 sleep_state;
318 struct list_head resources;
319 struct acpi_device_wakeup_flags flags;
320 struct acpi_device_wakeup_context context;
321 struct wakeup_source *ws;
322 int prepare_count;
323 int enable_count;
324 };
325
326 struct acpi_device_physical_node {
327 unsigned int node_id;
328 struct list_head node;
329 struct device *dev;
330 bool put_online:1;
331 };
332
333 struct acpi_device_properties {
334 const guid_t *guid;
335 const union acpi_object *properties;
336 struct list_head list;
337 };
338
339
340 struct acpi_device_data {
341 const union acpi_object *pointer;
342 struct list_head properties;
343 const union acpi_object *of_compatible;
344 struct list_head subnodes;
345 };
346
347 struct acpi_gpio_mapping;
348
349
350 struct acpi_device {
351 int device_type;
352 acpi_handle handle;
353 struct fwnode_handle fwnode;
354 struct acpi_device *parent;
355 struct list_head children;
356 struct list_head node;
357 struct list_head wakeup_list;
358 struct list_head del_list;
359 struct acpi_device_status status;
360 struct acpi_device_flags flags;
361 struct acpi_device_pnp pnp;
362 struct acpi_device_power power;
363 struct acpi_device_wakeup wakeup;
364 struct acpi_device_perf performance;
365 struct acpi_device_dir dir;
366 struct acpi_device_data data;
367 struct acpi_scan_handler *handler;
368 struct acpi_hotplug_context *hp;
369 struct acpi_driver *driver;
370 const struct acpi_gpio_mapping *driver_gpios;
371 void *driver_data;
372 struct device dev;
373 unsigned int physical_node_count;
374 unsigned int dep_unmet;
375 struct list_head physical_node_list;
376 struct mutex physical_node_lock;
377 void (*remove)(struct acpi_device *);
378 };
379
380
381 struct acpi_data_node {
382 const char *name;
383 acpi_handle handle;
384 struct fwnode_handle fwnode;
385 struct fwnode_handle *parent;
386 struct acpi_device_data data;
387 struct list_head sibling;
388 struct kobject kobj;
389 struct completion kobj_done;
390 };
391
392 extern const struct fwnode_operations acpi_device_fwnode_ops;
393 extern const struct fwnode_operations acpi_data_fwnode_ops;
394 extern const struct fwnode_operations acpi_static_fwnode_ops;
395
396 bool is_acpi_device_node(const struct fwnode_handle *fwnode);
397 bool is_acpi_data_node(const struct fwnode_handle *fwnode);
398
399 static inline bool is_acpi_node(const struct fwnode_handle *fwnode)
400 {
401 return (is_acpi_device_node(fwnode) || is_acpi_data_node(fwnode));
402 }
403
404 #define to_acpi_device_node(__fwnode) \
405 ({ \
406 typeof(__fwnode) __to_acpi_device_node_fwnode = __fwnode; \
407 \
408 is_acpi_device_node(__to_acpi_device_node_fwnode) ? \
409 container_of(__to_acpi_device_node_fwnode, \
410 struct acpi_device, fwnode) : \
411 NULL; \
412 })
413
414 #define to_acpi_data_node(__fwnode) \
415 ({ \
416 typeof(__fwnode) __to_acpi_data_node_fwnode = __fwnode; \
417 \
418 is_acpi_data_node(__to_acpi_data_node_fwnode) ? \
419 container_of(__to_acpi_data_node_fwnode, \
420 struct acpi_data_node, fwnode) : \
421 NULL; \
422 })
423
424 static inline bool is_acpi_static_node(const struct fwnode_handle *fwnode)
425 {
426 return !IS_ERR_OR_NULL(fwnode) &&
427 fwnode->ops == &acpi_static_fwnode_ops;
428 }
429
430 static inline bool acpi_data_node_match(const struct fwnode_handle *fwnode,
431 const char *name)
432 {
433 return is_acpi_data_node(fwnode) ?
434 (!strcmp(to_acpi_data_node(fwnode)->name, name)) : false;
435 }
436
437 static inline struct fwnode_handle *acpi_fwnode_handle(struct acpi_device *adev)
438 {
439 return &adev->fwnode;
440 }
441
442 static inline void *acpi_driver_data(struct acpi_device *d)
443 {
444 return d->driver_data;
445 }
446
447 #define to_acpi_device(d) container_of(d, struct acpi_device, dev)
448 #define to_acpi_driver(d) container_of(d, struct acpi_driver, drv)
449
450 static inline void acpi_set_device_status(struct acpi_device *adev, u32 sta)
451 {
452 *((u32 *)&adev->status) = sta;
453 }
454
455 static inline void acpi_set_hp_context(struct acpi_device *adev,
456 struct acpi_hotplug_context *hp)
457 {
458 hp->self = adev;
459 adev->hp = hp;
460 }
461
462 void acpi_initialize_hp_context(struct acpi_device *adev,
463 struct acpi_hotplug_context *hp,
464 int (*notify)(struct acpi_device *, u32),
465 void (*uevent)(struct acpi_device *, u32));
466
467
468 extern struct bus_type acpi_bus_type;
469
470
471
472
473
474
475 struct acpi_bus_event {
476 struct list_head node;
477 acpi_device_class device_class;
478 acpi_bus_id bus_id;
479 u32 type;
480 u32 data;
481 };
482
483 extern struct kobject *acpi_kobj;
484 extern int acpi_bus_generate_netlink_event(const char*, const char*, u8, int);
485 void acpi_bus_private_data_handler(acpi_handle, void *);
486 int acpi_bus_get_private_data(acpi_handle, void **);
487 int acpi_bus_attach_private_data(acpi_handle, void *);
488 void acpi_bus_detach_private_data(acpi_handle);
489 extern int acpi_notifier_call_chain(struct acpi_device *, u32, u32);
490 extern int register_acpi_notifier(struct notifier_block *);
491 extern int unregister_acpi_notifier(struct notifier_block *);
492
493
494
495
496
497 int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device);
498 struct acpi_device *acpi_bus_get_acpi_device(acpi_handle handle);
499 void acpi_bus_put_acpi_device(struct acpi_device *adev);
500 acpi_status acpi_bus_get_status_handle(acpi_handle handle,
501 unsigned long long *sta);
502 int acpi_bus_get_status(struct acpi_device *device);
503
504 int acpi_bus_set_power(acpi_handle handle, int state);
505 const char *acpi_power_state_string(int state);
506 int acpi_device_set_power(struct acpi_device *device, int state);
507 int acpi_bus_init_power(struct acpi_device *device);
508 int acpi_device_fix_up_power(struct acpi_device *device);
509 int acpi_bus_update_power(acpi_handle handle, int *state_p);
510 int acpi_device_update_power(struct acpi_device *device, int *state_p);
511 bool acpi_bus_power_manageable(acpi_handle handle);
512 int acpi_device_power_add_dependent(struct acpi_device *adev,
513 struct device *dev);
514 void acpi_device_power_remove_dependent(struct acpi_device *adev,
515 struct device *dev);
516
517 #ifdef CONFIG_PM
518 bool acpi_bus_can_wakeup(acpi_handle handle);
519 #else
520 static inline bool acpi_bus_can_wakeup(acpi_handle handle) { return false; }
521 #endif
522
523 void acpi_scan_lock_acquire(void);
524 void acpi_scan_lock_release(void);
525 void acpi_lock_hp_context(void);
526 void acpi_unlock_hp_context(void);
527 int acpi_scan_add_handler(struct acpi_scan_handler *handler);
528 int acpi_bus_register_driver(struct acpi_driver *driver);
529 void acpi_bus_unregister_driver(struct acpi_driver *driver);
530 int acpi_bus_scan(acpi_handle handle);
531 void acpi_bus_trim(struct acpi_device *start);
532 acpi_status acpi_bus_get_ejd(acpi_handle handle, acpi_handle * ejd);
533 int acpi_match_device_ids(struct acpi_device *device,
534 const struct acpi_device_id *ids);
535 void acpi_set_modalias(struct acpi_device *adev, const char *default_id,
536 char *modalias, size_t len);
537 int acpi_create_dir(struct acpi_device *);
538 void acpi_remove_dir(struct acpi_device *);
539
540 static inline bool acpi_device_enumerated(struct acpi_device *adev)
541 {
542 return adev && adev->flags.initialized && adev->flags.visited;
543 }
544
545
546
547
548
549
550
551
552
553 #define module_acpi_driver(__acpi_driver) \
554 module_driver(__acpi_driver, acpi_bus_register_driver, \
555 acpi_bus_unregister_driver)
556
557
558
559
560 struct acpi_bus_type {
561 struct list_head list;
562 const char *name;
563 bool (*match)(struct device *dev);
564 struct acpi_device * (*find_companion)(struct device *);
565 void (*setup)(struct device *);
566 void (*cleanup)(struct device *);
567 };
568 int register_acpi_bus_type(struct acpi_bus_type *);
569 int unregister_acpi_bus_type(struct acpi_bus_type *);
570 int acpi_bind_one(struct device *dev, struct acpi_device *adev);
571 int acpi_unbind_one(struct device *dev);
572
573 struct acpi_pci_root {
574 struct acpi_device * device;
575 struct pci_bus *bus;
576 u16 segment;
577 struct resource secondary;
578
579 u32 osc_support_set;
580 u32 osc_control_set;
581 phys_addr_t mcfg_addr;
582 };
583
584
585
586 bool acpi_dma_supported(struct acpi_device *adev);
587 enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev);
588 int acpi_dma_get_range(struct device *dev, u64 *dma_addr, u64 *offset,
589 u64 *size);
590 int acpi_dma_configure(struct device *dev, enum dev_dma_attr attr);
591
592 struct acpi_device *acpi_find_child_device(struct acpi_device *parent,
593 u64 address, bool check_children);
594 int acpi_is_root_bridge(acpi_handle);
595 struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle);
596
597 int acpi_enable_wakeup_device_power(struct acpi_device *dev, int state);
598 int acpi_disable_wakeup_device_power(struct acpi_device *dev);
599
600 #ifdef CONFIG_X86
601 bool acpi_device_always_present(struct acpi_device *adev);
602 #else
603 static inline bool acpi_device_always_present(struct acpi_device *adev)
604 {
605 return false;
606 }
607 #endif
608
609 #ifdef CONFIG_PM
610 void acpi_pm_wakeup_event(struct device *dev);
611 acpi_status acpi_add_pm_notifier(struct acpi_device *adev, struct device *dev,
612 void (*func)(struct acpi_device_wakeup_context *context));
613 acpi_status acpi_remove_pm_notifier(struct acpi_device *adev);
614 bool acpi_pm_device_can_wakeup(struct device *dev);
615 int acpi_pm_device_sleep_state(struct device *, int *, int);
616 int acpi_pm_set_device_wakeup(struct device *dev, bool enable);
617 int acpi_pm_set_bridge_wakeup(struct device *dev, bool enable);
618 #else
619 static inline void acpi_pm_wakeup_event(struct device *dev)
620 {
621 }
622 static inline acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
623 struct device *dev,
624 void (*func)(struct acpi_device_wakeup_context *context))
625 {
626 return AE_SUPPORT;
627 }
628 static inline acpi_status acpi_remove_pm_notifier(struct acpi_device *adev)
629 {
630 return AE_SUPPORT;
631 }
632 static inline bool acpi_pm_device_can_wakeup(struct device *dev)
633 {
634 return false;
635 }
636 static inline int acpi_pm_device_sleep_state(struct device *d, int *p, int m)
637 {
638 if (p)
639 *p = ACPI_STATE_D0;
640
641 return (m >= ACPI_STATE_D0 && m <= ACPI_STATE_D3_COLD) ?
642 m : ACPI_STATE_D0;
643 }
644 static inline int acpi_pm_set_device_wakeup(struct device *dev, bool enable)
645 {
646 return -ENODEV;
647 }
648 static inline int acpi_pm_set_bridge_wakeup(struct device *dev, bool enable)
649 {
650 return -ENODEV;
651 }
652 #endif
653
654 #ifdef CONFIG_ACPI_SYSTEM_POWER_STATES_SUPPORT
655 bool acpi_sleep_state_supported(u8 sleep_state);
656 #else
657 static inline bool acpi_sleep_state_supported(u8 sleep_state) { return false; }
658 #endif
659
660 #ifdef CONFIG_ACPI_SLEEP
661 u32 acpi_target_system_state(void);
662 #else
663 static inline u32 acpi_target_system_state(void) { return ACPI_STATE_S0; }
664 #endif
665
666 static inline bool acpi_device_power_manageable(struct acpi_device *adev)
667 {
668 return adev->flags.power_manageable;
669 }
670
671 static inline bool acpi_device_can_wakeup(struct acpi_device *adev)
672 {
673 return adev->wakeup.flags.valid;
674 }
675
676 static inline bool acpi_device_can_poweroff(struct acpi_device *adev)
677 {
678 return adev->power.states[ACPI_STATE_D3_COLD].flags.valid ||
679 ((acpi_gbl_FADT.header.revision < 6) &&
680 adev->power.states[ACPI_STATE_D3_HOT].flags.explicit_set);
681 }
682
683 struct acpi_device *
684 acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv);
685
686 static inline void acpi_dev_put(struct acpi_device *adev)
687 {
688 put_device(&adev->dev);
689 }
690 #else
691
692 static inline int register_acpi_bus_type(void *bus) { return 0; }
693 static inline int unregister_acpi_bus_type(void *bus) { return 0; }
694
695 #endif
696
697 #endif