1 /*
2 * acpi_bus.h - ACPI Bus Driver ($Revision: 22 $)
3 *
4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6 *
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or (at
12 * your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
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 /* TBD: Make dynamic */
34 #define ACPI_MAX_HANDLES 10
35 struct acpi_handle_list {
36 u32 count;
37 acpi_handle handles[ACPI_MAX_HANDLES];
38 };
39
40 /* acpi_utils.h */
41 acpi_status
42 acpi_extract_package(union acpi_object *package,
43 struct acpi_buffer *format, struct acpi_buffer *buffer);
44 acpi_status
45 acpi_evaluate_integer(acpi_handle handle,
46 acpi_string pathname,
47 struct acpi_object_list *arguments, unsigned long long *data);
48 acpi_status
49 acpi_evaluate_reference(acpi_handle handle,
50 acpi_string pathname,
51 struct acpi_object_list *arguments,
52 struct acpi_handle_list *list);
53 acpi_status
54 acpi_evaluate_hotplug_ost(acpi_handle handle, u32 source_event,
55 u32 status_code, struct acpi_buffer *status_buf);
56
57 acpi_status
58 acpi_get_physical_device_location(acpi_handle handle, struct acpi_pld_info **pld);
59 #ifdef CONFIG_ACPI
60
61 #include <linux/proc_fs.h>
62
63 #define ACPI_BUS_FILE_ROOT "acpi"
64 extern struct proc_dir_entry *acpi_root_dir;
65
66 enum acpi_bus_removal_type {
67 ACPI_BUS_REMOVAL_NORMAL = 0,
68 ACPI_BUS_REMOVAL_EJECT,
69 ACPI_BUS_REMOVAL_SUPRISE,
70 ACPI_BUS_REMOVAL_TYPE_COUNT
71 };
72
73 enum acpi_bus_device_type {
74 ACPI_BUS_TYPE_DEVICE = 0,
75 ACPI_BUS_TYPE_POWER,
76 ACPI_BUS_TYPE_PROCESSOR,
77 ACPI_BUS_TYPE_THERMAL,
78 ACPI_BUS_TYPE_POWER_BUTTON,
79 ACPI_BUS_TYPE_SLEEP_BUTTON,
80 ACPI_BUS_DEVICE_TYPE_COUNT
81 };
82
83 struct acpi_driver;
84 struct acpi_device;
85
86 /*
87 * ACPI Scan Handler
88 * -----------------
89 */
90
91 enum acpi_hotplug_mode {
92 AHM_GENERIC = 0,
93 AHM_CONTAINER,
94 AHM_COUNT
95 };
96
97 struct acpi_hotplug_profile {
98 struct kobject kobj;
99 bool enabled:1;
100 enum acpi_hotplug_mode mode;
101 };
102
to_acpi_hotplug_profile(struct kobject * kobj)103 static inline struct acpi_hotplug_profile *to_acpi_hotplug_profile(
104 struct kobject *kobj)
105 {
106 return container_of(kobj, struct acpi_hotplug_profile, kobj);
107 }
108
109 struct acpi_scan_handler {
110 const struct acpi_device_id *ids;
111 struct list_head list_node;
112 int (*attach)(struct acpi_device *dev, const struct acpi_device_id *id);
113 void (*detach)(struct acpi_device *dev);
114 struct acpi_hotplug_profile hotplug;
115 };
116
117 /*
118 * ACPI Driver
119 * -----------
120 */
121
122 typedef int (*acpi_op_add) (struct acpi_device * device);
123 typedef int (*acpi_op_remove) (struct acpi_device * device);
124 typedef void (*acpi_op_notify) (struct acpi_device * device, u32 event);
125
126 struct acpi_device_ops {
127 acpi_op_add add;
128 acpi_op_remove remove;
129 acpi_op_notify notify;
130 };
131
132 #define ACPI_DRIVER_ALL_NOTIFY_EVENTS 0x1 /* system AND device events */
133
134 struct acpi_driver {
135 char name[80];
136 char class[80];
137 const struct acpi_device_id *ids; /* Supported Hardware IDs */
138 unsigned int flags;
139 struct acpi_device_ops ops;
140 struct device_driver drv;
141 struct module *owner;
142 };
143
144 /*
145 * ACPI Device
146 * -----------
147 */
148
149 /* Status (_STA) */
150
151 struct acpi_device_status {
152 u32 present:1;
153 u32 enabled:1;
154 u32 show_in_ui:1;
155 u32 functional:1;
156 u32 battery_present:1;
157 u32 reserved:27;
158 };
159
160 /* Flags */
161
162 struct acpi_device_flags {
163 u32 dynamic_status:1;
164 u32 removable:1;
165 u32 ejectable:1;
166 u32 suprise_removal_ok:1;
167 u32 power_manageable:1;
168 u32 performance_manageable:1;
169 u32 eject_pending:1;
170 u32 match_driver:1;
171 u32 reserved:24;
172 };
173
174 /* File System */
175
176 struct acpi_device_dir {
177 struct proc_dir_entry *entry;
178 };
179
180 #define acpi_device_dir(d) ((d)->dir.entry)
181
182 /* Plug and Play */
183
184 typedef char acpi_bus_id[8];
185 typedef unsigned long acpi_bus_address;
186 typedef char acpi_device_name[40];
187 typedef char acpi_device_class[20];
188
189 struct acpi_hardware_id {
190 struct list_head list;
191 char *id;
192 };
193
194 struct acpi_pnp_type {
195 u32 hardware_id:1;
196 u32 bus_address:1;
197 u32 reserved:30;
198 };
199
200 struct acpi_device_pnp {
201 acpi_bus_id bus_id; /* Object name */
202 struct acpi_pnp_type type; /* ID type */
203 acpi_bus_address bus_address; /* _ADR */
204 char *unique_id; /* _UID */
205 struct list_head ids; /* _HID and _CIDs */
206 acpi_device_name device_name; /* Driver-determined */
207 acpi_device_class device_class; /* " */
208 union acpi_object *str_obj; /* unicode string for _STR method */
209 unsigned long sun; /* _SUN */
210 };
211
212 #define acpi_device_bid(d) ((d)->pnp.bus_id)
213 #define acpi_device_adr(d) ((d)->pnp.bus_address)
214 const 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 /* Power Management */
219
220 struct acpi_device_power_flags {
221 u32 explicit_get:1; /* _PSC present? */
222 u32 power_resources:1; /* Power resources */
223 u32 inrush_current:1; /* Serialize Dx->D0 */
224 u32 power_removed:1; /* Optimize Dx->D0 */
225 u32 reserved:28;
226 };
227
228 struct acpi_device_power_state {
229 struct {
230 u8 valid:1;
231 u8 os_accessible:1;
232 u8 explicit_set:1; /* _PSx present? */
233 u8 reserved:6;
234 } flags;
235 int power; /* % Power (compared to D0) */
236 int latency; /* Dx->D0 time (microseconds) */
237 struct list_head resources; /* Power resources referenced */
238 };
239
240 struct acpi_device_power {
241 int state; /* Current state */
242 struct acpi_device_power_flags flags;
243 struct acpi_device_power_state states[ACPI_D_STATE_COUNT]; /* Power states (D0-D3Cold) */
244 };
245
246 /* Performance Management */
247
248 struct acpi_device_perf_flags {
249 u8 reserved:8;
250 };
251
252 struct acpi_device_perf_state {
253 struct {
254 u8 valid:1;
255 u8 reserved:7;
256 } flags;
257 u8 power; /* % Power (compared to P0) */
258 u8 performance; /* % Performance ( " ) */
259 int latency; /* Px->P0 time (microseconds) */
260 };
261
262 struct 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 /* Wakeup Management */
270 struct acpi_device_wakeup_flags {
271 u8 valid:1; /* Can successfully enable wakeup? */
272 u8 run_wake:1; /* Run-Wake GPE devices */
273 u8 notifier_present:1; /* Wake-up notify handler has been installed */
274 };
275
276 struct 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
285 struct acpi_device_physical_node {
286 u8 node_id;
287 struct list_head node;
288 struct device *dev;
289 };
290
291 /* set maximum of physical nodes to 32 for expansibility */
292 #define ACPI_MAX_PHYSICAL_NODE 32
293
294 /* Device */
295 struct acpi_device {
296 int device_type;
297 acpi_handle handle; /* no handle for fixed hardware */
298 struct acpi_device *parent;
299 struct list_head children;
300 struct list_head node;
301 struct list_head wakeup_list;
302 struct acpi_device_status status;
303 struct acpi_device_flags flags;
304 struct acpi_device_pnp pnp;
305 struct acpi_device_power power;
306 struct acpi_device_wakeup wakeup;
307 struct acpi_device_perf performance;
308 struct acpi_device_dir dir;
309 struct acpi_scan_handler *handler;
310 struct acpi_driver *driver;
311 void *driver_data;
312 struct device dev;
313 enum acpi_bus_removal_type removal_type; /* indicate for different removal type */
314 u8 physical_node_count;
315 struct list_head physical_node_list;
316 struct mutex physical_node_lock;
317 DECLARE_BITMAP(physical_node_id_bitmap, ACPI_MAX_PHYSICAL_NODE);
318 struct list_head power_dependent;
319 void (*remove)(struct acpi_device *);
320 };
321
acpi_driver_data(struct acpi_device * d)322 static inline void *acpi_driver_data(struct acpi_device *d)
323 {
324 return d->driver_data;
325 }
326
327 #define to_acpi_device(d) container_of(d, struct acpi_device, dev)
328 #define to_acpi_driver(d) container_of(d, struct acpi_driver, drv)
329
330 /* acpi_device.dev.bus == &acpi_bus_type */
331 extern struct bus_type acpi_bus_type;
332
333 /*
334 * Events
335 * ------
336 */
337
338 struct acpi_bus_event {
339 struct list_head node;
340 acpi_device_class device_class;
341 acpi_bus_id bus_id;
342 u32 type;
343 u32 data;
344 };
345
346 struct acpi_eject_event {
347 struct acpi_device *device;
348 u32 event;
349 };
350
351 struct acpi_hp_work {
352 struct work_struct work;
353 acpi_handle handle;
354 u32 type;
355 void *context;
356 };
357 void alloc_acpi_hp_work(acpi_handle handle, u32 type, void *context,
358 void (*func)(struct work_struct *work));
359
360 extern struct kobject *acpi_kobj;
361 extern int acpi_bus_generate_netlink_event(const char*, const char*, u8, int);
362 void acpi_bus_private_data_handler(acpi_handle, void *);
363 int acpi_bus_get_private_data(acpi_handle, void **);
364 extern int acpi_notifier_call_chain(struct acpi_device *, u32, u32);
365 extern int register_acpi_notifier(struct notifier_block *);
366 extern int unregister_acpi_notifier(struct notifier_block *);
367
368 extern int register_acpi_bus_notifier(struct notifier_block *nb);
369 extern void unregister_acpi_bus_notifier(struct notifier_block *nb);
370 /*
371 * External Functions
372 */
373
374 int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device);
375 void acpi_bus_data_handler(acpi_handle handle, void *context);
376 acpi_status acpi_bus_get_status_handle(acpi_handle handle,
377 unsigned long long *sta);
378 int acpi_bus_get_status(struct acpi_device *device);
379
380 int acpi_bus_set_power(acpi_handle handle, int state);
381 const char *acpi_power_state_string(int state);
382 int acpi_device_get_power(struct acpi_device *device, int *state);
383 int acpi_device_set_power(struct acpi_device *device, int state);
384 int acpi_bus_init_power(struct acpi_device *device);
385 int acpi_device_fix_up_power(struct acpi_device *device);
386 int acpi_bus_update_power(acpi_handle handle, int *state_p);
387 bool acpi_bus_power_manageable(acpi_handle handle);
388
389 #ifdef CONFIG_PM
390 bool acpi_bus_can_wakeup(acpi_handle handle);
391 #else
acpi_bus_can_wakeup(acpi_handle handle)392 static inline bool acpi_bus_can_wakeup(acpi_handle handle) { return false; }
393 #endif
394
395 #ifdef CONFIG_ACPI_PROC_EVENT
396 int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data);
397 int acpi_bus_generate_proc_event4(const char *class, const char *bid, u8 type, int data);
398 int acpi_bus_receive_event(struct acpi_bus_event *event);
399 #else
acpi_bus_generate_proc_event(struct acpi_device * device,u8 type,int data)400 static inline int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data)
401 { return 0; }
402 #endif
403
404 void acpi_scan_lock_acquire(void);
405 void acpi_scan_lock_release(void);
406 int acpi_scan_add_handler(struct acpi_scan_handler *handler);
407 int acpi_bus_register_driver(struct acpi_driver *driver);
408 void acpi_bus_unregister_driver(struct acpi_driver *driver);
409 int acpi_bus_scan(acpi_handle handle);
410 void acpi_bus_hot_remove_device(void *context);
411 void acpi_bus_trim(struct acpi_device *start);
412 acpi_status acpi_bus_get_ejd(acpi_handle handle, acpi_handle * ejd);
413 int acpi_match_device_ids(struct acpi_device *device,
414 const struct acpi_device_id *ids);
415 int acpi_create_dir(struct acpi_device *);
416 void acpi_remove_dir(struct acpi_device *);
417
418
419 /**
420 * module_acpi_driver(acpi_driver) - Helper macro for registering an ACPI driver
421 * @__acpi_driver: acpi_driver struct
422 *
423 * Helper macro for ACPI drivers which do not do anything special in module
424 * init/exit. This eliminates a lot of boilerplate. Each module may only
425 * use this macro once, and calling it replaces module_init() and module_exit()
426 */
427 #define module_acpi_driver(__acpi_driver) \
428 module_driver(__acpi_driver, acpi_bus_register_driver, \
429 acpi_bus_unregister_driver)
430
431 /*
432 * Bind physical devices with ACPI devices
433 */
434 struct acpi_bus_type {
435 struct list_head list;
436 const char *name;
437 bool (*match)(struct device *dev);
438 int (*find_device) (struct device *, acpi_handle *);
439 void (*setup)(struct device *);
440 void (*cleanup)(struct device *);
441 };
442 int register_acpi_bus_type(struct acpi_bus_type *);
443 int unregister_acpi_bus_type(struct acpi_bus_type *);
444
445 struct acpi_pci_root {
446 struct list_head node;
447 struct acpi_device * device;
448 struct pci_bus *bus;
449 u16 segment;
450 struct resource secondary; /* downstream bus range */
451
452 u32 osc_support_set; /* _OSC state of support bits */
453 u32 osc_control_set; /* _OSC state of control bits */
454 phys_addr_t mcfg_addr;
455 };
456
457 /* helper */
458 acpi_handle acpi_get_child(acpi_handle, u64);
459 int acpi_is_root_bridge(acpi_handle);
460 struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle);
461 #define DEVICE_ACPI_HANDLE(dev) ((acpi_handle)ACPI_HANDLE(dev))
462
463 int acpi_enable_wakeup_device_power(struct acpi_device *dev, int state);
464 int acpi_disable_wakeup_device_power(struct acpi_device *dev);
465
466 #ifdef CONFIG_PM
467 acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
468 acpi_notify_handler handler, void *context);
469 acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,
470 acpi_notify_handler handler);
471 int acpi_device_power_state(struct device *dev, struct acpi_device *adev,
472 u32 target_state, int d_max_in, int *d_min_p);
473 int acpi_pm_device_sleep_state(struct device *, int *, int);
474 void acpi_dev_pm_add_dependent(acpi_handle handle, struct device *depdev);
475 void acpi_dev_pm_remove_dependent(acpi_handle handle, struct device *depdev);
476 #else
acpi_add_pm_notifier(struct acpi_device * adev,acpi_notify_handler handler,void * context)477 static inline acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
478 acpi_notify_handler handler,
479 void *context)
480 {
481 return AE_SUPPORT;
482 }
acpi_remove_pm_notifier(struct acpi_device * adev,acpi_notify_handler handler)483 static inline acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,
484 acpi_notify_handler handler)
485 {
486 return AE_SUPPORT;
487 }
__acpi_device_power_state(int m,int * p)488 static inline int __acpi_device_power_state(int m, int *p)
489 {
490 if (p)
491 *p = ACPI_STATE_D0;
492 return (m >= ACPI_STATE_D0 && m <= ACPI_STATE_D3) ? m : ACPI_STATE_D0;
493 }
acpi_device_power_state(struct device * dev,struct acpi_device * adev,u32 target_state,int d_max_in,int * d_min_p)494 static inline int acpi_device_power_state(struct device *dev,
495 struct acpi_device *adev,
496 u32 target_state, int d_max_in,
497 int *d_min_p)
498 {
499 return __acpi_device_power_state(d_max_in, d_min_p);
500 }
acpi_pm_device_sleep_state(struct device * d,int * p,int m)501 static inline int acpi_pm_device_sleep_state(struct device *d, int *p, int m)
502 {
503 return __acpi_device_power_state(m, p);
504 }
acpi_dev_pm_add_dependent(acpi_handle handle,struct device * depdev)505 static inline void acpi_dev_pm_add_dependent(acpi_handle handle,
506 struct device *depdev) {}
acpi_dev_pm_remove_dependent(acpi_handle handle,struct device * depdev)507 static inline void acpi_dev_pm_remove_dependent(acpi_handle handle,
508 struct device *depdev) {}
509 #endif
510
511 #ifdef CONFIG_PM_RUNTIME
512 int __acpi_device_run_wake(struct acpi_device *, bool);
513 int acpi_pm_device_run_wake(struct device *, bool);
514 #else
__acpi_device_run_wake(struct acpi_device * adev,bool en)515 static inline int __acpi_device_run_wake(struct acpi_device *adev, bool en)
516 {
517 return -ENODEV;
518 }
acpi_pm_device_run_wake(struct device * dev,bool enable)519 static inline int acpi_pm_device_run_wake(struct device *dev, bool enable)
520 {
521 return -ENODEV;
522 }
523 #endif
524
525 #ifdef CONFIG_PM_SLEEP
526 int __acpi_device_sleep_wake(struct acpi_device *, u32, bool);
527 int acpi_pm_device_sleep_wake(struct device *, bool);
528 #else
__acpi_device_sleep_wake(struct acpi_device * adev,u32 target_state,bool enable)529 static inline int __acpi_device_sleep_wake(struct acpi_device *adev,
530 u32 target_state, bool enable)
531 {
532 return -ENODEV;
533 }
acpi_pm_device_sleep_wake(struct device * dev,bool enable)534 static inline int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
535 {
536 return -ENODEV;
537 }
538 #endif
539
540 #ifdef CONFIG_ACPI_SLEEP
541 u32 acpi_target_system_state(void);
542 #else
acpi_target_system_state(void)543 static inline u32 acpi_target_system_state(void) { return ACPI_STATE_S0; }
544 #endif
545
acpi_device_power_manageable(struct acpi_device * adev)546 static inline bool acpi_device_power_manageable(struct acpi_device *adev)
547 {
548 return adev->flags.power_manageable;
549 }
550
acpi_device_can_wakeup(struct acpi_device * adev)551 static inline bool acpi_device_can_wakeup(struct acpi_device *adev)
552 {
553 return adev->wakeup.flags.valid;
554 }
555
acpi_device_can_poweroff(struct acpi_device * adev)556 static inline bool acpi_device_can_poweroff(struct acpi_device *adev)
557 {
558 return adev->power.states[ACPI_STATE_D3_COLD].flags.os_accessible;
559 }
560
561 #else /* CONFIG_ACPI */
562
register_acpi_bus_type(void * bus)563 static inline int register_acpi_bus_type(void *bus) { return 0; }
unregister_acpi_bus_type(void * bus)564 static inline int unregister_acpi_bus_type(void *bus) { return 0; }
565
566 #endif /* CONFIG_ACPI */
567
568 #endif /*__ACPI_BUS_H__*/
569