blob: e3862587b9dee1c29b95c5566a154785c8847da8 [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);
Jiang Liu952c63e2013-06-29 00:24:38 +080059
60bool acpi_has_method(acpi_handle handle, char *name);
Jiang Liu0db98202013-06-29 00:24:39 +080061acpi_status acpi_execute_simple_method(acpi_handle handle, char *method,
62 u64 arg);
Jiang Liu952c63e2013-06-29 00:24:38 +080063
Len Brown76f58582005-08-24 12:10:49 -040064#ifdef CONFIG_ACPI
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66#include <linux/proc_fs.h>
67
68#define ACPI_BUS_FILE_ROOT "acpi"
Len Brown4be44fc2005-08-05 00:44:28 -040069extern struct proc_dir_entry *acpi_root_dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
Linus Torvalds1da177e2005-04-16 15:20:36 -070071enum acpi_bus_device_type {
Len Brown4be44fc2005-08-05 00:44:28 -040072 ACPI_BUS_TYPE_DEVICE = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 ACPI_BUS_TYPE_POWER,
74 ACPI_BUS_TYPE_PROCESSOR,
75 ACPI_BUS_TYPE_THERMAL,
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 ACPI_BUS_TYPE_POWER_BUTTON,
77 ACPI_BUS_TYPE_SLEEP_BUTTON,
78 ACPI_BUS_DEVICE_TYPE_COUNT
79};
80
81struct acpi_driver;
82struct acpi_device;
83
Linus Torvalds1da177e2005-04-16 15:20:36 -070084/*
Rafael J. Wysockica589f92013-01-30 14:27:29 +010085 * ACPI Scan Handler
86 * -----------------
87 */
88
Rafael J. Wysockia33ec392013-03-03 23:05:29 +010089enum acpi_hotplug_mode {
90 AHM_GENERIC = 0,
91 AHM_CONTAINER,
92 AHM_COUNT
93};
94
95struct acpi_hotplug_profile {
Rafael J. Wysocki3f8055c2013-03-03 23:08:16 +010096 struct kobject kobj;
Rafael J. Wysockia33ec392013-03-03 23:05:29 +010097 bool enabled:1;
98 enum acpi_hotplug_mode mode;
99};
100
Rafael J. Wysocki3f8055c2013-03-03 23:08:16 +0100101static inline struct acpi_hotplug_profile *to_acpi_hotplug_profile(
102 struct kobject *kobj)
103{
104 return container_of(kobj, struct acpi_hotplug_profile, kobj);
105}
106
Rafael J. Wysockica589f92013-01-30 14:27:29 +0100107struct acpi_scan_handler {
108 const struct acpi_device_id *ids;
109 struct list_head list_node;
110 int (*attach)(struct acpi_device *dev, const struct acpi_device_id *id);
111 void (*detach)(struct acpi_device *dev);
Rafael J. Wysockia33ec392013-03-03 23:05:29 +0100112 struct acpi_hotplug_profile hotplug;
Rafael J. Wysockica589f92013-01-30 14:27:29 +0100113};
114
115/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 * ACPI Driver
117 * -----------
118 */
119
Len Brown4be44fc2005-08-05 00:44:28 -0400120typedef int (*acpi_op_add) (struct acpi_device * device);
Rafael J. Wysocki51fac832013-01-24 00:24:48 +0100121typedef int (*acpi_op_remove) (struct acpi_device * device);
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000122typedef void (*acpi_op_notify) (struct acpi_device * device, u32 event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
124struct acpi_device_ops {
Len Brown4be44fc2005-08-05 00:44:28 -0400125 acpi_op_add add;
126 acpi_op_remove remove;
Bjorn Helgaas46ec8592009-03-30 17:48:13 +0000127 acpi_op_notify notify;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128};
129
Bjorn Helgaas6d278132009-04-30 09:35:37 -0600130#define ACPI_DRIVER_ALL_NOTIFY_EVENTS 0x1 /* system AND device events */
131
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132struct acpi_driver {
Len Brown4be44fc2005-08-05 00:44:28 -0400133 char name[80];
134 char class[80];
Thomas Renninger8c8eb782007-07-23 14:43:32 +0200135 const struct acpi_device_id *ids; /* Supported Hardware IDs */
Bjorn Helgaas6d278132009-04-30 09:35:37 -0600136 unsigned int flags;
Len Brown4be44fc2005-08-05 00:44:28 -0400137 struct acpi_device_ops ops;
Patrick Mocheld43ec682006-12-07 20:56:23 +0800138 struct device_driver drv;
Patrick Mochel1890a972006-12-07 20:56:31 +0800139 struct module *owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140};
141
142/*
143 * ACPI Device
144 * -----------
145 */
146
147/* Status (_STA) */
148
149struct acpi_device_status {
Len Brown4be44fc2005-08-05 00:44:28 -0400150 u32 present:1;
151 u32 enabled:1;
152 u32 show_in_ui:1;
153 u32 functional:1;
154 u32 battery_present:1;
155 u32 reserved:27;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156};
157
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158/* Flags */
159
160struct acpi_device_flags {
Len Brown4be44fc2005-08-05 00:44:28 -0400161 u32 dynamic_status:1;
Len Brown4be44fc2005-08-05 00:44:28 -0400162 u32 removable:1;
163 u32 ejectable:1;
Len Brown4be44fc2005-08-05 00:44:28 -0400164 u32 power_manageable:1;
Toshi Kanic4753e52012-05-23 20:25:20 -0600165 u32 eject_pending:1;
Rafael J. Wysocki209d3b12012-12-21 00:36:48 +0100166 u32 match_driver:1;
Toshi Kani358b4b32013-06-04 21:56:25 +0000167 u32 reserved:26;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168};
169
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170/* File System */
171
172struct acpi_device_dir {
Len Brown4be44fc2005-08-05 00:44:28 -0400173 struct proc_dir_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174};
175
176#define acpi_device_dir(d) ((d)->dir.entry)
177
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178/* Plug and Play */
179
Zhao Yakui24c5c4c2009-05-21 16:25:35 +0800180typedef char acpi_bus_id[8];
Len Brown4be44fc2005-08-05 00:44:28 -0400181typedef unsigned long acpi_bus_address;
Len Brown4be44fc2005-08-05 00:44:28 -0400182typedef char acpi_device_name[40];
183typedef char acpi_device_class[20];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600185struct acpi_hardware_id {
186 struct list_head list;
187 char *id;
188};
189
Toshi Kanid4e1a692013-03-04 21:30:41 +0000190struct acpi_pnp_type {
191 u32 hardware_id:1;
192 u32 bus_address:1;
193 u32 reserved:30;
194};
195
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196struct acpi_device_pnp {
Toshi Kanid4e1a692013-03-04 21:30:41 +0000197 acpi_bus_id bus_id; /* Object name */
198 struct acpi_pnp_type type; /* ID type */
Len Brown4be44fc2005-08-05 00:44:28 -0400199 acpi_bus_address bus_address; /* _ADR */
Toshi Kanid4e1a692013-03-04 21:30:41 +0000200 char *unique_id; /* _UID */
Bjorn Helgaas7f47fa62009-09-21 13:35:19 -0600201 struct list_head ids; /* _HID and _CIDs */
Len Brown4be44fc2005-08-05 00:44:28 -0400202 acpi_device_name device_name; /* Driver-determined */
203 acpi_device_class device_class; /* " */
Lance Ortizd1efe3c2012-10-02 12:43:23 -0600204 union acpi_object *str_obj; /* unicode string for _STR method */
Yasuaki Ishimatsubb74ac22012-11-16 02:56:59 +0100205 unsigned long sun; /* _SUN */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206};
207
208#define acpi_device_bid(d) ((d)->pnp.bus_id)
209#define acpi_device_adr(d) ((d)->pnp.bus_address)
Thomas Renninger620e1122010-10-01 10:54:00 +0200210const char *acpi_device_hid(struct acpi_device *device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211#define acpi_device_name(d) ((d)->pnp.device_name)
212#define acpi_device_class(d) ((d)->pnp.device_class)
213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214/* Power Management */
215
216struct acpi_device_power_flags {
Len Brown4be44fc2005-08-05 00:44:28 -0400217 u32 explicit_get:1; /* _PSC present? */
218 u32 power_resources:1; /* Power resources */
219 u32 inrush_current:1; /* Serialize Dx->D0 */
220 u32 power_removed:1; /* Optimize Dx->D0 */
221 u32 reserved:28;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222};
223
224struct acpi_device_power_state {
225 struct {
Len Brown4be44fc2005-08-05 00:44:28 -0400226 u8 valid:1;
Aaron Lu1399dfc2012-11-21 23:33:40 +0100227 u8 os_accessible:1;
Len Brown4be44fc2005-08-05 00:44:28 -0400228 u8 explicit_set:1; /* _PSx present? */
229 u8 reserved:6;
230 } flags;
231 int power; /* % Power (compared to D0) */
232 int latency; /* Dx->D0 time (microseconds) */
Rafael J. Wysocki0b224522013-01-17 14:11:06 +0100233 struct list_head resources; /* Power resources referenced */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234};
235
236struct acpi_device_power {
Len Brown4be44fc2005-08-05 00:44:28 -0400237 int state; /* Current state */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 struct acpi_device_power_flags flags;
Lin Mingb4a03b92011-06-01 23:54:02 +0800239 struct acpi_device_power_state states[ACPI_D_STATE_COUNT]; /* Power states (D0-D3Cold) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240};
241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242/* Performance Management */
243
244struct acpi_device_perf_flags {
Len Brown4be44fc2005-08-05 00:44:28 -0400245 u8 reserved:8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246};
247
248struct acpi_device_perf_state {
249 struct {
Len Brown4be44fc2005-08-05 00:44:28 -0400250 u8 valid:1;
251 u8 reserved:7;
252 } flags;
253 u8 power; /* % Power (compared to P0) */
254 u8 performance; /* % Performance ( " ) */
255 int latency; /* Px->P0 time (microseconds) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256};
257
258struct acpi_device_perf {
Len Brown4be44fc2005-08-05 00:44:28 -0400259 int state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 struct acpi_device_perf_flags flags;
Len Brown4be44fc2005-08-05 00:44:28 -0400261 int state_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 struct acpi_device_perf_state *states;
263};
264
265/* Wakeup Management */
266struct acpi_device_wakeup_flags {
Len Brown4be44fc2005-08-05 00:44:28 -0400267 u8 valid:1; /* Can successfully enable wakeup? */
268 u8 run_wake:1; /* Run-Wake GPE devices */
Rafael J. Wysockib67ea762010-02-17 23:44:09 +0100269 u8 notifier_present:1; /* Wake-up notify handler has been installed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270};
271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272struct acpi_device_wakeup {
Len Brown4be44fc2005-08-05 00:44:28 -0400273 acpi_handle gpe_device;
Lin Ming439913f2010-01-28 10:53:19 +0800274 u64 gpe_number;
275 u64 sleep_state;
Rafael J. Wysocki993cbe52013-01-17 14:11:06 +0100276 struct list_head resources;
Len Brown4be44fc2005-08-05 00:44:28 -0400277 struct acpi_device_wakeup_flags flags;
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200278 int prepare_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279};
280
Lan Tianyu1033f902012-08-17 14:44:09 +0800281struct acpi_device_physical_node {
282 u8 node_id;
283 struct list_head node;
284 struct device *dev;
Rafael J. Wysocki683058e2013-05-03 00:26:16 +0200285 bool put_online:1;
Lan Tianyu1033f902012-08-17 14:44:09 +0800286};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Lan Tianyu1033f902012-08-17 14:44:09 +0800288/* set maximum of physical nodes to 32 for expansibility */
289#define ACPI_MAX_PHYSICAL_NODE 32
290
291/* Device */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292struct acpi_device {
Bjorn Helgaascaaa6ef2009-09-21 19:29:10 +0000293 int device_type;
294 acpi_handle handle; /* no handle for fixed hardware */
Len Brown4be44fc2005-08-05 00:44:28 -0400295 struct acpi_device *parent;
296 struct list_head children;
297 struct list_head node;
298 struct list_head wakeup_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 struct acpi_device_status status;
300 struct acpi_device_flags flags;
Len Brown4be44fc2005-08-05 00:44:28 -0400301 struct acpi_device_pnp pnp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 struct acpi_device_power power;
303 struct acpi_device_wakeup wakeup;
Len Brown4be44fc2005-08-05 00:44:28 -0400304 struct acpi_device_perf performance;
305 struct acpi_device_dir dir;
Rafael J. Wysockica589f92013-01-30 14:27:29 +0100306 struct acpi_scan_handler *handler;
Len Brown4be44fc2005-08-05 00:44:28 -0400307 struct acpi_driver *driver;
308 void *driver_data;
Patrick Mochel5b327262006-05-10 10:33:00 -0400309 struct device dev;
Lan Tianyu1033f902012-08-17 14:44:09 +0800310 u8 physical_node_count;
311 struct list_head physical_node_list;
312 struct mutex physical_node_lock;
313 DECLARE_BITMAP(physical_node_id_bitmap, ACPI_MAX_PHYSICAL_NODE);
Rafael J. Wysockibc9b6402013-01-17 14:11:05 +0100314 struct list_head power_dependent;
Rafael J. Wysockib1c0f992013-01-24 12:50:09 +0100315 void (*remove)(struct acpi_device *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316};
317
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700318static inline void *acpi_driver_data(struct acpi_device *d)
319{
320 return d->driver_data;
321}
322
Patrick Mocheld43ec682006-12-07 20:56:23 +0800323#define to_acpi_device(d) container_of(d, struct acpi_device, dev)
324#define to_acpi_driver(d) container_of(d, struct acpi_driver, drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
David Brownell55955aa2007-05-08 00:28:35 -0700326/* acpi_device.dev.bus == &acpi_bus_type */
327extern struct bus_type acpi_bus_type;
328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329/*
330 * Events
331 * ------
332 */
333
334struct acpi_bus_event {
Len Brown4be44fc2005-08-05 00:44:28 -0400335 struct list_head node;
336 acpi_device_class device_class;
337 acpi_bus_id bus_id;
338 u32 type;
339 u32 data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340};
341
Toshi Kanic4753e52012-05-23 20:25:20 -0600342struct acpi_eject_event {
Yinghai Lu5993c462013-01-11 22:40:41 +0000343 struct acpi_device *device;
Toshi Kanic4753e52012-05-23 20:25:20 -0600344 u32 event;
345};
346
Yinghai Lu92d8aff2013-01-21 13:20:47 -0800347struct acpi_hp_work {
348 struct work_struct work;
349 acpi_handle handle;
350 u32 type;
351 void *context;
352};
353void alloc_acpi_hp_work(acpi_handle handle, u32 type, void *context,
354 void (*func)(struct work_struct *work));
355
Greg Kroah-Hartman99e0d2f2007-11-02 16:19:59 -0700356extern struct kobject *acpi_kobj;
Zhang Rui962ce8c2007-08-23 01:24:31 +0800357extern int acpi_bus_generate_netlink_event(const char*, const char*, u8, int);
Bob Moore8e4319c2009-06-29 13:43:27 +0800358void acpi_bus_private_data_handler(acpi_handle, void *);
Zhang Rui20733932008-01-17 15:51:21 +0800359int acpi_bus_get_private_data(acpi_handle, void **);
Zhang Rui9ee85242008-01-25 14:48:06 +0800360extern int acpi_notifier_call_chain(struct acpi_device *, u32, u32);
361extern int register_acpi_notifier(struct notifier_block *);
362extern int unregister_acpi_notifier(struct notifier_block *);
Shaohua Li6bd00a62008-08-28 10:04:29 +0800363
364extern int register_acpi_bus_notifier(struct notifier_block *nb);
365extern void unregister_acpi_bus_notifier(struct notifier_block *nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366/*
367 * External Functions
368 */
369
370int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device);
Bob Moore8e4319c2009-06-29 13:43:27 +0800371void acpi_bus_data_handler(acpi_handle handle, void *context);
Bjorn Helgaas402ac532009-09-21 19:30:01 +0000372acpi_status acpi_bus_get_status_handle(acpi_handle handle,
373 unsigned long long *sta);
Len Brown4be44fc2005-08-05 00:44:28 -0400374int acpi_bus_get_status(struct acpi_device *device);
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100375
Len Brown4be44fc2005-08-05 00:44:28 -0400376int acpi_bus_set_power(acpi_handle handle, int state);
Rafael J. Wysocki96bfd3c2013-01-17 14:11:08 +0100377const char *acpi_power_state_string(int state);
Rafael J. Wysockiad0c3b02013-01-17 14:11:08 +0100378int acpi_device_get_power(struct acpi_device *device, int *state);
Rafael J. Wysocki078eb122012-11-02 01:40:45 +0100379int acpi_device_set_power(struct acpi_device *device, int state);
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100380int acpi_bus_init_power(struct acpi_device *device);
Rafael J. Wysockib9e95fc2013-06-19 00:45:34 +0200381int acpi_device_fix_up_power(struct acpi_device *device);
Rafael J. Wysocki25eed402010-11-25 00:09:15 +0100382int acpi_bus_update_power(acpi_handle handle, int *state_p);
Rafael J. Wysocki3737b2b2008-07-07 03:30:55 +0200383bool acpi_bus_power_manageable(acpi_handle handle);
Rafael J. Wysockiec4602a2013-05-16 22:29:28 +0200384
385#ifdef CONFIG_PM
Rafael J. Wysockieb9d0fe2008-07-07 03:34:48 +0200386bool acpi_bus_can_wakeup(acpi_handle handle);
Rafael J. Wysockiec4602a2013-05-16 22:29:28 +0200387#else
388static inline bool acpi_bus_can_wakeup(acpi_handle handle) { return false; }
389#endif
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100390
Len Brown14e04fb32007-08-23 15:20:26 -0400391#ifdef CONFIG_ACPI_PROC_EVENT
392int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data);
Alexey Starikovskiy8db85d42007-09-26 19:43:16 +0400393int acpi_bus_generate_proc_event4(const char *class, const char *bid, u8 type, int data);
Len Brown4be44fc2005-08-05 00:44:28 -0400394int acpi_bus_receive_event(struct acpi_bus_event *event);
Len Brown14e04fb32007-08-23 15:20:26 -0400395#else
396static inline int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data)
397 { return 0; }
398#endif
Rafael J. Wysocki3757b942013-02-13 14:36:47 +0100399
400void acpi_scan_lock_acquire(void);
401void acpi_scan_lock_release(void);
Rafael J. Wysockica589f92013-01-30 14:27:29 +0100402int acpi_scan_add_handler(struct acpi_scan_handler *handler);
Len Brown4be44fc2005-08-05 00:44:28 -0400403int acpi_bus_register_driver(struct acpi_driver *driver);
Bjorn Helgaas06ea8e082006-04-27 05:25:00 -0400404void acpi_bus_unregister_driver(struct acpi_driver *driver);
Rafael J. Wysockib8bd7592013-01-19 01:27:35 +0100405int acpi_bus_scan(acpi_handle handle);
Toshi Kanic4753e52012-05-23 20:25:20 -0600406void acpi_bus_hot_remove_device(void *context);
Rafael J. Wysockibfee26d2013-01-26 00:27:44 +0100407void acpi_bus_trim(struct acpi_device *start);
Len Brownfd350942007-05-09 23:34:35 -0400408acpi_status acpi_bus_get_ejd(acpi_handle handle, acpi_handle * ejd);
Thomas Renninger8c8eb782007-07-23 14:43:32 +0200409int acpi_match_device_ids(struct acpi_device *device,
410 const struct acpi_device_id *ids);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411int acpi_create_dir(struct acpi_device *);
412void acpi_remove_dir(struct acpi_device *);
413
Mika Westerberg0d2cf8f2012-09-07 10:31:38 +0300414
415/**
416 * module_acpi_driver(acpi_driver) - Helper macro for registering an ACPI driver
417 * @__acpi_driver: acpi_driver struct
418 *
419 * Helper macro for ACPI drivers which do not do anything special in module
420 * init/exit. This eliminates a lot of boilerplate. Each module may only
421 * use this macro once, and calling it replaces module_init() and module_exit()
422 */
423#define module_acpi_driver(__acpi_driver) \
424 module_driver(__acpi_driver, acpi_bus_register_driver, \
425 acpi_bus_unregister_driver)
426
David Shaohua Li4e10d122005-03-18 18:45:35 -0500427/*
428 * Bind physical devices with ACPI devices
429 */
David Shaohua Li4e10d122005-03-18 18:45:35 -0500430struct acpi_bus_type {
Len Brown4be44fc2005-08-05 00:44:28 -0400431 struct list_head list;
Rafael J. Wysocki53540092013-03-03 22:35:20 +0100432 const char *name;
433 bool (*match)(struct device *dev);
Len Brown4be44fc2005-08-05 00:44:28 -0400434 int (*find_device) (struct device *, acpi_handle *);
Rafael J. Wysocki11909ca2012-12-23 00:02:13 +0100435 void (*setup)(struct device *);
436 void (*cleanup)(struct device *);
David Shaohua Li4e10d122005-03-18 18:45:35 -0500437};
438int register_acpi_bus_type(struct acpi_bus_type *);
439int unregister_acpi_bus_type(struct acpi_bus_type *);
Thomas Renninger22c13f92008-08-01 17:37:54 +0200440
Alex Chiang76d56de2009-07-23 17:03:00 -0600441struct acpi_pci_root {
Alex Chiang76d56de2009-07-23 17:03:00 -0600442 struct acpi_device * device;
Alex Chiang76d56de2009-07-23 17:03:00 -0600443 struct pci_bus *bus;
444 u16 segment;
Bjorn Helgaas6ad95512010-03-11 12:20:06 -0700445 struct resource secondary; /* downstream bus range */
Alex Chiang76d56de2009-07-23 17:03:00 -0600446
447 u32 osc_support_set; /* _OSC state of support bits */
448 u32 osc_control_set; /* _OSC state of control bits */
Jiang Liuf4b57a32012-06-22 14:55:16 +0800449 phys_addr_t mcfg_addr;
Alex Chiang76d56de2009-07-23 17:03:00 -0600450};
451
David Shaohua Li4e10d122005-03-18 18:45:35 -0500452/* helper */
Lin Ming439913f2010-01-28 10:53:19 +0800453acpi_handle acpi_get_child(acpi_handle, u64);
Alexander Chiang27558202009-06-10 19:55:14 +0000454int acpi_is_root_bridge(acpi_handle);
Alex Chiang76d56de2009-07-23 17:03:00 -0600455struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle);
Rafael J. Wysocki95f8a082012-11-21 00:21:50 +0100456#define DEVICE_ACPI_HANDLE(dev) ((acpi_handle)ACPI_HANDLE(dev))
David Shaohua Li4e10d122005-03-18 18:45:35 -0500457
Rafael J. Wysockib67ea762010-02-17 23:44:09 +0100458int acpi_enable_wakeup_device_power(struct acpi_device *dev, int state);
459int acpi_disable_wakeup_device_power(struct acpi_device *dev);
460
Rafael J. Wysockiaa338602011-02-11 00:06:54 +0100461#ifdef CONFIG_PM
Rafael J. Wysockiec2cd812012-11-02 01:40:09 +0100462acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
463 acpi_notify_handler handler, void *context);
464acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,
465 acpi_notify_handler handler);
Huang Yingee85f542012-06-23 10:23:48 +0800466int acpi_pm_device_sleep_state(struct device *, int *, int);
Rafael J. Wysockibc9b6402013-01-17 14:11:05 +0100467void acpi_dev_pm_add_dependent(acpi_handle handle, struct device *depdev);
468void acpi_dev_pm_remove_dependent(acpi_handle handle, struct device *depdev);
Rafael J. Wysocki761afb82010-10-14 23:24:13 +0200469#else
Rafael J. Wysockiec2cd812012-11-02 01:40:09 +0100470static inline acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
471 acpi_notify_handler handler,
472 void *context)
473{
474 return AE_SUPPORT;
475}
476static inline acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,
477 acpi_notify_handler handler)
478{
479 return AE_SUPPORT;
480}
Rafael J. Wysockib25c77e2013-06-16 00:37:42 +0200481static inline int acpi_pm_device_sleep_state(struct device *d, int *p, int m)
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200482{
483 if (p)
484 *p = ACPI_STATE_D0;
Rafael J. Wysockib25c77e2013-06-16 00:37:42 +0200485
Huang Yingee85f542012-06-23 10:23:48 +0800486 return (m >= ACPI_STATE_D0 && m <= ACPI_STATE_D3) ? m : ACPI_STATE_D0;
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200487}
Rafael J. Wysockibc9b6402013-01-17 14:11:05 +0100488static inline void acpi_dev_pm_add_dependent(acpi_handle handle,
489 struct device *depdev) {}
490static inline void acpi_dev_pm_remove_dependent(acpi_handle handle,
491 struct device *depdev) {}
Rafael J. Wysocki761afb82010-10-14 23:24:13 +0200492#endif
493
Rafael J. Wysockibdda27f2012-10-26 13:40:04 +0200494#ifdef CONFIG_PM_RUNTIME
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100495int __acpi_device_run_wake(struct acpi_device *, bool);
Lin Mingb24e5092012-03-27 15:43:25 +0800496int acpi_pm_device_run_wake(struct device *, bool);
Rafael J. Wysocki761afb82010-10-14 23:24:13 +0200497#else
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100498static inline int __acpi_device_run_wake(struct acpi_device *adev, bool en)
499{
500 return -ENODEV;
501}
Lin Mingb24e5092012-03-27 15:43:25 +0800502static inline int acpi_pm_device_run_wake(struct device *dev, bool enable)
503{
504 return -ENODEV;
505}
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200506#endif
507
508#ifdef CONFIG_PM_SLEEP
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100509int __acpi_device_sleep_wake(struct acpi_device *, u32, bool);
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200510int acpi_pm_device_sleep_wake(struct device *, bool);
David Howellsf7a1b862008-07-08 15:00:54 +0100511#else
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100512static inline int __acpi_device_sleep_wake(struct acpi_device *adev,
513 u32 target_state, bool enable)
David Howellsf7a1b862008-07-08 15:00:54 +0100514{
515 return -ENODEV;
Rafael J. Wysocki761afb82010-10-14 23:24:13 +0200516}
Shaohua Lifd4aff12007-07-17 22:40:25 +0200517static inline int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
Len Brownfd350942007-05-09 23:34:35 -0400518{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 return -ENODEV;
520}
521#endif
522
David Rientjes99926a82012-11-10 22:48:33 +0100523#ifdef CONFIG_ACPI_SLEEP
524u32 acpi_target_system_state(void);
525#else
526static inline u32 acpi_target_system_state(void) { return ACPI_STATE_S0; }
527#endif
528
Rafael J. Wysocki078eb122012-11-02 01:40:45 +0100529static inline bool acpi_device_power_manageable(struct acpi_device *adev)
530{
531 return adev->flags.power_manageable;
532}
533
534static inline bool acpi_device_can_wakeup(struct acpi_device *adev)
535{
536 return adev->wakeup.flags.valid;
537}
538
Aaron Lu1399dfc2012-11-21 23:33:40 +0100539static inline bool acpi_device_can_poweroff(struct acpi_device *adev)
540{
541 return adev->power.states[ACPI_STATE_D3_COLD].flags.os_accessible;
542}
543
Matthew Garrett66886d62012-05-11 16:08:25 +0800544#else /* CONFIG_ACPI */
545
Len Brown7ae30982012-06-04 00:29:11 -0400546static inline int register_acpi_bus_type(void *bus) { return 0; }
547static inline int unregister_acpi_bus_type(void *bus) { return 0; }
Matthew Garrett66886d62012-05-11 16:08:25 +0800548
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549#endif /* CONFIG_ACPI */
550
551#endif /*__ACPI_BUS_H__*/