Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
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> | |
d568df84 | 28 | #include <linux/kernel.h> |
1da177e4 LT |
29 | #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> | |
6697c052 | 34 | #include <linux/acpi.h> |
5a0e3ad6 | 35 | #include <linux/slab.h> |
1da177e4 LT |
36 | #ifdef CONFIG_X86 |
37 | #include <asm/mpspec.h> | |
38 | #endif | |
7752d5cf | 39 | #include <linux/pci.h> |
eccddd32 | 40 | #include <acpi/apei.h> |
eb27cae8 | 41 | #include <linux/dmi.h> |
cd51e61c | 42 | #include <linux/suspend.h> |
1da177e4 | 43 | |
e60cc7a6 BH |
44 | #include "internal.h" |
45 | ||
1da177e4 | 46 | #define _COMPONENT ACPI_BUS_COMPONENT |
f52fd66d | 47 | ACPI_MODULE_NAME("bus"); |
1da177e4 | 48 | |
4be44fcd LB |
49 | struct acpi_device *acpi_root; |
50 | struct proc_dir_entry *acpi_root_dir; | |
1da177e4 LT |
51 | EXPORT_SYMBOL(acpi_root_dir); |
52 | ||
cce4f632 | 53 | #ifdef CONFIG_X86 |
aa2110cb LM |
54 | static int set_copy_dsdt(const struct dmi_system_id *id) |
55 | { | |
56 | printk(KERN_NOTICE "%s detected - " | |
57 | "force copy of DSDT to local memory\n", id->ident); | |
58 | acpi_gbl_copy_dsdt_locally = 1; | |
59 | return 0; | |
60 | } | |
61 | ||
62 | static struct dmi_system_id dsdt_dmi_table[] __initdata = { | |
63 | /* | |
100cf877 | 64 | * Invoke DSDT corruption work-around on all Toshiba Satellite. |
aa2110cb LM |
65 | * https://bugzilla.kernel.org/show_bug.cgi?id=14679 |
66 | */ | |
67 | { | |
68 | .callback = set_copy_dsdt, | |
100cf877 | 69 | .ident = "TOSHIBA Satellite", |
aa2110cb LM |
70 | .matches = { |
71 | DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), | |
100cf877 | 72 | DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"), |
aa2110cb | 73 | }, |
cce4f632 LM |
74 | }, |
75 | {} | |
aa2110cb | 76 | }; |
cce4f632 LM |
77 | #else |
78 | static struct dmi_system_id dsdt_dmi_table[] __initdata = { | |
79 | {} | |
80 | }; | |
81 | #endif | |
aa2110cb | 82 | |
1da177e4 LT |
83 | /* -------------------------------------------------------------------------- |
84 | Device Management | |
85 | -------------------------------------------------------------------------- */ | |
86 | ||
402ac536 BH |
87 | acpi_status acpi_bus_get_status_handle(acpi_handle handle, |
88 | unsigned long long *sta) | |
1da177e4 | 89 | { |
402ac536 | 90 | acpi_status status; |
4be44fcd | 91 | |
402ac536 BH |
92 | status = acpi_evaluate_integer(handle, "_STA", NULL, sta); |
93 | if (ACPI_SUCCESS(status)) | |
94 | return AE_OK; | |
1da177e4 | 95 | |
402ac536 BH |
96 | if (status == AE_NOT_FOUND) { |
97 | *sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED | | |
98 | ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING; | |
99 | return AE_OK; | |
1da177e4 | 100 | } |
402ac536 BH |
101 | return status; |
102 | } | |
1da177e4 | 103 | |
402ac536 BH |
104 | int acpi_bus_get_status(struct acpi_device *device) |
105 | { | |
106 | acpi_status status; | |
107 | unsigned long long sta; | |
108 | ||
109 | status = acpi_bus_get_status_handle(device->handle, &sta); | |
110 | if (ACPI_FAILURE(status)) | |
111 | return -ENODEV; | |
112 | ||
25db115b | 113 | acpi_set_device_status(device, sta); |
1da177e4 LT |
114 | |
115 | if (device->status.functional && !device->status.present) { | |
39a0ad87 ZY |
116 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]: " |
117 | "functional but not present;\n", | |
25db115b | 118 | device->pnp.bus_id, (u32)sta)); |
1da177e4 LT |
119 | } |
120 | ||
4be44fcd | 121 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n", |
25db115b | 122 | device->pnp.bus_id, (u32)sta)); |
d550d98d | 123 | return 0; |
1da177e4 | 124 | } |
4be44fcd | 125 | EXPORT_SYMBOL(acpi_bus_get_status); |
1da177e4 | 126 | |
20733939 | 127 | void acpi_bus_private_data_handler(acpi_handle handle, |
8e4319c4 | 128 | void *context) |
20733939 ZR |
129 | { |
130 | return; | |
131 | } | |
132 | EXPORT_SYMBOL(acpi_bus_private_data_handler); | |
133 | ||
134 | int acpi_bus_get_private_data(acpi_handle handle, void **data) | |
135 | { | |
6a8c0af6 | 136 | acpi_status status; |
20733939 ZR |
137 | |
138 | if (!*data) | |
139 | return -EINVAL; | |
140 | ||
141 | status = acpi_get_data(handle, acpi_bus_private_data_handler, data); | |
142 | if (ACPI_FAILURE(status) || !*data) { | |
143 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n", | |
144 | handle)); | |
145 | return -ENODEV; | |
146 | } | |
147 | ||
148 | return 0; | |
149 | } | |
150 | EXPORT_SYMBOL(acpi_bus_get_private_data); | |
151 | ||
f244d8b6 RW |
152 | void acpi_bus_no_hotplug(acpi_handle handle) |
153 | { | |
154 | struct acpi_device *adev = NULL; | |
155 | ||
156 | acpi_bus_get_device(handle, &adev); | |
157 | if (adev) | |
158 | adev->flags.no_hotplug = true; | |
159 | } | |
160 | EXPORT_SYMBOL_GPL(acpi_bus_no_hotplug); | |
161 | ||
70023de8 SL |
162 | static void acpi_print_osc_error(acpi_handle handle, |
163 | struct acpi_osc_context *context, char *error) | |
164 | { | |
165 | struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER}; | |
166 | int i; | |
167 | ||
168 | if (ACPI_FAILURE(acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer))) | |
169 | printk(KERN_DEBUG "%s\n", error); | |
170 | else { | |
171 | printk(KERN_DEBUG "%s:%s\n", (char *)buffer.pointer, error); | |
172 | kfree(buffer.pointer); | |
173 | } | |
174 | printk(KERN_DEBUG"_OSC request data:"); | |
175 | for (i = 0; i < context->cap.length; i += sizeof(u32)) | |
176 | printk("%x ", *((u32 *)(context->cap.pointer + i))); | |
177 | printk("\n"); | |
178 | } | |
179 | ||
4b3db708 | 180 | acpi_status acpi_str_to_uuid(char *str, u8 *uuid) |
70023de8 SL |
181 | { |
182 | int i; | |
183 | static int opc_map_to_uuid[16] = {6, 4, 2, 0, 11, 9, 16, 14, 19, 21, | |
184 | 24, 26, 28, 30, 32, 34}; | |
185 | ||
186 | if (strlen(str) != 36) | |
187 | return AE_BAD_PARAMETER; | |
188 | for (i = 0; i < 36; i++) { | |
189 | if (i == 8 || i == 13 || i == 18 || i == 23) { | |
190 | if (str[i] != '-') | |
191 | return AE_BAD_PARAMETER; | |
192 | } else if (!isxdigit(str[i])) | |
193 | return AE_BAD_PARAMETER; | |
194 | } | |
195 | for (i = 0; i < 16; i++) { | |
965fd9e9 AS |
196 | uuid[i] = hex_to_bin(str[opc_map_to_uuid[i]]) << 4; |
197 | uuid[i] |= hex_to_bin(str[opc_map_to_uuid[i] + 1]); | |
70023de8 SL |
198 | } |
199 | return AE_OK; | |
200 | } | |
4b3db708 | 201 | EXPORT_SYMBOL_GPL(acpi_str_to_uuid); |
70023de8 SL |
202 | |
203 | acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context) | |
204 | { | |
205 | acpi_status status; | |
206 | struct acpi_object_list input; | |
207 | union acpi_object in_params[4]; | |
208 | union acpi_object *out_obj; | |
209 | u8 uuid[16]; | |
210 | u32 errors; | |
9dc130fc | 211 | struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL}; |
70023de8 SL |
212 | |
213 | if (!context) | |
214 | return AE_ERROR; | |
215 | if (ACPI_FAILURE(acpi_str_to_uuid(context->uuid_str, uuid))) | |
216 | return AE_ERROR; | |
217 | context->ret.length = ACPI_ALLOCATE_BUFFER; | |
218 | context->ret.pointer = NULL; | |
219 | ||
220 | /* Setting up input parameters */ | |
221 | input.count = 4; | |
222 | input.pointer = in_params; | |
223 | in_params[0].type = ACPI_TYPE_BUFFER; | |
224 | in_params[0].buffer.length = 16; | |
225 | in_params[0].buffer.pointer = uuid; | |
226 | in_params[1].type = ACPI_TYPE_INTEGER; | |
227 | in_params[1].integer.value = context->rev; | |
228 | in_params[2].type = ACPI_TYPE_INTEGER; | |
229 | in_params[2].integer.value = context->cap.length/sizeof(u32); | |
230 | in_params[3].type = ACPI_TYPE_BUFFER; | |
231 | in_params[3].buffer.length = context->cap.length; | |
232 | in_params[3].buffer.pointer = context->cap.pointer; | |
233 | ||
9dc130fc | 234 | status = acpi_evaluate_object(handle, "_OSC", &input, &output); |
70023de8 SL |
235 | if (ACPI_FAILURE(status)) |
236 | return status; | |
237 | ||
9dc130fc | 238 | if (!output.length) |
70023de8 SL |
239 | return AE_NULL_OBJECT; |
240 | ||
9dc130fc SL |
241 | out_obj = output.pointer; |
242 | if (out_obj->type != ACPI_TYPE_BUFFER | |
243 | || out_obj->buffer.length != context->cap.length) { | |
70023de8 SL |
244 | acpi_print_osc_error(handle, context, |
245 | "_OSC evaluation returned wrong type"); | |
246 | status = AE_TYPE; | |
247 | goto out_kfree; | |
248 | } | |
249 | /* Need to ignore the bit0 in result code */ | |
250 | errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0); | |
251 | if (errors) { | |
252 | if (errors & OSC_REQUEST_ERROR) | |
253 | acpi_print_osc_error(handle, context, | |
254 | "_OSC request failed"); | |
255 | if (errors & OSC_INVALID_UUID_ERROR) | |
256 | acpi_print_osc_error(handle, context, | |
257 | "_OSC invalid UUID"); | |
258 | if (errors & OSC_INVALID_REVISION_ERROR) | |
259 | acpi_print_osc_error(handle, context, | |
260 | "_OSC invalid revision"); | |
261 | if (errors & OSC_CAPABILITIES_MASK_ERROR) { | |
b938a229 | 262 | if (((u32 *)context->cap.pointer)[OSC_QUERY_DWORD] |
70023de8 SL |
263 | & OSC_QUERY_ENABLE) |
264 | goto out_success; | |
265 | status = AE_SUPPORT; | |
266 | goto out_kfree; | |
267 | } | |
268 | status = AE_ERROR; | |
269 | goto out_kfree; | |
270 | } | |
271 | out_success: | |
9dc130fc | 272 | context->ret.length = out_obj->buffer.length; |
e2cb5f08 AE |
273 | context->ret.pointer = kmemdup(out_obj->buffer.pointer, |
274 | context->ret.length, GFP_KERNEL); | |
9dc130fc SL |
275 | if (!context->ret.pointer) { |
276 | status = AE_NO_MEMORY; | |
277 | goto out_kfree; | |
278 | } | |
9dc130fc | 279 | status = AE_OK; |
70023de8 SL |
280 | |
281 | out_kfree: | |
9dc130fc SL |
282 | kfree(output.pointer); |
283 | if (status != AE_OK) | |
284 | context->ret.pointer = NULL; | |
70023de8 SL |
285 | return status; |
286 | } | |
287 | EXPORT_SYMBOL(acpi_run_osc); | |
288 | ||
eccddd32 | 289 | bool osc_sb_apei_support_acked; |
3563ff96 SL |
290 | static u8 sb_uuid_str[] = "0811B06E-4A27-44F9-8D60-3CBBC22E7B48"; |
291 | static void acpi_bus_osc_support(void) | |
292 | { | |
293 | u32 capbuf[2]; | |
294 | struct acpi_osc_context context = { | |
295 | .uuid_str = sb_uuid_str, | |
296 | .rev = 1, | |
297 | .cap.length = 8, | |
298 | .cap.pointer = capbuf, | |
299 | }; | |
300 | acpi_handle handle; | |
301 | ||
b938a229 BH |
302 | capbuf[OSC_QUERY_DWORD] = OSC_QUERY_ENABLE; |
303 | capbuf[OSC_SUPPORT_DWORD] = OSC_SB_PR3_SUPPORT; /* _PR3 is in use */ | |
6a4e2b75 ZY |
304 | #if defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR) ||\ |
305 | defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR_MODULE) | |
b938a229 | 306 | capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PAD_SUPPORT; |
3563ff96 | 307 | #endif |
6a4e2b75 ZY |
308 | |
309 | #if defined(CONFIG_ACPI_PROCESSOR) || defined(CONFIG_ACPI_PROCESSOR_MODULE) | |
b938a229 | 310 | capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PPC_OST_SUPPORT; |
6a4e2b75 | 311 | #endif |
eccddd32 | 312 | |
c2f4191a | 313 | #ifdef ACPI_HOTPLUG_OST |
b938a229 | 314 | capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_HOTPLUG_OST_SUPPORT; |
c2f4191a TK |
315 | #endif |
316 | ||
eccddd32 | 317 | if (!ghes_disable) |
b938a229 | 318 | capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_APEI_SUPPORT; |
3563ff96 SL |
319 | if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle))) |
320 | return; | |
eccddd32 HY |
321 | if (ACPI_SUCCESS(acpi_run_osc(handle, &context))) { |
322 | u32 *capbuf_ret = context.ret.pointer; | |
b938a229 | 323 | if (context.ret.length > OSC_SUPPORT_DWORD) |
eccddd32 | 324 | osc_sb_apei_support_acked = |
b938a229 | 325 | capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_APEI_SUPPORT; |
3563ff96 | 326 | kfree(context.ret.pointer); |
eccddd32 HY |
327 | } |
328 | /* do we need to check other returned cap? Sounds no */ | |
3563ff96 SL |
329 | } |
330 | ||
1da177e4 LT |
331 | /* -------------------------------------------------------------------------- |
332 | Notification Handling | |
333 | -------------------------------------------------------------------------- */ | |
334 | ||
1da177e4 LT |
335 | /** |
336 | * acpi_bus_notify | |
337 | * --------------- | |
338 | * Callback for all 'system-level' device notifications (values 0x00-0x7F). | |
339 | */ | |
4be44fcd | 340 | static void acpi_bus_notify(acpi_handle handle, u32 type, void *data) |
1da177e4 | 341 | { |
4be44fcd | 342 | struct acpi_device *device = NULL; |
6d278131 | 343 | struct acpi_driver *driver; |
1da177e4 | 344 | |
02c37bd8 BH |
345 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Notification %#02x to handle %p\n", |
346 | type, handle)); | |
347 | ||
1da177e4 LT |
348 | switch (type) { |
349 | ||
350 | case ACPI_NOTIFY_BUS_CHECK: | |
f4b734c3 | 351 | /* TBD */ |
1da177e4 LT |
352 | break; |
353 | ||
354 | case ACPI_NOTIFY_DEVICE_CHECK: | |
f4b734c3 | 355 | /* TBD */ |
1da177e4 LT |
356 | break; |
357 | ||
358 | case ACPI_NOTIFY_DEVICE_WAKE: | |
1da177e4 LT |
359 | /* TBD */ |
360 | break; | |
361 | ||
362 | case ACPI_NOTIFY_EJECT_REQUEST: | |
1da177e4 LT |
363 | /* TBD */ |
364 | break; | |
365 | ||
366 | case ACPI_NOTIFY_DEVICE_CHECK_LIGHT: | |
1da177e4 LT |
367 | /* TBD: Exactly what does 'light' mean? */ |
368 | break; | |
369 | ||
370 | case ACPI_NOTIFY_FREQUENCY_MISMATCH: | |
1da177e4 LT |
371 | /* TBD */ |
372 | break; | |
373 | ||
374 | case ACPI_NOTIFY_BUS_MODE_MISMATCH: | |
1da177e4 LT |
375 | /* TBD */ |
376 | break; | |
377 | ||
378 | case ACPI_NOTIFY_POWER_FAULT: | |
1da177e4 LT |
379 | /* TBD */ |
380 | break; | |
381 | ||
382 | default: | |
4be44fcd LB |
383 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, |
384 | "Received unknown/unsupported notification [%08x]\n", | |
385 | type)); | |
1da177e4 LT |
386 | break; |
387 | } | |
388 | ||
ff754e2e BH |
389 | acpi_bus_get_device(handle, &device); |
390 | if (device) { | |
391 | driver = device->driver; | |
392 | if (driver && driver->ops.notify && | |
393 | (driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS)) | |
394 | driver->ops.notify(device, type); | |
395 | } | |
1da177e4 LT |
396 | } |
397 | ||
398 | /* -------------------------------------------------------------------------- | |
399 | Initialization/Cleanup | |
400 | -------------------------------------------------------------------------- */ | |
401 | ||
4be44fcd | 402 | static int __init acpi_bus_init_irq(void) |
1da177e4 | 403 | { |
6a8c0af6 | 404 | acpi_status status; |
4be44fcd | 405 | char *message = NULL; |
1da177e4 | 406 | |
1da177e4 | 407 | |
aafbcd16 | 408 | /* |
1da177e4 LT |
409 | * Let the system know what interrupt model we are using by |
410 | * evaluating the \_PIC object, if exists. | |
411 | */ | |
412 | ||
413 | switch (acpi_irq_model) { | |
414 | case ACPI_IRQ_MODEL_PIC: | |
415 | message = "PIC"; | |
416 | break; | |
417 | case ACPI_IRQ_MODEL_IOAPIC: | |
418 | message = "IOAPIC"; | |
419 | break; | |
420 | case ACPI_IRQ_MODEL_IOSAPIC: | |
421 | message = "IOSAPIC"; | |
422 | break; | |
3948ec94 JK |
423 | case ACPI_IRQ_MODEL_PLATFORM: |
424 | message = "platform specific model"; | |
425 | break; | |
1da177e4 LT |
426 | default: |
427 | printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n"); | |
d550d98d | 428 | return -ENODEV; |
1da177e4 LT |
429 | } |
430 | ||
431 | printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message); | |
432 | ||
0db98202 | 433 | status = acpi_execute_simple_method(NULL, "\\_PIC", acpi_irq_model); |
1da177e4 | 434 | if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) { |
a6fc6720 | 435 | ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC")); |
d550d98d | 436 | return -ENODEV; |
1da177e4 LT |
437 | } |
438 | ||
d550d98d | 439 | return 0; |
1da177e4 LT |
440 | } |
441 | ||
67a119f9 | 442 | u8 acpi_gbl_permanent_mmap; |
ad71860a AS |
443 | |
444 | ||
4be44fcd | 445 | void __init acpi_early_init(void) |
1da177e4 | 446 | { |
6a8c0af6 | 447 | acpi_status status; |
1da177e4 LT |
448 | |
449 | if (acpi_disabled) | |
d550d98d | 450 | return; |
1da177e4 | 451 | |
61686124 BM |
452 | printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION); |
453 | ||
1da177e4 LT |
454 | /* enable workarounds, unless strict ACPI spec. compliance */ |
455 | if (!acpi_strict) | |
456 | acpi_gbl_enable_interpreter_slack = TRUE; | |
457 | ||
ad71860a AS |
458 | acpi_gbl_permanent_mmap = 1; |
459 | ||
aa2110cb LM |
460 | /* |
461 | * If the machine falls into the DMI check table, | |
462 | * DSDT will be copied to memory | |
463 | */ | |
464 | dmi_check_system(dsdt_dmi_table); | |
465 | ||
ad71860a AS |
466 | status = acpi_reallocate_root_table(); |
467 | if (ACPI_FAILURE(status)) { | |
468 | printk(KERN_ERR PREFIX | |
469 | "Unable to reallocate ACPI tables\n"); | |
470 | goto error0; | |
471 | } | |
472 | ||
1da177e4 LT |
473 | status = acpi_initialize_subsystem(); |
474 | if (ACPI_FAILURE(status)) { | |
4be44fcd LB |
475 | printk(KERN_ERR PREFIX |
476 | "Unable to initialize the ACPI Interpreter\n"); | |
1da177e4 LT |
477 | goto error0; |
478 | } | |
479 | ||
480 | status = acpi_load_tables(); | |
481 | if (ACPI_FAILURE(status)) { | |
4be44fcd LB |
482 | printk(KERN_ERR PREFIX |
483 | "Unable to load the System Description Tables\n"); | |
1da177e4 LT |
484 | goto error0; |
485 | } | |
486 | ||
1da177e4 LT |
487 | #ifdef CONFIG_X86 |
488 | if (!acpi_ioapic) { | |
1da177e4 | 489 | /* compatible (0) means level (3) */ |
5f3b1a8b AS |
490 | if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) { |
491 | acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK; | |
492 | acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL; | |
493 | } | |
1da177e4 | 494 | /* Set PIC-mode SCI trigger type */ |
cee324b1 | 495 | acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt, |
5f3b1a8b | 496 | (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2); |
1da177e4 | 497 | } else { |
1da177e4 | 498 | /* |
cee324b1 | 499 | * now that acpi_gbl_FADT is initialized, |
1da177e4 LT |
500 | * update it with result from INT_SRC_OVR parsing |
501 | */ | |
cee324b1 | 502 | acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi; |
1da177e4 LT |
503 | } |
504 | #endif | |
505 | ||
4505a201 | 506 | status = acpi_enable_subsystem(~ACPI_NO_ACPI_ENABLE); |
1da177e4 LT |
507 | if (ACPI_FAILURE(status)) { |
508 | printk(KERN_ERR PREFIX "Unable to enable ACPI\n"); | |
509 | goto error0; | |
510 | } | |
511 | ||
d550d98d | 512 | return; |
1da177e4 | 513 | |
4be44fcd | 514 | error0: |
1da177e4 | 515 | disable_acpi(); |
d550d98d | 516 | return; |
1da177e4 LT |
517 | } |
518 | ||
4be44fcd | 519 | static int __init acpi_bus_init(void) |
1da177e4 | 520 | { |
6a8c0af6 BH |
521 | int result; |
522 | acpi_status status; | |
1da177e4 | 523 | |
176f9c18 | 524 | acpi_os_initialize1(); |
1da177e4 | 525 | |
4505a201 | 526 | status = acpi_enable_subsystem(ACPI_NO_ACPI_ENABLE); |
1da177e4 | 527 | if (ACPI_FAILURE(status)) { |
4be44fcd LB |
528 | printk(KERN_ERR PREFIX |
529 | "Unable to start the ACPI Interpreter\n"); | |
1da177e4 LT |
530 | goto error1; |
531 | } | |
532 | ||
1da177e4 LT |
533 | /* |
534 | * ACPI 2.0 requires the EC driver to be loaded and work before | |
535 | * the EC device is found in the namespace (i.e. before acpi_initialize_objects() | |
536 | * is called). | |
537 | * | |
aafbcd16 | 538 | * This is accomplished by looking for the ECDT table, and getting |
1da177e4 LT |
539 | * the EC parameters out of that. |
540 | */ | |
541 | status = acpi_ec_ecdt_probe(); | |
542 | /* Ignore result. Not having an ECDT is not fatal. */ | |
1da177e4 LT |
543 | |
544 | status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION); | |
545 | if (ACPI_FAILURE(status)) { | |
546 | printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n"); | |
547 | goto error1; | |
548 | } | |
549 | ||
fc54ab72 LM |
550 | /* |
551 | * _OSC method may exist in module level code, | |
552 | * so it must be run after ACPI_FULL_INITIALIZATION | |
553 | */ | |
554 | acpi_bus_osc_support(); | |
555 | ||
b1d248d9 ZR |
556 | /* |
557 | * _PDC control method may load dynamic SSDT tables, | |
558 | * and we need to install the table handler before that. | |
559 | */ | |
560 | acpi_sysfs_init(); | |
561 | ||
78f16996 AC |
562 | acpi_early_processor_set_pdc(); |
563 | ||
455c8793 ZY |
564 | /* |
565 | * Maybe EC region is required at bus_scan/acpi_get_devices. So it | |
566 | * is necessary to enable it as early as possible. | |
567 | */ | |
568 | acpi_boot_ec_enable(); | |
569 | ||
1da177e4 LT |
570 | printk(KERN_INFO PREFIX "Interpreter enabled\n"); |
571 | ||
aafbcd16 AS |
572 | /* Initialize sleep structures */ |
573 | acpi_sleep_init(); | |
574 | ||
1da177e4 LT |
575 | /* |
576 | * Get the system interrupt model and evaluate \_PIC. | |
577 | */ | |
578 | result = acpi_bus_init_irq(); | |
579 | if (result) | |
580 | goto error1; | |
581 | ||
582 | /* | |
583 | * Register the for all standard device notifications. | |
584 | */ | |
4be44fcd LB |
585 | status = |
586 | acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY, | |
587 | &acpi_bus_notify, NULL); | |
1da177e4 | 588 | if (ACPI_FAILURE(status)) { |
4be44fcd LB |
589 | printk(KERN_ERR PREFIX |
590 | "Unable to register for device notifications\n"); | |
1da177e4 LT |
591 | goto error1; |
592 | } | |
593 | ||
594 | /* | |
595 | * Create the top ACPI proc directory | |
596 | */ | |
597 | acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL); | |
598 | ||
d550d98d | 599 | return 0; |
1da177e4 LT |
600 | |
601 | /* Mimic structured exception handling */ | |
4be44fcd | 602 | error1: |
1da177e4 | 603 | acpi_terminate(); |
d550d98d | 604 | return -ENODEV; |
1da177e4 LT |
605 | } |
606 | ||
99e0d2fc | 607 | struct kobject *acpi_kobj; |
f2d4753f | 608 | EXPORT_SYMBOL_GPL(acpi_kobj); |
1da177e4 | 609 | |
4be44fcd | 610 | static int __init acpi_init(void) |
1da177e4 | 611 | { |
6831c6ed | 612 | int result; |
1da177e4 | 613 | |
1da177e4 LT |
614 | if (acpi_disabled) { |
615 | printk(KERN_INFO PREFIX "Interpreter disabled.\n"); | |
d550d98d | 616 | return -ENODEV; |
1da177e4 LT |
617 | } |
618 | ||
f62ed9e3 | 619 | acpi_kobj = kobject_create_and_add("acpi", firmware_kobj); |
99e0d2fc | 620 | if (!acpi_kobj) { |
96b2dd1f | 621 | printk(KERN_WARNING "%s: kset create error\n", __func__); |
99e0d2fc GKH |
622 | acpi_kobj = NULL; |
623 | } | |
1da177e4 | 624 | |
0e46517d | 625 | init_acpi_device_notify(); |
1da177e4 | 626 | result = acpi_bus_init(); |
6831c6ed | 627 | if (result) { |
1da177e4 | 628 | disable_acpi(); |
81d0273d | 629 | return result; |
6831c6ed | 630 | } |
81d0273d | 631 | |
6831c6ed | 632 | pci_mmcfg_late_init(); |
e747f274 | 633 | acpi_scan_init(); |
a5f820fe | 634 | acpi_ec_init(); |
a25ee920 | 635 | acpi_debugfs_init(); |
9cee43e0 | 636 | acpi_sleep_proc_init(); |
201b8c65 | 637 | acpi_wakeup_device_init(); |
6831c6ed | 638 | return 0; |
1da177e4 LT |
639 | } |
640 | ||
641 | subsys_initcall(acpi_init); |