blob: 98db31d9f9b410908b2056b192bf9813bc8ce4aa [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Patrick Mochel5b327262006-05-10 10:33:00 -040029#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
31#include <acpi/acpi.h>
32
Linus Torvalds1da177e2005-04-16 15:20:36 -070033/* TBD: Make dynamic */
34#define ACPI_MAX_HANDLES 10
35struct acpi_handle_list {
Len Brown4be44fc2005-08-05 00:44:28 -040036 u32 count;
37 acpi_handle handles[ACPI_MAX_HANDLES];
Linus Torvalds1da177e2005-04-16 15:20:36 -070038};
39
Linus Torvalds1da177e2005-04-16 15:20:36 -070040/* acpi_utils.h */
41acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -040042acpi_extract_package(union acpi_object *package,
43 struct acpi_buffer *format, struct acpi_buffer *buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -070044acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -040045acpi_evaluate_integer(acpi_handle handle,
46 acpi_string pathname,
Matthew Wilcox27663c52008-10-10 02:22:59 -040047 struct acpi_object_list *arguments, unsigned long long *data);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -040049acpi_evaluate_reference(acpi_handle handle,
50 acpi_string pathname,
51 struct acpi_object_list *arguments,
52 struct acpi_handle_list *list);
Toshi Kani275c58d2012-05-23 20:25:19 -060053acpi_status
54acpi_evaluate_hotplug_ost(acpi_handle handle, u32 source_event,
55 u32 status_code, struct acpi_buffer *status_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Matthew Garrett38ac0f12012-05-11 16:08:26 +080057acpi_status
Feng Tang8ede06a2012-08-21 09:56:58 +080058acpi_get_physical_device_location(acpi_handle handle, struct acpi_pld_info **pld);
Len Brown76f58582005-08-24 12:10:49 -040059#ifdef CONFIG_ACPI
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
61#include <linux/proc_fs.h>
62
63#define ACPI_BUS_FILE_ROOT "acpi"
Len Brown4be44fc2005-08-05 00:44:28 -040064extern struct proc_dir_entry *acpi_root_dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66enum acpi_bus_removal_type {
Len Brown4be44fc2005-08-05 00:44:28 -040067 ACPI_BUS_REMOVAL_NORMAL = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 ACPI_BUS_REMOVAL_EJECT,
69 ACPI_BUS_REMOVAL_SUPRISE,
70 ACPI_BUS_REMOVAL_TYPE_COUNT
71};
72
73enum acpi_bus_device_type {
Len Brown4be44fc2005-08-05 00:44:28 -040074 ACPI_BUS_TYPE_DEVICE = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 ACPI_BUS_TYPE_POWER,
76 ACPI_BUS_TYPE_PROCESSOR,
77 ACPI_BUS_TYPE_THERMAL,
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 ACPI_BUS_TYPE_POWER_BUTTON,
79 ACPI_BUS_TYPE_SLEEP_BUTTON,
80 ACPI_BUS_DEVICE_TYPE_COUNT
81};
82
83struct acpi_driver;
84struct acpi_device;
85
Linus Torvalds1da177e2005-04-16 15:20:36 -070086/*
Rafael J. Wysockica589f92013-01-30 14:27:29 +010087 * ACPI Scan Handler
88 * -----------------
89 */
90
Rafael J. Wysockia33ec392013-03-03 23:05:29 +010091enum acpi_hotplug_mode {
92 AHM_GENERIC = 0,
93 AHM_CONTAINER,
94 AHM_COUNT
95};
96
97struct acpi_hotplug_profile {
Rafael J. Wysocki3f8055c2013-03-03 23:08:16 +010098 struct kobject kobj;
Rafael J. Wysockia33ec392013-03-03 23:05:29 +010099 bool enabled:1;
100 enum acpi_hotplug_mode mode;
101};
102
Rafael J. Wysocki3f8055c2013-03-03 23:08:16 +0100103static 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
Rafael J. Wysockica589f92013-01-30 14:27:29 +0100109struct 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);
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100114 struct acpi_hotplug_profile hotplug;
Rafael J. Wysockica589f92013-01-30 14:27:29 +0100115};
116
117/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 * ACPI Driver
119 * -----------
120 */
121
Len Brown4be44fc2005-08-05 00:44:28 -0400122typedef int (*acpi_op_add) (struct acpi_device * device);
Rafael J. Wysocki51fac832013-01-24 00:24:48 +0100123typedef int (*acpi_op_remove) (struct acpi_device * device);
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000124typedef void (*acpi_op_notify) (struct acpi_device * device, u32 event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
126struct acpi_device_ops {
Len Brown4be44fc2005-08-05 00:44:28 -0400127 acpi_op_add add;
128 acpi_op_remove remove;
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000129 acpi_op_notify notify;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130};
131
Bjorn Helgaas6d278132009-04-30 09:35:37 -0600132#define ACPI_DRIVER_ALL_NOTIFY_EVENTS 0x1 /* system AND device events */
133
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134struct acpi_driver {
Len Brown4be44fc2005-08-05 00:44:28 -0400135 char name[80];
136 char class[80];
Thomas Renninger8c8eb782007-07-23 14:43:32 +0200137 const struct acpi_device_id *ids; /* Supported Hardware IDs */
Bjorn Helgaas6d278132009-04-30 09:35:37 -0600138 unsigned int flags;
Len Brown4be44fc2005-08-05 00:44:28 -0400139 struct acpi_device_ops ops;
Patrick Mocheld43ec682006-12-07 20:56:23 +0800140 struct device_driver drv;
Patrick Mochel1890a972006-12-07 20:56:31 +0800141 struct module *owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142};
143
144/*
145 * ACPI Device
146 * -----------
147 */
148
149/* Status (_STA) */
150
151struct acpi_device_status {
Len Brown4be44fc2005-08-05 00:44:28 -0400152 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158};
159
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160/* Flags */
161
162struct acpi_device_flags {
Len Brown4be44fc2005-08-05 00:44:28 -0400163 u32 dynamic_status:1;
Len Brown4be44fc2005-08-05 00:44:28 -0400164 u32 removable:1;
165 u32 ejectable:1;
Len Brown4be44fc2005-08-05 00:44:28 -0400166 u32 suprise_removal_ok:1;
167 u32 power_manageable:1;
168 u32 performance_manageable:1;
Toshi Kanic4753e52012-05-23 20:25:20 -0600169 u32 eject_pending:1;
Rafael J. Wysocki209d3b12012-12-21 00:36:48 +0100170 u32 match_driver:1;
Toshi Kanid4e1a692013-03-04 21:30:41 +0000171 u32 reserved:24;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172};
173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174/* File System */
175
176struct acpi_device_dir {
Len Brown4be44fc2005-08-05 00:44:28 -0400177 struct proc_dir_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178};
179
180#define acpi_device_dir(d) ((d)->dir.entry)
181
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182/* Plug and Play */
183
Zhao Yakui24c5c4c2009-05-21 16:25:35 +0800184typedef char acpi_bus_id[8];
Len Brown4be44fc2005-08-05 00:44:28 -0400185typedef unsigned long acpi_bus_address;
Len Brown4be44fc2005-08-05 00:44:28 -0400186typedef char acpi_device_name[40];
187typedef char acpi_device_class[20];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600189struct acpi_hardware_id {
190 struct list_head list;
191 char *id;
192};
193
Toshi Kanid4e1a692013-03-04 21:30:41 +0000194struct acpi_pnp_type {
195 u32 hardware_id:1;
196 u32 bus_address:1;
197 u32 reserved:30;
198};
199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200struct acpi_device_pnp {
Toshi Kanid4e1a692013-03-04 21:30:41 +0000201 acpi_bus_id bus_id; /* Object name */
202 struct acpi_pnp_type type; /* ID type */
Len Brown4be44fc2005-08-05 00:44:28 -0400203 acpi_bus_address bus_address; /* _ADR */
Toshi Kanid4e1a692013-03-04 21:30:41 +0000204 char *unique_id; /* _UID */
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600205 struct list_head ids; /* _HID and _CIDs */
Len Brown4be44fc2005-08-05 00:44:28 -0400206 acpi_device_name device_name; /* Driver-determined */
207 acpi_device_class device_class; /* " */
Lance Ortizd1efe3c2012-10-02 12:43:23 -0600208 union acpi_object *str_obj; /* unicode string for _STR method */
Yasuaki Ishimatsubb74ac22012-11-16 02:56:59 +0100209 unsigned long sun; /* _SUN */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210};
211
212#define acpi_device_bid(d) ((d)->pnp.bus_id)
213#define acpi_device_adr(d) ((d)->pnp.bus_address)
Thomas Renninger620e1122010-10-01 10:54:00 +0200214const char *acpi_device_hid(struct acpi_device *device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215#define acpi_device_name(d) ((d)->pnp.device_name)
216#define acpi_device_class(d) ((d)->pnp.device_class)
217
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218/* Power Management */
219
220struct acpi_device_power_flags {
Len Brown4be44fc2005-08-05 00:44:28 -0400221 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226};
227
228struct acpi_device_power_state {
229 struct {
Len Brown4be44fc2005-08-05 00:44:28 -0400230 u8 valid:1;
Aaron Lu1399dfc2012-11-21 23:33:40 +0100231 u8 os_accessible:1;
Len Brown4be44fc2005-08-05 00:44:28 -0400232 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) */
Rafael J. Wysocki0b224522013-01-17 14:11:06 +0100237 struct list_head resources; /* Power resources referenced */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238};
239
240struct acpi_device_power {
Len Brown4be44fc2005-08-05 00:44:28 -0400241 int state; /* Current state */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 struct acpi_device_power_flags flags;
Lin Mingb4a03b92011-06-01 23:54:02 +0800243 struct acpi_device_power_state states[ACPI_D_STATE_COUNT]; /* Power states (D0-D3Cold) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244};
245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246/* Performance Management */
247
248struct acpi_device_perf_flags {
Len Brown4be44fc2005-08-05 00:44:28 -0400249 u8 reserved:8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250};
251
252struct acpi_device_perf_state {
253 struct {
Len Brown4be44fc2005-08-05 00:44:28 -0400254 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) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260};
261
262struct acpi_device_perf {
Len Brown4be44fc2005-08-05 00:44:28 -0400263 int state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 struct acpi_device_perf_flags flags;
Len Brown4be44fc2005-08-05 00:44:28 -0400265 int state_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 struct acpi_device_perf_state *states;
267};
268
269/* Wakeup Management */
270struct acpi_device_wakeup_flags {
Len Brown4be44fc2005-08-05 00:44:28 -0400271 u8 valid:1; /* Can successfully enable wakeup? */
272 u8 run_wake:1; /* Run-Wake GPE devices */
Rafael J. Wysockib67ea762010-02-17 23:44:09 +0100273 u8 notifier_present:1; /* Wake-up notify handler has been installed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274};
275
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276struct acpi_device_wakeup {
Len Brown4be44fc2005-08-05 00:44:28 -0400277 acpi_handle gpe_device;
Lin Ming439913f2010-01-28 10:53:19 +0800278 u64 gpe_number;
279 u64 sleep_state;
Rafael J. Wysocki993cbe52013-01-17 14:11:06 +0100280 struct list_head resources;
Len Brown4be44fc2005-08-05 00:44:28 -0400281 struct acpi_device_wakeup_flags flags;
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200282 int prepare_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283};
284
Lan Tianyu1033f902012-08-17 14:44:09 +0800285struct acpi_device_physical_node {
286 u8 node_id;
287 struct list_head node;
288 struct device *dev;
289};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
Lan Tianyu1033f902012-08-17 14:44:09 +0800291/* set maximum of physical nodes to 32 for expansibility */
292#define ACPI_MAX_PHYSICAL_NODE 32
293
294/* Device */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295struct acpi_device {
Bjorn Helgaascaaa6ef2009-09-21 19:29:10 +0000296 int device_type;
297 acpi_handle handle; /* no handle for fixed hardware */
Len Brown4be44fc2005-08-05 00:44:28 -0400298 struct acpi_device *parent;
299 struct list_head children;
300 struct list_head node;
301 struct list_head wakeup_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 struct acpi_device_status status;
303 struct acpi_device_flags flags;
Len Brown4be44fc2005-08-05 00:44:28 -0400304 struct acpi_device_pnp pnp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 struct acpi_device_power power;
306 struct acpi_device_wakeup wakeup;
Len Brown4be44fc2005-08-05 00:44:28 -0400307 struct acpi_device_perf performance;
308 struct acpi_device_dir dir;
Rafael J. Wysockica589f92013-01-30 14:27:29 +0100309 struct acpi_scan_handler *handler;
Len Brown4be44fc2005-08-05 00:44:28 -0400310 struct acpi_driver *driver;
311 void *driver_data;
Patrick Mochel5b327262006-05-10 10:33:00 -0400312 struct device dev;
Len Brownfd350942007-05-09 23:34:35 -0400313 enum acpi_bus_removal_type removal_type; /* indicate for different removal type */
Lan Tianyu1033f902012-08-17 14:44:09 +0800314 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);
Rafael J. Wysockibc9b6402013-01-17 14:11:05 +0100318 struct list_head power_dependent;
Rafael J. Wysockib1c0f992013-01-24 12:50:09 +0100319 void (*remove)(struct acpi_device *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320};
321
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700322static inline void *acpi_driver_data(struct acpi_device *d)
323{
324 return d->driver_data;
325}
326
Patrick Mocheld43ec682006-12-07 20:56:23 +0800327#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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
David Brownell55955aa2007-05-08 00:28:35 -0700330/* acpi_device.dev.bus == &acpi_bus_type */
331extern struct bus_type acpi_bus_type;
332
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333/*
334 * Events
335 * ------
336 */
337
338struct acpi_bus_event {
Len Brown4be44fc2005-08-05 00:44:28 -0400339 struct list_head node;
340 acpi_device_class device_class;
341 acpi_bus_id bus_id;
342 u32 type;
343 u32 data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344};
345
Toshi Kanic4753e52012-05-23 20:25:20 -0600346struct acpi_eject_event {
Yinghai Lu5993c462013-01-11 22:40:41 +0000347 struct acpi_device *device;
Toshi Kanic4753e52012-05-23 20:25:20 -0600348 u32 event;
349};
350
Yinghai Lu92d8aff2013-01-21 13:20:47 -0800351struct acpi_hp_work {
352 struct work_struct work;
353 acpi_handle handle;
354 u32 type;
355 void *context;
356};
357void alloc_acpi_hp_work(acpi_handle handle, u32 type, void *context,
358 void (*func)(struct work_struct *work));
359
Greg Kroah-Hartman99e0d2f2007-11-02 16:19:59 -0700360extern struct kobject *acpi_kobj;
Zhang Rui962ce8c2007-08-23 01:24:31 +0800361extern int acpi_bus_generate_netlink_event(const char*, const char*, u8, int);
Bob Moore8e4319c2009-06-29 13:43:27 +0800362void acpi_bus_private_data_handler(acpi_handle, void *);
Zhang Rui20733932008-01-17 15:51:21 +0800363int acpi_bus_get_private_data(acpi_handle, void **);
Zhang Rui9ee85242008-01-25 14:48:06 +0800364extern int acpi_notifier_call_chain(struct acpi_device *, u32, u32);
365extern int register_acpi_notifier(struct notifier_block *);
366extern int unregister_acpi_notifier(struct notifier_block *);
Shaohua Li6bd00a62008-08-28 10:04:29 +0800367
368extern int register_acpi_bus_notifier(struct notifier_block *nb);
369extern void unregister_acpi_bus_notifier(struct notifier_block *nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370/*
371 * External Functions
372 */
373
374int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device);
Bob Moore8e4319c2009-06-29 13:43:27 +0800375void acpi_bus_data_handler(acpi_handle handle, void *context);
Bjorn Helgaas402ac532009-09-21 19:30:01 +0000376acpi_status acpi_bus_get_status_handle(acpi_handle handle,
377 unsigned long long *sta);
Len Brown4be44fc2005-08-05 00:44:28 -0400378int acpi_bus_get_status(struct acpi_device *device);
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100379
380#ifdef CONFIG_PM
Len Brown4be44fc2005-08-05 00:44:28 -0400381int acpi_bus_set_power(acpi_handle handle, int state);
Rafael J. Wysocki96bfd3c2013-01-17 14:11:08 +0100382const char *acpi_power_state_string(int state);
Rafael J. Wysockiad0c3b02013-01-17 14:11:08 +0100383int acpi_device_get_power(struct acpi_device *device, int *state);
Rafael J. Wysocki078eb122012-11-02 01:40:45 +0100384int acpi_device_set_power(struct acpi_device *device, int state);
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100385int acpi_bus_init_power(struct acpi_device *device);
Rafael J. Wysocki25eed402010-11-25 00:09:15 +0100386int acpi_bus_update_power(acpi_handle handle, int *state_p);
Rafael J. Wysocki3737b2b2008-07-07 03:30:55 +0200387bool acpi_bus_power_manageable(acpi_handle handle);
Rafael J. Wysockieb9d0fe2008-07-07 03:34:48 +0200388bool acpi_bus_can_wakeup(acpi_handle handle);
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100389#else /* !CONFIG_PM */
390static inline int acpi_bus_set_power(acpi_handle handle, int state)
391{
392 return 0;
393}
394static inline const char *acpi_power_state_string(int state)
395{
396 return "D0";
397}
398static inline int acpi_device_get_power(struct acpi_device *device, int *state)
399{
400 return 0;
401}
402static inline int acpi_device_set_power(struct acpi_device *device, int state)
403{
404 return 0;
405}
406static inline int acpi_bus_init_power(struct acpi_device *device)
407{
408 return 0;
409}
410static inline int acpi_bus_update_power(acpi_handle handle, int *state_p)
411{
412 return 0;
413}
414static inline bool acpi_bus_power_manageable(acpi_handle handle)
415{
416 return false;
417}
418static inline bool acpi_bus_can_wakeup(acpi_handle handle)
419{
420 return false;
421}
422#endif /* !CONFIG_PM */
423
Len Brown14e04fb2007-08-23 15:20:26 -0400424#ifdef CONFIG_ACPI_PROC_EVENT
425int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data);
Alexey Starikovskiy8db85d42007-09-26 19:43:16 +0400426int acpi_bus_generate_proc_event4(const char *class, const char *bid, u8 type, int data);
Len Brown4be44fc2005-08-05 00:44:28 -0400427int acpi_bus_receive_event(struct acpi_bus_event *event);
Len Brown14e04fb2007-08-23 15:20:26 -0400428#else
429static inline int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data)
430 { return 0; }
431#endif
Rafael J. Wysocki3757b942013-02-13 14:36:47 +0100432
433void acpi_scan_lock_acquire(void);
434void acpi_scan_lock_release(void);
Rafael J. Wysockica589f92013-01-30 14:27:29 +0100435int acpi_scan_add_handler(struct acpi_scan_handler *handler);
Len Brown4be44fc2005-08-05 00:44:28 -0400436int acpi_bus_register_driver(struct acpi_driver *driver);
Bjorn Helgaas06ea8e082006-04-27 05:25:00 -0400437void acpi_bus_unregister_driver(struct acpi_driver *driver);
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +0100438int acpi_bus_scan(acpi_handle handle);
Toshi Kanic4753e52012-05-23 20:25:20 -0600439void acpi_bus_hot_remove_device(void *context);
Rafael J. Wysockibfee26d2013-01-26 00:27:44 +0100440void acpi_bus_trim(struct acpi_device *start);
Len Brownfd350942007-05-09 23:34:35 -0400441acpi_status acpi_bus_get_ejd(acpi_handle handle, acpi_handle * ejd);
Thomas Renninger8c8eb782007-07-23 14:43:32 +0200442int acpi_match_device_ids(struct acpi_device *device,
443 const struct acpi_device_id *ids);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444int acpi_create_dir(struct acpi_device *);
445void acpi_remove_dir(struct acpi_device *);
446
Mika Westerberg0d2cf8f2012-09-07 10:31:38 +0300447
448/**
449 * module_acpi_driver(acpi_driver) - Helper macro for registering an ACPI driver
450 * @__acpi_driver: acpi_driver struct
451 *
452 * Helper macro for ACPI drivers which do not do anything special in module
453 * init/exit. This eliminates a lot of boilerplate. Each module may only
454 * use this macro once, and calling it replaces module_init() and module_exit()
455 */
456#define module_acpi_driver(__acpi_driver) \
457 module_driver(__acpi_driver, acpi_bus_register_driver, \
458 acpi_bus_unregister_driver)
459
David Shaohua Li4e10d122005-03-18 18:45:35 -0500460/*
461 * Bind physical devices with ACPI devices
462 */
David Shaohua Li4e10d122005-03-18 18:45:35 -0500463struct acpi_bus_type {
Len Brown4be44fc2005-08-05 00:44:28 -0400464 struct list_head list;
Rafael J. Wysocki53540092013-03-03 22:35:20 +0100465 const char *name;
466 bool (*match)(struct device *dev);
Len Brown4be44fc2005-08-05 00:44:28 -0400467 int (*find_device) (struct device *, acpi_handle *);
Rafael J. Wysocki11909ca2012-12-23 00:02:13 +0100468 void (*setup)(struct device *);
469 void (*cleanup)(struct device *);
David Shaohua Li4e10d122005-03-18 18:45:35 -0500470};
471int register_acpi_bus_type(struct acpi_bus_type *);
472int unregister_acpi_bus_type(struct acpi_bus_type *);
Thomas Renninger22c13f92008-08-01 17:37:54 +0200473
Alex Chiang76d56de2009-07-23 17:03:00 -0600474struct acpi_pci_root {
475 struct list_head node;
476 struct acpi_device * device;
Alex Chiang76d56de2009-07-23 17:03:00 -0600477 struct pci_bus *bus;
478 u16 segment;
Bjorn Helgaas6ad95512010-03-11 12:20:06 -0700479 struct resource secondary; /* downstream bus range */
Alex Chiang76d56de2009-07-23 17:03:00 -0600480
481 u32 osc_support_set; /* _OSC state of support bits */
482 u32 osc_control_set; /* _OSC state of control bits */
Jiang Liuf4b57a32012-06-22 14:55:16 +0800483 phys_addr_t mcfg_addr;
Alex Chiang76d56de2009-07-23 17:03:00 -0600484};
485
David Shaohua Li4e10d122005-03-18 18:45:35 -0500486/* helper */
Lin Ming439913f2010-01-28 10:53:19 +0800487acpi_handle acpi_get_child(acpi_handle, u64);
Alexander Chiang27558202009-06-10 19:55:14 +0000488int acpi_is_root_bridge(acpi_handle);
Alex Chiang76d56de2009-07-23 17:03:00 -0600489struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle);
Rafael J. Wysocki95f8a082012-11-21 00:21:50 +0100490#define DEVICE_ACPI_HANDLE(dev) ((acpi_handle)ACPI_HANDLE(dev))
David Shaohua Li4e10d122005-03-18 18:45:35 -0500491
Rafael J. Wysockib67ea762010-02-17 23:44:09 +0100492int acpi_enable_wakeup_device_power(struct acpi_device *dev, int state);
493int acpi_disable_wakeup_device_power(struct acpi_device *dev);
494
Rafael J. Wysockiaa338602011-02-11 00:06:54 +0100495#ifdef CONFIG_PM
Rafael J. Wysockiec2cd812012-11-02 01:40:09 +0100496acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
497 acpi_notify_handler handler, void *context);
498acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,
499 acpi_notify_handler handler);
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100500int acpi_device_power_state(struct device *dev, struct acpi_device *adev,
501 u32 target_state, int d_max_in, int *d_min_p);
Huang Yingee85f542012-06-23 10:23:48 +0800502int acpi_pm_device_sleep_state(struct device *, int *, int);
Rafael J. Wysockibc9b6402013-01-17 14:11:05 +0100503void acpi_dev_pm_add_dependent(acpi_handle handle, struct device *depdev);
504void acpi_dev_pm_remove_dependent(acpi_handle handle, struct device *depdev);
Rafael J. Wysocki761afb82010-10-14 23:24:13 +0200505#else
Rafael J. Wysockiec2cd812012-11-02 01:40:09 +0100506static inline acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
507 acpi_notify_handler handler,
508 void *context)
509{
510 return AE_SUPPORT;
511}
512static inline acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,
513 acpi_notify_handler handler)
514{
515 return AE_SUPPORT;
516}
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100517static inline int __acpi_device_power_state(int m, int *p)
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200518{
519 if (p)
520 *p = ACPI_STATE_D0;
Huang Yingee85f542012-06-23 10:23:48 +0800521 return (m >= ACPI_STATE_D0 && m <= ACPI_STATE_D3) ? m : ACPI_STATE_D0;
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200522}
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100523static inline int acpi_device_power_state(struct device *dev,
524 struct acpi_device *adev,
525 u32 target_state, int d_max_in,
526 int *d_min_p)
527{
528 return __acpi_device_power_state(d_max_in, d_min_p);
529}
530static inline int acpi_pm_device_sleep_state(struct device *d, int *p, int m)
531{
532 return __acpi_device_power_state(m, p);
533}
Rafael J. Wysockibc9b6402013-01-17 14:11:05 +0100534static inline void acpi_dev_pm_add_dependent(acpi_handle handle,
535 struct device *depdev) {}
536static inline void acpi_dev_pm_remove_dependent(acpi_handle handle,
537 struct device *depdev) {}
Rafael J. Wysocki761afb82010-10-14 23:24:13 +0200538#endif
539
Rafael J. Wysockibdda27f2012-10-26 13:40:04 +0200540#ifdef CONFIG_PM_RUNTIME
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100541int __acpi_device_run_wake(struct acpi_device *, bool);
Lin Mingb24e5092012-03-27 15:43:25 +0800542int acpi_pm_device_run_wake(struct device *, bool);
Rafael J. Wysocki761afb82010-10-14 23:24:13 +0200543#else
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100544static inline int __acpi_device_run_wake(struct acpi_device *adev, bool en)
545{
546 return -ENODEV;
547}
Lin Mingb24e5092012-03-27 15:43:25 +0800548static inline int acpi_pm_device_run_wake(struct device *dev, bool enable)
549{
550 return -ENODEV;
551}
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200552#endif
553
554#ifdef CONFIG_PM_SLEEP
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100555int __acpi_device_sleep_wake(struct acpi_device *, u32, bool);
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200556int acpi_pm_device_sleep_wake(struct device *, bool);
David Howellsf7a1b862008-07-08 15:00:54 +0100557#else
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100558static inline int __acpi_device_sleep_wake(struct acpi_device *adev,
559 u32 target_state, bool enable)
David Howellsf7a1b862008-07-08 15:00:54 +0100560{
561 return -ENODEV;
Rafael J. Wysocki761afb82010-10-14 23:24:13 +0200562}
Shaohua Lifd4aff12007-07-17 22:40:25 +0200563static inline int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
Len Brownfd350942007-05-09 23:34:35 -0400564{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 return -ENODEV;
566}
567#endif
568
David Rientjes99926a82012-11-10 22:48:33 +0100569#ifdef CONFIG_ACPI_SLEEP
570u32 acpi_target_system_state(void);
571#else
572static inline u32 acpi_target_system_state(void) { return ACPI_STATE_S0; }
573#endif
574
Rafael J. Wysocki078eb122012-11-02 01:40:45 +0100575static inline bool acpi_device_power_manageable(struct acpi_device *adev)
576{
577 return adev->flags.power_manageable;
578}
579
580static inline bool acpi_device_can_wakeup(struct acpi_device *adev)
581{
582 return adev->wakeup.flags.valid;
583}
584
Aaron Lu1399dfc2012-11-21 23:33:40 +0100585static inline bool acpi_device_can_poweroff(struct acpi_device *adev)
586{
587 return adev->power.states[ACPI_STATE_D3_COLD].flags.os_accessible;
588}
589
Matthew Garrett66886d62012-05-11 16:08:25 +0800590#else /* CONFIG_ACPI */
591
Len Brown7ae30982012-06-04 00:29:11 -0400592static inline int register_acpi_bus_type(void *bus) { return 0; }
593static inline int unregister_acpi_bus_type(void *bus) { return 0; }
Matthew Garrett66886d62012-05-11 16:08:25 +0800594
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595#endif /* CONFIG_ACPI */
596
597#endif /*__ACPI_BUS_H__*/