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