blob: 15d677e6cee9bf06be6282d5aa734b8a9c21fe96 [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 Brown4be44fc2005-08-05 00:44:28 -040042ACPI_MODULE_NAME("acpi_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 /*
150 * Get the device's power state either directly (via _PSC) or
151 * 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",
Len Brownaf4f9492006-07-09 16:33:26 -0400195 device->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 Karasyov0feabb02006-05-08 00:00:00 -0400202 if (!device->flags.force_power_state) {
203 if (device->power.state == ACPI_STATE_UNKNOWN)
204 acpi_bus_get_power(device->handle, &device->power.state);
205 if (state == device->power.state) {
206 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n",
207 state));
Patrick Mocheld550d982006-06-27 00:41:40 -0400208 return 0;
Konstantin Karasyov0feabb02006-05-08 00:00:00 -0400209 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 }
211 if (!device->power.states[state].flags.valid) {
Len Browncece9292006-06-26 23:04:31 -0400212 printk(KERN_WARNING PREFIX "Device does not support D%d\n", state);
Patrick Mocheld550d982006-06-27 00:41:40 -0400213 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 }
215 if (device->parent && (state < device->parent->power.state)) {
Len Browncece9292006-06-26 23:04:31 -0400216 printk(KERN_WARNING PREFIX
Thomas Renningera6fc6722006-06-26 23:58:43 -0400217 "Cannot set device to a higher-powered"
Len Browncece9292006-06-26 23:04:31 -0400218 " state than parent\n");
Patrick Mocheld550d982006-06-27 00:41:40 -0400219 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 }
221
222 /*
223 * Transition Power
224 * ----------------
225 * On transitions to a high-powered state we first apply power (via
226 * power resources) then evalute _PSx. Conversly for transitions to
227 * a lower-powered state.
David Shaohua Lib9131002005-03-19 00:16:18 -0500228 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 if (state < device->power.state) {
230 if (device->power.flags.power_resources) {
231 result = acpi_power_transition(device, state);
232 if (result)
233 goto end;
234 }
235 if (device->power.states[state].flags.explicit_set) {
Len Brown4be44fc2005-08-05 00:44:28 -0400236 status = acpi_evaluate_object(device->handle,
237 object_name, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 if (ACPI_FAILURE(status)) {
239 result = -ENODEV;
240 goto end;
241 }
242 }
Len Brown4be44fc2005-08-05 00:44:28 -0400243 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 if (device->power.states[state].flags.explicit_set) {
Len Brown4be44fc2005-08-05 00:44:28 -0400245 status = acpi_evaluate_object(device->handle,
246 object_name, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 if (ACPI_FAILURE(status)) {
248 result = -ENODEV;
249 goto end;
250 }
251 }
252 if (device->power.flags.power_resources) {
253 result = acpi_power_transition(device, state);
254 if (result)
255 goto end;
256 }
257 }
258
Len Brown4be44fc2005-08-05 00:44:28 -0400259 end:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 if (result)
Len Browncece9292006-06-26 23:04:31 -0400261 printk(KERN_WARNING PREFIX
262 "Transitioning device [%s] to D%d\n",
263 device->pnp.bus_id, state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 else
Len Brown4be44fc2005-08-05 00:44:28 -0400265 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
266 "Device [%s] transitioned to D%d\n",
267 device->pnp.bus_id, state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
Patrick Mocheld550d982006-06-27 00:41:40 -0400269 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270}
Len Brown4be44fc2005-08-05 00:44:28 -0400271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272EXPORT_SYMBOL(acpi_bus_set_power);
273
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274/* --------------------------------------------------------------------------
275 Event Management
276 -------------------------------------------------------------------------- */
277
278static DEFINE_SPINLOCK(acpi_bus_event_lock);
279
280LIST_HEAD(acpi_bus_event_list);
281DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);
282
Len Brown4be44fc2005-08-05 00:44:28 -0400283extern int event_is_open;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
Len Brown4be44fc2005-08-05 00:44:28 -0400285int acpi_bus_generate_event(struct acpi_device *device, u8 type, int data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286{
Len Brown4be44fc2005-08-05 00:44:28 -0400287 struct acpi_bus_event *event = NULL;
288 unsigned long flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
291 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400292 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
294 /* drop event on the floor if no one's listening */
295 if (!event_is_open)
Patrick Mocheld550d982006-06-27 00:41:40 -0400296 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
298 event = kmalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
299 if (!event)
Patrick Mocheld550d982006-06-27 00:41:40 -0400300 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
302 strcpy(event->device_class, device->pnp.device_class);
303 strcpy(event->bus_id, device->pnp.bus_id);
304 event->type = type;
305 event->data = data;
306
307 spin_lock_irqsave(&acpi_bus_event_lock, flags);
308 list_add_tail(&event->node, &acpi_bus_event_list);
309 spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
310
311 wake_up_interruptible(&acpi_bus_event_queue);
312
Patrick Mocheld550d982006-06-27 00:41:40 -0400313 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314}
Len Brown4be44fc2005-08-05 00:44:28 -0400315
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316EXPORT_SYMBOL(acpi_bus_generate_event);
317
Len Brown4be44fc2005-08-05 00:44:28 -0400318int acpi_bus_receive_event(struct acpi_bus_event *event)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319{
Len Brown4be44fc2005-08-05 00:44:28 -0400320 unsigned long flags = 0;
321 struct acpi_bus_event *entry = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
323 DECLARE_WAITQUEUE(wait, current);
324
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
326 if (!event)
Patrick Mocheld550d982006-06-27 00:41:40 -0400327 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328
329 if (list_empty(&acpi_bus_event_list)) {
330
331 set_current_state(TASK_INTERRUPTIBLE);
332 add_wait_queue(&acpi_bus_event_queue, &wait);
333
334 if (list_empty(&acpi_bus_event_list))
335 schedule();
336
337 remove_wait_queue(&acpi_bus_event_queue, &wait);
338 set_current_state(TASK_RUNNING);
339
340 if (signal_pending(current))
Patrick Mocheld550d982006-06-27 00:41:40 -0400341 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 }
343
344 spin_lock_irqsave(&acpi_bus_event_lock, flags);
Len Brown4be44fc2005-08-05 00:44:28 -0400345 entry =
346 list_entry(acpi_bus_event_list.next, struct acpi_bus_event, node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 if (entry)
348 list_del(&entry->node);
349 spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
350
351 if (!entry)
Patrick Mocheld550d982006-06-27 00:41:40 -0400352 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
354 memcpy(event, entry, sizeof(struct acpi_bus_event));
355
356 kfree(entry);
357
Patrick Mocheld550d982006-06-27 00:41:40 -0400358 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
Len Brown4be44fc2005-08-05 00:44:28 -0400361EXPORT_SYMBOL(acpi_bus_receive_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
363/* --------------------------------------------------------------------------
364 Notification Handling
365 -------------------------------------------------------------------------- */
366
367static int
Len Brown4be44fc2005-08-05 00:44:28 -0400368acpi_bus_check_device(struct acpi_device *device, int *status_changed)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369{
Len Brown4be44fc2005-08-05 00:44:28 -0400370 acpi_status status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 struct acpi_device_status old_status;
372
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
374 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400375 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
377 if (status_changed)
378 *status_changed = 0;
379
380 old_status = device->status;
381
382 /*
383 * Make sure this device's parent is present before we go about
384 * messing with the device.
385 */
386 if (device->parent && !device->parent->status.present) {
387 device->status = device->parent->status;
388 if (STRUCT_TO_INT(old_status) != STRUCT_TO_INT(device->status)) {
389 if (status_changed)
390 *status_changed = 1;
391 }
Patrick Mocheld550d982006-06-27 00:41:40 -0400392 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 }
394
395 status = acpi_bus_get_status(device);
396 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400397 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
399 if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400400 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
402 if (status_changed)
403 *status_changed = 1;
Len Brown4be44fc2005-08-05 00:44:28 -0400404
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 /*
406 * Device Insertion/Removal
407 */
408 if ((device->status.present) && !(old_status.present)) {
409 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device insertion detected\n"));
410 /* TBD: Handle device insertion */
Len Brown4be44fc2005-08-05 00:44:28 -0400411 } else if (!(device->status.present) && (old_status.present)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n"));
413 /* TBD: Handle device removal */
414 }
415
Patrick Mocheld550d982006-06-27 00:41:40 -0400416 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417}
418
Len Brown4be44fc2005-08-05 00:44:28 -0400419static int acpi_bus_check_scope(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420{
Len Brown4be44fc2005-08-05 00:44:28 -0400421 int result = 0;
422 int status_changed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424
425 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400426 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
428 /* Status Change? */
429 result = acpi_bus_check_device(device, &status_changed);
430 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400431 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
433 if (!status_changed)
Patrick Mocheld550d982006-06-27 00:41:40 -0400434 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
436 /*
437 * TBD: Enumerate child devices within this device's scope and
438 * run acpi_bus_check_device()'s on them.
439 */
440
Patrick Mocheld550d982006-06-27 00:41:40 -0400441 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442}
443
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444/**
445 * acpi_bus_notify
446 * ---------------
447 * Callback for all 'system-level' device notifications (values 0x00-0x7F).
448 */
Len Brown4be44fc2005-08-05 00:44:28 -0400449static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450{
Len Brown4be44fc2005-08-05 00:44:28 -0400451 int result = 0;
452 struct acpi_device *device = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
455 if (acpi_bus_get_device(handle, &device))
Patrick Mocheld550d982006-06-27 00:41:40 -0400456 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457
458 switch (type) {
459
460 case ACPI_NOTIFY_BUS_CHECK:
Len Brown4be44fc2005-08-05 00:44:28 -0400461 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
462 "Received BUS CHECK notification for device [%s]\n",
463 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 result = acpi_bus_check_scope(device);
465 /*
466 * TBD: We'll need to outsource certain events to non-ACPI
Len Brown4be44fc2005-08-05 00:44:28 -0400467 * drivers via the device manager (device.c).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 */
469 break;
470
471 case ACPI_NOTIFY_DEVICE_CHECK:
Len Brown4be44fc2005-08-05 00:44:28 -0400472 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
473 "Received DEVICE CHECK notification for device [%s]\n",
474 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 result = acpi_bus_check_device(device, NULL);
476 /*
477 * TBD: We'll need to outsource certain events to non-ACPI
Len Brown4be44fc2005-08-05 00:44:28 -0400478 * drivers via the device manager (device.c).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 */
480 break;
481
482 case ACPI_NOTIFY_DEVICE_WAKE:
Len Brown4be44fc2005-08-05 00:44:28 -0400483 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
484 "Received DEVICE WAKE notification for device [%s]\n",
485 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 /* TBD */
487 break;
488
489 case ACPI_NOTIFY_EJECT_REQUEST:
Len Brown4be44fc2005-08-05 00:44:28 -0400490 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
491 "Received EJECT REQUEST notification for device [%s]\n",
492 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 /* TBD */
494 break;
495
496 case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
Len Brown4be44fc2005-08-05 00:44:28 -0400497 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
498 "Received DEVICE CHECK LIGHT notification for device [%s]\n",
499 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 /* TBD: Exactly what does 'light' mean? */
501 break;
502
503 case ACPI_NOTIFY_FREQUENCY_MISMATCH:
Len Brown4be44fc2005-08-05 00:44:28 -0400504 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
505 "Received FREQUENCY MISMATCH notification for device [%s]\n",
506 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 /* TBD */
508 break;
509
510 case ACPI_NOTIFY_BUS_MODE_MISMATCH:
Len Brown4be44fc2005-08-05 00:44:28 -0400511 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
512 "Received BUS MODE MISMATCH notification for device [%s]\n",
513 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 /* TBD */
515 break;
516
517 case ACPI_NOTIFY_POWER_FAULT:
Len Brown4be44fc2005-08-05 00:44:28 -0400518 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
519 "Received POWER FAULT notification for device [%s]\n",
520 device->pnp.bus_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 /* TBD */
522 break;
523
524 default:
Len Brown4be44fc2005-08-05 00:44:28 -0400525 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
526 "Received unknown/unsupported notification [%08x]\n",
527 type));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 break;
529 }
530
Patrick Mocheld550d982006-06-27 00:41:40 -0400531 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532}
533
534/* --------------------------------------------------------------------------
535 Initialization/Cleanup
536 -------------------------------------------------------------------------- */
537
Len Brown4be44fc2005-08-05 00:44:28 -0400538static int __init acpi_bus_init_irq(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539{
Len Brown4be44fc2005-08-05 00:44:28 -0400540 acpi_status status = AE_OK;
541 union acpi_object arg = { ACPI_TYPE_INTEGER };
542 struct acpi_object_list arg_list = { 1, &arg };
543 char *message = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
546 /*
547 * Let the system know what interrupt model we are using by
548 * evaluating the \_PIC object, if exists.
549 */
550
551 switch (acpi_irq_model) {
552 case ACPI_IRQ_MODEL_PIC:
553 message = "PIC";
554 break;
555 case ACPI_IRQ_MODEL_IOAPIC:
556 message = "IOAPIC";
557 break;
558 case ACPI_IRQ_MODEL_IOSAPIC:
559 message = "IOSAPIC";
560 break;
John Keller3948ec92006-12-22 11:50:04 -0600561 case ACPI_IRQ_MODEL_PLATFORM:
562 message = "platform specific model";
563 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 default:
565 printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
Patrick Mocheld550d982006-06-27 00:41:40 -0400566 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 }
568
569 printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);
570
571 arg.integer.value = acpi_irq_model;
572
573 status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL);
574 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400575 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400576 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 }
578
Patrick Mocheld550d982006-06-27 00:41:40 -0400579 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580}
581
Alexey Starikovskiyad718602007-02-02 19:48:19 +0300582acpi_native_uint acpi_gbl_permanent_mmap;
583
584
Len Brown4be44fc2005-08-05 00:44:28 -0400585void __init acpi_early_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586{
Len Brown4be44fc2005-08-05 00:44:28 -0400587 acpi_status status = AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
589 if (acpi_disabled)
Patrick Mocheld550d982006-06-27 00:41:40 -0400590 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591
Bob Moore61686122006-03-17 16:44:00 -0500592 printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);
593
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 /* enable workarounds, unless strict ACPI spec. compliance */
595 if (!acpi_strict)
596 acpi_gbl_enable_interpreter_slack = TRUE;
597
Alexey Starikovskiyad718602007-02-02 19:48:19 +0300598 acpi_gbl_permanent_mmap = 1;
599
600 status = acpi_reallocate_root_table();
601 if (ACPI_FAILURE(status)) {
602 printk(KERN_ERR PREFIX
603 "Unable to reallocate ACPI tables\n");
604 goto error0;
605 }
606
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 status = acpi_initialize_subsystem();
608 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400609 printk(KERN_ERR PREFIX
610 "Unable to initialize the ACPI Interpreter\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 goto error0;
612 }
613
614 status = acpi_load_tables();
615 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400616 printk(KERN_ERR PREFIX
617 "Unable to load the System Description Tables\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 goto error0;
619 }
620
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621#ifdef CONFIG_X86
622 if (!acpi_ioapic) {
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300623 extern u8 acpi_sci_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
625 /* compatible (0) means level (3) */
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300626 if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) {
627 acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK;
628 acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL;
629 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 /* Set PIC-mode SCI trigger type */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300631 acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt,
Alexey Starikovskiy5f3b1a82007-02-02 19:48:22 +0300632 (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 } else {
634 extern int acpi_sci_override_gsi;
635 /*
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300636 * now that acpi_gbl_FADT is initialized,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 * update it with result from INT_SRC_OVR parsing
638 */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300639 acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 }
641#endif
642
Len Brown4be44fc2005-08-05 00:44:28 -0400643 status =
644 acpi_enable_subsystem(~
645 (ACPI_NO_HARDWARE_INIT |
646 ACPI_NO_ACPI_ENABLE));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 if (ACPI_FAILURE(status)) {
648 printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
649 goto error0;
650 }
651
Patrick Mocheld550d982006-06-27 00:41:40 -0400652 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
Len Brown4be44fc2005-08-05 00:44:28 -0400654 error0:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 disable_acpi();
Patrick Mocheld550d982006-06-27 00:41:40 -0400656 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657}
658
Len Brown4be44fc2005-08-05 00:44:28 -0400659static int __init acpi_bus_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660{
Len Brown4be44fc2005-08-05 00:44:28 -0400661 int result = 0;
662 acpi_status status = AE_OK;
663 extern acpi_status acpi_os_initialize1(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665
666 status = acpi_os_initialize1();
667
Len Brown4be44fc2005-08-05 00:44:28 -0400668 status =
669 acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400671 printk(KERN_ERR PREFIX
672 "Unable to start the ACPI Interpreter\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 goto error1;
674 }
675
676 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400677 printk(KERN_ERR PREFIX
678 "Unable to initialize ACPI OS objects\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 goto error1;
680 }
681#ifdef CONFIG_ACPI_EC
682 /*
683 * ACPI 2.0 requires the EC driver to be loaded and work before
684 * the EC device is found in the namespace (i.e. before acpi_initialize_objects()
685 * is called).
686 *
687 * This is accomplished by looking for the ECDT table, and getting
688 * the EC parameters out of that.
689 */
690 status = acpi_ec_ecdt_probe();
691 /* Ignore result. Not having an ECDT is not fatal. */
692#endif
693
694 status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
695 if (ACPI_FAILURE(status)) {
696 printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
697 goto error1;
698 }
699
700 printk(KERN_INFO PREFIX "Interpreter enabled\n");
701
702 /*
703 * Get the system interrupt model and evaluate \_PIC.
704 */
705 result = acpi_bus_init_irq();
706 if (result)
707 goto error1;
708
709 /*
710 * Register the for all standard device notifications.
711 */
Len Brown4be44fc2005-08-05 00:44:28 -0400712 status =
713 acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
714 &acpi_bus_notify, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400716 printk(KERN_ERR PREFIX
717 "Unable to register for device notifications\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 goto error1;
719 }
720
721 /*
722 * Create the top ACPI proc directory
723 */
724 acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
725
Patrick Mocheld550d982006-06-27 00:41:40 -0400726 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
728 /* Mimic structured exception handling */
Len Brown4be44fc2005-08-05 00:44:28 -0400729 error1:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 acpi_terminate();
Patrick Mocheld550d982006-06-27 00:41:40 -0400731 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732}
733
Len Brown4be44fc2005-08-05 00:44:28 -0400734decl_subsys(acpi, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Len Brown4be44fc2005-08-05 00:44:28 -0400736static int __init acpi_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737{
Len Brown4be44fc2005-08-05 00:44:28 -0400738 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 if (acpi_disabled) {
742 printk(KERN_INFO PREFIX "Interpreter disabled.\n");
Patrick Mocheld550d982006-06-27 00:41:40 -0400743 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 }
745
Randy Dunlapd568df82006-07-12 01:47:00 -0400746 result = firmware_register(&acpi_subsys);
747 if (result < 0)
748 printk(KERN_WARNING "%s: firmware_register error: %d\n",
749 __FUNCTION__, result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
751 result = acpi_bus_init();
752
753 if (!result) {
Jeff Garzikbca73e42005-11-13 16:06:25 -0800754#ifdef CONFIG_PM_LEGACY
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 if (!PM_IS_ACTIVE())
756 pm_active = 1;
757 else {
Len Brown4be44fc2005-08-05 00:44:28 -0400758 printk(KERN_INFO PREFIX
759 "APM is already active, exiting\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 disable_acpi();
761 result = -ENODEV;
762 }
763#endif
764 } else
765 disable_acpi();
766
Patrick Mocheld550d982006-06-27 00:41:40 -0400767 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768}
769
770subsys_initcall(acpi_init);