Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0-or-later */
2 : : /*
3 : : * acpi_bus.h - ACPI Bus Driver ($Revision: 22 $)
4 : : *
5 : : * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
6 : : * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
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 : : /* TBD: Make dynamic */
16 : : #define ACPI_MAX_HANDLES 10
17 : : struct acpi_handle_list {
18 : : u32 count;
19 : : acpi_handle handles[ACPI_MAX_HANDLES];
20 : : };
21 : :
22 : : /* acpi_utils.h */
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 : 0 : 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 : 0 : union acpi_object *obj;
61 : :
62 : 0 : obj = acpi_evaluate_dsm(handle, guid, rev, func, argv4);
63 [ # # # # ]: 0 : if (obj && obj->type != type) {
64 : 0 : ACPI_FREE(obj);
65 : 0 : obj = NULL;
66 : : }
67 : :
68 : 0 : 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 : : * ACPI Scan Handler
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 : 0 : static inline struct acpi_hotplug_profile *to_acpi_hotplug_profile(
116 : : struct kobject *kobj)
117 : : {
118 : 0 : 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 : : * ACPI Hotplug Context
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 : : * ACPI Driver
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 /* system AND device events */
160 : :
161 : : struct acpi_driver {
162 : : char name[80];
163 : : char class[80];
164 : : const struct acpi_device_id *ids; /* Supported Hardware IDs */
165 : : unsigned int flags;
166 : : struct acpi_device_ops ops;
167 : : struct device_driver drv;
168 : : struct module *owner;
169 : : };
170 : :
171 : : /*
172 : : * ACPI Device
173 : : * -----------
174 : : */
175 : :
176 : : /* Status (_STA) */
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 : : /* Flags */
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 : : /* File System */
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 : : /* Plug and Play */
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; /* Object name */
235 : : struct acpi_pnp_type type; /* ID type */
236 : : acpi_bus_address bus_address; /* _ADR */
237 : : char *unique_id; /* _UID */
238 : : struct list_head ids; /* _HID and _CIDs */
239 : : acpi_device_name device_name; /* Driver-determined */
240 : : acpi_device_class device_class; /* " */
241 : : union acpi_object *str_obj; /* unicode string for _STR method */
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 : : /* Power Management */
252 : :
253 : : struct acpi_device_power_flags {
254 : : u32 explicit_get:1; /* _PSC present? */
255 : : u32 power_resources:1; /* Power resources */
256 : : u32 inrush_current:1; /* Serialize Dx->D0 */
257 : : u32 power_removed:1; /* Optimize Dx->D0 */
258 : : u32 ignore_parent:1; /* Power is independent of parent power state */
259 : : u32 dsw_present:1; /* _DSW present? */
260 : : u32 reserved:26;
261 : : };
262 : :
263 : : struct acpi_device_power_state {
264 : : struct {
265 : : u8 valid:1;
266 : : u8 explicit_set:1; /* _PSx present? */
267 : : u8 reserved:6;
268 : : } flags;
269 : : int power; /* % Power (compared to D0) */
270 : : int latency; /* Dx->D0 time (microseconds) */
271 : : struct list_head resources; /* Power resources referenced */
272 : : };
273 : :
274 : : struct acpi_device_power {
275 : : int state; /* Current state */
276 : : struct acpi_device_power_flags flags;
277 : : struct acpi_device_power_state states[ACPI_D_STATE_COUNT]; /* Power states (D0-D3Cold) */
278 : : };
279 : :
280 : : /* Performance Management */
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; /* % Power (compared to P0) */
292 : : u8 performance; /* % Performance ( " ) */
293 : : int latency; /* Px->P0 time (microseconds) */
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 : : /* Wakeup Management */
304 : : struct acpi_device_wakeup_flags {
305 : : u8 valid:1; /* Can successfully enable wakeup? */
306 : : u8 notifier_present:1; /* Wake-up notify handler has been installed */
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 : : /* ACPI Device Specific Data (_DSD) */
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 : : /* Device */
350 : : struct acpi_device {
351 : : int device_type;
352 : : acpi_handle handle; /* no handle for fixed hardware */
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 : : /* Non-device subnode */
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 : 0 : static inline bool acpi_data_node_match(const struct fwnode_handle *fwnode,
431 : : const char *name)
432 : : {
433 [ # # ]: 0 : return is_acpi_data_node(fwnode) ?
434 [ # # # # : 0 : (!strcmp(to_acpi_data_node(fwnode)->name, name)) : false;
# # # # ]
435 : : }
436 : :
437 : 57 : static inline struct fwnode_handle *acpi_fwnode_handle(struct acpi_device *adev)
438 : : {
439 [ # # ]: 57 : return &adev->fwnode;
440 : : }
441 : :
442 : 21 : static inline void *acpi_driver_data(struct acpi_device *d)
443 : : {
444 [ - - + + : 21 : 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 : 516 : static inline void acpi_set_device_status(struct acpi_device *adev, u32 sta)
451 : : {
452 : 516 : *((u32 *)&adev->status) = sta;
453 : 0 : }
454 : :
455 : 102 : static inline void acpi_set_hp_context(struct acpi_device *adev,
456 : : struct acpi_hotplug_context *hp)
457 : : {
458 : 102 : hp->self = adev;
459 : 99 : adev->hp = hp;
460 : 3 : }
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 : : /* acpi_device.dev.bus == &acpi_bus_type */
468 : : extern struct bus_type acpi_bus_type;
469 : :
470 : : /*
471 : : * Events
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 : : * External Functions
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 : 0 : static inline bool acpi_device_enumerated(struct acpi_device *adev)
541 : : {
542 [ # # # # : 0 : return adev && adev->flags.initialized && adev->flags.visited;
# # # # #
# # # # #
# # ]
543 : : }
544 : :
545 : : /**
546 : : * module_acpi_driver(acpi_driver) - Helper macro for registering an ACPI driver
547 : : * @__acpi_driver: acpi_driver struct
548 : : *
549 : : * Helper macro for ACPI drivers which do not do anything special in module
550 : : * init/exit. This eliminates a lot of boilerplate. Each module may only
551 : : * use this macro once, and calling it replaces module_init() and module_exit()
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 : : * Bind physical devices with ACPI devices
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; /* downstream bus range */
578 : :
579 : : u32 osc_support_set; /* _OSC state of support bits */
580 : : u32 osc_control_set; /* _OSC state of control bits */
581 : : phys_addr_t mcfg_addr;
582 : : };
583 : :
584 : : /* helper */
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 : 3 : static inline bool acpi_device_power_manageable(struct acpi_device *adev)
667 : : {
668 [ - - - - : 3 : return adev->flags.power_manageable;
- - + - ]
669 : : }
670 : :
671 : 0 : static inline bool acpi_device_can_wakeup(struct acpi_device *adev)
672 : : {
673 [ # # # # : 0 : 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 : : bool acpi_dev_hid_uid_match(struct acpi_device *adev, const char *hid2, const char *uid2);
684 : :
685 : : struct acpi_device *
686 : : acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv);
687 : :
688 : 0 : static inline void acpi_dev_put(struct acpi_device *adev)
689 : : {
690 : 0 : put_device(&adev->dev);
691 : 0 : }
692 : : #else /* CONFIG_ACPI */
693 : :
694 : : static inline int register_acpi_bus_type(void *bus) { return 0; }
695 : : static inline int unregister_acpi_bus_type(void *bus) { return 0; }
696 : :
697 : : #endif /* CONFIG_ACPI */
698 : :
699 : : #endif /*__ACPI_BUS_H__*/
|
