Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include "acpi.h"

#define ACPI_BUS_CLASS          "system_bus"

#define ACPI_BUS_DEVICE_NAME    "System Bus"

#define STRUCT_TO_INT(s)        (*((int*)&s))

extern struct list_head acpi_device_list;

DEFINE_MUTEX(acpi_device_lock);

	unsigned int instance_no;

	struct list_head node;

};

    char *id;

};

#define acpi_device_name(d) ((d)->pnp.device_name)

{

#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_OBJECT_LIST *arguments, unsigned long long *data)

{

    ACPI_STATUS status = AE_OK;

    ACPI_OBJECT element;

    ACPI_BUFFER buffer = { 0, NULL };

    if (!data)

    buffer.Length = sizeof(ACPI_OBJECT);

    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) {

        return AE_BAD_DATA;

    }

    *data = element.Integer.Value;

    ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%llu]\n", *data));

    return AE_OK;

    /* 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);

        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",

                  handle));

        return -ENODEV;

    }

    return 0;

}

{

    ACPI_STATUS status;

    status = acpi_evaluate_integer(handle, "_STA", NULL, sta);

    {

        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;

}

   -------------------------------------------------------------------------- */

int acpi_match_device_ids(struct acpi_device *device,

{

    const struct acpi_device_ids *id;

    struct acpi_hardware_id *hwid;

    /*

     * driver for it.

     */

//    if (!device->status.present)

//        return -ENODEV;

    for (id = ids; id->id[0]; id++)

            if (!strcmp((char *) id->id, hwid->id))

                return 0;

    return -ENOENT;

    int result;

    struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;

    int found = 0;

    /*

     * -------

     * 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);

		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)

    mutex_unlock(&acpi_device_lock);

//    device->dev.bus = &acpi_bus_type;

//    result = device_register(&device->dev);

//    if (result) {

//        dev_err(&device->dev, "Error registering device\n");

//        goto end;

//    }

end:

    mutex_lock(&acpi_device_lock);

    if (device->parent)

        list_del(&device->node);

    mutex_unlock(&acpi_device_lock);

    return result;

}

    ACPI_STATUS status;

    struct      acpi_device *device;

    int         ret;

    /*

     * have handles, but we fabricate acpi_devices for them, so we have

     * to deal with them specially.

     */

    if (handle == NULL)

        return acpi_root;

	do {

        if (status == AE_NULL_ENTRY)

            return NULL;

        if (ACPI_FAILURE(status))

            return acpi_root;

        ret = acpi_bus_get_device(handle, &device);

            return device;

    } while (1);

}

    ACPI_STATUS status = AE_OK;

    ACPI_HANDLE temp   = NULL;

    /* Presence of _STA indicates 'dynamic_status' */

    if (ACPI_SUCCESS(status))

        device->flags.dynamic_status = 1;

    /* Presence of _RMV indicates 'removable' */

    if (ACPI_SUCCESS(status))

        device->flags.removable = 1;

    /* Presence of _EJD|_EJ0 indicates 'ejectable' */

    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' */

    if (ACPI_SUCCESS(status))

        device->flags.lockable = 1;

    /* Presence of _PS0|_PR0 indicates 'power manageable' */

    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 */

    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;

    /*

     * ------

     * 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_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

    ACPI_HANDLE h_dummy;

    long video_caps = 0;

    if (!device)

    /* Is this device able to support video switching ? */

        ACPI_SUCCESS(AcpiGetHandle(device->handle, "_DOS", &h_dummy)))

        video_caps |= ACPI_VIDEO_OUTPUT_SWITCHING;

    /* Is this device able to retrieve a video ROM ? */

        video_caps |= ACPI_VIDEO_ROM_AVAILABLE;

    /* Is this device able to configure which video head to be POSTed ? */

        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;

/*

 *

 * 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);

        return -ENODEV;

    if ((ACPI_SUCCESS(AcpiGetHandle(handle, "_GTF", &tmp))) ||

        (ACPI_SUCCESS(AcpiGetHandle(handle, "_STM", &tmp))) ||

        (ACPI_SUCCESS(AcpiGetHandle(handle, "_SDD", &tmp))))

        return 0;

    if (AcpiGetParent(handle, &phandle))

    if ((ACPI_SUCCESS(AcpiGetHandle(phandle, "_GTF", &tmp))) ||

        (ACPI_SUCCESS(AcpiGetHandle(phandle, "_STM", &tmp))) ||

        (ACPI_SUCCESS(AcpiGetHandle(phandle, "_SDD", &tmp))))

        return 0;

    return -ENODEV;

/*

 */

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);

}

static void acpi_add_id(struct acpi_device *device, const char *dev_id)

    struct acpi_hardware_id *id;

    id = kmalloc(sizeof(*id), GFP_KERNEL);

        return;

    INIT_LIST_HEAD(&id->list);

    id->id = kmalloc(strlen(dev_id) + 1, GFP_KERNEL);

        kfree(id);

        return;

    }

    strcpy(id->id, dev_id);

}

    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);

                printk(KERN_ERR PREFIX "%s: Error reading device info\n", __func__);

                return;

            }

            if (info->Valid & ACPI_VALID_HID)

            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);

        /*

         * 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;

        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;

    }

    /*

     * 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;

    /*

     * -------

     * 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,

    if (ACPI_SUCCESS(status))

        return 0;

	printk(KERN_ERR PREFIX "Error attaching device data\n");

}

                  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;

		printk(KERN_ERR PREFIX "Memory allocation error\n");

        return -ENOMEM;

    }

    INIT_LIST_HEAD(&device->pnp.ids);

    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);

    /*

     * -----

     * 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;

    /*

     * -----------------

     * TBD: Synch with Core's enumeration/initialization process.

     */

    acpi_device_set_id(device);

    result = acpi_device_register(device);

    /*

     */

    if (device->flags.bus_address) {

        if (device->parent && device->parent->ops.bind)

            device->parent->ops.bind(device);

    }

end:

    AcpiGetName(handle, ACPI_FULL_PATHNAME, &buffer);

    kfree(buffer.Pointer);

    AcpiGetObjectInfo(handle, &info);

      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) {

    };

    return result;

}

#define ACPI_STA_DEFAULT (ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED | \

static int acpi_bus_type_and_status(ACPI_HANDLE handle, int *type,

{

    ACPI_STATUS status;

    ACPI_OBJECT_TYPE acpi_type;

    status = AcpiGetType(handle, &acpi_type);

        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;

{

    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);

        return AE_OK;

    if (!(sta & ACPI_STA_DEVICE_PRESENT) &&

        return AE_CTRL_DEPTH;

    /*

     * 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)

/*

        status = acpi_start_single_object(device);

        if (ACPI_FAILURE(status))

            return AE_CTRL_DEPTH;

    }

*/

    if (!*return_value)

    return AE_OK;

}

{

    ACPI_STATUS status;

    void *device = NULL;

    status = acpi_bus_check_add(handle, 0, ops, &device);

        AcpiWalkNamespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,

                    acpi_bus_check_add, NULL, ops, &device);

    if (child)

    if (device)

    else

        return -ENODEV;

}

    int err;

    struct acpi_bus_ops ops;

    memset(&ops, 0, sizeof(ops));

    ops.acpi_op_start = 1;

    err = acpi_bus_scan(ACPI_ROOT_OBJECT, &ops, &acpi_root);

    return err;