Merge branches 'apei', 'battery-mwh-fix', 'bugzilla-10807', 'bugzilla-14736', 'bugzil...
[linux-2.6.git] / drivers / acpi / bus.c
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>
28 #include <linux/kernel.h>
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>
34 #include <linux/acpi.h>
35 #include <linux/slab.h>
36 #ifdef CONFIG_X86
37 #include <asm/mpspec.h>
38 #endif
39 #include <linux/pci.h>
40 #include <acpi/acpi_bus.h>
41 #include <acpi/acpi_drivers.h>
42 #include <linux/dmi.h>
43
44 #include "internal.h"
45
46 #define _COMPONENT              ACPI_BUS_COMPONENT
47 ACPI_MODULE_NAME("bus");
48
49 struct acpi_device *acpi_root;
50 struct proc_dir_entry *acpi_root_dir;
51 EXPORT_SYMBOL(acpi_root_dir);
52
53 #define STRUCT_TO_INT(s)        (*((int*)&s))
54
55 static int set_power_nocheck(const struct dmi_system_id *id)
56 {
57         printk(KERN_NOTICE PREFIX "%s detected - "
58                 "disable power check in power transition\n", id->ident);
59         acpi_power_nocheck = 1;
60         return 0;
61 }
62 static struct dmi_system_id __cpuinitdata power_nocheck_dmi_table[] = {
63         {
64         set_power_nocheck, "HP Pavilion 05", {
65         DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
66         DMI_MATCH(DMI_SYS_VENDOR, "HP Pavilion 05"),
67         DMI_MATCH(DMI_PRODUCT_VERSION, "2001211RE101GLEND") }, NULL},
68         {},
69 };
70
71
72 #ifdef CONFIG_X86
73 static int set_copy_dsdt(const struct dmi_system_id *id)
74 {
75         printk(KERN_NOTICE "%s detected - "
76                 "force copy of DSDT to local memory\n", id->ident);
77         acpi_gbl_copy_dsdt_locally = 1;
78         return 0;
79 }
80
81 static struct dmi_system_id dsdt_dmi_table[] __initdata = {
82         /*
83          * Invoke DSDT corruption work-around on all Toshiba Satellite.
84          * https://bugzilla.kernel.org/show_bug.cgi?id=14679
85          */
86         {
87          .callback = set_copy_dsdt,
88          .ident = "TOSHIBA Satellite",
89          .matches = {
90                 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
91                 DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
92                 },
93         },
94         {}
95 };
96 #else
97 static struct dmi_system_id dsdt_dmi_table[] __initdata = {
98         {}
99 };
100 #endif
101
102 /* --------------------------------------------------------------------------
103                                 Device Management
104    -------------------------------------------------------------------------- */
105
106 int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
107 {
108         acpi_status status = AE_OK;
109
110
111         if (!device)
112                 return -EINVAL;
113
114         /* TBD: Support fixed-feature devices */
115
116         status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);
117         if (ACPI_FAILURE(status) || !*device) {
118                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
119                                   handle));
120                 return -ENODEV;
121         }
122
123         return 0;
124 }
125
126 EXPORT_SYMBOL(acpi_bus_get_device);
127
128 acpi_status acpi_bus_get_status_handle(acpi_handle handle,
129                                        unsigned long long *sta)
130 {
131         acpi_status status;
132
133         status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
134         if (ACPI_SUCCESS(status))
135                 return AE_OK;
136
137         if (status == AE_NOT_FOUND) {
138                 *sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
139                        ACPI_STA_DEVICE_UI      | ACPI_STA_DEVICE_FUNCTIONING;
140                 return AE_OK;
141         }
142         return status;
143 }
144
145 int acpi_bus_get_status(struct acpi_device *device)
146 {
147         acpi_status status;
148         unsigned long long sta;
149
150         status = acpi_bus_get_status_handle(device->handle, &sta);
151         if (ACPI_FAILURE(status))
152                 return -ENODEV;
153
154         STRUCT_TO_INT(device->status) = (int) sta;
155
156         if (device->status.functional && !device->status.present) {
157                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]: "
158                        "functional but not present;\n",
159                         device->pnp.bus_id,
160                         (u32) STRUCT_TO_INT(device->status)));
161         }
162
163         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
164                           device->pnp.bus_id,
165                           (u32) STRUCT_TO_INT(device->status)));
166         return 0;
167 }
168 EXPORT_SYMBOL(acpi_bus_get_status);
169
170 void acpi_bus_private_data_handler(acpi_handle handle,
171                                    void *context)
172 {
173         return;
174 }
175 EXPORT_SYMBOL(acpi_bus_private_data_handler);
176
177 int acpi_bus_get_private_data(acpi_handle handle, void **data)
178 {
179         acpi_status status = AE_OK;
180
181         if (!*data)
182                 return -EINVAL;
183
184         status = acpi_get_data(handle, acpi_bus_private_data_handler, data);
185         if (ACPI_FAILURE(status) || !*data) {
186                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
187                                 handle));
188                 return -ENODEV;
189         }
190
191         return 0;
192 }
193 EXPORT_SYMBOL(acpi_bus_get_private_data);
194
195 /* --------------------------------------------------------------------------
196                                  Power Management
197    -------------------------------------------------------------------------- */
198
199 int acpi_bus_get_power(acpi_handle handle, int *state)
200 {
201         int result = 0;
202         acpi_status status = 0;
203         struct acpi_device *device = NULL;
204         unsigned long long psc = 0;
205
206
207         result = acpi_bus_get_device(handle, &device);
208         if (result)
209                 return result;
210
211         *state = ACPI_STATE_UNKNOWN;
212
213         if (!device->flags.power_manageable) {
214                 /* TBD: Non-recursive algorithm for walking up hierarchy */
215                 if (device->parent)
216                         *state = device->parent->power.state;
217                 else
218                         *state = ACPI_STATE_D0;
219         } else {
220                 /*
221                  * Get the device's power state either directly (via _PSC) or
222                  * indirectly (via power resources).
223                  */
224                 if (device->power.flags.power_resources) {
225                         result = acpi_power_get_inferred_state(device);
226                         if (result)
227                                 return result;
228                 } else if (device->power.flags.explicit_get) {
229                         status = acpi_evaluate_integer(device->handle, "_PSC",
230                                                        NULL, &psc);
231                         if (ACPI_FAILURE(status))
232                                 return -ENODEV;
233                         device->power.state = (int)psc;
234                 }
235
236                 *state = device->power.state;
237         }
238
239         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n",
240                           device->pnp.bus_id, device->power.state));
241
242         return 0;
243 }
244
245 EXPORT_SYMBOL(acpi_bus_get_power);
246
247 int acpi_bus_set_power(acpi_handle handle, int state)
248 {
249         int result = 0;
250         acpi_status status = AE_OK;
251         struct acpi_device *device = NULL;
252         char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' };
253
254
255         result = acpi_bus_get_device(handle, &device);
256         if (result)
257                 return result;
258
259         if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
260                 return -EINVAL;
261
262         /* Make sure this is a valid target state */
263
264         if (!device->flags.power_manageable) {
265                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device `[%s]' is not power manageable\n",
266                                 kobject_name(&device->dev.kobj)));
267                 return -ENODEV;
268         }
269         /*
270          * Get device's current power state
271          */
272         if (!acpi_power_nocheck) {
273                 /*
274                  * Maybe the incorrect power state is returned on the bogus
275                  * bios, which is different with the real power state.
276                  * For example: the bios returns D0 state and the real power
277                  * state is D3. OS expects to set the device to D0 state. In
278                  * such case if OS uses the power state returned by the BIOS,
279                  * the device can't be transisted to the correct power state.
280                  * So if the acpi_power_nocheck is set, it is unnecessary to
281                  * get the power state by calling acpi_bus_get_power.
282                  */
283                 acpi_bus_get_power(device->handle, &device->power.state);
284         }
285         if ((state == device->power.state) && !device->flags.force_power_state) {
286                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n",
287                                   state));
288                 return 0;
289         }
290
291         if (!device->power.states[state].flags.valid) {
292                 printk(KERN_WARNING PREFIX "Device does not support D%d\n", state);
293                 return -ENODEV;
294         }
295         if (device->parent && (state < device->parent->power.state)) {
296                 printk(KERN_WARNING PREFIX
297                               "Cannot set device to a higher-powered"
298                               " state than parent\n");
299                 return -ENODEV;
300         }
301
302         /*
303          * Transition Power
304          * ----------------
305          * On transitions to a high-powered state we first apply power (via
306          * power resources) then evalute _PSx.  Conversly for transitions to
307          * a lower-powered state.
308          */
309         if (state < device->power.state) {
310                 if (device->power.flags.power_resources) {
311                         result = acpi_power_transition(device, state);
312                         if (result)
313                                 goto end;
314                 }
315                 if (device->power.states[state].flags.explicit_set) {
316                         status = acpi_evaluate_object(device->handle,
317                                                       object_name, NULL, NULL);
318                         if (ACPI_FAILURE(status)) {
319                                 result = -ENODEV;
320                                 goto end;
321                         }
322                 }
323         } else {
324                 if (device->power.states[state].flags.explicit_set) {
325                         status = acpi_evaluate_object(device->handle,
326                                                       object_name, NULL, NULL);
327                         if (ACPI_FAILURE(status)) {
328                                 result = -ENODEV;
329                                 goto end;
330                         }
331                 }
332                 if (device->power.flags.power_resources) {
333                         result = acpi_power_transition(device, state);
334                         if (result)
335                                 goto end;
336                 }
337         }
338
339       end:
340         if (result)
341                 printk(KERN_WARNING PREFIX
342                               "Device [%s] failed to transition to D%d\n",
343                               device->pnp.bus_id, state);
344         else {
345                 device->power.state = state;
346                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
347                                   "Device [%s] transitioned to D%d\n",
348                                   device->pnp.bus_id, state));
349         }
350
351         return result;
352 }
353
354 EXPORT_SYMBOL(acpi_bus_set_power);
355
356 bool acpi_bus_power_manageable(acpi_handle handle)
357 {
358         struct acpi_device *device;
359         int result;
360
361         result = acpi_bus_get_device(handle, &device);
362         return result ? false : device->flags.power_manageable;
363 }
364
365 EXPORT_SYMBOL(acpi_bus_power_manageable);
366
367 bool acpi_bus_can_wakeup(acpi_handle handle)
368 {
369         struct acpi_device *device;
370         int result;
371
372         result = acpi_bus_get_device(handle, &device);
373         return result ? false : device->wakeup.flags.valid;
374 }
375
376 EXPORT_SYMBOL(acpi_bus_can_wakeup);
377
378 static void acpi_print_osc_error(acpi_handle handle,
379         struct acpi_osc_context *context, char *error)
380 {
381         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER};
382         int i;
383
384         if (ACPI_FAILURE(acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer)))
385                 printk(KERN_DEBUG "%s\n", error);
386         else {
387                 printk(KERN_DEBUG "%s:%s\n", (char *)buffer.pointer, error);
388                 kfree(buffer.pointer);
389         }
390         printk(KERN_DEBUG"_OSC request data:");
391         for (i = 0; i < context->cap.length; i += sizeof(u32))
392                 printk("%x ", *((u32 *)(context->cap.pointer + i)));
393         printk("\n");
394 }
395
396 static acpi_status acpi_str_to_uuid(char *str, u8 *uuid)
397 {
398         int i;
399         static int opc_map_to_uuid[16] = {6, 4, 2, 0, 11, 9, 16, 14, 19, 21,
400                 24, 26, 28, 30, 32, 34};
401
402         if (strlen(str) != 36)
403                 return AE_BAD_PARAMETER;
404         for (i = 0; i < 36; i++) {
405                 if (i == 8 || i == 13 || i == 18 || i == 23) {
406                         if (str[i] != '-')
407                                 return AE_BAD_PARAMETER;
408                 } else if (!isxdigit(str[i]))
409                         return AE_BAD_PARAMETER;
410         }
411         for (i = 0; i < 16; i++) {
412                 uuid[i] = hex_to_bin(str[opc_map_to_uuid[i]]) << 4;
413                 uuid[i] |= hex_to_bin(str[opc_map_to_uuid[i] + 1]);
414         }
415         return AE_OK;
416 }
417
418 acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context)
419 {
420         acpi_status status;
421         struct acpi_object_list input;
422         union acpi_object in_params[4];
423         union acpi_object *out_obj;
424         u8 uuid[16];
425         u32 errors;
426         struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
427
428         if (!context)
429                 return AE_ERROR;
430         if (ACPI_FAILURE(acpi_str_to_uuid(context->uuid_str, uuid)))
431                 return AE_ERROR;
432         context->ret.length = ACPI_ALLOCATE_BUFFER;
433         context->ret.pointer = NULL;
434
435         /* Setting up input parameters */
436         input.count = 4;
437         input.pointer = in_params;
438         in_params[0].type               = ACPI_TYPE_BUFFER;
439         in_params[0].buffer.length      = 16;
440         in_params[0].buffer.pointer     = uuid;
441         in_params[1].type               = ACPI_TYPE_INTEGER;
442         in_params[1].integer.value      = context->rev;
443         in_params[2].type               = ACPI_TYPE_INTEGER;
444         in_params[2].integer.value      = context->cap.length/sizeof(u32);
445         in_params[3].type               = ACPI_TYPE_BUFFER;
446         in_params[3].buffer.length      = context->cap.length;
447         in_params[3].buffer.pointer     = context->cap.pointer;
448
449         status = acpi_evaluate_object(handle, "_OSC", &input, &output);
450         if (ACPI_FAILURE(status))
451                 return status;
452
453         if (!output.length)
454                 return AE_NULL_OBJECT;
455
456         out_obj = output.pointer;
457         if (out_obj->type != ACPI_TYPE_BUFFER
458                 || out_obj->buffer.length != context->cap.length) {
459                 acpi_print_osc_error(handle, context,
460                         "_OSC evaluation returned wrong type");
461                 status = AE_TYPE;
462                 goto out_kfree;
463         }
464         /* Need to ignore the bit0 in result code */
465         errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0);
466         if (errors) {
467                 if (errors & OSC_REQUEST_ERROR)
468                         acpi_print_osc_error(handle, context,
469                                 "_OSC request failed");
470                 if (errors & OSC_INVALID_UUID_ERROR)
471                         acpi_print_osc_error(handle, context,
472                                 "_OSC invalid UUID");
473                 if (errors & OSC_INVALID_REVISION_ERROR)
474                         acpi_print_osc_error(handle, context,
475                                 "_OSC invalid revision");
476                 if (errors & OSC_CAPABILITIES_MASK_ERROR) {
477                         if (((u32 *)context->cap.pointer)[OSC_QUERY_TYPE]
478                             & OSC_QUERY_ENABLE)
479                                 goto out_success;
480                         status = AE_SUPPORT;
481                         goto out_kfree;
482                 }
483                 status = AE_ERROR;
484                 goto out_kfree;
485         }
486 out_success:
487         context->ret.length = out_obj->buffer.length;
488         context->ret.pointer = kmalloc(context->ret.length, GFP_KERNEL);
489         if (!context->ret.pointer) {
490                 status =  AE_NO_MEMORY;
491                 goto out_kfree;
492         }
493         memcpy(context->ret.pointer, out_obj->buffer.pointer,
494                 context->ret.length);
495         status =  AE_OK;
496
497 out_kfree:
498         kfree(output.pointer);
499         if (status != AE_OK)
500                 context->ret.pointer = NULL;
501         return status;
502 }
503 EXPORT_SYMBOL(acpi_run_osc);
504
505 static u8 sb_uuid_str[] = "0811B06E-4A27-44F9-8D60-3CBBC22E7B48";
506 static void acpi_bus_osc_support(void)
507 {
508         u32 capbuf[2];
509         struct acpi_osc_context context = {
510                 .uuid_str = sb_uuid_str,
511                 .rev = 1,
512                 .cap.length = 8,
513                 .cap.pointer = capbuf,
514         };
515         acpi_handle handle;
516
517         capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
518         capbuf[OSC_SUPPORT_TYPE] = OSC_SB_PR3_SUPPORT; /* _PR3 is in use */
519 #if defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR) ||\
520                         defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR_MODULE)
521         capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PAD_SUPPORT;
522 #endif
523
524 #if defined(CONFIG_ACPI_PROCESSOR) || defined(CONFIG_ACPI_PROCESSOR_MODULE)
525         capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PPC_OST_SUPPORT;
526 #endif
527         if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
528                 return;
529         if (ACPI_SUCCESS(acpi_run_osc(handle, &context)))
530                 kfree(context.ret.pointer);
531         /* do we need to check the returned cap? Sounds no */
532 }
533
534 /* --------------------------------------------------------------------------
535                                 Event Management
536    -------------------------------------------------------------------------- */
537
538 #ifdef CONFIG_ACPI_PROC_EVENT
539 static DEFINE_SPINLOCK(acpi_bus_event_lock);
540
541 LIST_HEAD(acpi_bus_event_list);
542 DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);
543
544 extern int event_is_open;
545
546 int acpi_bus_generate_proc_event4(const char *device_class, const char *bus_id, u8 type, int data)
547 {
548         struct acpi_bus_event *event;
549         unsigned long flags = 0;
550
551         /* drop event on the floor if no one's listening */
552         if (!event_is_open)
553                 return 0;
554
555         event = kzalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
556         if (!event)
557                 return -ENOMEM;
558
559         strcpy(event->device_class, device_class);
560         strcpy(event->bus_id, bus_id);
561         event->type = type;
562         event->data = data;
563
564         spin_lock_irqsave(&acpi_bus_event_lock, flags);
565         list_add_tail(&event->node, &acpi_bus_event_list);
566         spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
567
568         wake_up_interruptible(&acpi_bus_event_queue);
569
570         return 0;
571
572 }
573
574 EXPORT_SYMBOL_GPL(acpi_bus_generate_proc_event4);
575
576 int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data)
577 {
578         if (!device)
579                 return -EINVAL;
580         return acpi_bus_generate_proc_event4(device->pnp.device_class,
581                                              device->pnp.bus_id, type, data);
582 }
583
584 EXPORT_SYMBOL(acpi_bus_generate_proc_event);
585
586 int acpi_bus_receive_event(struct acpi_bus_event *event)
587 {
588         unsigned long flags = 0;
589         struct acpi_bus_event *entry = NULL;
590
591         DECLARE_WAITQUEUE(wait, current);
592
593
594         if (!event)
595                 return -EINVAL;
596
597         if (list_empty(&acpi_bus_event_list)) {
598
599                 set_current_state(TASK_INTERRUPTIBLE);
600                 add_wait_queue(&acpi_bus_event_queue, &wait);
601
602                 if (list_empty(&acpi_bus_event_list))
603                         schedule();
604
605                 remove_wait_queue(&acpi_bus_event_queue, &wait);
606                 set_current_state(TASK_RUNNING);
607
608                 if (signal_pending(current))
609                         return -ERESTARTSYS;
610         }
611
612         spin_lock_irqsave(&acpi_bus_event_lock, flags);
613         if (!list_empty(&acpi_bus_event_list)) {
614                 entry = list_entry(acpi_bus_event_list.next,
615                                    struct acpi_bus_event, node);
616                 list_del(&entry->node);
617         }
618         spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
619
620         if (!entry)
621                 return -ENODEV;
622
623         memcpy(event, entry, sizeof(struct acpi_bus_event));
624
625         kfree(entry);
626
627         return 0;
628 }
629
630 #endif  /* CONFIG_ACPI_PROC_EVENT */
631
632 /* --------------------------------------------------------------------------
633                              Notification Handling
634    -------------------------------------------------------------------------- */
635
636 static void acpi_bus_check_device(acpi_handle handle)
637 {
638         struct acpi_device *device;
639         acpi_status status;
640         struct acpi_device_status old_status;
641
642         if (acpi_bus_get_device(handle, &device))
643                 return;
644         if (!device)
645                 return;
646
647         old_status = device->status;
648
649         /*
650          * Make sure this device's parent is present before we go about
651          * messing with the device.
652          */
653         if (device->parent && !device->parent->status.present) {
654                 device->status = device->parent->status;
655                 return;
656         }
657
658         status = acpi_bus_get_status(device);
659         if (ACPI_FAILURE(status))
660                 return;
661
662         if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
663                 return;
664
665         /*
666          * Device Insertion/Removal
667          */
668         if ((device->status.present) && !(old_status.present)) {
669                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device insertion detected\n"));
670                 /* TBD: Handle device insertion */
671         } else if (!(device->status.present) && (old_status.present)) {
672                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n"));
673                 /* TBD: Handle device removal */
674         }
675 }
676
677 static void acpi_bus_check_scope(acpi_handle handle)
678 {
679         /* Status Change? */
680         acpi_bus_check_device(handle);
681
682         /*
683          * TBD: Enumerate child devices within this device's scope and
684          *       run acpi_bus_check_device()'s on them.
685          */
686 }
687
688 static BLOCKING_NOTIFIER_HEAD(acpi_bus_notify_list);
689 int register_acpi_bus_notifier(struct notifier_block *nb)
690 {
691         return blocking_notifier_chain_register(&acpi_bus_notify_list, nb);
692 }
693 EXPORT_SYMBOL_GPL(register_acpi_bus_notifier);
694
695 void unregister_acpi_bus_notifier(struct notifier_block *nb)
696 {
697         blocking_notifier_chain_unregister(&acpi_bus_notify_list, nb);
698 }
699 EXPORT_SYMBOL_GPL(unregister_acpi_bus_notifier);
700
701 /**
702  * acpi_bus_notify
703  * ---------------
704  * Callback for all 'system-level' device notifications (values 0x00-0x7F).
705  */
706 static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
707 {
708         struct acpi_device *device = NULL;
709         struct acpi_driver *driver;
710
711         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Notification %#02x to handle %p\n",
712                           type, handle));
713
714         blocking_notifier_call_chain(&acpi_bus_notify_list,
715                 type, (void *)handle);
716
717         switch (type) {
718
719         case ACPI_NOTIFY_BUS_CHECK:
720                 acpi_bus_check_scope(handle);
721                 /*
722                  * TBD: We'll need to outsource certain events to non-ACPI
723                  *      drivers via the device manager (device.c).
724                  */
725                 break;
726
727         case ACPI_NOTIFY_DEVICE_CHECK:
728                 acpi_bus_check_device(handle);
729                 /*
730                  * TBD: We'll need to outsource certain events to non-ACPI
731                  *      drivers via the device manager (device.c).
732                  */
733                 break;
734
735         case ACPI_NOTIFY_DEVICE_WAKE:
736                 /* TBD */
737                 break;
738
739         case ACPI_NOTIFY_EJECT_REQUEST:
740                 /* TBD */
741                 break;
742
743         case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
744                 /* TBD: Exactly what does 'light' mean? */
745                 break;
746
747         case ACPI_NOTIFY_FREQUENCY_MISMATCH:
748                 /* TBD */
749                 break;
750
751         case ACPI_NOTIFY_BUS_MODE_MISMATCH:
752                 /* TBD */
753                 break;
754
755         case ACPI_NOTIFY_POWER_FAULT:
756                 /* TBD */
757                 break;
758
759         default:
760                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
761                                   "Received unknown/unsupported notification [%08x]\n",
762                                   type));
763                 break;
764         }
765
766         acpi_bus_get_device(handle, &device);
767         if (device) {
768                 driver = device->driver;
769                 if (driver && driver->ops.notify &&
770                     (driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS))
771                         driver->ops.notify(device, type);
772         }
773 }
774
775 /* --------------------------------------------------------------------------
776                              Initialization/Cleanup
777    -------------------------------------------------------------------------- */
778
779 static int __init acpi_bus_init_irq(void)
780 {
781         acpi_status status = AE_OK;
782         union acpi_object arg = { ACPI_TYPE_INTEGER };
783         struct acpi_object_list arg_list = { 1, &arg };
784         char *message = NULL;
785
786
787         /*
788          * Let the system know what interrupt model we are using by
789          * evaluating the \_PIC object, if exists.
790          */
791
792         switch (acpi_irq_model) {
793         case ACPI_IRQ_MODEL_PIC:
794                 message = "PIC";
795                 break;
796         case ACPI_IRQ_MODEL_IOAPIC:
797                 message = "IOAPIC";
798                 break;
799         case ACPI_IRQ_MODEL_IOSAPIC:
800                 message = "IOSAPIC";
801                 break;
802         case ACPI_IRQ_MODEL_PLATFORM:
803                 message = "platform specific model";
804                 break;
805         default:
806                 printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
807                 return -ENODEV;
808         }
809
810         printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);
811
812         arg.integer.value = acpi_irq_model;
813
814         status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL);
815         if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
816                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
817                 return -ENODEV;
818         }
819
820         return 0;
821 }
822
823 u8 acpi_gbl_permanent_mmap;
824
825
826 void __init acpi_early_init(void)
827 {
828         acpi_status status = AE_OK;
829
830         if (acpi_disabled)
831                 return;
832
833         printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);
834
835         /* enable workarounds, unless strict ACPI spec. compliance */
836         if (!acpi_strict)
837                 acpi_gbl_enable_interpreter_slack = TRUE;
838
839         acpi_gbl_permanent_mmap = 1;
840
841         /*
842          * If the machine falls into the DMI check table,
843          * DSDT will be copied to memory
844          */
845         dmi_check_system(dsdt_dmi_table);
846
847         status = acpi_reallocate_root_table();
848         if (ACPI_FAILURE(status)) {
849                 printk(KERN_ERR PREFIX
850                        "Unable to reallocate ACPI tables\n");
851                 goto error0;
852         }
853
854         status = acpi_initialize_subsystem();
855         if (ACPI_FAILURE(status)) {
856                 printk(KERN_ERR PREFIX
857                        "Unable to initialize the ACPI Interpreter\n");
858                 goto error0;
859         }
860
861         status = acpi_load_tables();
862         if (ACPI_FAILURE(status)) {
863                 printk(KERN_ERR PREFIX
864                        "Unable to load the System Description Tables\n");
865                 goto error0;
866         }
867
868 #ifdef CONFIG_X86
869         if (!acpi_ioapic) {
870                 /* compatible (0) means level (3) */
871                 if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) {
872                         acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK;
873                         acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL;
874                 }
875                 /* Set PIC-mode SCI trigger type */
876                 acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt,
877                                          (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
878         } else {
879                 /*
880                  * now that acpi_gbl_FADT is initialized,
881                  * update it with result from INT_SRC_OVR parsing
882                  */
883                 acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi;
884         }
885 #endif
886
887         status =
888             acpi_enable_subsystem(~
889                                   (ACPI_NO_HARDWARE_INIT |
890                                    ACPI_NO_ACPI_ENABLE));
891         if (ACPI_FAILURE(status)) {
892                 printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
893                 goto error0;
894         }
895
896         return;
897
898       error0:
899         disable_acpi();
900         return;
901 }
902
903 static int __init acpi_bus_init(void)
904 {
905         int result = 0;
906         acpi_status status = AE_OK;
907         extern acpi_status acpi_os_initialize1(void);
908
909         acpi_os_initialize1();
910
911         status =
912             acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE);
913         if (ACPI_FAILURE(status)) {
914                 printk(KERN_ERR PREFIX
915                        "Unable to start the ACPI Interpreter\n");
916                 goto error1;
917         }
918
919         /*
920          * ACPI 2.0 requires the EC driver to be loaded and work before
921          * the EC device is found in the namespace (i.e. before acpi_initialize_objects()
922          * is called).
923          *
924          * This is accomplished by looking for the ECDT table, and getting
925          * the EC parameters out of that.
926          */
927         status = acpi_ec_ecdt_probe();
928         /* Ignore result. Not having an ECDT is not fatal. */
929
930         acpi_bus_osc_support();
931
932         status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
933         if (ACPI_FAILURE(status)) {
934                 printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
935                 goto error1;
936         }
937
938         acpi_early_processor_set_pdc();
939
940         /*
941          * Maybe EC region is required at bus_scan/acpi_get_devices. So it
942          * is necessary to enable it as early as possible.
943          */
944         acpi_boot_ec_enable();
945
946         printk(KERN_INFO PREFIX "Interpreter enabled\n");
947
948         /* Initialize sleep structures */
949         acpi_sleep_init();
950
951         /*
952          * Get the system interrupt model and evaluate \_PIC.
953          */
954         result = acpi_bus_init_irq();
955         if (result)
956                 goto error1;
957
958         /*
959          * Register the for all standard device notifications.
960          */
961         status =
962             acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
963                                         &acpi_bus_notify, NULL);
964         if (ACPI_FAILURE(status)) {
965                 printk(KERN_ERR PREFIX
966                        "Unable to register for device notifications\n");
967                 goto error1;
968         }
969
970         /*
971          * Create the top ACPI proc directory
972          */
973         acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
974
975         return 0;
976
977         /* Mimic structured exception handling */
978       error1:
979         acpi_terminate();
980         return -ENODEV;
981 }
982
983 struct kobject *acpi_kobj;
984
985 static int __init acpi_init(void)
986 {
987         int result = 0;
988
989
990         if (acpi_disabled) {
991                 printk(KERN_INFO PREFIX "Interpreter disabled.\n");
992                 return -ENODEV;
993         }
994
995         acpi_kobj = kobject_create_and_add("acpi", firmware_kobj);
996         if (!acpi_kobj) {
997                 printk(KERN_WARNING "%s: kset create error\n", __func__);
998                 acpi_kobj = NULL;
999         }
1000
1001         init_acpi_device_notify();
1002         result = acpi_bus_init();
1003
1004         if (!result) {
1005                 pci_mmcfg_late_init();
1006                 if (!(pm_flags & PM_APM))
1007                         pm_flags |= PM_ACPI;
1008                 else {
1009                         printk(KERN_INFO PREFIX
1010                                "APM is already active, exiting\n");
1011                         disable_acpi();
1012                         result = -ENODEV;
1013                 }
1014         } else
1015                 disable_acpi();
1016
1017         if (acpi_disabled)
1018                 return result;
1019
1020         /*
1021          * If the laptop falls into the DMI check table, the power state check
1022          * will be disabled in the course of device power transition.
1023          */
1024         dmi_check_system(power_nocheck_dmi_table);
1025
1026         acpi_scan_init();
1027         acpi_ec_init();
1028         acpi_power_init();
1029         acpi_sysfs_init();
1030         acpi_debugfs_init();
1031         acpi_sleep_proc_init();
1032         acpi_wakeup_device_init();
1033         return result;
1034 }
1035
1036 subsys_initcall(acpi_init);