acpi_bus.h File Reference

#include <acpi.h>
#include "list.h"

Include dependency graph for acpi_bus.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	acpi_handle_list
struct	acpi_bus_ops
struct	acpi_device_ops
struct	acpi_driver
struct	acpi_device_status
struct	acpi_device_flags
struct	acpi_device_pnp
struct	acpi_device_power_flags
struct	acpi_device_power_state
struct	acpi_device_power
struct	acpi_device_perf_flags
struct	acpi_device_perf_state
struct	acpi_device_perf
struct	acpi_device_wakeup_flags
struct	acpi_device_wakeup_state
struct	acpi_device_wakeup
struct	acpi_device
struct	acpi_bus_event
struct	acpi_pci_root

Macros
#define	ACPI_MAX_HANDLES   10
#define	ACPI_DRIVER_ALL_NOTIFY_EVENTS   0x1 /* system AND device events */
#define	acpi_device_bid(d)   ((d)->pnp.bus_id)
#define	acpi_device_adr(d)   ((d)->pnp.bus_address)
#define	acpi_device_hid(d)   ((d)->pnp.hardware_id)
#define	acpi_device_uid(d)   ((d)->pnp.unique_id)
#define	acpi_device_name(d)   ((d)->pnp.device_name)
#define	acpi_device_class(d)   ((d)->pnp.device_class)
#define	acpi_driver_data(d)   ((d)->driver_data)
#define	to_acpi_device(d)   container_of(d, struct acpi_device, dev)
#define	to_acpi_driver(d)   container_of(d, struct acpi_driver, drv)

Typedefs
typedef int(*	acpi_op_add) (struct acpi_device *device)
typedef int(*	acpi_op_remove) (struct acpi_device *device, int type)
typedef int(*	acpi_op_start) (struct acpi_device *device)
typedef int(*	acpi_op_suspend) (struct acpi_device *device, int state)
typedef int(*	acpi_op_resume) (struct acpi_device *device, int state)
typedef int(*	acpi_op_scan) (struct acpi_device *device)
typedef int(*	acpi_op_bind) (struct acpi_device *device)
typedef int(*	acpi_op_unbind) (struct acpi_device *device)
typedef void(*	acpi_op_notify) (struct acpi_device *device, UINT32 event)
typedef char	acpi_bus_id[8]
typedef unsigned long	acpi_bus_address
typedef char *	acpi_hardware_id
typedef char	acpi_unique_id[9]
typedef char	acpi_device_name[40]
typedef char	acpi_device_class[20]

Enumerations
enum	acpi_bus_removal_type { ACPI_BUS_REMOVAL_NORMAL = 0 , ACPI_BUS_REMOVAL_EJECT , ACPI_BUS_REMOVAL_SUPRISE , ACPI_BUS_REMOVAL_TYPE_COUNT }
enum	acpi_bus_device_type {   ACPI_BUS_TYPE_DEVICE = 0 , ACPI_BUS_TYPE_POWER , ACPI_BUS_TYPE_PROCESSOR , ACPI_BUS_TYPE_THERMAL ,   ACPI_BUS_TYPE_SYSTEM , ACPI_BUS_TYPE_POWER_BUTTON , ACPI_BUS_TYPE_SLEEP_BUTTON , ACPI_BUS_TYPE_POWER_BUTTONF ,   ACPI_BUS_TYPE_SLEEP_BUTTONF , ACPI_BUS_DEVICE_TYPE_COUNT }
enum	acpi_irq_model_id { ACPI_IRQ_MODEL_PIC = 0 , ACPI_IRQ_MODEL_IOAPIC , ACPI_IRQ_MODEL_IOSAPIC , ACPI_IRQ_MODEL_COUNT }

Functions
ACPI_STATUS	acpi_extract_package (ACPI_OBJECT *package, ACPI_BUFFER *format, ACPI_BUFFER *buffer)
ACPI_STATUS	acpi_evaluate_integer (ACPI_HANDLE handle, ACPI_STRING pathname, struct acpi_object_list *arguments, unsigned long long *data)
ACPI_STATUS	acpi_evaluate_reference (ACPI_HANDLE handle, ACPI_STRING pathname, struct acpi_object_list *arguments, struct acpi_handle_list *list)
NTSTATUS	acpi_create_volatile_registry_tables (void)
int	acpi_bus_get_private_data (ACPI_HANDLE, void **)
void	acpi_bus_data_handler (ACPI_HANDLE handle, void *context)
ACPI_STATUS	acpi_bus_get_status_handle (ACPI_HANDLE handle, unsigned long long *sta)
int	acpi_bus_get_status (struct acpi_device *device)
int	acpi_bus_get_power (ACPI_HANDLE handle, int *state)
int	acpi_bus_set_power (ACPI_HANDLE handle, int state)
BOOLEAN	acpi_bus_power_manageable (ACPI_HANDLE handle)
BOOLEAN	acpi_bus_can_wakeup (ACPI_HANDLE handle)
int	acpi_bus_generate_proc_event (struct acpi_device *device, UINT8 type, int data)
int	acpi_bus_generate_event (struct acpi_device *device, UINT8 type, int data)
int	acpi_bus_receive_event (struct acpi_bus_event *event)
int	acpi_bus_register_driver (struct acpi_driver *driver)
void	acpi_bus_unregister_driver (struct acpi_driver *driver)
int	acpi_bus_add (struct acpi_device **child, struct acpi_device *parent, ACPI_HANDLE handle, int type)
int	acpi_bus_trim (struct acpi_device *start, int rmdevice)
int	acpi_bus_start (struct acpi_device *device)
ACPI_STATUS	acpi_bus_get_ejd (ACPI_HANDLE handle, ACPI_HANDLE *ejd)
int	acpi_match_device_ids (struct acpi_device *device, const struct acpi_pnp_device_id *ids)
int	acpi_bus_get_device (ACPI_HANDLE handle, struct acpi_device **device)
int	acpi_init (void)
ACPI_STATUS	acpi_suspend (UINT32 state)

Variables
struct bus_type	acpi_bus_type
enum acpi_irq_model_id	acpi_irq_model

Macro Definition Documentation

acpi_device_adr

#define acpi_device_adr

(

d

)

((d)->pnp.bus_address)

Definition at line 187 of file acpi_bus.h.

acpi_device_bid

#define acpi_device_bid

(

d

)

((d)->pnp.bus_id)

Definition at line 186 of file acpi_bus.h.

acpi_device_class

#define acpi_device_class

(

d

)

((d)->pnp.device_class)

Definition at line 191 of file acpi_bus.h.

acpi_device_hid

#define acpi_device_hid

(

d

)

((d)->pnp.hardware_id)

Definition at line 188 of file acpi_bus.h.

acpi_device_name

#define acpi_device_name

(

d

)

((d)->pnp.device_name)

Definition at line 190 of file acpi_bus.h.

acpi_device_uid

#define acpi_device_uid

(

d

)

((d)->pnp.unique_id)

Definition at line 189 of file acpi_bus.h.

ACPI_DRIVER_ALL_NOTIFY_EVENTS

#define ACPI_DRIVER_ALL_NOTIFY_EVENTS   0x1 /* system AND device events */

Definition at line 119 of file acpi_bus.h.

acpi_driver_data

#define acpi_driver_data

(

d

)

((d)->driver_data)

Definition at line 289 of file acpi_bus.h.

ACPI_MAX_HANDLES

#define ACPI_MAX_HANDLES   10

Definition at line 35 of file acpi_bus.h.

to_acpi_device

#define to_acpi_device

(

d

)

container_of(d, struct acpi_device, dev)

Definition at line 291 of file acpi_bus.h.

to_acpi_driver

#define to_acpi_driver

(

d

)

container_of(d, struct acpi_driver, drv)

Definition at line 292 of file acpi_bus.h.

Typedef Documentation

acpi_bus_address

typedef unsigned long acpi_bus_address

Definition at line 170 of file acpi_bus.h.

acpi_bus_id

typedef char acpi_bus_id[8]

Definition at line 169 of file acpi_bus.h.

acpi_device_class

typedef char acpi_device_class[20]

Definition at line 174 of file acpi_bus.h.

acpi_device_name

typedef char acpi_device_name[40]

Definition at line 173 of file acpi_bus.h.

acpi_hardware_id

typedef char* acpi_hardware_id

Definition at line 171 of file acpi_bus.h.

acpi_op_add

typedef int(* acpi_op_add) (struct acpi_device *device)

Definition at line 92 of file acpi_bus.h.

acpi_op_bind

typedef int(* acpi_op_bind) (struct acpi_device *device)

Definition at line 98 of file acpi_bus.h.

acpi_op_notify

typedef void(* acpi_op_notify) (struct acpi_device *device, UINT32 event)

Definition at line 100 of file acpi_bus.h.

acpi_op_remove

typedef int(* acpi_op_remove) (struct acpi_device *device, int type)

Definition at line 93 of file acpi_bus.h.

acpi_op_resume

typedef int(* acpi_op_resume) (struct acpi_device *device, int state)

Definition at line 96 of file acpi_bus.h.

acpi_op_scan

typedef int(* acpi_op_scan) (struct acpi_device *device)

Definition at line 97 of file acpi_bus.h.

acpi_op_start

typedef int(* acpi_op_start) (struct acpi_device *device)

Definition at line 94 of file acpi_bus.h.

acpi_op_suspend

typedef int(* acpi_op_suspend) (struct acpi_device *device, int state)

Definition at line 95 of file acpi_bus.h.

acpi_op_unbind

typedef int(* acpi_op_unbind) (struct acpi_device *device)

Definition at line 99 of file acpi_bus.h.

acpi_unique_id

typedef char acpi_unique_id[9]

Definition at line 172 of file acpi_bus.h.

Enumeration Type Documentation

acpi_bus_device_type

enum acpi_bus_device_type

Enumerator
ACPI_BUS_TYPE_DEVICE
ACPI_BUS_TYPE_POWER
ACPI_BUS_TYPE_PROCESSOR
ACPI_BUS_TYPE_THERMAL
ACPI_BUS_TYPE_SYSTEM
ACPI_BUS_TYPE_POWER_BUTTON
ACPI_BUS_TYPE_SLEEP_BUTTON
ACPI_BUS_TYPE_POWER_BUTTONF
ACPI_BUS_TYPE_SLEEP_BUTTONF
ACPI_BUS_DEVICE_TYPE_COUNT

Definition at line 70 of file acpi_bus.h.

                          {
    ACPI_BUS_TYPE_DEVICE    = 0,
    ACPI_BUS_TYPE_POWER,
    ACPI_BUS_TYPE_PROCESSOR,
    ACPI_BUS_TYPE_THERMAL,
    ACPI_BUS_TYPE_SYSTEM,
    ACPI_BUS_TYPE_POWER_BUTTON,
    ACPI_BUS_TYPE_SLEEP_BUTTON,
    ACPI_BUS_TYPE_POWER_BUTTONF,
    ACPI_BUS_TYPE_SLEEP_BUTTONF,
    ACPI_BUS_DEVICE_TYPE_COUNT
};

acpi_bus_removal_type

enum acpi_bus_removal_type

Enumerator
ACPI_BUS_REMOVAL_NORMAL
ACPI_BUS_REMOVAL_EJECT
ACPI_BUS_REMOVAL_SUPRISE
ACPI_BUS_REMOVAL_TYPE_COUNT

Definition at line 63 of file acpi_bus.h.

                           {
    ACPI_BUS_REMOVAL_NORMAL = 0,
    ACPI_BUS_REMOVAL_EJECT,
    ACPI_BUS_REMOVAL_SUPRISE,
    ACPI_BUS_REMOVAL_TYPE_COUNT
};

acpi_irq_model_id

enum acpi_irq_model_id

Enumerator
ACPI_IRQ_MODEL_PIC
ACPI_IRQ_MODEL_IOAPIC
ACPI_IRQ_MODEL_IOSAPIC
ACPI_IRQ_MODEL_COUNT

Definition at line 384 of file acpi_bus.h.

                       {
    ACPI_IRQ_MODEL_PIC = 0,
    ACPI_IRQ_MODEL_IOAPIC,
    ACPI_IRQ_MODEL_IOSAPIC,
    ACPI_IRQ_MODEL_COUNT
};

Function Documentation

acpi_bus_add()

int acpi_bus_add	(	struct acpi_device **	child,
		struct acpi_device *	parent,
		ACPI_HANDLE	handle,
		int	type
	)

Definition at line 1130 of file bus.c.

{
    int         result = 0;
    ACPI_STATUS     status = AE_OK;
    struct acpi_device  *device = NULL;
    char            bus_id[5] = {'?',0};
    ACPI_BUFFER buffer;
    ACPI_DEVICE_INFO    *info = NULL;
    char            *hid = NULL;
    char            *uid = NULL;
    ACPI_PNP_DEVICE_ID_LIST *cid_list = NULL;
    int         i = 0;
    acpi_unique_id      static_uid_buffer;
 
    if (!child)
        return_VALUE(AE_BAD_PARAMETER);
 
    device = ExAllocatePoolWithTag(NonPagedPool,sizeof(struct acpi_device), 'DpcA');
    if (!device) {
        DPRINT1("Memory allocation error\n");
        return_VALUE(-12);
    }
    memset(device, 0, sizeof(struct acpi_device));
 
    device->handle = handle;
    device->parent = parent;
 
    /*
     * Bus ID
     * ------
     * The device's Bus ID is simply the object name.
     * TBD: Shouldn't this value be unique (within the ACPI namespace)?
     */
    switch (type) {
    case ACPI_BUS_TYPE_SYSTEM:
        snprintf(device->pnp.bus_id, sizeof(device->pnp.bus_id), "%s", "ACPI");
        break;
    case ACPI_BUS_TYPE_POWER_BUTTONF:
    case ACPI_BUS_TYPE_POWER_BUTTON:
        snprintf(device->pnp.bus_id, sizeof(device->pnp.bus_id), "%s", "PWRF");
        break;
    case ACPI_BUS_TYPE_SLEEP_BUTTONF:
    case ACPI_BUS_TYPE_SLEEP_BUTTON:
        snprintf(device->pnp.bus_id, sizeof(device->pnp.bus_id), "%s", "SLPF");
        break;
    default:
        buffer.Length = sizeof(bus_id);
        buffer.Pointer = bus_id;
        AcpiGetName(handle, ACPI_SINGLE_NAME, &buffer);
 
 
        /* Clean up trailing underscores (if any) */
        for (i = 3; i > 1; i--) {
            if (bus_id[i] == '_')
                bus_id[i] = '\0';
            else
                break;
        }
        snprintf(device->pnp.bus_id, sizeof(device->pnp.bus_id), "%s", bus_id);
        buffer.Pointer = NULL;
 
        break;
    }
 
    /*
     * Flags
     * -----
     * Get prior to calling acpi_bus_get_status() so we know whether
     * or not _STA is present.  Note that we only look for object
     * handles -- cannot evaluate objects until we know the device is
     * present and properly initialized.
     */
    result = acpi_bus_get_flags(device);
    if (result)
        goto end;
 
    /*
     * Status
     * ------
     * See if the device is present.  We always assume that non-Device()
     * objects (e.g. thermal zones, power resources, processors, etc.) are
     * present, functioning, etc. (at least when parent object is present).
     * Note that _STA has a different meaning for some objects (e.g.
     * power resources) so we need to be careful how we use it.
     */
    switch (type) {
    case ACPI_BUS_TYPE_DEVICE:
        result = acpi_bus_get_status(device);
        if (result)
            goto end;
        break;
    default:
        STRUCT_TO_INT(device->status) = 0x0F;
        break;
    }
    if (!device->status.present) {
        result = -2;
        goto end;
    }
 
    /*
     * Initialize Device
     * -----------------
     * TBD: Synch with Core's enumeration/initialization process.
     */
 
    /*
     * Hardware ID, Unique ID, & Bus Address
     * -------------------------------------
     */
    switch (type) {
    case ACPI_BUS_TYPE_DEVICE:
        status = AcpiGetObjectInfo(handle,&info);
        if (ACPI_FAILURE(status)) {
            ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
                "Error reading device info\n"));
            result = AE_NOT_FOUND;
            info = NULL;
            goto end;
        }
        if (info->Valid & ACPI_VALID_HID)
            hid = info->HardwareId.String;
        if (info->Valid & ACPI_VALID_UID)
            uid = info->UniqueId.String;
        if (info->Valid & ACPI_VALID_CID) {
            cid_list = &info->CompatibleIdList;
            device->pnp.cid_list = ExAllocatePoolWithTag(NonPagedPool,cid_list->ListSize, 'DpcA');
            if (device->pnp.cid_list) {
                char *p = (char *)&device->pnp.cid_list->Ids[cid_list->Count];
                device->pnp.cid_list->Count = cid_list->Count;
                device->pnp.cid_list->ListSize = cid_list->ListSize;
                for (i = 0; i < cid_list->Count; i++) {
                    device->pnp.cid_list->Ids[i].Length = cid_list->Ids[i].Length;
                    device->pnp.cid_list->Ids[i].String = p;
                    ASSERT(p + cid_list->Ids[i].Length <= (char *)device->pnp.cid_list + cid_list->ListSize);
                    memcpy(device->pnp.cid_list->Ids[i].String,
                        cid_list->Ids[i].String, cid_list->Ids[i].Length);
                    p += cid_list->Ids[i].Length;
                }
            }
            else
                DPRINT("Memory allocation error\n");
        }
        if (info->Valid & ACPI_VALID_ADR) {
            device->pnp.bus_address = info->Address;
            device->flags.bus_address = 1;
        }
        break;
    case ACPI_BUS_TYPE_POWER:
        hid = ACPI_POWER_HID;
        uid = static_uid_buffer;
        snprintf(uid, sizeof(static_uid_buffer), "%d", (PowerDeviceCount++));
        break;
    case ACPI_BUS_TYPE_PROCESSOR:
        hid = ACPI_PROCESSOR_HID;
        uid = static_uid_buffer;
        snprintf(uid, sizeof(static_uid_buffer), "_%d", (ProcessorCount++));
        break;
    case ACPI_BUS_TYPE_SYSTEM:
        hid = ACPI_SYSTEM_HID;
        break;
    case ACPI_BUS_TYPE_THERMAL:
        hid = ACPI_THERMAL_HID;
        uid = static_uid_buffer;
        snprintf(uid, sizeof(static_uid_buffer), "%d", (ThermalZoneCount++));
        break;
    case ACPI_BUS_TYPE_POWER_BUTTON:
        hid = ACPI_BUTTON_HID_POWER;
        uid = static_uid_buffer;
        snprintf(uid, sizeof(static_uid_buffer), "%d", (PowerButtonCount++));
        break;
    case ACPI_BUS_TYPE_POWER_BUTTONF:
        hid = ACPI_BUTTON_HID_POWERF;
        uid = static_uid_buffer;
        snprintf(uid, sizeof(static_uid_buffer), "%d", (FixedPowerButtonCount++));
        break;
    case ACPI_BUS_TYPE_SLEEP_BUTTON:
        hid = ACPI_BUTTON_HID_SLEEP;
        uid = static_uid_buffer;
        snprintf(uid, sizeof(static_uid_buffer), "%d", (SleepButtonCount++));
        break;
    case ACPI_BUS_TYPE_SLEEP_BUTTONF:
        hid = ACPI_BUTTON_HID_SLEEPF;
        uid = static_uid_buffer;
        snprintf(uid, sizeof(static_uid_buffer), "%d", (FixedSleepButtonCount++));
        break;
    }
 
    /*
     * \_SB
     * ----
     * Fix for the system root bus device -- the only root-level device.
     */
    if (((ACPI_HANDLE)parent == ACPI_ROOT_OBJECT) && (type == ACPI_BUS_TYPE_DEVICE)) {
        hid = ACPI_BUS_HID;
        snprintf(device->pnp.device_name, sizeof(device->pnp.device_name), "%s", ACPI_BUS_DEVICE_NAME);
        snprintf(device->pnp.device_class, sizeof(device->pnp.device_class), "%s", ACPI_BUS_CLASS);
    }
 
    if (hid) {
        device->pnp.hardware_id = ExAllocatePoolWithTag(NonPagedPool, strlen(hid) + 1, 'DpcA');
        if (device->pnp.hardware_id) {
            snprintf(device->pnp.hardware_id, strlen(hid) + 1, "%s", hid);
            device->flags.hardware_id = 1;
        }
    }
    if (uid) {
        snprintf(device->pnp.unique_id, sizeof(device->pnp.unique_id), "%s", uid);
        device->flags.unique_id = 1;
    }
 
    /*
     * If we called get_object_info, we now are finished with the buffer,
     * so we can free it.
     */
    //if (buffer.Pointer)
        //AcpiOsFree(buffer.Pointer);
 
    /*
     * Power Management
     * ----------------
     */
    if (device->flags.power_manageable) {
        result = acpi_bus_get_power_flags(device);
        if (result)
            goto end;
    }
 
    /*
     * Performance Management
     * ----------------------
     */
    if (device->flags.performance_manageable) {
        result = acpi_bus_get_perf_flags(device);
        if (result)
            goto end;
    }
 
    /*
     * Context
     * -------
     * Attach this 'struct acpi_device' to the ACPI object.  This makes
     * resolutions from handle->device very efficient.  Note that we need
     * to be careful with fixed-feature devices as they all attach to the
     * root object.
     */
    switch (type) {
    case ACPI_BUS_TYPE_POWER_BUTTON:
    case ACPI_BUS_TYPE_POWER_BUTTONF:
    case ACPI_BUS_TYPE_SLEEP_BUTTON:
    case ACPI_BUS_TYPE_SLEEP_BUTTONF:
        break;
    default:
        status = AcpiAttachData(device->handle,
            acpi_bus_data_handler, device);
        break;
    }
    if (ACPI_FAILURE(status)) {
        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
            "Error attaching device data\n"));
        result = AE_NOT_FOUND;
        goto end;
    }
 
    /*
     * Linkage
     * -------
     * Link this device to its parent and siblings.
     */
    INIT_LIST_HEAD(&device->children);
    if (!device->parent)
        INIT_LIST_HEAD(&device->node);
    else
        list_add_tail(&device->node, &device->parent->children);
 
    /*
     * Global Device Hierarchy:
     * ------------------------
     * Register this device with the global device hierarchy.
     */
    acpi_device_register(device, parent);
 
    /*
     * Bind _ADR-Based Devices
     * -----------------------
     * If there's a a bus address (_ADR) then we utilize the parent's
     * 'bind' function (if exists) to bind the ACPI- and natively-
     * enumerated device representations.
     */
    if (device->flags.bus_address) {
        if (device->parent && device->parent->ops.bind)
            device->parent->ops.bind(device);
    }
 
    /*
     * Locate & Attach Driver
     * ----------------------
     * If there's a hardware id (_HID) or compatible ids (_CID) we check
     * to see if there's a driver installed for this kind of device.  Note
     * that drivers can install before or after a device is enumerated.
     *
     * TBD: Assumes LDM provides driver hot-plug capability.
     */
    if (device->flags.hardware_id || device->flags.compatible_ids)
        acpi_bus_find_driver(device);
 
end:
    if (info != NULL)
        ACPI_FREE(info);
    if (result) {
        if (device->pnp.cid_list) {
            ExFreePoolWithTag(device->pnp.cid_list, 'DpcA');
        }
        if (device->pnp.hardware_id) {
            ExFreePoolWithTag(device->pnp.hardware_id, 'DpcA');
        }
        ExFreePoolWithTag(device, 'DpcA');
        return_VALUE(result);
    }
    *child = device;
 
    return_VALUE(0);
}

Referenced by acpi_bus_init(), acpi_bus_scan(), and acpi_bus_scan_fixed().

acpi_bus_can_wakeup()

BOOLEAN acpi_bus_can_wakeup

(

ACPI_HANDLE

handle

)

Definition at line 360 of file bus.c.

{
    struct acpi_device *device;
    int result;
 
    result = acpi_bus_get_device(handle, &device);
    return result ? 0 : device->wakeup.flags.valid;
}

acpi_bus_data_handler()

void acpi_bus_data_handler	(	ACPI_HANDLE	handle,
		void *	context
	)

Definition at line 95 of file bus.c.

{
    DPRINT1("acpi_bus_data_handler not implemented\n");
 
    /* TBD */
 
    return;
}

Referenced by acpi_bus_add(), and acpi_bus_get_device().

acpi_bus_generate_event()

int acpi_bus_generate_event	(	struct acpi_device *	device,
		UINT8	type,
		int	data
	)

Definition at line 485 of file bus.c.

{
    ULONG_PTR TypeData = 0;
 
    DPRINT("acpi_bus_generate_event\n");
 
    if (!device)
        return_VALUE(AE_BAD_PARAMETER);
 
    /* drop event on the floor if no one's listening */
    if (!event_is_open)
        return_VALUE(0);
 
    /* Data shouldn't even get near 24 bits */
    ASSERT(!(data & 0xFF000000));
 
    TypeData = data;
    TypeData |= type << 24;
 
    KeInsertQueueDpc(&event_dpc, device, (PVOID)TypeData);
 
    return_VALUE(0);
}

Referenced by acpi_button_notify().

acpi_bus_generate_proc_event()

int acpi_bus_generate_proc_event	(	struct acpi_device *	device,
		UINT8	type,
		int	data
	)

acpi_bus_get_device()

int acpi_bus_get_device	(	ACPI_HANDLE	handle,
		struct acpi_device **	device
	)

Definition at line 108 of file bus.c.

{
    ACPI_STATUS     status = AE_OK;
 
    if (!device)
        return_VALUE(AE_BAD_PARAMETER);
 
    /* TBD: Support fixed-feature devices */
 
    status = AcpiGetData(handle, acpi_bus_data_handler, (void**)device);
    if (ACPI_FAILURE(status) || !*device) {
        DPRINT( "Error getting context for object [%p]\n",
            handle);
        return_VALUE(AE_NOT_FOUND);
    }
 
    return 0;
}

Referenced by acpi_bus_can_wakeup(), acpi_bus_check_device(), acpi_bus_get_power(), acpi_bus_notify(), acpi_bus_power_manageable(), acpi_bus_set_power(), acpi_power_get_context(), Bus_PDO_PnP(), Bus_PDO_QueryDeviceCaps(), Bus_PDO_QueryDeviceId(), Bus_PDO_QueryResources(), and Bus_PlugInDevice().

acpi_bus_get_ejd()

ACPI_STATUS acpi_bus_get_ejd	(	ACPI_HANDLE	handle,
		ACPI_HANDLE *	ejd
	)

acpi_bus_get_power()

int acpi_bus_get_power	(	ACPI_HANDLE	handle,
		int *	state
	)

Definition at line 198 of file bus.c.

{
    int         result = 0;
    ACPI_STATUS             status = 0;
    struct acpi_device  *device = NULL;
    unsigned long long      psc = 0;
 
    result = acpi_bus_get_device(handle, &device);
    if (result)
        return_VALUE(result);
 
    *state = ACPI_STATE_UNKNOWN;
 
    if (!device->flags.power_manageable) {
        /* TBD: Non-recursive algorithm for walking up hierarchy */
        if (device->parent)
            *state = device->parent->power.state;
        else
            *state = ACPI_STATE_D0;
    }
    else {
        /*
         * Get the device's power state either directly (via _PSC) or
         * indirectly (via power resources).
         */
        if (device->power.flags.explicit_get) {
            status = acpi_evaluate_integer(device->handle, "_PSC",
                NULL, &psc);
            if (ACPI_FAILURE(status))
                return_VALUE(AE_NOT_FOUND);
            device->power.state = (int) psc;
        }
        else if (device->power.flags.power_resources) {
            result = acpi_power_get_inferred_state(device);
            if (result)
                return_VALUE(result);
        }
 
        *state = device->power.state;
    }
 
    DPRINT("Device [%s] power state is D%d\n",
        device->pnp.bus_id, device->power.state);
 
    return_VALUE(0);
}

Referenced by acpi_bus_set_power(), and Bus_InitializePdo().

acpi_bus_get_private_data()

int acpi_bus_get_private_data	(	ACPI_HANDLE	handle,
		void **	data
	)

Definition at line 178 of file bus.c.

{
    ACPI_STATUS status = AE_OK;
 
    if (!*data)
        return -1;
 
    status = AcpiGetData(handle, acpi_bus_private_data_handler, data);
    if (ACPI_FAILURE(status) || !*data) {
        DPRINT("No context for object [%p]\n", handle);
        return -1;
    }
 
    return 0;
}

acpi_bus_get_status()

int acpi_bus_get_status

(

struct acpi_device *

device

)

Definition at line 147 of file bus.c.

{
    ACPI_STATUS status;
    unsigned long long sta;
 
    status = acpi_bus_get_status_handle(device->handle, &sta);
    if (ACPI_FAILURE(status))
        return -1;
 
    STRUCT_TO_INT(device->status) = (int) sta;
 
    if (device->status.functional && !device->status.present) {
        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]: "
               "functional but not present;\n",
            device->pnp.bus_id,
            (UINT32) STRUCT_TO_INT(device->status)));
    }
 
    ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
              device->pnp.bus_id,
              (UINT32) STRUCT_TO_INT(device->status)));
    return 0;
}

Referenced by acpi_bus_add(), and acpi_bus_check_device().

acpi_bus_get_status_handle()

ACPI_STATUS acpi_bus_get_status_handle	(	ACPI_HANDLE	handle,
		unsigned long long *	sta
	)

Definition at line 129 of file bus.c.

{
    ACPI_STATUS status;
 
    status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
    if (ACPI_SUCCESS(status))
        return AE_OK;
 
    if (status == AE_NOT_FOUND) {
        *sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
               ACPI_STA_DEVICE_UI      | ACPI_STA_DEVICE_FUNCTIONING;
        return AE_OK;
    }
    return status;
}

Referenced by acpi_bus_get_status().

acpi_bus_power_manageable()

BOOLEAN acpi_bus_power_manageable

(

ACPI_HANDLE

handle

)

Definition at line 351 of file bus.c.

{
    struct acpi_device *device;
    int result;
 
    result = acpi_bus_get_device(handle, &device);
    return result ? 0 : device->flags.power_manageable;
}

Referenced by Bus_PDO_PnP(), and Bus_PDO_Power().

acpi_bus_receive_event()

int acpi_bus_receive_event

(

struct acpi_bus_event *

event

)

Definition at line 513 of file bus.c.

{
//  unsigned long       flags = 0;
    struct acpi_bus_event   *entry = NULL;
    KIRQL OldIrql;
 
    //DECLARE_WAITQUEUE(wait, current);
 
    DPRINT("acpi_bus_receive_event\n");
 
    if (!event)
        return AE_BAD_PARAMETER;
 
    event_is_open++;
    KeWaitForSingleObject(&AcpiEventQueue,
                  Executive,
                  KernelMode,
                  FALSE,
                  NULL);
    event_is_open--;
    KeClearEvent(&AcpiEventQueue);
 
    if (list_empty(&acpi_bus_event_list))
        return_VALUE(AE_NOT_FOUND);
 
//  spin_lock_irqsave(&acpi_bus_event_lock, flags);
    KeAcquireSpinLock(&acpi_bus_event_lock, &OldIrql);
    entry = list_entry(acpi_bus_event_list.next, struct acpi_bus_event, node);
    if (entry)
        list_del(&entry->node);
    KeReleaseSpinLock(&acpi_bus_event_lock, OldIrql);
//  spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
 
    if (!entry)
        return_VALUE(AE_NOT_FOUND);
 
    memcpy(event, entry, sizeof(struct acpi_bus_event));
 
    ExFreePoolWithTag(entry, 'epcA');
    return_VALUE(0);
}

Referenced by ButtonWaitThread().

acpi_bus_register_driver()

int acpi_bus_register_driver

(

struct acpi_driver *

driver

)

acpi_bus_register_driver

Registers a driver with the ACPI bus. Searches the namespace for all devices that match the driver's criteria and binds.

Definition at line 1029 of file bus.c.

{
    if (!driver)
        return_VALUE(AE_BAD_PARAMETER);
 
    //if (acpi_disabled)
    //  return_VALUE(AE_NOT_FOUND);
 
    down(&acpi_bus_drivers_lock);
    list_add_tail(&driver->node, &acpi_bus_drivers);
    up(&acpi_bus_drivers_lock);
 
    acpi_bus_walk(acpi_root, acpi_bus_attach,
        WALK_DOWN, driver);
 
    return_VALUE(driver->references);
}

Referenced by acpi_button_init(), acpi_power_init(), and acpi_system_init().

acpi_bus_set_power()

int acpi_bus_set_power	(	ACPI_HANDLE	handle,
		int	state
	)

Definition at line 249 of file bus.c.

{
    int         result = 0;
    ACPI_STATUS     status = AE_OK;
    struct acpi_device  *device = NULL;
    char            object_name[5] = {'_','P','S','0'+state,'\0'};
 
 
    result = acpi_bus_get_device(handle, &device);
    if (result)
        return_VALUE(result);
 
    if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
        return_VALUE(AE_BAD_PARAMETER);
 
    /* Make sure this is a valid target state */
 
    if (!device->flags.power_manageable) {
        DPRINT1( "Device is not power manageable\n");
        return_VALUE(AE_NOT_FOUND);
    }
    /*
     * Get device's current power state
     */
    //if (!acpi_power_nocheck) {
        /*
         * Maybe the incorrect power state is returned on the bogus
         * bios, which is different with the real power state.
         * For example: the bios returns D0 state and the real power
         * state is D3. OS expects to set the device to D0 state. In
         * such case if OS uses the power state returned by the BIOS,
         * the device can't be transisted to the correct power state.
         * So if the acpi_power_nocheck is set, it is unnecessary to
         * get the power state by calling acpi_bus_get_power.
         */
        acpi_bus_get_power(device->handle, &device->power.state);
    //}
 
    if ((state == device->power.state) && !device->flags.force_power_state) {
        DPRINT1("Device is already at D%d\n", state);
        return 0;
    }
    if (!device->power.states[state].flags.valid) {
        DPRINT1( "Device does not support D%d\n", state);
        return AE_NOT_FOUND;
    }
    if (device->parent && (state < device->parent->power.state)) {
        DPRINT1( "Cannot set device to a higher-powered state than parent\n");
        return AE_NOT_FOUND;
    }
 
    /*
     * Transition Power
     * ----------------
     * On transitions to a high-powered state we first apply power (via
     * power resources) then evalute _PSx.  Conversely for transitions to
     * a lower-powered state.
     */
    if (state < device->power.state) {
        if (device->power.flags.power_resources) {
            result = acpi_power_transition(device, state);
            if (result)
                goto end;
        }
        if (device->power.states[state].flags.explicit_set) {
            status = AcpiEvaluateObject(device->handle,
                object_name, NULL, NULL);
            if (ACPI_FAILURE(status)) {
                result = AE_NOT_FOUND;
                goto end;
            }
        }
    }
    else {
        if (device->power.states[state].flags.explicit_set) {
            status = AcpiEvaluateObject(device->handle,
                object_name, NULL, NULL);
            if (ACPI_FAILURE(status)) {
                result = AE_NOT_FOUND;
                goto end;
            }
        }
        if (device->power.flags.power_resources) {
            result = acpi_power_transition(device, state);
            if (result)
                goto end;
        }
    }
 
end:
    if (result)
        DPRINT( "Error transitioning device [%s] to D%d\n",
            device->pnp.bus_id, state);
    else
        DPRINT("Device [%s] transitioned to D%d\n",
            device->pnp.bus_id, state);
 
    return result;
}

Referenced by Bus_PDO_PnP(), and Bus_PDO_Power().

acpi_bus_start()

int acpi_bus_start

(

struct acpi_device *

device

)

acpi_bus_trim()

int acpi_bus_trim	(	struct acpi_device *	start,
		int	rmdevice
	)

acpi_bus_unregister_driver()

void acpi_bus_unregister_driver

(

struct acpi_driver *

driver

)

acpi_bus_unregister_driver

Unregisters a driver with the ACPI bus. Searches the namespace for all devices that match the driver's criteria and unbinds.

Definition at line 1056 of file bus.c.

{
    if (!driver)
        return;
 
    acpi_bus_walk(acpi_root, acpi_bus_unattach, WALK_UP, driver);
 
    if (driver->references)
        return;
 
    down(&acpi_bus_drivers_lock);
    list_del(&driver->node);
    up(&acpi_bus_drivers_lock);
 
    return;
}

Referenced by acpi_button_exit(), and acpi_system_exit().

acpi_create_volatile_registry_tables()

NTSTATUS acpi_create_volatile_registry_tables

(

void

)

Definition at line 525 of file utils.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING HardwareKeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\HARDWARE\\ACPI");
    HANDLE KeyHandle = NULL;
    NTSTATUS Status;
    ACPI_STATUS AcpiStatus;
    ACPI_TABLE_HEADER *OutTable;
    ACPI_PHYSICAL_ADDRESS RsdpAddress;
    ACPI_TABLE_RSDP *Rsdp;
    ACPI_PHYSICAL_ADDRESS Address;
    UINT32 TableEntrySize;
 
    /* Create Main Hardware ACPI key*/
    InitializeObjectAttributes(&ObjectAttributes,
                               &HardwareKeyName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
    Status = ZwCreateKey(&KeyHandle,
                         KEY_WRITE,
                         &ObjectAttributes,
                         0,
                         NULL,
                         REG_OPTION_VOLATILE,
                         NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ZwCreateKey() for ACPI failed (Status 0x%08lx)\n", Status);
        return Status;
    }
    /* Read DSDT table */
    AcpiStatus = AcpiGetTable(ACPI_SIG_DSDT, 0, &OutTable);
    if (ACPI_FAILURE(AcpiStatus))
    {
        DPRINT1("AcpiGetTable() for DSDT failed (Status 0x%08lx)\n", AcpiStatus);
        Status = STATUS_UNSUCCESSFUL;
        goto done;
    }
    /* Dump DSDT table */
    Status = acpi_create_registry_table(KeyHandle, OutTable, L"DSDT");
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("acpi_dump_table_to_registry() for DSDT failed (Status 0x%08lx)\n", Status);
        goto done;
    }
    /* Read FACS table */
    AcpiStatus = AcpiGetTable(ACPI_SIG_FACS, 0, &OutTable);
    if (ACPI_FAILURE(AcpiStatus))
    {
        DPRINT1("AcpiGetTable() for FACS failed (Status 0x%08lx)\n", AcpiStatus);
        Status = STATUS_UNSUCCESSFUL;
        goto done;
    }
    /* Dump FACS table */
    Status = acpi_create_registry_table(KeyHandle, OutTable, L"FACS");
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("acpi_dump_table_to_registry() for FACS failed (Status 0x%08lx)\n", Status);
        goto done;
    }
    /* Read FACS table */
    AcpiStatus = AcpiGetTable(ACPI_SIG_FADT, 0, &OutTable);
    if (ACPI_FAILURE(AcpiStatus))
    {
        DPRINT1("AcpiGetTable() for FADT failed (Status 0x%08lx)\n", AcpiStatus);
        Status = STATUS_UNSUCCESSFUL;
        goto done;
    }
    /* Dump FADT table */
    Status = acpi_create_registry_table(KeyHandle, OutTable, L"FADT");
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("acpi_dump_table_to_registry() for FADT failed (Status 0x%08lx)\n", Status);
        goto done;
    }
    /* This is a rough copy from ACPICA reading of RSDT/XSDT and added to avoid patching acpica */
    RsdpAddress = AcpiOsGetRootPointer();
    /* Map the entire RSDP and extract the address of the RSDT or XSDT */
    Rsdp = AcpiOsMapMemory(RsdpAddress, sizeof(ACPI_TABLE_RSDP));
    if (!Rsdp)
    {
        DPRINT1("AcpiOsMapMemory() failed\n");
        Status = STATUS_NO_MEMORY;
        goto done;
    }
    /* Use XSDT if present and not overridden. Otherwise, use RSDT */
    if ((Rsdp->Revision > 1) &&
        Rsdp->XsdtPhysicalAddress &&
        !AcpiGbl_DoNotUseXsdt)
    {
        /*
        * RSDP contains an XSDT (64-bit physical addresses). We must use
        * the XSDT if the revision is > 1 and the XSDT pointer is present,
        * as per the ACPI specification.
        */
        Address = (ACPI_PHYSICAL_ADDRESS)Rsdp->XsdtPhysicalAddress;
        TableEntrySize = ACPI_XSDT_ENTRY_SIZE;
    }
    else
    {
        /* Root table is an RSDT (32-bit physical addresses) */
        Address = (ACPI_PHYSICAL_ADDRESS)Rsdp->RsdtPhysicalAddress;
        TableEntrySize = ACPI_RSDT_ENTRY_SIZE;
    }
    /*
    * It is not possible to map more than one entry in some environments,
    * so unmap the RSDP here before mapping other tables
    */
    AcpiOsUnmapMemory(Rsdp, sizeof(ACPI_TABLE_RSDP));
    OutTable = AcpiOsMapMemory(Address, TableEntrySize);
    if (!OutTable)
    {
        DPRINT1("AcpiOsMapMemory() failed\n");
        Status = STATUS_NO_MEMORY;
        goto done;
    }
    /* Dump RSDT table */
    Status = acpi_create_registry_table(KeyHandle, OutTable, L"RSDT");
    AcpiOsUnmapMemory(OutTable, TableEntrySize);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("acpi_dump_table_to_registry() for RSDT failed (Status 0x%08lx)\n", Status);
    }
 
done:
    ZwClose(KeyHandle);
    return Status;
}

Referenced by Bus_StartFdo().

acpi_evaluate_integer()

ACPI_STATUS acpi_evaluate_integer	(	ACPI_HANDLE	handle,
		ACPI_STRING	pathname,
		struct acpi_object_list *	arguments,
		unsigned long long *	data
	)

Definition at line 242 of file utils.c.

{
    ACPI_STATUS             status = AE_OK;
    ACPI_OBJECT element;
    ACPI_BUFFER buffer = {sizeof(ACPI_OBJECT), &element};
 
    ACPI_FUNCTION_TRACE("acpi_evaluate_integer");
 
    if (!data)
        return_ACPI_STATUS(AE_BAD_PARAMETER);
 
    status = AcpiEvaluateObject(handle, pathname, arguments, &buffer);
    if (ACPI_FAILURE(status)) {
        acpi_util_eval_error(handle, pathname, status);
        return_ACPI_STATUS(status);
    }
 
    if (element.Type != ACPI_TYPE_INTEGER) {
        acpi_util_eval_error(handle, pathname, AE_BAD_DATA);
        return_ACPI_STATUS(AE_BAD_DATA);
    }
 
    *data = element.Integer.Value;
 
    ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%lu]\n", *data));
 
    return_ACPI_STATUS(AE_OK);
}

Referenced by acpi_bus_get_power(), acpi_bus_get_status_handle(), acpi_power_get_state(), and Bus_PDO_QueryResources().

acpi_evaluate_reference()

ACPI_STATUS acpi_evaluate_reference	(	ACPI_HANDLE	handle,
		ACPI_STRING	pathname,
		struct acpi_object_list *	arguments,
		struct acpi_handle_list *	list
	)

Definition at line 277 of file utils.c.

{
    ACPI_STATUS     status = AE_OK;
    ACPI_OBJECT *package = NULL;
    ACPI_OBJECT *element = NULL;
    ACPI_BUFFER buffer = {ACPI_ALLOCATE_BUFFER, NULL};
    UINT32          i = 0;
 
    ACPI_FUNCTION_TRACE("acpi_evaluate_reference");
 
    if (!list) {
        return_ACPI_STATUS(AE_BAD_PARAMETER);
    }
 
    /* Evaluate object. */
 
    status = AcpiEvaluateObject(handle, pathname, arguments, &buffer);
    if (ACPI_FAILURE(status))
        goto end;
 
    package = (ACPI_OBJECT *) buffer.Pointer;
 
    if ((buffer.Length == 0) || !package) {
        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
            "No return object (len %X ptr %p)\n",
            buffer.Length, package));
        status = AE_BAD_DATA;
        acpi_util_eval_error(handle, pathname, status);
        goto end;
    }
    if (package->Type != ACPI_TYPE_PACKAGE) {
        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
            "Expecting a [Package], found type %X\n",
            package->Type));
        status = AE_BAD_DATA;
        acpi_util_eval_error(handle, pathname, status);
        goto end;
    }
    if (!package->Package.Count) {
        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
            "[Package] has zero elements (%p)\n",
            package));
        status = AE_BAD_DATA;
        acpi_util_eval_error(handle, pathname, status);
        goto end;
    }
 
    if (package->Package.Count > ACPI_MAX_HANDLES) {
        return AE_NO_MEMORY;
    }
    list->count = package->Package.Count;
 
    /* Extract package data. */
 
    for (i = 0; i < list->count; i++) {
 
        element = &(package->Package.Elements[i]);
 
        if (element->Type != ACPI_TYPE_LOCAL_REFERENCE) {
            status = AE_BAD_DATA;
            ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
                "Expecting a [Reference] package element, found type %X\n",
                element->type));
            acpi_util_eval_error(handle, pathname, status);
            break;
        }
 
        if (!element->Reference.Handle) {
            ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid reference in"
                   " package %s\n", pathname));
            status = AE_NULL_ENTRY;
            break;
        }
        /* Get the  ACPI_HANDLE. */
 
        list->handles[i] = element->Reference.Handle;
        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found reference [%p]\n",
            list->handles[i]));
    }
 
end:
    if (ACPI_FAILURE(status)) {
        list->count = 0;
        //ExFreePool(list->handles);
    }
 
    if (buffer.Pointer)
        AcpiOsFree(buffer.Pointer);
 
    return_ACPI_STATUS(status);
}

Referenced by acpi_bus_get_power_flags().

acpi_extract_package()

ACPI_STATUS acpi_extract_package	(	ACPI_OBJECT *	package,
		ACPI_BUFFER *	format,
		ACPI_BUFFER *	buffer
	)

Definition at line 60 of file utils.c.

{
    UINT32          size_required = 0;
    UINT32          tail_offset = 0;
    char            *format_string = NULL;
    UINT32          format_count = 0;
    UINT32          i = 0;
    UINT8           *head = NULL;
    UINT8           *tail = NULL;
 
    if (!package || (package->Type != ACPI_TYPE_PACKAGE) || (package->Package.Count < 1)) {
        ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid 'package' argument\n"));
        return_ACPI_STATUS(AE_BAD_PARAMETER);
    }
 
    if (!format || !format->Pointer || (format->Length < 1)) {
        ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid 'format' argument\n"));
        return_ACPI_STATUS(AE_BAD_PARAMETER);
    }
 
    if (!buffer) {
        ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid 'buffer' argument\n"));
        return_ACPI_STATUS(AE_BAD_PARAMETER);
    }
 
    format_count = (format->Length/sizeof(char)) - 1;
    if (format_count > package->Package.Count) {
        ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Format specifies more objects [%d] than exist in package [%d].", format_count, package->package.count));
        return_ACPI_STATUS(AE_BAD_DATA);
    }
 
    format_string = format->Pointer;
 
    /*
     * Calculate size_required.
     */
    for (i=0; i<format_count; i++) {
 
        ACPI_OBJECT *element = &(package->Package.Elements[i]);
 
        if (!element) {
            return_ACPI_STATUS(AE_BAD_DATA);
        }
 
        switch (element->Type) {
 
        case ACPI_TYPE_INTEGER:
            switch (format_string[i]) {
            case 'N':
                size_required += sizeof(ACPI_INTEGER);
                tail_offset += sizeof(ACPI_INTEGER);
                break;
            case 'S':
                size_required += sizeof(char*) + sizeof(ACPI_INTEGER) + sizeof(char);
                tail_offset += sizeof(char*);
                break;
            default:
                ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid package element [%d]: got number, expecting [%c].\n", i, format_string[i]));
                return_ACPI_STATUS(AE_BAD_DATA);
                break;
            }
            break;
 
        case ACPI_TYPE_STRING:
        case ACPI_TYPE_BUFFER:
            switch (format_string[i]) {
            case 'S':
                size_required += sizeof(char*) + (element->String.Length * sizeof(char)) + sizeof(char);
                tail_offset += sizeof(char*);
                break;
            case 'B':
                size_required += sizeof(UINT8*) + (element->Buffer.Length * sizeof(UINT8));
                tail_offset += sizeof(UINT8*);
                break;
            default:
                ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid package element [%d] got string/buffer, expecting [%c].\n", i, format_string[i]));
                return_ACPI_STATUS(AE_BAD_DATA);
                break;
            }
            break;
 
        case ACPI_TYPE_PACKAGE:
        default:
            ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found unsupported element at index=%d\n", i));
            /* TBD: handle nested packages... */
            return_ACPI_STATUS(AE_SUPPORT);
            break;
        }
    }
 
    /*
     * Validate output buffer.
     */
    if (buffer->Length < size_required) {
        buffer->Length = size_required;
        return_ACPI_STATUS(AE_BUFFER_OVERFLOW);
    }
    else if (buffer->Length != size_required || !buffer->Pointer) {
        return_ACPI_STATUS(AE_BAD_PARAMETER);
    }
 
    head = buffer->Pointer;
    tail = ((PUCHAR)buffer->Pointer) + tail_offset;
 
    /*
     * Extract package data.
     */
    for (i=0; i<format_count; i++) {
 
        UINT8 **pointer = NULL;
        ACPI_OBJECT *element = &(package->Package.Elements[i]);
 
        if (!element) {
            return_ACPI_STATUS(AE_BAD_DATA);
        }
 
        switch (element->Type) {
 
        case ACPI_TYPE_INTEGER:
            switch (format_string[i]) {
            case 'N':
                *((ACPI_INTEGER*)head) = element->Integer.Value;
                head += sizeof(ACPI_INTEGER);
                break;
            case 'S':
                pointer = (UINT8**)head;
                *pointer = tail;
                *((ACPI_INTEGER*)tail) = element->Integer.Value;
                head += sizeof(ACPI_INTEGER*);
                tail += sizeof(ACPI_INTEGER);
                /* NULL terminate string */
                *tail = (char)0;
                tail += sizeof(char);
                break;
            default:
                /* Should never get here */
                break;
            }
            break;
 
        case ACPI_TYPE_STRING:
        case ACPI_TYPE_BUFFER:
            switch (format_string[i]) {
            case 'S':
                pointer = (UINT8**)head;
                *pointer = tail;
                memcpy(tail, element->String.Pointer, element->String.Length);
                head += sizeof(char*);
                tail += element->String.Length * sizeof(char);
                /* NULL terminate string */
                *tail = (char)0;
                tail += sizeof(char);
                break;
            case 'B':
                pointer = (UINT8**)head;
                *pointer = tail;
                memcpy(tail, element->Buffer.Pointer, element->Buffer.Length);
                head += sizeof(UINT8*);
                tail += element->Buffer.Length * sizeof(UINT8);
                break;
            default:
                /* Should never get here */
                break;
            }
            break;
 
        case ACPI_TYPE_PACKAGE:
            /* TBD: handle nested packages... */
        default:
            /* Should never get here */
            break;
        }
    }
 
    return_ACPI_STATUS(AE_OK);
}

acpi_init()

int acpi_init

(

void

)

Definition at line 1754 of file bus.c.

{
    int         result = 0;
 
    DPRINT("acpi_init\n");
 
    DPRINT("Subsystem revision %08x\n",ACPI_CA_VERSION);
 
    KeInitializeSpinLock(&acpi_bus_event_lock);
    KeInitializeEvent(&AcpiEventQueue, NotificationEvent, FALSE);
    ExInitializeFastMutex(&acpi_bus_drivers_lock);
 
    result = acpi_bus_init();
 
    //if (!result) {
        //pci_mmcfg_late_init();
        //if (!(pm_flags & PM_APM))
        //  pm_flags |= PM_ACPI;
        //else {
            //DPRINT1("APM is already active, exiting\n");
            //disable_acpi();
            //result = -ENODEV;
        //}
    //} else
    //  disable_acpi();
 
    /*
     * If the laptop falls into the DMI check table, the power state check
     * will be disabled in the course of device power transistion.
     */
    //dmi_check_system(power_nocheck_dmi_table);
 
    /*
     * Install drivers required for proper enumeration of the
     * ACPI namespace.
     */
    acpi_system_init(); /* ACPI System */
    acpi_power_init();  /* ACPI Bus Power Management */
    acpi_button_init();
    //acpi_ec_init();       /* ACPI Embedded Controller */
#ifdef CONFIG_ACPI_PCI
    if (!acpi_pci_disabled) {
        acpi_pci_link_init();   /* ACPI PCI Interrupt Link */
        acpi_pci_root_init();   /* ACPI PCI Root Bridge */
    }
#endif
 
    //acpi_scan_init();
    //acpi_ec_init();
    //acpi_power_init();
    //acpi_system_init();
    //acpi_debug_init();
    //acpi_sleep_proc_init();
    //acpi_wakeup_device_init();
 
    return result;
}

Referenced by Bus_StartFdo().

acpi_match_device_ids()

int acpi_match_device_ids	(	struct acpi_device *	device,
		const struct acpi_pnp_device_id *	ids
	)

acpi_suspend()

ACPI_STATUS acpi_suspend

(

UINT32

state

)

acpi_suspend - OS-agnostic system suspend/resume support (S? states) @state: state we're entering

Definition at line 347 of file system.c.

{
    ACPI_STATUS status;
 
    /* only support S1 and S5 on kernel 2.4 */
    //if (state != ACPI_STATE_S1 && state != ACPI_STATE_S4
    //    && state != ACPI_STATE_S5)
    //  return AE_ERROR;
 
 
    //if (ACPI_STATE_S4 == state) {
    //  /* For s4bios, we need a wakeup address. */
    //  if (1 == AcpiGbl_FACS->S4bios_f &&
    //      0 != AcpiGbl_FADT->smi_cmd) {
    //      if (!acpi_wakeup_address)
    //          return AE_ERROR;
    //      AcpiSetFirmwareWakingVector((acpi_physical_address) acpi_wakeup_address);
    //  } else
    //      /* We don't support S4 under 2.4.  Give up */
    //      return AE_ERROR;
    //}
    AcpiEnterSleepStatePrep(state);
 
    status = AcpiEnterSleepState(state);
    if (!ACPI_SUCCESS(status) && state != ACPI_STATE_S5)
        return status;
 
    /* disable interrupts and flush caches */
    _disable();
    ACPI_FLUSH_CPU_CACHE();
 
    /* perform OS-specific sleep actions */
    status = acpi_system_suspend(state);
 
    /* Even if we failed to go to sleep, all of the devices are in an suspended
     * mode. So, we run these unconditionally to make sure we have a usable system
     * no matter what.
     */
    AcpiLeaveSleepState(state);
    acpi_system_restore_state(state);
 
    /* make sure interrupts are enabled */
    _enable();
 
    /* reset firmware waking vector */
    AcpiSetFirmwareWakingVector(0, 0);
 
    return status;
}

Referenced by Bus_FDO_Power().

Variable Documentation

acpi_bus_type

struct bus_type acpi_bus_type

extern

acpi_irq_model

enum acpi_irq_model_id acpi_irq_model

extern