1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#ifndef __ACPI_BUS_H__
27#define __ACPI_BUS_H__
28
29#include <linux/device.h>
30
31
32#define ACPI_MAX_HANDLES 10
33struct acpi_handle_list {
34 u32 count;
35 acpi_handle handles[ACPI_MAX_HANDLES];
36};
37
38
39acpi_status
40acpi_extract_package(union acpi_object *package,
41 struct acpi_buffer *format, struct acpi_buffer *buffer);
42acpi_status
43acpi_evaluate_integer(acpi_handle handle,
44 acpi_string pathname,
45 struct acpi_object_list *arguments, unsigned long long *data);
46acpi_status
47acpi_evaluate_reference(acpi_handle handle,
48 acpi_string pathname,
49 struct acpi_object_list *arguments,
50 struct acpi_handle_list *list);
51acpi_status
52acpi_evaluate_hotplug_ost(acpi_handle handle, u32 source_event,
53 u32 status_code, struct acpi_buffer *status_buf);
54
55acpi_status
56acpi_get_physical_device_location(acpi_handle handle, struct acpi_pld_info **pld);
57
58bool acpi_has_method(acpi_handle handle, char *name);
59acpi_status acpi_execute_simple_method(acpi_handle handle, char *method,
60 u64 arg);
61acpi_status acpi_evaluate_ej0(acpi_handle handle);
62acpi_status acpi_evaluate_lck(acpi_handle handle, int lock);
63bool acpi_ata_match(acpi_handle handle);
64bool acpi_bay_match(acpi_handle handle);
65bool acpi_dock_match(acpi_handle handle);
66
67bool acpi_check_dsm(acpi_handle handle, const u8 *uuid, int rev, u64 funcs);
68union acpi_object *acpi_evaluate_dsm(acpi_handle handle, const u8 *uuid,
69 int rev, int func, union acpi_object *argv4);
70
71static inline union acpi_object *
72acpi_evaluate_dsm_typed(acpi_handle handle, const u8 *uuid, int rev, int func,
73 union acpi_object *argv4, acpi_object_type type)
74{
75 union acpi_object *obj;
76
77 obj = acpi_evaluate_dsm(handle, uuid, rev, func, argv4);
78 if (obj && obj->type != type) {
79 ACPI_FREE(obj);
80 obj = NULL;
81 }
82
83 return obj;
84}
85
86#define ACPI_INIT_DSM_ARGV4(cnt, eles) \
87 { \
88 .package.type = ACPI_TYPE_PACKAGE, \
89 .package.count = (cnt), \
90 .package.elements = (eles) \
91 }
92
93#ifdef CONFIG_ACPI
94
95#include <linux/proc_fs.h>
96
97#define ACPI_BUS_FILE_ROOT "acpi"
98extern struct proc_dir_entry *acpi_root_dir;
99
100enum acpi_bus_device_type {
101 ACPI_BUS_TYPE_DEVICE = 0,
102 ACPI_BUS_TYPE_POWER,
103 ACPI_BUS_TYPE_PROCESSOR,
104 ACPI_BUS_TYPE_THERMAL,
105 ACPI_BUS_TYPE_POWER_BUTTON,
106 ACPI_BUS_TYPE_SLEEP_BUTTON,
107 ACPI_BUS_DEVICE_TYPE_COUNT
108};
109
110struct acpi_driver;
111struct acpi_device;
112
113
114
115
116
117
118struct acpi_hotplug_profile {
119 struct kobject kobj;
120 int (*scan_dependent)(struct acpi_device *adev);
121 bool enabled:1;
122 bool demand_offline:1;
123};
124
125static inline struct acpi_hotplug_profile *to_acpi_hotplug_profile(
126 struct kobject *kobj)
127{
128 return container_of(kobj, struct acpi_hotplug_profile, kobj);
129}
130
131struct acpi_scan_handler {
132 const struct acpi_device_id *ids;
133 struct list_head list_node;
134 int (*attach)(struct acpi_device *dev, const struct acpi_device_id *id);
135 void (*detach)(struct acpi_device *dev);
136 struct acpi_hotplug_profile hotplug;
137};
138
139
140
141
142
143
144typedef int (*acpi_op_add) (struct acpi_device * device);
145typedef int (*acpi_op_remove) (struct acpi_device * device);
146typedef void (*acpi_op_notify) (struct acpi_device * device, u32 event);
147
148struct acpi_device_ops {
149 acpi_op_add add;
150 acpi_op_remove remove;
151 acpi_op_notify notify;
152};
153
154#define ACPI_DRIVER_ALL_NOTIFY_EVENTS 0x1
155
156struct acpi_driver {
157 char name[80];
158 char class[80];
159 const struct acpi_device_id *ids;
160 unsigned int flags;
161 struct acpi_device_ops ops;
162 struct device_driver drv;
163 struct module *owner;
164};
165
166
167
168
169
170
171
172
173struct acpi_device_status {
174 u32 present:1;
175 u32 enabled:1;
176 u32 show_in_ui:1;
177 u32 functional:1;
178 u32 battery_present:1;
179 u32 reserved:27;
180};
181
182
183
184struct acpi_device_flags {
185 u32 dynamic_status:1;
186 u32 removable:1;
187 u32 ejectable:1;
188 u32 power_manageable:1;
189 u32 match_driver:1;
190 u32 initialized:1;
191 u32 visited:1;
192 u32 no_hotplug:1;
193 u32 reserved:24;
194};
195
196
197
198struct acpi_device_dir {
199 struct proc_dir_entry *entry;
200};
201
202#define acpi_device_dir(d) ((d)->dir.entry)
203
204
205
206typedef char acpi_bus_id[8];
207typedef unsigned long acpi_bus_address;
208typedef char acpi_device_name[40];
209typedef char acpi_device_class[20];
210
211struct acpi_hardware_id {
212 struct list_head list;
213 char *id;
214};
215
216struct acpi_pnp_type {
217 u32 hardware_id:1;
218 u32 bus_address:1;
219 u32 reserved:30;
220};
221
222struct acpi_device_pnp {
223 acpi_bus_id bus_id;
224 struct acpi_pnp_type type;
225 acpi_bus_address bus_address;
226 char *unique_id;
227 struct list_head ids;
228 acpi_device_name device_name;
229 acpi_device_class device_class;
230 union acpi_object *str_obj;
231 unsigned long sun;
232};
233
234#define acpi_device_bid(d) ((d)->pnp.bus_id)
235#define acpi_device_adr(d) ((d)->pnp.bus_address)
236const char *acpi_device_hid(struct acpi_device *device);
237#define acpi_device_name(d) ((d)->pnp.device_name)
238#define acpi_device_class(d) ((d)->pnp.device_class)
239
240
241
242struct acpi_device_power_flags {
243 u32 explicit_get:1;
244 u32 power_resources:1;
245 u32 inrush_current:1;
246 u32 power_removed:1;
247 u32 ignore_parent:1;
248 u32 reserved:27;
249};
250
251struct acpi_device_power_state {
252 struct {
253 u8 valid:1;
254 u8 os_accessible:1;
255 u8 explicit_set:1;
256 u8 reserved:6;
257 } flags;
258 int power;
259 int latency;
260 struct list_head resources;
261};
262
263struct acpi_device_power {
264 int state;
265 struct acpi_device_power_flags flags;
266 struct acpi_device_power_state states[ACPI_D_STATE_COUNT];
267};
268
269
270
271struct acpi_device_perf_flags {
272 u8 reserved:8;
273};
274
275struct acpi_device_perf_state {
276 struct {
277 u8 valid:1;
278 u8 reserved:7;
279 } flags;
280 u8 power;
281 u8 performance;
282 int latency;
283};
284
285struct acpi_device_perf {
286 int state;
287 struct acpi_device_perf_flags flags;
288 int state_count;
289 struct acpi_device_perf_state *states;
290};
291
292
293struct acpi_device_wakeup_flags {
294 u8 valid:1;
295 u8 run_wake:1;
296 u8 notifier_present:1;
297};
298
299struct acpi_device_wakeup {
300 acpi_handle gpe_device;
301 u64 gpe_number;
302 u64 sleep_state;
303 struct list_head resources;
304 struct acpi_device_wakeup_flags flags;
305 int prepare_count;
306};
307
308struct acpi_device_physical_node {
309 unsigned int node_id;
310 struct list_head node;
311 struct device *dev;
312 bool put_online:1;
313};
314
315
316struct acpi_device {
317 int device_type;
318 acpi_handle handle;
319 struct acpi_device *parent;
320 struct list_head children;
321 struct list_head node;
322 struct list_head wakeup_list;
323 struct list_head del_list;
324 struct acpi_device_status status;
325 struct acpi_device_flags flags;
326 struct acpi_device_pnp pnp;
327 struct acpi_device_power power;
328 struct acpi_device_wakeup wakeup;
329 struct acpi_device_perf performance;
330 struct acpi_device_dir dir;
331 struct acpi_scan_handler *handler;
332 struct acpi_driver *driver;
333 void *driver_data;
334 struct device dev;
335 unsigned int physical_node_count;
336 struct list_head physical_node_list;
337 struct mutex physical_node_lock;
338 void (*remove)(struct acpi_device *);
339};
340
341static inline void *acpi_driver_data(struct acpi_device *d)
342{
343 return d->driver_data;
344}
345
346#define to_acpi_device(d) container_of(d, struct acpi_device, dev)
347#define to_acpi_driver(d) container_of(d, struct acpi_driver, drv)
348
349static inline void acpi_set_device_status(struct acpi_device *adev, u32 sta)
350{
351 *((u32 *)&adev->status) = sta;
352}
353
354
355extern struct bus_type acpi_bus_type;
356
357
358
359
360
361
362struct acpi_bus_event {
363 struct list_head node;
364 acpi_device_class device_class;
365 acpi_bus_id bus_id;
366 u32 type;
367 u32 data;
368};
369
370extern struct kobject *acpi_kobj;
371extern int acpi_bus_generate_netlink_event(const char*, const char*, u8, int);
372void acpi_bus_private_data_handler(acpi_handle, void *);
373int acpi_bus_get_private_data(acpi_handle, void **);
374void acpi_bus_no_hotplug(acpi_handle handle);
375extern int acpi_notifier_call_chain(struct acpi_device *, u32, u32);
376extern int register_acpi_notifier(struct notifier_block *);
377extern int unregister_acpi_notifier(struct notifier_block *);
378
379
380
381
382
383int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device);
384acpi_status acpi_bus_get_status_handle(acpi_handle handle,
385 unsigned long long *sta);
386int acpi_bus_get_status(struct acpi_device *device);
387
388int acpi_bus_set_power(acpi_handle handle, int state);
389const char *acpi_power_state_string(int state);
390int acpi_device_get_power(struct acpi_device *device, int *state);
391int acpi_device_set_power(struct acpi_device *device, int state);
392int acpi_bus_init_power(struct acpi_device *device);
393int acpi_device_fix_up_power(struct acpi_device *device);
394int acpi_bus_update_power(acpi_handle handle, int *state_p);
395bool acpi_bus_power_manageable(acpi_handle handle);
396
397#ifdef CONFIG_PM
398bool acpi_bus_can_wakeup(acpi_handle handle);
399#else
400static inline bool acpi_bus_can_wakeup(acpi_handle handle) { return false; }
401#endif
402
403void acpi_scan_lock_acquire(void);
404void acpi_scan_lock_release(void);
405int acpi_scan_add_handler(struct acpi_scan_handler *handler);
406int acpi_bus_register_driver(struct acpi_driver *driver);
407void acpi_bus_unregister_driver(struct acpi_driver *driver);
408int acpi_bus_scan(acpi_handle handle);
409void acpi_bus_trim(struct acpi_device *start);
410acpi_status acpi_bus_get_ejd(acpi_handle handle, acpi_handle * ejd);
411int acpi_match_device_ids(struct acpi_device *device,
412 const struct acpi_device_id *ids);
413int acpi_create_dir(struct acpi_device *);
414void acpi_remove_dir(struct acpi_device *);
415
416static inline bool acpi_device_enumerated(struct acpi_device *adev)
417{
418 return adev && adev->flags.initialized && adev->flags.visited;
419}
420
421typedef void (*acpi_hp_callback)(void *data, u32 src);
422
423acpi_status acpi_hotplug_execute(acpi_hp_callback func, void *data, u32 src);
424
425
426
427
428
429
430
431
432
433#define module_acpi_driver(__acpi_driver) \
434 module_driver(__acpi_driver, acpi_bus_register_driver, \
435 acpi_bus_unregister_driver)
436
437
438
439
440struct acpi_bus_type {
441 struct list_head list;
442 const char *name;
443 bool (*match)(struct device *dev);
444 struct acpi_device * (*find_companion)(struct device *);
445 void (*setup)(struct device *);
446 void (*cleanup)(struct device *);
447};
448int register_acpi_bus_type(struct acpi_bus_type *);
449int unregister_acpi_bus_type(struct acpi_bus_type *);
450
451struct acpi_pci_root {
452 struct acpi_device * device;
453 struct pci_bus *bus;
454 u16 segment;
455 struct resource secondary;
456
457 u32 osc_support_set;
458 u32 osc_control_set;
459 phys_addr_t mcfg_addr;
460};
461
462
463
464struct acpi_device *acpi_find_child_device(struct acpi_device *parent,
465 u64 address, bool check_children);
466int acpi_is_root_bridge(acpi_handle);
467struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle);
468
469int acpi_enable_wakeup_device_power(struct acpi_device *dev, int state);
470int acpi_disable_wakeup_device_power(struct acpi_device *dev);
471
472#ifdef CONFIG_PM
473acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
474 acpi_notify_handler handler, void *context);
475acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,
476 acpi_notify_handler handler);
477int acpi_pm_device_sleep_state(struct device *, int *, int);
478#else
479static inline acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
480 acpi_notify_handler handler,
481 void *context)
482{
483 return AE_SUPPORT;
484}
485static inline acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,
486 acpi_notify_handler handler)
487{
488 return AE_SUPPORT;
489}
490static inline int acpi_pm_device_sleep_state(struct device *d, int *p, int m)
491{
492 if (p)
493 *p = ACPI_STATE_D0;
494
495 return (m >= ACPI_STATE_D0 && m <= ACPI_STATE_D3_COLD) ?
496 m : ACPI_STATE_D0;
497}
498#endif
499
500#ifdef CONFIG_PM_RUNTIME
501int __acpi_device_run_wake(struct acpi_device *, bool);
502int acpi_pm_device_run_wake(struct device *, bool);
503#else
504static inline int __acpi_device_run_wake(struct acpi_device *adev, bool en)
505{
506 return -ENODEV;
507}
508static inline int acpi_pm_device_run_wake(struct device *dev, bool enable)
509{
510 return -ENODEV;
511}
512#endif
513
514#ifdef CONFIG_PM_SLEEP
515int __acpi_device_sleep_wake(struct acpi_device *, u32, bool);
516int acpi_pm_device_sleep_wake(struct device *, bool);
517#else
518static inline int __acpi_device_sleep_wake(struct acpi_device *adev,
519 u32 target_state, bool enable)
520{
521 return -ENODEV;
522}
523static inline int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
524{
525 return -ENODEV;
526}
527#endif
528
529#ifdef CONFIG_ACPI_SLEEP
530u32 acpi_target_system_state(void);
531#else
532static inline u32 acpi_target_system_state(void) { return ACPI_STATE_S0; }
533#endif
534
535static inline bool acpi_device_power_manageable(struct acpi_device *adev)
536{
537 return adev->flags.power_manageable;
538}
539
540static inline bool acpi_device_can_wakeup(struct acpi_device *adev)
541{
542 return adev->wakeup.flags.valid;
543}
544
545static inline bool acpi_device_can_poweroff(struct acpi_device *adev)
546{
547 return adev->power.states[ACPI_STATE_D3_COLD].flags.os_accessible;
548}
549
550#else
551
552static inline int register_acpi_bus_type(void *bus) { return 0; }
553static inline int unregister_acpi_bus_type(void *bus) { return 0; }
554
555#endif
556
557#endif
558