blob: 7411915243530f8e0a9bcd2bf7a78ce4cf576a61 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * acpi_bus.c - ACPI Bus Driver ($Revision: 80 $)
3 *
4 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
5 *
6 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or (at
11 * your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
21 *
22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
23 */
24
25#include <linux/module.h>
26#include <linux/init.h>
27#include <linux/ioport.h>
Randy Dunlapd568df82006-07-12 01:47:00 -040028#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/list.h>
30#include <linux/sched.h>
31#include <linux/pm.h>
32#include <linux/device.h>
33#include <linux/proc_fs.h>
Harvey Harrison6697c052008-02-09 23:24:08 +010034#include <linux/acpi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#ifdef CONFIG_X86
36#include <asm/mpspec.h>
37#endif
Robert Hancock7752d5c2008-02-15 01:27:20 -080038#include <linux/pci.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <acpi/acpi_bus.h>
40#include <acpi/acpi_drivers.h>
Len Browneb27cae2009-07-06 23:40:19 -040041#include <linux/dmi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Bjorn Helgaase60cc7a2009-03-13 12:08:26 -060043#include "internal.h"
44
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#define _COMPONENT ACPI_BUS_COMPONENT
Len Brownf52fd662007-02-12 22:42:12 -050046ACPI_MODULE_NAME("bus");
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
Len Brown4be44fc2005-08-05 00:44:28 -040048struct acpi_device *acpi_root;
49struct proc_dir_entry *acpi_root_dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -070050EXPORT_SYMBOL(acpi_root_dir);
51
52#define STRUCT_TO_INT(s) (*((int*)&s))
53
Zhao Yakui6415e122008-08-11 14:59:59 +080054static int set_power_nocheck(const struct dmi_system_id *id)
55{
56 printk(KERN_NOTICE PREFIX "%s detected - "
57 "disable power check in power transistion\n", id->ident);
58 acpi_power_nocheck = 1;
59 return 0;
60}
61static struct dmi_system_id __cpuinitdata power_nocheck_dmi_table[] = {
62 {
63 set_power_nocheck, "HP Pavilion 05", {
64 DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
65 DMI_MATCH(DMI_SYS_VENDOR, "HP Pavilion 05"),
66 DMI_MATCH(DMI_PRODUCT_VERSION, "2001211RE101GLEND") }, NULL},
67 {},
68};
69
70
Linus Torvalds1da177e2005-04-16 15:20:36 -070071/* --------------------------------------------------------------------------
72 Device Management
73 -------------------------------------------------------------------------- */
74
Len Brown4be44fc2005-08-05 00:44:28 -040075int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
Linus Torvalds1da177e2005-04-16 15:20:36 -070076{
Len Brown4be44fc2005-08-05 00:44:28 -040077 acpi_status status = AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -040081 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83 /* TBD: Support fixed-feature devices */
84
Len Brown4be44fc2005-08-05 00:44:28 -040085 status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 if (ACPI_FAILURE(status) || !*device) {
Len Brown9805cb72006-07-25 13:30:57 -040087 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
88 handle));
Patrick Mocheld550d982006-06-27 00:41:40 -040089 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 }
91
Patrick Mocheld550d982006-06-27 00:41:40 -040092 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093}
Len Brown4be44fc2005-08-05 00:44:28 -040094
Linus Torvalds1da177e2005-04-16 15:20:36 -070095EXPORT_SYMBOL(acpi_bus_get_device);
96
Bjorn Helgaas402ac532009-09-21 19:30:01 +000097acpi_status acpi_bus_get_status_handle(acpi_handle handle,
98 unsigned long long *sta)
99{
100 acpi_status status;
101
102 status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
103 if (ACPI_SUCCESS(status))
104 return AE_OK;
105
106 if (status == AE_NOT_FOUND) {
107 *sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
108 ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING;
109 return AE_OK;
110 }
111 return status;
112}
113
Len Brown4be44fc2005-08-05 00:44:28 -0400114int acpi_bus_get_status(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115{
Bjorn Helgaas402ac532009-09-21 19:30:01 +0000116 acpi_status status;
117 unsigned long long sta;
Len Brown4be44fc2005-08-05 00:44:28 -0400118
Bjorn Helgaas402ac532009-09-21 19:30:01 +0000119 status = acpi_bus_get_status_handle(device->handle, &sta);
120 if (ACPI_FAILURE(status))
121 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122
Bjorn Helgaas402ac532009-09-21 19:30:01 +0000123 STRUCT_TO_INT(device->status) = (int) sta;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
125 if (device->status.functional && !device->status.present) {
Zhao Yakui39a0ad82008-08-11 13:40:22 +0800126 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]: "
127 "functional but not present;\n",
128 device->pnp.bus_id,
129 (u32) STRUCT_TO_INT(device->status)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 }
131
Len Brown4be44fc2005-08-05 00:44:28 -0400132 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
133 device->pnp.bus_id,
134 (u32) STRUCT_TO_INT(device->status)));
Patrick Mocheld550d982006-06-27 00:41:40 -0400135 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136}
Len Brown4be44fc2005-08-05 00:44:28 -0400137EXPORT_SYMBOL(acpi_bus_get_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
Zhang Rui20733932008-01-17 15:51:21 +0800139void acpi_bus_private_data_handler(acpi_handle handle,
Bob Moore8e4319c2009-06-29 13:43:27 +0800140 void *context)
Zhang Rui20733932008-01-17 15:51:21 +0800141{
142 return;
143}
144EXPORT_SYMBOL(acpi_bus_private_data_handler);
145
146int acpi_bus_get_private_data(acpi_handle handle, void **data)
147{
148 acpi_status status = AE_OK;
149
150 if (!*data)
151 return -EINVAL;
152
153 status = acpi_get_data(handle, acpi_bus_private_data_handler, data);
154 if (ACPI_FAILURE(status) || !*data) {
155 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
156 handle));
157 return -ENODEV;
158 }
159
160 return 0;
161}
162EXPORT_SYMBOL(acpi_bus_get_private_data);
163
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164/* --------------------------------------------------------------------------
165 Power Management
166 -------------------------------------------------------------------------- */
167
Len Brown4be44fc2005-08-05 00:44:28 -0400168int acpi_bus_get_power(acpi_handle handle, int *state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169{
Len Brown4be44fc2005-08-05 00:44:28 -0400170 int result = 0;
171 acpi_status status = 0;
172 struct acpi_device *device = NULL;
Matthew Wilcox27663c52008-10-10 02:22:59 -0400173 unsigned long long psc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
176 result = acpi_bus_get_device(handle, &device);
177 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400178 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
180 *state = ACPI_STATE_UNKNOWN;
181
182 if (!device->flags.power_manageable) {
183 /* TBD: Non-recursive algorithm for walking up hierarchy */
184 if (device->parent)
185 *state = device->parent->power.state;
186 else
187 *state = ACPI_STATE_D0;
Len Brown4be44fc2005-08-05 00:44:28 -0400188 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 /*
Alexey Starikovskiyaafbcd12007-02-10 01:32:16 -0500190 * Get the device's power state either directly (via _PSC) or
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 * indirectly (via power resources).
192 */
193 if (device->power.flags.explicit_get) {
Len Brown4be44fc2005-08-05 00:44:28 -0400194 status = acpi_evaluate_integer(device->handle, "_PSC",
195 NULL, &psc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400197 return -ENODEV;
Len Brown4be44fc2005-08-05 00:44:28 -0400198 device->power.state = (int)psc;
199 } else if (device->power.flags.power_resources) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 result = acpi_power_get_inferred_state(device);
201 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400202 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 }
204
205 *state = device->power.state;
206 }
207
208 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400209 device->pnp.bus_id, device->power.state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
Patrick Mocheld550d982006-06-27 00:41:40 -0400211 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212}
Len Brown4be44fc2005-08-05 00:44:28 -0400213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214EXPORT_SYMBOL(acpi_bus_get_power);
215
Len Brown4be44fc2005-08-05 00:44:28 -0400216int acpi_bus_set_power(acpi_handle handle, int state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217{
Len Brown4be44fc2005-08-05 00:44:28 -0400218 int result = 0;
219 acpi_status status = AE_OK;
220 struct acpi_device *device = NULL;
221 char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
224 result = acpi_bus_get_device(handle, &device);
225 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400226 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
228 if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
Patrick Mocheld550d982006-06-27 00:41:40 -0400229 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
231 /* Make sure this is a valid target state */
232
233 if (!device->flags.power_manageable) {
Len Brown9805cb72006-07-25 13:30:57 -0400234 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device `[%s]' is not power manageable\n",
Greg Kroah-Hartman19c38de2007-09-12 15:06:57 -0700235 kobject_name(&device->dev.kobj)));
Patrick Mocheld550d982006-06-27 00:41:40 -0400236 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 }
David Shaohua Lib9131002005-03-19 00:16:18 -0500238 /*
Alexey Starikovskiyc35923b2007-10-22 14:19:09 +0400239 * Get device's current power state
David Shaohua Lib9131002005-03-19 00:16:18 -0500240 */
Zhao Yakuif5adfaa2008-08-11 14:57:50 +0800241 if (!acpi_power_nocheck) {
242 /*
243 * Maybe the incorrect power state is returned on the bogus
244 * bios, which is different with the real power state.
245 * For example: the bios returns D0 state and the real power
246 * state is D3. OS expects to set the device to D0 state. In
247 * such case if OS uses the power state returned by the BIOS,
248 * the device can't be transisted to the correct power state.
249 * So if the acpi_power_nocheck is set, it is unnecessary to
250 * get the power state by calling acpi_bus_get_power.
251 */
252 acpi_bus_get_power(device->handle, &device->power.state);
253 }
Len Brownec683732008-01-23 22:41:20 -0500254 if ((state == device->power.state) && !device->flags.force_power_state) {
Konstantin Karasyovb1028c52007-02-16 02:23:07 -0500255 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n",
256 state));
257 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 }
Konstantin Karasyovb1028c52007-02-16 02:23:07 -0500259
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 if (!device->power.states[state].flags.valid) {
Len Browncece9292006-06-26 23:04:31 -0400261 printk(KERN_WARNING PREFIX "Device does not support D%d\n", state);
Patrick Mocheld550d982006-06-27 00:41:40 -0400262 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 }
264 if (device->parent && (state < device->parent->power.state)) {
Len Browncece9292006-06-26 23:04:31 -0400265 printk(KERN_WARNING PREFIX
Thomas Renningera6fc6722006-06-26 23:58:43 -0400266 "Cannot set device to a higher-powered"
Len Browncece9292006-06-26 23:04:31 -0400267 " state than parent\n");
Patrick Mocheld550d982006-06-27 00:41:40 -0400268 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 }
270
271 /*
272 * Transition Power
273 * ----------------
274 * On transitions to a high-powered state we first apply power (via
275 * power resources) then evalute _PSx. Conversly for transitions to
276 * a lower-powered state.
David Shaohua Lib9131002005-03-19 00:16:18 -0500277 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 if (state < device->power.state) {
279 if (device->power.flags.power_resources) {
280 result = acpi_power_transition(device, state);
281 if (result)
282 goto end;
283 }
284 if (device->power.states[state].flags.explicit_set) {
Len Brown4be44fc2005-08-05 00:44:28 -0400285 status = acpi_evaluate_object(device->handle,
286 object_name, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 if (ACPI_FAILURE(status)) {
288 result = -ENODEV;
289 goto end;
290 }
291 }
Len Brown4be44fc2005-08-05 00:44:28 -0400292 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 if (device->power.states[state].flags.explicit_set) {
Len Brown4be44fc2005-08-05 00:44:28 -0400294 status = acpi_evaluate_object(device->handle,
295 object_name, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 if (ACPI_FAILURE(status)) {
297 result = -ENODEV;
298 goto end;
299 }
300 }
301 if (device->power.flags.power_resources) {
302 result = acpi_power_transition(device, state);
303 if (result)
304 goto end;
305 }
306 }
307
Len Brown4be44fc2005-08-05 00:44:28 -0400308 end:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 if (result)
Len Browncece9292006-06-26 23:04:31 -0400310 printk(KERN_WARNING PREFIX
Len Brownddc50b62009-05-08 00:07:30 -0400311 "Device [%s] failed to transition to D%d\n",
Len Browncece9292006-06-26 23:04:31 -0400312 device->pnp.bus_id, state);
Shaohua Li5e321322007-10-11 23:53:58 +0200313 else {
314 device->power.state = state;
Len Brown4be44fc2005-08-05 00:44:28 -0400315 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
316 "Device [%s] transitioned to D%d\n",
317 device->pnp.bus_id, state));
Shaohua Li5e321322007-10-11 23:53:58 +0200318 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
Patrick Mocheld550d982006-06-27 00:41:40 -0400320 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321}
Len Brown4be44fc2005-08-05 00:44:28 -0400322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323EXPORT_SYMBOL(acpi_bus_set_power);
324
Rafael J. Wysocki3737b2b2008-07-07 03:30:55 +0200325bool acpi_bus_power_manageable(acpi_handle handle)
326{
327 struct acpi_device *device;
328 int result;
329
330 result = acpi_bus_get_device(handle, &device);
331 return result ? false : device->flags.power_manageable;
332}
333
334EXPORT_SYMBOL(acpi_bus_power_manageable);
335
Rafael J. Wysockieb9d0fe2008-07-07 03:34:48 +0200336bool acpi_bus_can_wakeup(acpi_handle handle)
337{
338 struct acpi_device *device;
339 int result;
340
341 result = acpi_bus_get_device(handle, &device);
342 return result ? false : device->wakeup.flags.valid;
343}
344
345EXPORT_SYMBOL(acpi_bus_can_wakeup);
346
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347/* --------------------------------------------------------------------------
348 Event Management
349 -------------------------------------------------------------------------- */
350
Len Brown14e04fb2007-08-23 15:20:26 -0400351#ifdef CONFIG_ACPI_PROC_EVENT
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352static DEFINE_SPINLOCK(acpi_bus_event_lock);
353
354LIST_HEAD(acpi_bus_event_list);
355DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);
356
Len Brown4be44fc2005-08-05 00:44:28 -0400357extern int event_is_open;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358
Alexey Starikovskiy8db85d42007-09-26 19:43:16 +0400359int acpi_bus_generate_proc_event4(const char *device_class, const char *bus_id, u8 type, int data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360{
Alexey Starikovskiy8db85d42007-09-26 19:43:16 +0400361 struct acpi_bus_event *event;
Len Brown4be44fc2005-08-05 00:44:28 -0400362 unsigned long flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 /* drop event on the floor if no one's listening */
365 if (!event_is_open)
Patrick Mocheld550d982006-06-27 00:41:40 -0400366 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
368 event = kmalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
369 if (!event)
Patrick Mocheld550d982006-06-27 00:41:40 -0400370 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371
Alexey Starikovskiy8db85d42007-09-26 19:43:16 +0400372 strcpy(event->device_class, device_class);
373 strcpy(event->bus_id, bus_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 event->type = type;
375 event->data = data;
376
377 spin_lock_irqsave(&acpi_bus_event_lock, flags);
378 list_add_tail(&event->node, &acpi_bus_event_list);
379 spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
380
381 wake_up_interruptible(&acpi_bus_event_queue);
382
Patrick Mocheld550d982006-06-27 00:41:40 -0400383 return 0;
Alexey Starikovskiy8db85d42007-09-26 19:43:16 +0400384
385}
386
387EXPORT_SYMBOL_GPL(acpi_bus_generate_proc_event4);
388
389int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data)
390{
391 if (!device)
392 return -EINVAL;
393 return acpi_bus_generate_proc_event4(device->pnp.device_class,
394 device->pnp.bus_id, type, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395}
Len Brown4be44fc2005-08-05 00:44:28 -0400396
Len Brown14e04fb2007-08-23 15:20:26 -0400397EXPORT_SYMBOL(acpi_bus_generate_proc_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
Len Brown4be44fc2005-08-05 00:44:28 -0400399int acpi_bus_receive_event(struct acpi_bus_event *event)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400{
Len Brown4be44fc2005-08-05 00:44:28 -0400401 unsigned long flags = 0;
402 struct acpi_bus_event *entry = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
404 DECLARE_WAITQUEUE(wait, current);
405
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
407 if (!event)
Patrick Mocheld550d982006-06-27 00:41:40 -0400408 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
410 if (list_empty(&acpi_bus_event_list)) {
411
412 set_current_state(TASK_INTERRUPTIBLE);
413 add_wait_queue(&acpi_bus_event_queue, &wait);
414
415 if (list_empty(&acpi_bus_event_list))
416 schedule();
417
418 remove_wait_queue(&acpi_bus_event_queue, &wait);
419 set_current_state(TASK_RUNNING);
420
421 if (signal_pending(current))
Patrick Mocheld550d982006-06-27 00:41:40 -0400422 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 }
424
425 spin_lock_irqsave(&acpi_bus_event_lock, flags);
Chuck Ebbertf0a37e02008-04-15 14:34:47 -0700426 if (!list_empty(&acpi_bus_event_list)) {
427 entry = list_entry(acpi_bus_event_list.next,
428 struct acpi_bus_event, node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 list_del(&entry->node);
Chuck Ebbertf0a37e02008-04-15 14:34:47 -0700430 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
432
433 if (!entry)
Patrick Mocheld550d982006-06-27 00:41:40 -0400434 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
436 memcpy(event, entry, sizeof(struct acpi_bus_event));
437
438 kfree(entry);
439
Patrick Mocheld550d982006-06-27 00:41:40 -0400440 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
Len Brown14e04fb2007-08-23 15:20:26 -0400443#endif /* CONFIG_ACPI_PROC_EVENT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
445/* --------------------------------------------------------------------------
446 Notification Handling
447 -------------------------------------------------------------------------- */
448
Bjorn Helgaasff754e22009-05-22 11:43:56 -0600449static void acpi_bus_check_device(acpi_handle handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450{
Bjorn Helgaasff754e22009-05-22 11:43:56 -0600451 struct acpi_device *device;
Bjorn Helgaascdd5b8c2009-05-22 11:43:51 -0600452 acpi_status status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 struct acpi_device_status old_status;
454
Bjorn Helgaasff754e22009-05-22 11:43:56 -0600455 if (acpi_bus_get_device(handle, &device))
456 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 if (!device)
Bjorn Helgaascdd5b8c2009-05-22 11:43:51 -0600458 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 old_status = device->status;
461
462 /*
463 * Make sure this device's parent is present before we go about
464 * messing with the device.
465 */
466 if (device->parent && !device->parent->status.present) {
467 device->status = device->parent->status;
Bjorn Helgaascdd5b8c2009-05-22 11:43:51 -0600468 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 }
470
471 status = acpi_bus_get_status(device);
472 if (ACPI_FAILURE(status))
Bjorn Helgaascdd5b8c2009-05-22 11:43:51 -0600473 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
475 if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
Bjorn Helgaascdd5b8c2009-05-22 11:43:51 -0600476 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 /*
479 * Device Insertion/Removal
480 */
481 if ((device->status.present) && !(old_status.present)) {
482 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device insertion detected\n"));
483 /* TBD: Handle device insertion */
Len Brown4be44fc2005-08-05 00:44:28 -0400484 } else if (!(device->status.present) && (old_status.present)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n"));
486 /* TBD: Handle device removal */
487 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488}
489
Bjorn Helgaasff754e22009-05-22 11:43:56 -0600490static void acpi_bus_check_scope(acpi_handle handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 /* Status Change? */
Bjorn Helgaasff754e22009-05-22 11:43:56 -0600493 acpi_bus_check_device(handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 /*
496 * TBD: Enumerate child devices within this device's scope and
497 * run acpi_bus_check_device()'s on them.
498 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499}
500
Shaohua Li6bd00a62008-08-28 10:04:29 +0800501static BLOCKING_NOTIFIER_HEAD(acpi_bus_notify_list);
502int register_acpi_bus_notifier(struct notifier_block *nb)
503{
504 return blocking_notifier_chain_register(&acpi_bus_notify_list, nb);
505}
506EXPORT_SYMBOL_GPL(register_acpi_bus_notifier);
507
508void unregister_acpi_bus_notifier(struct notifier_block *nb)
509{
510 blocking_notifier_chain_unregister(&acpi_bus_notify_list, nb);
511}
512EXPORT_SYMBOL_GPL(unregister_acpi_bus_notifier);
513
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514/**
515 * acpi_bus_notify
516 * ---------------
517 * Callback for all 'system-level' device notifications (values 0x00-0x7F).
518 */
Len Brown4be44fc2005-08-05 00:44:28 -0400519static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520{
Len Brown4be44fc2005-08-05 00:44:28 -0400521 struct acpi_device *device = NULL;
Bjorn Helgaas6d278132009-04-30 09:35:37 -0600522 struct acpi_driver *driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
Bjorn Helgaas02c37bd2009-05-22 11:43:41 -0600524 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Notification %#02x to handle %p\n",
525 type, handle));
526
Shaohua Li6bd00a62008-08-28 10:04:29 +0800527 blocking_notifier_call_chain(&acpi_bus_notify_list,
528 type, (void *)handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 switch (type) {
531
532 case ACPI_NOTIFY_BUS_CHECK:
Bjorn Helgaasff754e22009-05-22 11:43:56 -0600533 acpi_bus_check_scope(handle);
Alexey Starikovskiyaafbcd12007-02-10 01:32:16 -0500534 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 * TBD: We'll need to outsource certain events to non-ACPI
Len Brown4be44fc2005-08-05 00:44:28 -0400536 * drivers via the device manager (device.c).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 */
538 break;
539
540 case ACPI_NOTIFY_DEVICE_CHECK:
Bjorn Helgaasff754e22009-05-22 11:43:56 -0600541 acpi_bus_check_device(handle);
Alexey Starikovskiyaafbcd12007-02-10 01:32:16 -0500542 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 * TBD: We'll need to outsource certain events to non-ACPI
Len Brown4be44fc2005-08-05 00:44:28 -0400544 * drivers via the device manager (device.c).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 */
546 break;
547
548 case ACPI_NOTIFY_DEVICE_WAKE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 /* TBD */
550 break;
551
552 case ACPI_NOTIFY_EJECT_REQUEST:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 /* TBD */
554 break;
555
556 case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 /* TBD: Exactly what does 'light' mean? */
558 break;
559
560 case ACPI_NOTIFY_FREQUENCY_MISMATCH:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 /* TBD */
562 break;
563
564 case ACPI_NOTIFY_BUS_MODE_MISMATCH:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 /* TBD */
566 break;
567
568 case ACPI_NOTIFY_POWER_FAULT:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 /* TBD */
570 break;
571
572 default:
Len Brown4be44fc2005-08-05 00:44:28 -0400573 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
574 "Received unknown/unsupported notification [%08x]\n",
575 type));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 break;
577 }
578
Bjorn Helgaasff754e22009-05-22 11:43:56 -0600579 acpi_bus_get_device(handle, &device);
580 if (device) {
581 driver = device->driver;
582 if (driver && driver->ops.notify &&
583 (driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS))
584 driver->ops.notify(device, type);
585 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586}
587
588/* --------------------------------------------------------------------------
589 Initialization/Cleanup
590 -------------------------------------------------------------------------- */
591
Len Brown4be44fc2005-08-05 00:44:28 -0400592static int __init acpi_bus_init_irq(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593{
Len Brown4be44fc2005-08-05 00:44:28 -0400594 acpi_status status = AE_OK;
595 union acpi_object arg = { ACPI_TYPE_INTEGER };
596 struct acpi_object_list arg_list = { 1, &arg };
597 char *message = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
Alexey Starikovskiyaafbcd12007-02-10 01:32:16 -0500600 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 * Let the system know what interrupt model we are using by
602 * evaluating the \_PIC object, if exists.
603 */
604
605 switch (acpi_irq_model) {
606 case ACPI_IRQ_MODEL_PIC:
607 message = "PIC";
608 break;
609 case ACPI_IRQ_MODEL_IOAPIC:
610 message = "IOAPIC";
611 break;
612 case ACPI_IRQ_MODEL_IOSAPIC:
613 message = "IOSAPIC";
614 break;
John Keller3948ec92006-12-22 11:50:04 -0600615 case ACPI_IRQ_MODEL_PLATFORM:
616 message = "platform specific model";
617 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 default:
619 printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
Patrick Mocheld550d982006-06-27 00:41:40 -0400620 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 }
622
623 printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);
624
625 arg.integer.value = acpi_irq_model;
626
627 status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL);
628 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400629 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400630 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 }
632
Patrick Mocheld550d982006-06-27 00:41:40 -0400633 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634}
635
Bob Moore67a119f2008-06-10 13:42:13 +0800636u8 acpi_gbl_permanent_mmap;
Alexey Starikovskiyad718602007-02-02 19:48:19 +0300637
638
Len Brown4be44fc2005-08-05 00:44:28 -0400639void __init acpi_early_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640{
Len Brown4be44fc2005-08-05 00:44:28 -0400641 acpi_status status = AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642
643 if (acpi_disabled)
Patrick Mocheld550d982006-06-27 00:41:40 -0400644 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
Bob Moore61686122006-03-17 16:44:00 -0500646 printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);
647
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 /* enable workarounds, unless strict ACPI spec. compliance */
649 if (!acpi_strict)
650 acpi_gbl_enable_interpreter_slack = TRUE;
651
Alexey Starikovskiyad718602007-02-02 19:48:19 +0300652 acpi_gbl_permanent_mmap = 1;
653
654 status = acpi_reallocate_root_table();
655 if (ACPI_FAILURE(status)) {
656 printk(KERN_ERR PREFIX
657 "Unable to reallocate ACPI tables\n");
658 goto error0;
659 }
660
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 status = acpi_initialize_subsystem();
662 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400663 printk(KERN_ERR PREFIX
664 "Unable to initialize the ACPI Interpreter\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 goto error0;
666 }
667
668 status = acpi_load_tables();
669 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400670 printk(KERN_ERR PREFIX
671 "Unable to load the System Description Tables\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 goto error0;
673 }
674
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675#ifdef CONFIG_X86
676 if (!acpi_ioapic) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 /* compatible (0) means level (3) */
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300678 if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) {
679 acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK;
680 acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL;
681 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 /* Set PIC-mode SCI trigger type */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300683 acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt,
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300684 (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 /*
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300687 * now that acpi_gbl_FADT is initialized,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 * update it with result from INT_SRC_OVR parsing
689 */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300690 acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 }
692#endif
693
Len Brown4be44fc2005-08-05 00:44:28 -0400694 status =
695 acpi_enable_subsystem(~
696 (ACPI_NO_HARDWARE_INIT |
697 ACPI_NO_ACPI_ENABLE));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 if (ACPI_FAILURE(status)) {
699 printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
700 goto error0;
701 }
702
Patrick Mocheld550d982006-06-27 00:41:40 -0400703 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704
Len Brown4be44fc2005-08-05 00:44:28 -0400705 error0:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 disable_acpi();
Patrick Mocheld550d982006-06-27 00:41:40 -0400707 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708}
709
Len Brown4be44fc2005-08-05 00:44:28 -0400710static int __init acpi_bus_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711{
Len Brown4be44fc2005-08-05 00:44:28 -0400712 int result = 0;
713 acpi_status status = AE_OK;
714 extern acpi_status acpi_os_initialize1(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
Jiri Slaby176f9c12009-03-04 11:55:27 -0800716 acpi_os_initialize1();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
Len Brown4be44fc2005-08-05 00:44:28 -0400718 status =
719 acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400721 printk(KERN_ERR PREFIX
722 "Unable to start the ACPI Interpreter\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 goto error1;
724 }
725
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 /*
727 * ACPI 2.0 requires the EC driver to be loaded and work before
728 * the EC device is found in the namespace (i.e. before acpi_initialize_objects()
729 * is called).
730 *
Alexey Starikovskiyaafbcd12007-02-10 01:32:16 -0500731 * This is accomplished by looking for the ECDT table, and getting
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 * the EC parameters out of that.
733 */
734 status = acpi_ec_ecdt_probe();
735 /* Ignore result. Not having an ECDT is not fatal. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
737 status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
738 if (ACPI_FAILURE(status)) {
739 printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
740 goto error1;
741 }
742
Zhao Yakui455c8792008-10-06 10:31:36 +0800743 /*
744 * Maybe EC region is required at bus_scan/acpi_get_devices. So it
745 * is necessary to enable it as early as possible.
746 */
747 acpi_boot_ec_enable();
748
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 printk(KERN_INFO PREFIX "Interpreter enabled\n");
750
Alexey Starikovskiyaafbcd12007-02-10 01:32:16 -0500751 /* Initialize sleep structures */
752 acpi_sleep_init();
753
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 /*
755 * Get the system interrupt model and evaluate \_PIC.
756 */
757 result = acpi_bus_init_irq();
758 if (result)
759 goto error1;
760
761 /*
762 * Register the for all standard device notifications.
763 */
Len Brown4be44fc2005-08-05 00:44:28 -0400764 status =
765 acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
766 &acpi_bus_notify, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400768 printk(KERN_ERR PREFIX
769 "Unable to register for device notifications\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 goto error1;
771 }
772
773 /*
774 * Create the top ACPI proc directory
775 */
776 acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
777
Patrick Mocheld550d982006-06-27 00:41:40 -0400778 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
780 /* Mimic structured exception handling */
Len Brown4be44fc2005-08-05 00:44:28 -0400781 error1:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 acpi_terminate();
Patrick Mocheld550d982006-06-27 00:41:40 -0400783 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784}
785
Greg Kroah-Hartman99e0d2f2007-11-02 16:19:59 -0700786struct kobject *acpi_kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787
Len Brown4be44fc2005-08-05 00:44:28 -0400788static int __init acpi_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789{
Len Brown4be44fc2005-08-05 00:44:28 -0400790 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 if (acpi_disabled) {
794 printk(KERN_INFO PREFIX "Interpreter disabled.\n");
Patrick Mocheld550d982006-06-27 00:41:40 -0400795 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 }
797
Greg Kroah-Hartmanf62ed9e2007-11-05 13:16:15 -0800798 acpi_kobj = kobject_create_and_add("acpi", firmware_kobj);
Greg Kroah-Hartman99e0d2f2007-11-02 16:19:59 -0700799 if (!acpi_kobj) {
Harvey Harrison96b2dd12008-03-05 18:24:51 -0800800 printk(KERN_WARNING "%s: kset create error\n", __func__);
Greg Kroah-Hartman99e0d2f2007-11-02 16:19:59 -0700801 acpi_kobj = NULL;
802 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803
Bjorn Helgaas0e465172009-03-24 16:50:09 -0600804 init_acpi_device_notify();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 result = acpi_bus_init();
806
807 if (!result) {
Robert Hancock7752d5c2008-02-15 01:27:20 -0800808 pci_mmcfg_late_init();
Len Brown9f9adec2007-12-13 17:38:03 -0500809 if (!(pm_flags & PM_APM))
810 pm_flags |= PM_ACPI;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 else {
Len Brown4be44fc2005-08-05 00:44:28 -0400812 printk(KERN_INFO PREFIX
813 "APM is already active, exiting\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 disable_acpi();
815 result = -ENODEV;
816 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 } else
818 disable_acpi();
Bjorn Helgaas81d02732009-03-24 16:49:38 -0600819
820 if (acpi_disabled)
821 return result;
822
Zhao Yakui6415e122008-08-11 14:59:59 +0800823 /*
824 * If the laptop falls into the DMI check table, the power state check
825 * will be disabled in the course of device power transistion.
826 */
827 dmi_check_system(power_nocheck_dmi_table);
Bjorn Helgaase747f272009-03-24 16:49:43 -0600828
829 acpi_scan_init();
Bjorn Helgaasa5f820f2009-03-24 16:49:48 -0600830 acpi_ec_init();
Bjorn Helgaas44515372009-03-24 16:49:53 -0600831 acpi_power_init();
Bjorn Helgaas141a0af2009-03-24 16:49:58 -0600832 acpi_system_init();
Bjorn Helgaas84f810c2009-03-24 16:50:03 -0600833 acpi_debug_init();
Bjorn Helgaas9cee43e2009-03-24 16:50:14 -0600834 acpi_sleep_proc_init();
Bjorn Helgaas201b8c62009-03-24 16:50:19 -0600835 acpi_wakeup_device_init();
Patrick Mocheld550d982006-06-27 00:41:40 -0400836 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837}
838
839subsys_initcall(acpi_init);