blob: dd49ea0d0ed3606a69dfc2a9580b64768ced7cb9 [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>
Jeff Garzikbca73e42005-11-13 16:06:25 -080032#include <linux/pm_legacy.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/device.h>
34#include <linux/proc_fs.h>
35#ifdef CONFIG_X86
36#include <asm/mpspec.h>
37#endif
38#include <acpi/acpi_bus.h>
39#include <acpi/acpi_drivers.h>
40
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#define _COMPONENT ACPI_BUS_COMPONENT
Len Brownf52fd662007-02-12 22:42:12 -050042ACPI_MODULE_NAME("bus");
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#ifdef CONFIG_X86
44extern void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger);
45#endif
46
Len Brown4be44fc2005-08-05 00:44:28 -040047struct acpi_device *acpi_root;
48struct proc_dir_entry *acpi_root_dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049EXPORT_SYMBOL(acpi_root_dir);
50
51#define STRUCT_TO_INT(s) (*((int*)&s))
52
53/* --------------------------------------------------------------------------
54 Device Management
55 -------------------------------------------------------------------------- */
56
Len Brown4be44fc2005-08-05 00:44:28 -040057int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058{
Len Brown4be44fc2005-08-05 00:44:28 -040059 acpi_status status = AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -040063 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
65 /* TBD: Support fixed-feature devices */
66
Len Brown4be44fc2005-08-05 00:44:28 -040067 status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 if (ACPI_FAILURE(status) || !*device) {
Len Brown9805cb72006-07-25 13:30:57 -040069 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
70 handle));
Patrick Mocheld550d982006-06-27 00:41:40 -040071 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 }
73
Patrick Mocheld550d982006-06-27 00:41:40 -040074 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075}
Len Brown4be44fc2005-08-05 00:44:28 -040076
Linus Torvalds1da177e2005-04-16 15:20:36 -070077EXPORT_SYMBOL(acpi_bus_get_device);
78
Len Brown4be44fc2005-08-05 00:44:28 -040079int acpi_bus_get_status(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -070080{
Len Brown4be44fc2005-08-05 00:44:28 -040081 acpi_status status = AE_OK;
82 unsigned long sta = 0;
83
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
85 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -040086 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
88 /*
89 * Evaluate _STA if present.
90 */
91 if (device->flags.dynamic_status) {
Len Brown4be44fc2005-08-05 00:44:28 -040092 status =
93 acpi_evaluate_integer(device->handle, "_STA", NULL, &sta);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -040095 return -ENODEV;
Len Brown4be44fc2005-08-05 00:44:28 -040096 STRUCT_TO_INT(device->status) = (int)sta;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 }
98
99 /*
100 * Otherwise we assume the status of our parent (unless we don't
101 * have one, in which case status is implied).
102 */
103 else if (device->parent)
104 device->status = device->parent->status;
105 else
106 STRUCT_TO_INT(device->status) = 0x0F;
107
108 if (device->status.functional && !device->status.present) {
109 printk(KERN_WARNING PREFIX "Device [%s] status [%08x]: "
Len Brown4be44fc2005-08-05 00:44:28 -0400110 "functional but not present; setting present\n",
111 device->pnp.bus_id, (u32) STRUCT_TO_INT(device->status));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 device->status.present = 1;
113 }
114
Len Brown4be44fc2005-08-05 00:44:28 -0400115 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
116 device->pnp.bus_id,
117 (u32) STRUCT_TO_INT(device->status)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
Patrick Mocheld550d982006-06-27 00:41:40 -0400119 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121
Len Brown4be44fc2005-08-05 00:44:28 -0400122EXPORT_SYMBOL(acpi_bus_get_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
124/* --------------------------------------------------------------------------
125 Power Management
126 -------------------------------------------------------------------------- */
127
Len Brown4be44fc2005-08-05 00:44:28 -0400128int acpi_bus_get_power(acpi_handle handle, int *state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129{
Len Brown4be44fc2005-08-05 00:44:28 -0400130 int result = 0;
131 acpi_status status = 0;
132 struct acpi_device *device = NULL;
133 unsigned long psc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
136 result = acpi_bus_get_device(handle, &device);
137 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400138 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
140 *state = ACPI_STATE_UNKNOWN;
141
142 if (!device->flags.power_manageable) {
143 /* TBD: Non-recursive algorithm for walking up hierarchy */
144 if (device->parent)
145 *state = device->parent->power.state;
146 else
147 *state = ACPI_STATE_D0;
Len Brown4be44fc2005-08-05 00:44:28 -0400148 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 /*
Alexey Starikovskiyaafbcd12007-02-10 01:32:16 -0500150 * Get the device's power state either directly (via _PSC) or
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 * indirectly (via power resources).
152 */
153 if (device->power.flags.explicit_get) {
Len Brown4be44fc2005-08-05 00:44:28 -0400154 status = acpi_evaluate_integer(device->handle, "_PSC",
155 NULL, &psc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400157 return -ENODEV;
Len Brown4be44fc2005-08-05 00:44:28 -0400158 device->power.state = (int)psc;
159 } else if (device->power.flags.power_resources) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 result = acpi_power_get_inferred_state(device);
161 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400162 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 }
164
165 *state = device->power.state;
166 }
167
168 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400169 device->pnp.bus_id, device->power.state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Patrick Mocheld550d982006-06-27 00:41:40 -0400171 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172}
Len Brown4be44fc2005-08-05 00:44:28 -0400173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174EXPORT_SYMBOL(acpi_bus_get_power);
175
Len Brown4be44fc2005-08-05 00:44:28 -0400176int acpi_bus_set_power(acpi_handle handle, int state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177{
Len Brown4be44fc2005-08-05 00:44:28 -0400178 int result = 0;
179 acpi_status status = AE_OK;
180 struct acpi_device *device = NULL;
181 char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
184 result = acpi_bus_get_device(handle, &device);
185 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400186 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
188 if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
Patrick Mocheld550d982006-06-27 00:41:40 -0400189 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
191 /* Make sure this is a valid target state */
192
193 if (!device->flags.power_manageable) {
Len Brown9805cb72006-07-25 13:30:57 -0400194 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device `[%s]' is not power manageable\n",
Patrick Mochelf883d9d2006-12-07 20:56:38 +0800195 device->dev.kobj.name));
Patrick Mocheld550d982006-06-27 00:41:40 -0400196 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 }
David Shaohua Lib9131002005-03-19 00:16:18 -0500198 /*
199 * Get device's current power state if it's unknown
200 * This means device power state isn't initialized or previous setting failed
201 */
Konstantin Karasyovb1028c52007-02-16 02:23:07 -0500202 if ((device->power.state == ACPI_STATE_UNKNOWN) || device->flags.force_power_state)
203 acpi_bus_get_power(device->handle, &device->power.state);
204 if ((state == device->power.state) && !device->flags.force_power_state) {
205 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n",
206 state));
207 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 }
Konstantin Karasyovb1028c52007-02-16 02:23:07 -0500209
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 if (!device->power.states[state].flags.valid) {
Len Browncece9292006-06-26 23:04:31 -0400211 printk(KERN_WARNING PREFIX "Device does not support D%d\n", state);
Patrick Mocheld550d982006-06-27 00:41:40 -0400212 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 }
214 if (device->parent && (state < device->parent->power.state)) {
Len Browncece9292006-06-26 23:04:31 -0400215 printk(KERN_WARNING PREFIX
Thomas Renningera6fc6722006-06-26 23:58:43 -0400216 "Cannot set device to a higher-powered"
Len Browncece9292006-06-26 23:04:31 -0400217 " state than parent\n");
Patrick Mocheld550d982006-06-27 00:41:40 -0400218 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 }
220
221 /*
222 * Transition Power
223 * ----------------
224 * On transitions to a high-powered state we first apply power (via
225 * power resources) then evalute _PSx. Conversly for transitions to
226 * a lower-powered state.
David Shaohua Lib9131002005-03-19 00:16:18 -0500227 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 if (state < device->power.state) {
229 if (device->power.flags.power_resources) {
230 result = acpi_power_transition(device, state);
231 if (result)
232 goto end;
233 }
234 if (device->power.states[state].flags.explicit_set) {
Len Brown4be44fc2005-08-05 00:44:28 -0400235 status = acpi_evaluate_object(device->handle,
236 object_name, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 if (ACPI_FAILURE(status)) {
238 result = -ENODEV;
239 goto end;
240 }
241 }
Len Brown4be44fc2005-08-05 00:44:28 -0400242 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 if (device->power.states[state].flags.explicit_set) {
Len Brown4be44fc2005-08-05 00:44:28 -0400244 status = acpi_evaluate_object(device->handle,
245 object_name, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 if (ACPI_FAILURE(status)) {
247 result = -ENODEV;
248 goto end;
249 }
250 }
251 if (device->power.flags.power_resources) {
252 result = acpi_power_transition(device, state);
253 if (result)
254 goto end;
255 }
256 }
257
Len Brown4be44fc2005-08-05 00:44:28 -0400258 end:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 if (result)
Len Browncece9292006-06-26 23:04:31 -0400260 printk(KERN_WARNING PREFIX
261 "Transitioning device [%s] to D%d\n",
262 device->pnp.bus_id, state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 else
Len Brown4be44fc2005-08-05 00:44:28 -0400264 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
265 "Device [%s] transitioned to D%d\n",
266 device->pnp.bus_id, state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
Patrick Mocheld550d982006-06-27 00:41:40 -0400268 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269}
Len Brown4be44fc2005-08-05 00:44:28 -0400270
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271EXPORT_SYMBOL(acpi_bus_set_power);
272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273/* --------------------------------------------------------------------------
274 Event Management
275 -------------------------------------------------------------------------- */
276
277static DEFINE_SPINLOCK(acpi_bus_event_lock);
278
279LIST_HEAD(acpi_bus_event_list);
280DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);
281
Len Brown4be44fc2005-08-05 00:44:28 -0400282extern int event_is_open;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
Len Brown4be44fc2005-08-05 00:44:28 -0400284int acpi_bus_generate_event(struct acpi_device *device, u8 type, int data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285{
Len Brown4be44fc2005-08-05 00:44:28 -0400286 struct acpi_bus_event *event = NULL;
287 unsigned long flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
290 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400291 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
293 /* drop event on the floor if no one's listening */
294 if (!event_is_open)
Patrick Mocheld550d982006-06-27 00:41:40 -0400295 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
297 event = kmalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
298 if (!event)
Patrick Mocheld550d982006-06-27 00:41:40 -0400299 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
301 strcpy(event->device_class, device->pnp.device_class);
302 strcpy(event->bus_id, device->pnp.bus_id);
303 event->type = type;
304 event->data = data;
305
306 spin_lock_irqsave(&acpi_bus_event_lock, flags);
307 list_add_tail(&event->node, &acpi_bus_event_list);
308 spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
309
310 wake_up_interruptible(&acpi_bus_event_queue);
311
Patrick Mocheld550d982006-06-27 00:41:40 -0400312 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313}
Len Brown4be44fc2005-08-05 00:44:28 -0400314
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315EXPORT_SYMBOL(acpi_bus_generate_event);
316
Len Brown4be44fc2005-08-05 00:44:28 -0400317int acpi_bus_receive_event(struct acpi_bus_event *event)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318{
Len Brown4be44fc2005-08-05 00:44:28 -0400319 unsigned long flags = 0;
320 struct acpi_bus_event *entry = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
322 DECLARE_WAITQUEUE(wait, current);
323
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324
325 if (!event)
Patrick Mocheld550d982006-06-27 00:41:40 -0400326 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
328 if (list_empty(&acpi_bus_event_list)) {
329
330 set_current_state(TASK_INTERRUPTIBLE);
331 add_wait_queue(&acpi_bus_event_queue, &wait);
332
333 if (list_empty(&acpi_bus_event_list))
334 schedule();
335
336 remove_wait_queue(&acpi_bus_event_queue, &wait);
337 set_current_state(TASK_RUNNING);
338
339 if (signal_pending(current))
Patrick Mocheld550d982006-06-27 00:41:40 -0400340 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 }
342
343 spin_lock_irqsave(&acpi_bus_event_lock, flags);
Len Brown4be44fc2005-08-05 00:44:28 -0400344 entry =
345 list_entry(acpi_bus_event_list.next, struct acpi_bus_event, node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 if (entry)
347 list_del(&entry->node);
348 spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
349
350 if (!entry)
Patrick Mocheld550d982006-06-27 00:41:40 -0400351 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
353 memcpy(event, entry, sizeof(struct acpi_bus_event));
354
355 kfree(entry);
356
Patrick Mocheld550d982006-06-27 00:41:40 -0400357 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
Len Brown4be44fc2005-08-05 00:44:28 -0400360EXPORT_SYMBOL(acpi_bus_receive_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
362/* --------------------------------------------------------------------------
363 Notification Handling
364 -------------------------------------------------------------------------- */
365
366static int
Len Brown4be44fc2005-08-05 00:44:28 -0400367acpi_bus_check_device(struct acpi_device *device, int *status_changed)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368{
Len Brown4be44fc2005-08-05 00:44:28 -0400369 acpi_status status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 struct acpi_device_status old_status;
371
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
373 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400374 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375
376 if (status_changed)
377 *status_changed = 0;
378
379 old_status = device->status;
380
381 /*
382 * Make sure this device's parent is present before we go about
383 * messing with the device.
384 */
385 if (device->parent && !device->parent->status.present) {
386 device->status = device->parent->status;
387 if (STRUCT_TO_INT(old_status) != STRUCT_TO_INT(device->status)) {
388 if (status_changed)
389 *status_changed = 1;
390 }
Patrick Mocheld550d982006-06-27 00:41:40 -0400391 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 }
393
394 status = acpi_bus_get_status(device);
395 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400396 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
398 if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400399 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
401 if (status_changed)
402 *status_changed = 1;
Len Brown4be44fc2005-08-05 00:44:28 -0400403
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 /*
405 * Device Insertion/Removal
406 */
407 if ((device->status.present) && !(old_status.present)) {
408 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device insertion detected\n"));
409 /* TBD: Handle device insertion */
Len Brown4be44fc2005-08-05 00:44:28 -0400410 } else if (!(device->status.present) && (old_status.present)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n"));
412 /* TBD: Handle device removal */
413 }
414
Patrick Mocheld550d982006-06-27 00:41:40 -0400415 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416}
417
Len Brown4be44fc2005-08-05 00:44:28 -0400418static int acpi_bus_check_scope(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419{
Len Brown4be44fc2005-08-05 00:44:28 -0400420 int result = 0;
421 int status_changed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
424 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400425 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
427 /* Status Change? */
428 result = acpi_bus_check_device(device, &status_changed);
429 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400430 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
432 if (!status_changed)
Patrick Mocheld550d982006-06-27 00:41:40 -0400433 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
435 /*
436 * TBD: Enumerate child devices within this device's scope and
437 * run acpi_bus_check_device()'s on them.
438 */
439
Patrick Mocheld550d982006-06-27 00:41:40 -0400440 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441}
442
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443/**
444 * acpi_bus_notify
445 * ---------------
446 * Callback for all 'system-level' device notifications (values 0x00-0x7F).
447 */
Len Brown4be44fc2005-08-05 00:44:28 -0400448static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449{
Len Brown4be44fc2005-08-05 00:44:28 -0400450 int result = 0;
451 struct acpi_device *device = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
454 if (acpi_bus_get_device(handle, &device))
Patrick Mocheld550d982006-06-27 00:41:40 -0400455 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
457 switch (type) {
458
459 case ACPI_NOTIFY_BUS_CHECK:
Len Brown4be44fc2005-08-05 00:44:28 -0400460 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
461 "Received BUS CHECK notification for device [%s]\n",
462 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 result = acpi_bus_check_scope(device);
Alexey Starikovskiyaafbcd12007-02-10 01:32:16 -0500464 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 * TBD: We'll need to outsource certain events to non-ACPI
Len Brown4be44fc2005-08-05 00:44:28 -0400466 * drivers via the device manager (device.c).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 */
468 break;
469
470 case ACPI_NOTIFY_DEVICE_CHECK:
Len Brown4be44fc2005-08-05 00:44:28 -0400471 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
472 "Received DEVICE CHECK notification for device [%s]\n",
473 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 result = acpi_bus_check_device(device, NULL);
Alexey Starikovskiyaafbcd12007-02-10 01:32:16 -0500475 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 * TBD: We'll need to outsource certain events to non-ACPI
Len Brown4be44fc2005-08-05 00:44:28 -0400477 * drivers via the device manager (device.c).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 */
479 break;
480
481 case ACPI_NOTIFY_DEVICE_WAKE:
Len Brown4be44fc2005-08-05 00:44:28 -0400482 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
483 "Received DEVICE WAKE notification for device [%s]\n",
484 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 /* TBD */
486 break;
487
488 case ACPI_NOTIFY_EJECT_REQUEST:
Len Brown4be44fc2005-08-05 00:44:28 -0400489 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
490 "Received EJECT REQUEST notification for device [%s]\n",
491 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 /* TBD */
493 break;
494
495 case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
Len Brown4be44fc2005-08-05 00:44:28 -0400496 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
497 "Received DEVICE CHECK LIGHT notification for device [%s]\n",
498 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 /* TBD: Exactly what does 'light' mean? */
500 break;
501
502 case ACPI_NOTIFY_FREQUENCY_MISMATCH:
Len Brown4be44fc2005-08-05 00:44:28 -0400503 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
504 "Received FREQUENCY MISMATCH notification for device [%s]\n",
505 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 /* TBD */
507 break;
508
509 case ACPI_NOTIFY_BUS_MODE_MISMATCH:
Len Brown4be44fc2005-08-05 00:44:28 -0400510 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
511 "Received BUS MODE MISMATCH notification for device [%s]\n",
512 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 /* TBD */
514 break;
515
516 case ACPI_NOTIFY_POWER_FAULT:
Len Brown4be44fc2005-08-05 00:44:28 -0400517 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
518 "Received POWER FAULT notification for device [%s]\n",
519 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 /* TBD */
521 break;
522
523 default:
Len Brown4be44fc2005-08-05 00:44:28 -0400524 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
525 "Received unknown/unsupported notification [%08x]\n",
526 type));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 break;
528 }
529
Patrick Mocheld550d982006-06-27 00:41:40 -0400530 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531}
532
533/* --------------------------------------------------------------------------
534 Initialization/Cleanup
535 -------------------------------------------------------------------------- */
536
Len Brown4be44fc2005-08-05 00:44:28 -0400537static int __init acpi_bus_init_irq(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538{
Len Brown4be44fc2005-08-05 00:44:28 -0400539 acpi_status status = AE_OK;
540 union acpi_object arg = { ACPI_TYPE_INTEGER };
541 struct acpi_object_list arg_list = { 1, &arg };
542 char *message = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
Alexey Starikovskiyaafbcd12007-02-10 01:32:16 -0500545 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 * Let the system know what interrupt model we are using by
547 * evaluating the \_PIC object, if exists.
548 */
549
550 switch (acpi_irq_model) {
551 case ACPI_IRQ_MODEL_PIC:
552 message = "PIC";
553 break;
554 case ACPI_IRQ_MODEL_IOAPIC:
555 message = "IOAPIC";
556 break;
557 case ACPI_IRQ_MODEL_IOSAPIC:
558 message = "IOSAPIC";
559 break;
John Keller3948ec92006-12-22 11:50:04 -0600560 case ACPI_IRQ_MODEL_PLATFORM:
561 message = "platform specific model";
562 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 default:
564 printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
Patrick Mocheld550d982006-06-27 00:41:40 -0400565 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 }
567
568 printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);
569
570 arg.integer.value = acpi_irq_model;
571
572 status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL);
573 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400574 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400575 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 }
577
Patrick Mocheld550d982006-06-27 00:41:40 -0400578 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579}
580
Alexey Starikovskiyad718602007-02-02 19:48:19 +0300581acpi_native_uint acpi_gbl_permanent_mmap;
582
583
Len Brown4be44fc2005-08-05 00:44:28 -0400584void __init acpi_early_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
Len Brown4be44fc2005-08-05 00:44:28 -0400586 acpi_status status = AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
588 if (acpi_disabled)
Patrick Mocheld550d982006-06-27 00:41:40 -0400589 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
Bob Moore61686122006-03-17 16:44:00 -0500591 printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);
592
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 /* enable workarounds, unless strict ACPI spec. compliance */
594 if (!acpi_strict)
595 acpi_gbl_enable_interpreter_slack = TRUE;
596
Alexey Starikovskiyad718602007-02-02 19:48:19 +0300597 acpi_gbl_permanent_mmap = 1;
598
599 status = acpi_reallocate_root_table();
600 if (ACPI_FAILURE(status)) {
601 printk(KERN_ERR PREFIX
602 "Unable to reallocate ACPI tables\n");
603 goto error0;
604 }
605
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 status = acpi_initialize_subsystem();
607 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400608 printk(KERN_ERR PREFIX
609 "Unable to initialize the ACPI Interpreter\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 goto error0;
611 }
612
613 status = acpi_load_tables();
614 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400615 printk(KERN_ERR PREFIX
616 "Unable to load the System Description Tables\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 goto error0;
618 }
619
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620#ifdef CONFIG_X86
621 if (!acpi_ioapic) {
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300622 extern u8 acpi_sci_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623
624 /* compatible (0) means level (3) */
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300625 if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) {
626 acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK;
627 acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL;
628 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 /* Set PIC-mode SCI trigger type */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300630 acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt,
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300631 (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 } else {
633 extern int acpi_sci_override_gsi;
634 /*
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300635 * now that acpi_gbl_FADT is initialized,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 * update it with result from INT_SRC_OVR parsing
637 */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300638 acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 }
640#endif
641
Len Brown4be44fc2005-08-05 00:44:28 -0400642 status =
643 acpi_enable_subsystem(~
644 (ACPI_NO_HARDWARE_INIT |
645 ACPI_NO_ACPI_ENABLE));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 if (ACPI_FAILURE(status)) {
647 printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
648 goto error0;
649 }
650
Patrick Mocheld550d982006-06-27 00:41:40 -0400651 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
Len Brown4be44fc2005-08-05 00:44:28 -0400653 error0:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 disable_acpi();
Patrick Mocheld550d982006-06-27 00:41:40 -0400655 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656}
657
Len Brown4be44fc2005-08-05 00:44:28 -0400658static int __init acpi_bus_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659{
Len Brown4be44fc2005-08-05 00:44:28 -0400660 int result = 0;
661 acpi_status status = AE_OK;
662 extern acpi_status acpi_os_initialize1(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
665 status = acpi_os_initialize1();
666
Len Brown4be44fc2005-08-05 00:44:28 -0400667 status =
668 acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400670 printk(KERN_ERR PREFIX
671 "Unable to start the ACPI Interpreter\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 goto error1;
673 }
674
675 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400676 printk(KERN_ERR PREFIX
677 "Unable to initialize ACPI OS objects\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 goto error1;
679 }
680#ifdef CONFIG_ACPI_EC
681 /*
682 * ACPI 2.0 requires the EC driver to be loaded and work before
683 * the EC device is found in the namespace (i.e. before acpi_initialize_objects()
684 * is called).
685 *
Alexey Starikovskiyaafbcd12007-02-10 01:32:16 -0500686 * This is accomplished by looking for the ECDT table, and getting
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 * the EC parameters out of that.
688 */
689 status = acpi_ec_ecdt_probe();
690 /* Ignore result. Not having an ECDT is not fatal. */
691#endif
692
693 status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
694 if (ACPI_FAILURE(status)) {
695 printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
696 goto error1;
697 }
698
699 printk(KERN_INFO PREFIX "Interpreter enabled\n");
700
Alexey Starikovskiyaafbcd12007-02-10 01:32:16 -0500701 /* Initialize sleep structures */
702 acpi_sleep_init();
703
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 /*
705 * Get the system interrupt model and evaluate \_PIC.
706 */
707 result = acpi_bus_init_irq();
708 if (result)
709 goto error1;
710
711 /*
712 * Register the for all standard device notifications.
713 */
Len Brown4be44fc2005-08-05 00:44:28 -0400714 status =
715 acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
716 &acpi_bus_notify, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400718 printk(KERN_ERR PREFIX
719 "Unable to register for device notifications\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 goto error1;
721 }
722
723 /*
724 * Create the top ACPI proc directory
725 */
726 acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
727
Patrick Mocheld550d982006-06-27 00:41:40 -0400728 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
730 /* Mimic structured exception handling */
Len Brown4be44fc2005-08-05 00:44:28 -0400731 error1:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 acpi_terminate();
Patrick Mocheld550d982006-06-27 00:41:40 -0400733 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734}
735
Len Brown4be44fc2005-08-05 00:44:28 -0400736decl_subsys(acpi, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737
Len Brown4be44fc2005-08-05 00:44:28 -0400738static int __init acpi_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739{
Len Brown4be44fc2005-08-05 00:44:28 -0400740 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 if (acpi_disabled) {
744 printk(KERN_INFO PREFIX "Interpreter disabled.\n");
Patrick Mocheld550d982006-06-27 00:41:40 -0400745 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 }
747
Randy Dunlapd568df82006-07-12 01:47:00 -0400748 result = firmware_register(&acpi_subsys);
749 if (result < 0)
750 printk(KERN_WARNING "%s: firmware_register error: %d\n",
751 __FUNCTION__, result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752
753 result = acpi_bus_init();
754
755 if (!result) {
Jeff Garzikbca73e42005-11-13 16:06:25 -0800756#ifdef CONFIG_PM_LEGACY
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 if (!PM_IS_ACTIVE())
758 pm_active = 1;
759 else {
Len Brown4be44fc2005-08-05 00:44:28 -0400760 printk(KERN_INFO PREFIX
761 "APM is already active, exiting\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 disable_acpi();
763 result = -ENODEV;
764 }
765#endif
766 } else
767 disable_acpi();
768
Patrick Mocheld550d982006-06-27 00:41:40 -0400769 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770}
771
772subsys_initcall(acpi_init);