WebSVN – Kolibri OS – Diff – /drivers/devman/scan.c


#include 
#include 
#include 
#include 
#include 
 
#include "acpi.h"
#include "acpi_bus.h"
 
 
#define PREFIX "ACPI: "
 
#define ACPI_BUS_CLASS          "system_bus"
#define ACPI_BUS_HID            "KLBSYBUS"
#define ACPI_BUS_DEVICE_NAME    "System Bus"
 
 
#define ACPI_IS_ROOT_DEVICE(device)    (!(device)->parent)
 
#define STRUCT_TO_INT(s)        (*((int*)&s))
 
 
extern struct acpi_device *acpi_root;
 
extern struct list_head acpi_device_list;
extern struct list_head acpi_bus_id_list;
 
DEFINE_MUTEX(acpi_device_lock);
 
 
struct acpi_device_bus_id{
	char bus_id[15];
	unsigned int instance_no;
	struct list_head node;
};
 
 
struct acpi_hardware_id {
    struct list_head list;
    char *id;
};
 
#define acpi_device_name(d) ((d)->pnp.device_name)
#define acpi_device_class(d)    ((d)->pnp.device_class)
 
 
static void
acpi_util_eval_error(ACPI_HANDLE h, ACPI_STRING p, ACPI_STATUS s)
{
#ifdef ACPI_DEBUG_OUTPUT
    char prefix[80] = {'\0'};
    ACPI_BUFFER buffer = {sizeof(prefix), prefix};
    AcpiGetName(h, ACPI_FULL_PATHNAME, &buffer);
    ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluate [%s.%s]: %s\n",
        (char *) prefix, p, AcpiFormatException(s)));
#else
    return;
#endif
}
 
ACPI_STATUS
acpi_evaluate_integer(ACPI_HANDLE handle, ACPI_STRING pathname,
              ACPI_OBJECT_LIST *arguments, unsigned long long *data)
{
    ACPI_STATUS status = AE_OK;
    ACPI_OBJECT element;
    ACPI_BUFFER buffer = { 0, NULL };
 
    if (!data)
        return AE_BAD_PARAMETER;
 
    buffer.Length = sizeof(ACPI_OBJECT);
    buffer.Pointer = &element;
    status = AcpiEvaluateObject(handle, pathname, arguments, &buffer);
    if (ACPI_FAILURE(status)) {
        acpi_util_eval_error(handle, pathname, status);
        return status;
    }
 
    if (element.Type != ACPI_TYPE_INTEGER) {
        acpi_util_eval_error(handle, pathname, AE_BAD_DATA);
        return AE_BAD_DATA;
    }
 
    *data = element.Integer.Value;
 
    ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%llu]\n", *data));
 
    return AE_OK;
}
 
 
void acpi_bus_data_handler(ACPI_HANDLE handle, void *context)
{
 
    /* TBD */
 
    return;
}
 
int acpi_bus_get_device(ACPI_HANDLE handle, struct acpi_device **device)
{
    ACPI_STATUS status = AE_OK;
 
    if (!device)
    {
        return -EINVAL;
    };
 
    /* TBD: Support fixed-feature devices */
 
    status = AcpiGetData(handle, acpi_bus_data_handler, (void **)device);
    if (ACPI_FAILURE(status) || !*device) {
        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
                  handle));
        return -ENODEV;
    }
    return 0;
}
 
 
ACPI_STATUS acpi_bus_get_status_handle(ACPI_HANDLE handle,
                       unsigned long long *sta)
{
    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;
}
 
 
 
/* --------------------------------------------------------------------------
			ACPI Bus operations
   -------------------------------------------------------------------------- */
 
int acpi_match_device_ids(struct acpi_device *device,
              const struct acpi_device_ids *ids)
{
    const struct acpi_device_ids *id;
    struct acpi_hardware_id *hwid;
 
    /*
     * If the device is not present, it is unnecessary to load device
     * driver for it.
     */
//    if (!device->status.present)
//        return -ENODEV;
 
    for (id = ids; id->id[0]; id++)
        list_for_each_entry(hwid, &device->pnp.ids, list)
            if (!strcmp((char *) id->id, hwid->id))
                return 0;
 
    return -ENOENT;
}
 
 
static int acpi_device_register(struct acpi_device *device)
{
    int result;
    struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
    int found = 0;
 
    /*
     * Linkage
     * -------
     * Link this device to its parent and siblings.
     */
    INIT_LIST_HEAD(&device->children);
    INIT_LIST_HEAD(&device->node);
 
    new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
    if (!new_bus_id) {
		printk(KERN_ERR PREFIX "Memory allocation error\n");
        return -ENOMEM;
    }
 
    mutex_lock(&acpi_device_lock);
    /*
     * Find suitable bus_id and instance number in acpi_bus_id_list
     * If failed, create one and link it into acpi_bus_id_list
     */
    list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node)
    {
		if (!strcmp(acpi_device_bus_id->bus_id,
                acpi_device_hid(device)))
        {
            acpi_device_bus_id->instance_no++;
            found = 1;
            kfree(new_bus_id);
            break;
        }
    };
 
    if (!found)
    {
        acpi_device_bus_id = new_bus_id;
        strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device));
        acpi_device_bus_id->instance_no = 0;
        list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
    }
 
//    dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
 
    if (device->parent)
        list_add_tail(&device->node, &device->parent->children);
 
    mutex_unlock(&acpi_device_lock);
 
//    device->dev.bus = &acpi_bus_type;
//    device->dev.release = &acpi_device_release;
//    result = device_register(&device->dev);
//    if (result) {
//        dev_err(&device->dev, "Error registering device\n");
//        goto end;
//    }
 
 
//    device->removal_type = ACPI_BUS_REMOVAL_NORMAL;
    return 0;
end:
    mutex_lock(&acpi_device_lock);
    if (device->parent)
        list_del(&device->node);
    mutex_unlock(&acpi_device_lock);
    return result;
}
 
 
static struct acpi_device *acpi_bus_get_parent(ACPI_HANDLE handle)
{
    ACPI_STATUS status;
    struct      acpi_device *device;
    int         ret;
 
    /*
     * Fixed hardware devices do not appear in the namespace and do not
     * have handles, but we fabricate acpi_devices for them, so we have
     * to deal with them specially.
     */
    if (handle == NULL)
        return acpi_root;
 
	do {
        status = AcpiGetParent(handle, &handle);
        if (status == AE_NULL_ENTRY)
            return NULL;
        if (ACPI_FAILURE(status))
            return acpi_root;
 
        ret = acpi_bus_get_device(handle, &device);
        if (ret == 0)
            return device;
    } while (1);
}
 
 
static int acpi_bus_get_flags(struct acpi_device *device)
{
    ACPI_STATUS status = AE_OK;
    ACPI_HANDLE temp   = NULL;
 
    /* Presence of _STA indicates 'dynamic_status' */
    status = AcpiGetHandle(device->handle, "_STA", &temp);
    if (ACPI_SUCCESS(status))
        device->flags.dynamic_status = 1;
 
    /* Presence of _RMV indicates 'removable' */
    status = AcpiGetHandle(device->handle, "_RMV", &temp);
    if (ACPI_SUCCESS(status))
        device->flags.removable = 1;
 
    /* Presence of _EJD|_EJ0 indicates 'ejectable' */
    status = AcpiGetHandle(device->handle, "_EJD", &temp);
    if (ACPI_SUCCESS(status))
        device->flags.ejectable = 1;
    else {
        status = AcpiGetHandle(device->handle, "_EJ0", &temp);
        if (ACPI_SUCCESS(status))
            device->flags.ejectable = 1;
    }
 
    /* Presence of _LCK indicates 'lockable' */
    status = AcpiGetHandle(device->handle, "_LCK", &temp);
    if (ACPI_SUCCESS(status))
        device->flags.lockable = 1;
 
    /* Presence of _PS0|_PR0 indicates 'power manageable' */
    status = AcpiGetHandle(device->handle, "_PS0", &temp);
    if (ACPI_FAILURE(status))
        status = AcpiGetHandle(device->handle, "_PR0", &temp);
    if (ACPI_SUCCESS(status))
        device->flags.power_manageable = 1;
 
    /* Presence of _PRW indicates wake capable */
    status = AcpiGetHandle(device->handle, "_PRW", &temp);
    if (ACPI_SUCCESS(status))
        device->flags.wake_capable = 1;
 
    /* TBD: Performance management */
 
    return 0;
}
 
static void acpi_device_get_busid(struct acpi_device *device)
{
    char bus_id[5] = { '?', 0 };
    struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
    int i = 0;
 
    /*
     * Bus ID
     * ------
     * The device's Bus ID is simply the object name.
     * TBD: Shouldn't this value be unique (within the ACPI namespace)?
     */
    if (ACPI_IS_ROOT_DEVICE(device)) {
        strcpy(device->pnp.bus_id, "ACPI");
        return;
    }
 
    switch (device->device_type)
    {
        case ACPI_BUS_TYPE_POWER_BUTTON:
            strcpy(device->pnp.bus_id, "PWRF");
            break;
        case ACPI_BUS_TYPE_SLEEP_BUTTON:
            strcpy(device->pnp.bus_id, "SLPF");
            break;
        default:
            AcpiGetName(device->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;
            }
            strcpy(device->pnp.bus_id, bus_id);
            break;
    }
}
 
 
#define ACPI_VIDEO_OUTPUT_SWITCHING         0x0001
#define ACPI_VIDEO_DEVICE_POSTING           0x0002
#define ACPI_VIDEO_ROM_AVAILABLE            0x0004
#define ACPI_VIDEO_BACKLIGHT                0x0008
#define ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR       0x0010
#define ACPI_VIDEO_BACKLIGHT_FORCE_VIDEO        0x0020
#define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VENDOR    0x0040
#define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VIDEO     0x0080
#define ACPI_VIDEO_BACKLIGHT_DMI_VENDOR         0x0100
#define ACPI_VIDEO_BACKLIGHT_DMI_VIDEO          0x0200
#define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VENDOR      0x0400
#define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VIDEO       0x0800
 
 
long acpi_is_video_device(struct acpi_device *device)
{
    ACPI_HANDLE h_dummy;
    long video_caps = 0;
 
    if (!device)
        return 0;
 
    /* Is this device able to support video switching ? */
    if (ACPI_SUCCESS(AcpiGetHandle(device->handle, "_DOD", &h_dummy)) ||
        ACPI_SUCCESS(AcpiGetHandle(device->handle, "_DOS", &h_dummy)))
        video_caps |= ACPI_VIDEO_OUTPUT_SWITCHING;
 
    /* Is this device able to retrieve a video ROM ? */
    if (ACPI_SUCCESS(AcpiGetHandle(device->handle, "_ROM", &h_dummy)))
        video_caps |= ACPI_VIDEO_ROM_AVAILABLE;
 
    /* Is this device able to configure which video head to be POSTed ? */
    if (ACPI_SUCCESS(AcpiGetHandle(device->handle, "_VPO", &h_dummy)) &&
        ACPI_SUCCESS(AcpiGetHandle(device->handle, "_GPD", &h_dummy)) &&
        ACPI_SUCCESS(AcpiGetHandle(device->handle, "_SPD", &h_dummy)))
        video_caps |= ACPI_VIDEO_DEVICE_POSTING;
 
     return video_caps;
}
 
/*
 * acpi_bay_match - see if a device is an ejectable driver bay
 *
 * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
 * then we can safely call it an ejectable drive bay
 */
static int acpi_bay_match(struct acpi_device *device){
    ACPI_STATUS status;
    ACPI_HANDLE handle;
    ACPI_HANDLE tmp;
    ACPI_HANDLE phandle;
 
    handle = device->handle;
 
    status = AcpiGetHandle(handle, "_EJ0", &tmp);
    if (ACPI_FAILURE(status))
        return -ENODEV;
 
    if ((ACPI_SUCCESS(AcpiGetHandle(handle, "_GTF", &tmp))) ||
        (ACPI_SUCCESS(AcpiGetHandle(handle, "_GTM", &tmp))) ||
        (ACPI_SUCCESS(AcpiGetHandle(handle, "_STM", &tmp))) ||
        (ACPI_SUCCESS(AcpiGetHandle(handle, "_SDD", &tmp))))
        return 0;
 
    if (AcpiGetParent(handle, &phandle))
        return -ENODEV;
 
    if ((ACPI_SUCCESS(AcpiGetHandle(phandle, "_GTF", &tmp))) ||
        (ACPI_SUCCESS(AcpiGetHandle(phandle, "_GTM", &tmp))) ||
        (ACPI_SUCCESS(AcpiGetHandle(phandle, "_STM", &tmp))) ||
        (ACPI_SUCCESS(AcpiGetHandle(phandle, "_SDD", &tmp))))
        return 0;
 
    return -ENODEV;
}
 
/*
 * acpi_dock_match - see if a device has a _DCK method
 */
static int acpi_dock_match(struct acpi_device *device)
{
    ACPI_HANDLE tmp;
    return AcpiGetHandle(device->handle, "_DCK", &tmp);
}
 
char *acpi_device_hid(struct acpi_device *device)
{
    struct acpi_hardware_id *hid;
 
    hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
    return hid->id;
}
 
static void acpi_add_id(struct acpi_device *device, const char *dev_id)
{
    struct acpi_hardware_id *id;
 
    id = kmalloc(sizeof(*id), GFP_KERNEL);
    if (!id)
        return;
 
    INIT_LIST_HEAD(&id->list);
 
    id->id = kmalloc(strlen(dev_id) + 1, GFP_KERNEL);
    if (!id->id) {
        kfree(id);
        return;
    }
 
    strcpy(id->id, dev_id);
    list_add_tail(&id->list, &device->pnp.ids);
}
 
 
 
static void acpi_device_set_id(struct acpi_device *device)
{
    ACPI_STATUS status;
    ACPI_DEVICE_INFO *info;
    ACPI_DEVICE_ID_LIST *cid_list;
    int i;
 
    switch (device->device_type)
    {
        case ACPI_BUS_TYPE_DEVICE:
		if (ACPI_IS_ROOT_DEVICE(device)) {
                acpi_add_id(device, ACPI_SYSTEM_HID);
                break;
            }
 
            status = AcpiGetObjectInfo(device->handle, &info);
            if (ACPI_FAILURE(status)) {
                printk(KERN_ERR PREFIX "%s: Error reading device info\n", __func__);
                return;
            }
 
            if (info->Valid & ACPI_VALID_HID)
                acpi_add_id(device, info->HardwareId.String);
            if (info->Valid & ACPI_VALID_CID)
            {
                cid_list = &info->CompatibleIdList;
                for (i = 0; i < cid_list->Count; i++)
                    acpi_add_id(device, cid_list->Ids[i].String);
            }
            if (info->Valid & ACPI_VALID_ADR) {
                device->pnp.bus_address = info->Address;
                device->flags.bus_address = 1;
            }
 
            kfree(info);
 
        /*
         * Some devices don't reliably have _HIDs & _CIDs, so add
         * synthetic HIDs to make sure drivers can find them.
         */
        if (acpi_is_video_device(device))
            acpi_add_id(device, ACPI_VIDEO_HID);
        else if (ACPI_SUCCESS(acpi_bay_match(device)))
            acpi_add_id(device, ACPI_BAY_HID);
        else if (ACPI_SUCCESS(acpi_dock_match(device)))
            acpi_add_id(device, ACPI_DOCK_HID);
        else if (!acpi_device_hid(device) &&
             ACPI_IS_ROOT_DEVICE(device->parent)) {
            acpi_add_id(device, ACPI_BUS_HID); /* \_SB, LNXSYBUS */
            strcpy(device->pnp.device_name, ACPI_BUS_DEVICE_NAME);
            strcpy(device->pnp.device_class, ACPI_BUS_CLASS);
        }
 
        break;
    case ACPI_BUS_TYPE_POWER:
        acpi_add_id(device, ACPI_POWER_HID);
        break;
    case ACPI_BUS_TYPE_PROCESSOR:
        acpi_add_id(device, ACPI_PROCESSOR_OBJECT_HID);
        break;
    case ACPI_BUS_TYPE_THERMAL:
        acpi_add_id(device, ACPI_THERMAL_HID);
        break;
    case ACPI_BUS_TYPE_POWER_BUTTON:
        acpi_add_id(device, ACPI_BUTTON_HID_POWERF);
        break;
    case ACPI_BUS_TYPE_SLEEP_BUTTON:
        acpi_add_id(device, ACPI_BUTTON_HID_SLEEPF);
        break;
    }
 
    /*
     * We build acpi_devices for some objects that don't have _HID or _CID,
     * e.g., PCI bridges and slots.  Drivers can't bind to these objects,
     * but we do use them indirectly by traversing the acpi_device tree.
     * This generic ID isn't useful for driver binding, but it provides
     * the useful property that "every acpi_device has an ID."
     */
    if (list_empty(&device->pnp.ids))
        acpi_add_id(device, "device");
}
 
static int acpi_device_set_context(struct acpi_device *device)
{
    ACPI_STATUS status;
 
    /*
     * Context
     * -------
     * Attach this 'struct acpi_device' to the ACPI object.  This makes
     * resolutions from handle->device very efficient.  Fixed hardware
     * devices have no handles, so we skip them.
     */
    if (!device->handle)
        return 0;
 
    status = AcpiAttachData(device->handle,
                  acpi_bus_data_handler, device);
    if (ACPI_SUCCESS(status))
        return 0;
 
	printk(KERN_ERR PREFIX "Error attaching device data\n");
    return -ENODEV;
}
 
 
static int acpi_add_single_object(struct acpi_device **child,
                  ACPI_HANDLE handle, int type,
                  unsigned long long sta,
                  struct acpi_bus_ops *ops)
{
    int result;
    struct acpi_device *device;
    ACPI_BUFFER buffer = { ACPI_ALLOCATE_BUFFER, NULL };
    ACPI_DEVICE_INFO *info = NULL;
    ACPI_DEVICE_ID_LIST *cid_list;
    int i;
 
 
    device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
    if (!device) {
		printk(KERN_ERR PREFIX "Memory allocation error\n");
        return -ENOMEM;
    }
 
    INIT_LIST_HEAD(&device->pnp.ids);
    device->device_type = type;
    device->handle = handle;
    device->parent = acpi_bus_get_parent(handle);
    device->bus_ops = *ops; /* workround for not call .start */
    STRUCT_TO_INT(device->status) = sta;
 
    acpi_device_get_busid(device);
 
    /*
     * Flags
     * -----
     * 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;
 
    /*
     * Initialize Device
     * -----------------
     * TBD: Synch with Core's enumeration/initialization process.
     */
    acpi_device_set_id(device);
 
 
    if ((result = acpi_device_set_context(device)))
        goto end;
 
    result = acpi_device_register(device);
 
    /*
     * Bind _ADR-Based Devices when hot add
     */
    if (device->flags.bus_address) {
        if (device->parent && device->parent->ops.bind)
            device->parent->ops.bind(device);
    }
 
end:
 
    AcpiGetName(handle, ACPI_FULL_PATHNAME, &buffer);
    dbgprintf(PREFIX "Adding [%s]", (char *)buffer.Pointer);
    kfree(buffer.Pointer);
 
    AcpiGetObjectInfo(handle, &info);
    if (info->Valid & ACPI_VALID_HID)
      dbgprintf (" HID: %s", info->HardwareId.String);
 
    if (info->Valid & ACPI_VALID_CID)
    {
        cid_list = &info->CompatibleIdList;
        for (i = 0; i < cid_list->Count; i++)
            dbgprintf("  CID: %s\n", cid_list->Ids[i].String);
    }
    dbgprintf("\n");
 
    kfree(info);
 
    if (!result) {
        *child = device;
    };
    return result;
}
 
#define ACPI_STA_DEFAULT (ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED | \
			  ACPI_STA_DEVICE_UI      | ACPI_STA_DEVICE_FUNCTIONING)
 
static int acpi_bus_type_and_status(ACPI_HANDLE handle, int *type,
                    unsigned long long *sta)
{
    ACPI_STATUS status;
    ACPI_OBJECT_TYPE acpi_type;
 
    status = AcpiGetType(handle, &acpi_type);
    if (ACPI_FAILURE(status))
        return -ENODEV;
 
    switch (acpi_type)
    {
        case ACPI_TYPE_ANY:     /* for ACPI_ROOT_OBJECT */
        case ACPI_TYPE_DEVICE:
            *type = ACPI_BUS_TYPE_DEVICE;
            status = acpi_bus_get_status_handle(handle, sta);
            if (ACPI_FAILURE(status))
                return -ENODEV;
            break;
        case ACPI_TYPE_PROCESSOR:
            *type = ACPI_BUS_TYPE_PROCESSOR;
            status = acpi_bus_get_status_handle(handle, sta);
            if (ACPI_FAILURE(status))
                return -ENODEV;
            break;
        case ACPI_TYPE_THERMAL:
            *type = ACPI_BUS_TYPE_THERMAL;
            *sta = ACPI_STA_DEFAULT;
            break;
        case ACPI_TYPE_POWER:
            *type = ACPI_BUS_TYPE_POWER;
            *sta = ACPI_STA_DEFAULT;
            break;
        default:
            return -ENODEV;
    }
 
    return 0;
}
 
 
static ACPI_STATUS acpi_bus_check_add(ACPI_HANDLE handle, u32 lvl,
                      void *context, void **return_value)
{
    struct acpi_bus_ops *ops = context;
    int type;
    unsigned long long sta;
    struct acpi_device *device;
    ACPI_STATUS status;
    int result;
 
    result = acpi_bus_type_and_status(handle, &type, &sta);
    if (result)
        return AE_OK;
 
    if (!(sta & ACPI_STA_DEVICE_PRESENT) &&
        !(sta & ACPI_STA_DEVICE_FUNCTIONING))
        return AE_CTRL_DEPTH;
 
    /*
     * We may already have an acpi_device from a previous enumeration.  If
     * so, we needn't add it again, but we may still have to start it.
     */
    device = NULL;
    acpi_bus_get_device(handle, &device);
    if (ops->acpi_op_add && !device)
        acpi_add_single_object(&device, handle, type, sta, ops);
 
    if (!device)
        return AE_CTRL_DEPTH;
 
/*
    if (ops->acpi_op_start && !(ops->acpi_op_add)) {
        status = acpi_start_single_object(device);
        if (ACPI_FAILURE(status))
            return AE_CTRL_DEPTH;
    }
*/
 
    if (!*return_value)
        *return_value = device;
    return AE_OK;
}
 
 
static int acpi_bus_scan(ACPI_HANDLE handle, struct acpi_bus_ops *ops,
             struct acpi_device **child)
{
    ACPI_STATUS status;
    void *device = NULL;
 
    status = acpi_bus_check_add(handle, 0, ops, &device);
    if (ACPI_SUCCESS(status))
        AcpiWalkNamespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
                    acpi_bus_check_add, NULL, ops, &device);
 
    if (child)
        *child = device;
 
    if (device)
        return 0;
    else
        return -ENODEV;
}
 
 
int acpi_scan()
{
    int err;
    struct acpi_bus_ops ops;
 
    memset(&ops, 0, sizeof(ops));
    ops.acpi_op_add = 1;
    ops.acpi_op_start = 1;
 
    err = acpi_bus_scan(ACPI_ROOT_OBJECT, &ops, &acpi_root);
 
    return err;
};


 

Rev 1867	Rev 9499
1	#include	1	#include
2	#include	2	#include
3	#include	3	#include
4	#include	4	#include
5	#include	5	#include
6		6
7	#include "acpi.h"	7	#include "acpi.h"
8	#include "acpi_bus.h"	8	#include "acpi_bus.h"
9		9
10		10
11	#define PREFIX "ACPI: "	11	#define PREFIX "ACPI: "
12		12
13	#define ACPI_BUS_CLASS "system_bus"	13	#define ACPI_BUS_CLASS "system_bus"
14	#define ACPI_BUS_HID "KLBSYBUS"	14	#define ACPI_BUS_HID "KLBSYBUS"
15	#define ACPI_BUS_DEVICE_NAME "System Bus"	15	#define ACPI_BUS_DEVICE_NAME "System Bus"
16		16
17		17
18	#define ACPI_IS_ROOT_DEVICE(device) (!(device)->parent)	18	#define ACPI_IS_ROOT_DEVICE(device) (!(device)->parent)
19		19
20	#define STRUCT_TO_INT(s) (((int)&s))	20	#define STRUCT_TO_INT(s) (((int)&s))
21		21
22		22
23	extern struct acpi_device *acpi_root;	23	extern struct acpi_device *acpi_root;
24		24
25	extern struct list_head acpi_device_list;	25	extern struct list_head acpi_device_list;
26	extern struct list_head acpi_bus_id_list;	26	extern struct list_head acpi_bus_id_list;
27		27
28	DEFINE_MUTEX(acpi_device_lock);	28	DEFINE_MUTEX(acpi_device_lock);
29		29
30		30
31	struct acpi_device_bus_id{	31	struct acpi_device_bus_id{
32	char bus_id[15];	32	char bus_id[15];
33	unsigned int instance_no;	33	unsigned int instance_no;
34	struct list_head node;	34	struct list_head node;
35	};	35	};
36		36
37		37
38	struct acpi_hardware_id {	38	struct acpi_hardware_id {
39	struct list_head list;	39	struct list_head list;
40	char *id;	40	char *id;
41	};	41	};
42		42
43	#define acpi_device_name(d) ((d)->pnp.device_name)	43	#define acpi_device_name(d) ((d)->pnp.device_name)
44	#define acpi_device_class(d) ((d)->pnp.device_class)	44	#define acpi_device_class(d) ((d)->pnp.device_class)
45		45
46		46
47	static void	47	static void
48	acpi_util_eval_error(ACPI_HANDLE h, ACPI_STRING p, ACPI_STATUS s)	48	acpi_util_eval_error(ACPI_HANDLE h, ACPI_STRING p, ACPI_STATUS s)
49	{	49	{
50	#ifdef ACPI_DEBUG_OUTPUT	50	#ifdef ACPI_DEBUG_OUTPUT
51	char prefix[80] = {'\0'};	51	char prefix[80] = {'\0'};
52	ACPI_BUFFER buffer = {sizeof(prefix), prefix};	52	ACPI_BUFFER buffer = {sizeof(prefix), prefix};
53	AcpiGetName(h, ACPI_FULL_PATHNAME, &buffer);	53	AcpiGetName(h, ACPI_FULL_PATHNAME, &buffer);
54	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluate [%s.%s]: %s\n",	54	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluate [%s.%s]: %s\n",
55	(char *) prefix, p, AcpiFormatException(s)));	55	(char *) prefix, p, AcpiFormatException(s)));
56	#else	56	#else
57	return;	57	return;
58	#endif	58	#endif
59	}	59	}
60		60
61	ACPI_STATUS	61	ACPI_STATUS
62	acpi_evaluate_integer(ACPI_HANDLE handle, ACPI_STRING pathname,	62	acpi_evaluate_integer(ACPI_HANDLE handle, ACPI_STRING pathname,
63	ACPI_OBJECT_LIST arguments, unsigned long long data)	63	ACPI_OBJECT_LIST arguments, unsigned long long data)
64	{	64	{
65	ACPI_STATUS status = AE_OK;	65	ACPI_STATUS status = AE_OK;
66	ACPI_OBJECT element;	66	ACPI_OBJECT element;
67	ACPI_BUFFER buffer = { 0, NULL };	67	ACPI_BUFFER buffer = { 0, NULL };
68		68
69	if (!data)	69	if (!data)
70	return AE_BAD_PARAMETER;	70	return AE_BAD_PARAMETER;
71		71
72	buffer.Length = sizeof(ACPI_OBJECT);	72	buffer.Length = sizeof(ACPI_OBJECT);
73	buffer.Pointer = &element;	73	buffer.Pointer = &element;
74	status = AcpiEvaluateObject(handle, pathname, arguments, &buffer);	74	status = AcpiEvaluateObject(handle, pathname, arguments, &buffer);
75	if (ACPI_FAILURE(status)) {	75	if (ACPI_FAILURE(status)) {
76	acpi_util_eval_error(handle, pathname, status);	76	acpi_util_eval_error(handle, pathname, status);
77	return status;	77	return status;
78	}	78	}
79		79
80	if (element.Type != ACPI_TYPE_INTEGER) {	80	if (element.Type != ACPI_TYPE_INTEGER) {
81	acpi_util_eval_error(handle, pathname, AE_BAD_DATA);	81	acpi_util_eval_error(handle, pathname, AE_BAD_DATA);
82	return AE_BAD_DATA;	82	return AE_BAD_DATA;
83	}	83	}
84		84
85	*data = element.Integer.Value;	85	*data = element.Integer.Value;
86		86
87	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%llu]\n", *data));	87	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%llu]\n", *data));
88		88
89	return AE_OK;	89	return AE_OK;
90	}	90	}
91		91
92		92
93	void acpi_bus_data_handler(ACPI_HANDLE handle, void *context)	93	void acpi_bus_data_handler(ACPI_HANDLE handle, void *context)
94	{	94	{
95		95
96	/* TBD */	96	/* TBD */
97		97
98	return;	98	return;
99	}	99	}
100		100
101	int acpi_bus_get_device(ACPI_HANDLE handle, struct acpi_device **device)	101	int acpi_bus_get_device(ACPI_HANDLE handle, struct acpi_device **device)
102	{	102	{
103	ACPI_STATUS status = AE_OK;	103	ACPI_STATUS status = AE_OK;
104		104
105	if (!device)	105	if (!device)
106	{	106	{
107	return -EINVAL;	107	return -EINVAL;
108	};	108	};
109		109
110	/* TBD: Support fixed-feature devices */	110	/* TBD: Support fixed-feature devices */
111		111
112	status = AcpiGetData(handle, acpi_bus_data_handler, (void **)device);	112	status = AcpiGetData(handle, acpi_bus_data_handler, (void **)device);
113	if (ACPI_FAILURE(status) \|\| !*device) {	113	if (ACPI_FAILURE(status) \|\| !*device) {
114	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",	114	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
115	handle));	115	handle));
116	return -ENODEV;	116	return -ENODEV;
117	}	117	}
118	return 0;	118	return 0;
119	}	119	}
120		120
121		121
122	ACPI_STATUS acpi_bus_get_status_handle(ACPI_HANDLE handle,	122	ACPI_STATUS acpi_bus_get_status_handle(ACPI_HANDLE handle,
123	unsigned long long *sta)	123	unsigned long long *sta)
124	{	124	{
125	ACPI_STATUS status;	125	ACPI_STATUS status;
126		126
127	status = acpi_evaluate_integer(handle, "_STA", NULL, sta);	127	status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
128	if (ACPI_SUCCESS(status))	128	if (ACPI_SUCCESS(status))
129	{	129	{
130	return AE_OK;	130	return AE_OK;
131	};	131	};
132		132
133	if (status == AE_NOT_FOUND)	133	if (status == AE_NOT_FOUND)
134	{	134	{
135	*sta = ACPI_STA_DEVICE_PRESENT \| ACPI_STA_DEVICE_ENABLED \|	135	*sta = ACPI_STA_DEVICE_PRESENT \| ACPI_STA_DEVICE_ENABLED \|
136	ACPI_STA_DEVICE_UI \| ACPI_STA_DEVICE_FUNCTIONING;	136	ACPI_STA_DEVICE_UI \| ACPI_STA_DEVICE_FUNCTIONING;
137	return AE_OK;	137	return AE_OK;
138	}	138	}
139	return status;	139	return status;
140	}	140	}
141		141
142		142
143		143
144	/* --------------------------------------------------------------------------	144	/* --------------------------------------------------------------------------
145	ACPI Bus operations	145	ACPI Bus operations
146	-------------------------------------------------------------------------- */	146	-------------------------------------------------------------------------- */
147		147
148	int acpi_match_device_ids(struct acpi_device *device,	148	int acpi_match_device_ids(struct acpi_device *device,
149	const struct acpi_device_ids *ids)	149	const struct acpi_device_ids *ids)
150	{	150	{
151	const struct acpi_device_ids *id;	151	const struct acpi_device_ids *id;
152	struct acpi_hardware_id *hwid;	152	struct acpi_hardware_id *hwid;
153		153
154	/*	154	/*
155	* If the device is not present, it is unnecessary to load device	155	* If the device is not present, it is unnecessary to load device
156	* driver for it.	156	* driver for it.
157	*/	157	*/
158	// if (!device->status.present)	158	// if (!device->status.present)
159	// return -ENODEV;	159	// return -ENODEV;
160		160
161	for (id = ids; id->id[0]; id++)	161	for (id = ids; id->id[0]; id++)
162	list_for_each_entry(hwid, &device->pnp.ids, list)	162	list_for_each_entry(hwid, &device->pnp.ids, list)
163	if (!strcmp((char *) id->id, hwid->id))	163	if (!strcmp((char *) id->id, hwid->id))
164	return 0;	164	return 0;
165		165
166	return -ENOENT;	166	return -ENOENT;
167	}	167	}
168		168
169		169
170	static int acpi_device_register(struct acpi_device *device)	170	static int acpi_device_register(struct acpi_device *device)
171	{	171	{
172	int result;	172	int result;
173	struct acpi_device_bus_id acpi_device_bus_id, new_bus_id;	173	struct acpi_device_bus_id acpi_device_bus_id, new_bus_id;
174	int found = 0;	174	int found = 0;
175		175
176	/*	176	/*
177	* Linkage	177	* Linkage
178	* -------	178	* -------
179	* Link this device to its parent and siblings.	179	* Link this device to its parent and siblings.
180	*/	180	*/
181	INIT_LIST_HEAD(&device->children);	181	INIT_LIST_HEAD(&device->children);
182	INIT_LIST_HEAD(&device->node);	182	INIT_LIST_HEAD(&device->node);
183		183
184	new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);	184	new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
185	if (!new_bus_id) {	185	if (!new_bus_id) {
186	printk(KERN_ERR PREFIX "Memory allocation error\n");	186	printk(KERN_ERR PREFIX "Memory allocation error\n");
187	return -ENOMEM;	187	return -ENOMEM;
188	}	188	}
189		189
190	mutex_lock(&acpi_device_lock);	190	mutex_lock(&acpi_device_lock);
191	/*	191	/*
192	* Find suitable bus_id and instance number in acpi_bus_id_list	192	* Find suitable bus_id and instance number in acpi_bus_id_list
193	* If failed, create one and link it into acpi_bus_id_list	193	* If failed, create one and link it into acpi_bus_id_list
194	*/	194	*/
195	list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node)	195	list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node)
196	{	196	{
197	if (!strcmp(acpi_device_bus_id->bus_id,	197	if (!strcmp(acpi_device_bus_id->bus_id,
198	acpi_device_hid(device)))	198	acpi_device_hid(device)))
199	{	199	{
200	acpi_device_bus_id->instance_no++;	200	acpi_device_bus_id->instance_no++;
201	found = 1;	201	found = 1;
202	kfree(new_bus_id);	202	kfree(new_bus_id);
203	break;	203	break;
204	}	204	}
205	};	205	};
206		206
207	if (!found)	207	if (!found)
208	{	208	{
209	acpi_device_bus_id = new_bus_id;	209	acpi_device_bus_id = new_bus_id;
210	strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device));	210	strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device));
211	acpi_device_bus_id->instance_no = 0;	211	acpi_device_bus_id->instance_no = 0;
212	list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);	212	list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
213	}	213	}
214		214
215	// dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);	215	// dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
216		216
217	if (device->parent)	217	if (device->parent)
218	list_add_tail(&device->node, &device->parent->children);	218	list_add_tail(&device->node, &device->parent->children);
219		219
220	mutex_unlock(&acpi_device_lock);	220	mutex_unlock(&acpi_device_lock);
221		221
222	// device->dev.bus = &acpi_bus_type;	222	// device->dev.bus = &acpi_bus_type;
223	// device->dev.release = &acpi_device_release;	223	// device->dev.release = &acpi_device_release;
224	// result = device_register(&device->dev);	224	// result = device_register(&device->dev);
225	// if (result) {	225	// if (result) {
226	// dev_err(&device->dev, "Error registering device\n");	226	// dev_err(&device->dev, "Error registering device\n");
227	// goto end;	227	// goto end;
228	// }	228	// }
229		229
230		230
231	// device->removal_type = ACPI_BUS_REMOVAL_NORMAL;	231	// device->removal_type = ACPI_BUS_REMOVAL_NORMAL;
232	return 0;	232	return 0;
233	end:	233	end:
234	mutex_lock(&acpi_device_lock);	234	mutex_lock(&acpi_device_lock);
235	if (device->parent)	235	if (device->parent)
236	list_del(&device->node);	236	list_del(&device->node);
237	mutex_unlock(&acpi_device_lock);	237	mutex_unlock(&acpi_device_lock);
238	return result;	238	return result;
239	}	239	}
240		240
241		241
242	static struct acpi_device *acpi_bus_get_parent(ACPI_HANDLE handle)	242	static struct acpi_device *acpi_bus_get_parent(ACPI_HANDLE handle)
243	{	243	{
244	ACPI_STATUS status;	244	ACPI_STATUS status;
245	struct acpi_device *device;	245	struct acpi_device *device;
246	int ret;	246	int ret;
247		247
248	/*	248	/*
249	* Fixed hardware devices do not appear in the namespace and do not	249	* Fixed hardware devices do not appear in the namespace and do not
250	* have handles, but we fabricate acpi_devices for them, so we have	250	* have handles, but we fabricate acpi_devices for them, so we have
251	* to deal with them specially.	251	* to deal with them specially.
252	*/	252	*/
253	if (handle == NULL)	253	if (handle == NULL)
254	return acpi_root;	254	return acpi_root;
255		255
256	do {	256	do {
257	status = AcpiGetParent(handle, &handle);	257	status = AcpiGetParent(handle, &handle);
258	if (status == AE_NULL_ENTRY)	258	if (status == AE_NULL_ENTRY)
259	return NULL;	259	return NULL;
260	if (ACPI_FAILURE(status))	260	if (ACPI_FAILURE(status))
261	return acpi_root;	261	return acpi_root;
262		262
263	ret = acpi_bus_get_device(handle, &device);	263	ret = acpi_bus_get_device(handle, &device);
264	if (ret == 0)	264	if (ret == 0)
265	return device;	265	return device;
266	} while (1);	266	} while (1);
267	}	267	}
268		268
269		269
270	static int acpi_bus_get_flags(struct acpi_device *device)	270	static int acpi_bus_get_flags(struct acpi_device *device)
271	{	271	{
272	ACPI_STATUS status = AE_OK;	272	ACPI_STATUS status = AE_OK;
273	ACPI_HANDLE temp = NULL;	273	ACPI_HANDLE temp = NULL;
274		274
275	/* Presence of _STA indicates 'dynamic_status' */	275	/* Presence of _STA indicates 'dynamic_status' */
276	status = AcpiGetHandle(device->handle, "_STA", &temp);	276	status = AcpiGetHandle(device->handle, "_STA", &temp);
277	if (ACPI_SUCCESS(status))	277	if (ACPI_SUCCESS(status))
278	device->flags.dynamic_status = 1;	278	device->flags.dynamic_status = 1;
279		279
280	/* Presence of _RMV indicates 'removable' */	280	/* Presence of _RMV indicates 'removable' */
281	status = AcpiGetHandle(device->handle, "_RMV", &temp);	281	status = AcpiGetHandle(device->handle, "_RMV", &temp);
282	if (ACPI_SUCCESS(status))	282	if (ACPI_SUCCESS(status))
283	device->flags.removable = 1;	283	device->flags.removable = 1;
284		284
285	/* Presence of _EJD\|_EJ0 indicates 'ejectable' */	285	/* Presence of _EJD\|_EJ0 indicates 'ejectable' */
286	status = AcpiGetHandle(device->handle, "_EJD", &temp);	286	status = AcpiGetHandle(device->handle, "_EJD", &temp);
287	if (ACPI_SUCCESS(status))	287	if (ACPI_SUCCESS(status))
288	device->flags.ejectable = 1;	288	device->flags.ejectable = 1;
289	else {	289	else {
290	status = AcpiGetHandle(device->handle, "_EJ0", &temp);	290	status = AcpiGetHandle(device->handle, "_EJ0", &temp);
291	if (ACPI_SUCCESS(status))	291	if (ACPI_SUCCESS(status))
292	device->flags.ejectable = 1;	292	device->flags.ejectable = 1;
293	}	293	}
294		294
295	/* Presence of _LCK indicates 'lockable' */	295	/* Presence of _LCK indicates 'lockable' */
296	status = AcpiGetHandle(device->handle, "_LCK", &temp);	296	status = AcpiGetHandle(device->handle, "_LCK", &temp);
297	if (ACPI_SUCCESS(status))	297	if (ACPI_SUCCESS(status))
298	device->flags.lockable = 1;	298	device->flags.lockable = 1;
299		299
300	/* Presence of _PS0\|_PR0 indicates 'power manageable' */	300	/* Presence of _PS0\|_PR0 indicates 'power manageable' */
301	status = AcpiGetHandle(device->handle, "_PS0", &temp);	301	status = AcpiGetHandle(device->handle, "_PS0", &temp);
302	if (ACPI_FAILURE(status))	302	if (ACPI_FAILURE(status))
303	status = AcpiGetHandle(device->handle, "_PR0", &temp);	303	status = AcpiGetHandle(device->handle, "_PR0", &temp);
304	if (ACPI_SUCCESS(status))	304	if (ACPI_SUCCESS(status))
305	device->flags.power_manageable = 1;	305	device->flags.power_manageable = 1;
306		306
307	/* Presence of _PRW indicates wake capable */	307	/* Presence of _PRW indicates wake capable */
308	status = AcpiGetHandle(device->handle, "_PRW", &temp);	308	status = AcpiGetHandle(device->handle, "_PRW", &temp);
309	if (ACPI_SUCCESS(status))	309	if (ACPI_SUCCESS(status))
310	device->flags.wake_capable = 1;	310	device->flags.wake_capable = 1;
311		311
312	/* TBD: Performance management */	312	/* TBD: Performance management */
313		313
314	return 0;	314	return 0;
315	}	315	}
316		316
317	static void acpi_device_get_busid(struct acpi_device *device)	317	static void acpi_device_get_busid(struct acpi_device *device)
318	{	318	{
319	char bus_id[5] = { '?', 0 };	319	char bus_id[5] = { '?', 0 };
320	struct acpi_buffer buffer = { sizeof(bus_id), bus_id };	320	struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
321	int i = 0;	321	int i = 0;
322		322
323	/*	323	/*
324	* Bus ID	324	* Bus ID
325	* ------	325	* ------
326	* The device's Bus ID is simply the object name.	326	* The device's Bus ID is simply the object name.
327	* TBD: Shouldn't this value be unique (within the ACPI namespace)?	327	* TBD: Shouldn't this value be unique (within the ACPI namespace)?
328	*/	328	*/
329	if (ACPI_IS_ROOT_DEVICE(device)) {	329	if (ACPI_IS_ROOT_DEVICE(device)) {
330	strcpy(device->pnp.bus_id, "ACPI");	330	strcpy(device->pnp.bus_id, "ACPI");
331	return;	331	return;
332	}	332	}
333		333
334	switch (device->device_type)	334	switch (device->device_type)
335	{	335	{
336	case ACPI_BUS_TYPE_POWER_BUTTON:	336	case ACPI_BUS_TYPE_POWER_BUTTON:
337	strcpy(device->pnp.bus_id, "PWRF");	337	strcpy(device->pnp.bus_id, "PWRF");
338	break;	338	break;
339	case ACPI_BUS_TYPE_SLEEP_BUTTON:	339	case ACPI_BUS_TYPE_SLEEP_BUTTON:
340	strcpy(device->pnp.bus_id, "SLPF");	340	strcpy(device->pnp.bus_id, "SLPF");
341	break;	341	break;
342	default:	342	default:
343	AcpiGetName(device->handle, ACPI_SINGLE_NAME, &buffer);	343	AcpiGetName(device->handle, ACPI_SINGLE_NAME, &buffer);
344	/* Clean up trailing underscores (if any) */	344	/* Clean up trailing underscores (if any) */
345	for (i = 3; i > 1; i--) {	345	for (i = 3; i > 1; i--) {
346	if (bus_id[i] == '_')	346	if (bus_id[i] == '_')
347	bus_id[i] = '\0';	347	bus_id[i] = '\0';
348	else	348	else
349	break;	349	break;
350	}	350	}
351	strcpy(device->pnp.bus_id, bus_id);	351	strcpy(device->pnp.bus_id, bus_id);
352	break;	352	break;
353	}	353	}
354	}	354	}
355		355
356		356
357	#define ACPI_VIDEO_OUTPUT_SWITCHING 0x0001	357	#define ACPI_VIDEO_OUTPUT_SWITCHING 0x0001
358	#define ACPI_VIDEO_DEVICE_POSTING 0x0002	358	#define ACPI_VIDEO_DEVICE_POSTING 0x0002
359	#define ACPI_VIDEO_ROM_AVAILABLE 0x0004	359	#define ACPI_VIDEO_ROM_AVAILABLE 0x0004
360	#define ACPI_VIDEO_BACKLIGHT 0x0008	360	#define ACPI_VIDEO_BACKLIGHT 0x0008
361	#define ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR 0x0010	361	#define ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR 0x0010
362	#define ACPI_VIDEO_BACKLIGHT_FORCE_VIDEO 0x0020	362	#define ACPI_VIDEO_BACKLIGHT_FORCE_VIDEO 0x0020
363	#define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VENDOR 0x0040	363	#define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VENDOR 0x0040
364	#define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VIDEO 0x0080	364	#define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VIDEO 0x0080
365	#define ACPI_VIDEO_BACKLIGHT_DMI_VENDOR 0x0100	365	#define ACPI_VIDEO_BACKLIGHT_DMI_VENDOR 0x0100
366	#define ACPI_VIDEO_BACKLIGHT_DMI_VIDEO 0x0200	366	#define ACPI_VIDEO_BACKLIGHT_DMI_VIDEO 0x0200
367	#define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VENDOR 0x0400	367	#define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VENDOR 0x0400
368	#define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VIDEO 0x0800	368	#define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VIDEO 0x0800
369		369
370		370
371	long acpi_is_video_device(struct acpi_device *device)	371	long acpi_is_video_device(struct acpi_device *device)
372	{	372	{
373	ACPI_HANDLE h_dummy;	373	ACPI_HANDLE h_dummy;
374	long video_caps = 0;	374	long video_caps = 0;
375		375
376	if (!device)	376	if (!device)
377	return 0;	377	return 0;
378		378
379	/* Is this device able to support video switching ? */	379	/* Is this device able to support video switching ? */
380	if (ACPI_SUCCESS(AcpiGetHandle(device->handle, "_DOD", &h_dummy)) \|\|	380	if (ACPI_SUCCESS(AcpiGetHandle(device->handle, "_DOD", &h_dummy)) \|\|
381	ACPI_SUCCESS(AcpiGetHandle(device->handle, "_DOS", &h_dummy)))	381	ACPI_SUCCESS(AcpiGetHandle(device->handle, "_DOS", &h_dummy)))
382	video_caps \|= ACPI_VIDEO_OUTPUT_SWITCHING;	382	video_caps \|= ACPI_VIDEO_OUTPUT_SWITCHING;
383		383
384	/* Is this device able to retrieve a video ROM ? */	384	/* Is this device able to retrieve a video ROM ? */
385	if (ACPI_SUCCESS(AcpiGetHandle(device->handle, "_ROM", &h_dummy)))	385	if (ACPI_SUCCESS(AcpiGetHandle(device->handle, "_ROM", &h_dummy)))
386	video_caps \|= ACPI_VIDEO_ROM_AVAILABLE;	386	video_caps \|= ACPI_VIDEO_ROM_AVAILABLE;
387		387
388	/* Is this device able to configure which video head to be POSTed ? */	388	/* Is this device able to configure which video head to be POSTed ? */
389	if (ACPI_SUCCESS(AcpiGetHandle(device->handle, "_VPO", &h_dummy)) &&	389	if (ACPI_SUCCESS(AcpiGetHandle(device->handle, "_VPO", &h_dummy)) &&
390	ACPI_SUCCESS(AcpiGetHandle(device->handle, "_GPD", &h_dummy)) &&	390	ACPI_SUCCESS(AcpiGetHandle(device->handle, "_GPD", &h_dummy)) &&
391	ACPI_SUCCESS(AcpiGetHandle(device->handle, "_SPD", &h_dummy)))	391	ACPI_SUCCESS(AcpiGetHandle(device->handle, "_SPD", &h_dummy)))
392	video_caps \|= ACPI_VIDEO_DEVICE_POSTING;	392	video_caps \|= ACPI_VIDEO_DEVICE_POSTING;
393		393
394	return video_caps;	394	return video_caps;
395	}	395	}
396		396
397	/*	397	/*
398	* acpi_bay_match - see if a device is an ejectable driver bay	398	* acpi_bay_match - see if a device is an ejectable driver bay
399	*	399	*
400	* If an acpi object is ejectable and has one of the ACPI ATA methods defined,	400	* If an acpi object is ejectable and has one of the ACPI ATA methods defined,
401	* then we can safely call it an ejectable drive bay	401	* then we can safely call it an ejectable drive bay
402	*/	402	*/
403	static int acpi_bay_match(struct acpi_device *device){	403	static int acpi_bay_match(struct acpi_device *device){
404	ACPI_STATUS status;	404	ACPI_STATUS status;
405	ACPI_HANDLE handle;	405	ACPI_HANDLE handle;
406	ACPI_HANDLE tmp;	406	ACPI_HANDLE tmp;
407	ACPI_HANDLE phandle;	407	ACPI_HANDLE phandle;
408		408
409	handle = device->handle;	409	handle = device->handle;
410		410
411	status = AcpiGetHandle(handle, "_EJ0", &tmp);	411	status = AcpiGetHandle(handle, "_EJ0", &tmp);
412	if (ACPI_FAILURE(status))	412	if (ACPI_FAILURE(status))
413	return -ENODEV;	413	return -ENODEV;
414		414
415	if ((ACPI_SUCCESS(AcpiGetHandle(handle, "_GTF", &tmp))) \|\|	415	if ((ACPI_SUCCESS(AcpiGetHandle(handle, "_GTF", &tmp))) \|\|
416	(ACPI_SUCCESS(AcpiGetHandle(handle, "_GTM", &tmp))) \|\|	416	(ACPI_SUCCESS(AcpiGetHandle(handle, "_GTM", &tmp))) \|\|
417	(ACPI_SUCCESS(AcpiGetHandle(handle, "_STM", &tmp))) \|\|	417	(ACPI_SUCCESS(AcpiGetHandle(handle, "_STM", &tmp))) \|\|
418	(ACPI_SUCCESS(AcpiGetHandle(handle, "_SDD", &tmp))))	418	(ACPI_SUCCESS(AcpiGetHandle(handle, "_SDD", &tmp))))
419	return 0;	419	return 0;
420		420
421	if (AcpiGetParent(handle, &phandle))	421	if (AcpiGetParent(handle, &phandle))
422	return -ENODEV;	422	return -ENODEV;
423		423
424	if ((ACPI_SUCCESS(AcpiGetHandle(phandle, "_GTF", &tmp))) \|\|	424	if ((ACPI_SUCCESS(AcpiGetHandle(phandle, "_GTF", &tmp))) \|\|
425	(ACPI_SUCCESS(AcpiGetHandle(phandle, "_GTM", &tmp))) \|\|	425	(ACPI_SUCCESS(AcpiGetHandle(phandle, "_GTM", &tmp))) \|\|
426	(ACPI_SUCCESS(AcpiGetHandle(phandle, "_STM", &tmp))) \|\|	426	(ACPI_SUCCESS(AcpiGetHandle(phandle, "_STM", &tmp))) \|\|
427	(ACPI_SUCCESS(AcpiGetHandle(phandle, "_SDD", &tmp))))	427	(ACPI_SUCCESS(AcpiGetHandle(phandle, "_SDD", &tmp))))
428	return 0;	428	return 0;
429		429
430	return -ENODEV;	430	return -ENODEV;
431	}	431	}
432		432
433	/*	433	/*
434	* acpi_dock_match - see if a device has a _DCK method	434	* acpi_dock_match - see if a device has a _DCK method
435	*/	435	*/
436	static int acpi_dock_match(struct acpi_device *device)	436	static int acpi_dock_match(struct acpi_device *device)
437	{	437	{
438	ACPI_HANDLE tmp;	438	ACPI_HANDLE tmp;
439	return AcpiGetHandle(device->handle, "_DCK", &tmp);	439	return AcpiGetHandle(device->handle, "_DCK", &tmp);
440	}	440	}
441		441
442	char acpi_device_hid(struct acpi_device device)	442	char acpi_device_hid(struct acpi_device device)
443	{	443	{
444	struct acpi_hardware_id *hid;	444	struct acpi_hardware_id *hid;
445		445
446	hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);	446	hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
447	return hid->id;	447	return hid->id;
448	}	448	}
449		449
450	static void acpi_add_id(struct acpi_device device, const char dev_id)	450	static void acpi_add_id(struct acpi_device device, const char dev_id)
451	{	451	{
452	struct acpi_hardware_id *id;	452	struct acpi_hardware_id *id;
453		453
454	id = kmalloc(sizeof(*id), GFP_KERNEL);	454	id = kmalloc(sizeof(*id), GFP_KERNEL);
455	if (!id)	455	if (!id)
456	return;	456	return;
457		457
458	INIT_LIST_HEAD(&id->list);	458	INIT_LIST_HEAD(&id->list);
459		459
460	id->id = kmalloc(strlen(dev_id) + 1, GFP_KERNEL);	460	id->id = kmalloc(strlen(dev_id) + 1, GFP_KERNEL);
461	if (!id->id) {	461	if (!id->id) {
462	kfree(id);	462	kfree(id);
463	return;	463	return;
464	}	464	}
465		465
466	strcpy(id->id, dev_id);	466	strcpy(id->id, dev_id);
467	list_add_tail(&id->list, &device->pnp.ids);	467	list_add_tail(&id->list, &device->pnp.ids);
468	}	468	}
469		469
470		470
471		471
472	static void acpi_device_set_id(struct acpi_device *device)	472	static void acpi_device_set_id(struct acpi_device *device)
473	{	473	{
474	ACPI_STATUS status;	474	ACPI_STATUS status;
475	ACPI_DEVICE_INFO *info;	475	ACPI_DEVICE_INFO *info;
476	ACPI_DEVICE_ID_LIST *cid_list;	476	ACPI_DEVICE_ID_LIST *cid_list;
477	int i;	477	int i;
478		478
479	switch (device->device_type)	479	switch (device->device_type)
480	{	480	{
481	case ACPI_BUS_TYPE_DEVICE:	481	case ACPI_BUS_TYPE_DEVICE:
482	if (ACPI_IS_ROOT_DEVICE(device)) {	482	if (ACPI_IS_ROOT_DEVICE(device)) {
483	acpi_add_id(device, ACPI_SYSTEM_HID);	483	acpi_add_id(device, ACPI_SYSTEM_HID);
484	break;	484	break;
485	}	485	}
486		486
487	status = AcpiGetObjectInfo(device->handle, &info);	487	status = AcpiGetObjectInfo(device->handle, &info);
488	if (ACPI_FAILURE(status)) {	488	if (ACPI_FAILURE(status)) {
489	printk(KERN_ERR PREFIX "%s: Error reading device info\n", __func__);	489	printk(KERN_ERR PREFIX "%s: Error reading device info\n", __func__);
490	return;	490	return;
491	}	491	}
492		492
493	if (info->Valid & ACPI_VALID_HID)	493	if (info->Valid & ACPI_VALID_HID)
494	acpi_add_id(device, info->HardwareId.String);	494	acpi_add_id(device, info->HardwareId.String);
495	if (info->Valid & ACPI_VALID_CID)	495	if (info->Valid & ACPI_VALID_CID)
496	{	496	{
497	cid_list = &info->CompatibleIdList;	497	cid_list = &info->CompatibleIdList;
498	for (i = 0; i < cid_list->Count; i++)	498	for (i = 0; i < cid_list->Count; i++)
499	acpi_add_id(device, cid_list->Ids[i].String);	499	acpi_add_id(device, cid_list->Ids[i].String);
500	}	500	}

Subversion Repositories Kolibri OS

(root)/drivers/devman/scan.c – Rev 1867 → 9499