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

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive