Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#define ACPI_BUS_HID            "KLBSYBUS"

#define ACPI_BUS_DEVICE_NAME    "System Bus"

static LIST_HEAD(acpi_bus_id_list);

DEFINE_MUTEX(acpi_device_lock);

{

    char bus_id[15];

    unsigned int instance_no;

    struct list_head node;

};

#define ACPI_NS_SYSTEM_BUS      "_SB_"

	ACPI_IRQ_MODEL_PIC = 0,

	ACPI_IRQ_MODEL_IOAPIC,

	ACPI_IRQ_MODEL_IOSAPIC,

	ACPI_IRQ_MODEL_PLATFORM,

	ACPI_IRQ_MODEL_COUNT

};

    ACPI_BUS_REMOVAL_NORMAL = 0,

    ACPI_BUS_REMOVAL_EJECT,

    ACPI_BUS_REMOVAL_SUPRISE,

    ACPI_BUS_REMOVAL_TYPE_COUNT

};

    ACPI_BUS_TYPE_DEVICE = 0,

    ACPI_BUS_TYPE_POWER,

    ACPI_BUS_TYPE_PROCESSOR,

    ACPI_BUS_TYPE_THERMAL,

    ACPI_BUS_TYPE_POWER_BUTTON,

    ACPI_BUS_TYPE_SLEEP_BUTTON,

    ACPI_BUS_DEVICE_TYPE_COUNT

};

 * _HID definitions

 * HIDs must conform to ACPI spec(6.1.4)

 * KolibriOS specific HIDs do not apply to this and begin with KOS:

 */

#define ACPI_PROCESSOR_OBJECT_HID   "KLBCPU"

#define ACPI_SYSTEM_HID             "KLBSYSTM"

#define ACPI_THERMAL_HID            "KLBTHERM"

#define ACPI_BUTTON_HID_POWERF      "KLBPWRBN"

#define ACPI_BUTTON_HID_SLEEPF      "KLBSLPBN"

#define ACPI_VIDEO_HID              "KLBVIDEO"

#define ACPI_BAY_HID                "KLBIOBAY"

#define ACPI_DOCK_HID               "KLBDOCK"

/* Quirk for broken IBM BIOSes */

#define ACPI_SMBUS_IBM_HID      "SMBUSIBM"

              ACPI_STA_DEVICE_UI      | ACPI_STA_DEVICE_FUNCTIONING)

#define PCI_MAX_PINS    4

static ACPI_HANDLE pci_root_handle;

    (addr_t)((addr_t)(addr) + (addr_t)(off))

//    (addr_t)((addr_t)(addr) + OS_BASE)

{

    u32_t acpi_op_add:1;

    u32_t acpi_op_start:1;

};

    u32 dynamic_status:1;

    u32 bus_address:1;

    u32 removable:1;

    u32 ejectable:1;

    u32 lockable:1;

    u32 suprise_removal_ok:1;

    u32 power_manageable:1;

    u32 performance_manageable:1;

    u32 wake_capable:1; /* Wakeup(_PRW) supported? */

    u32 force_power_state:1;

    u32 reserved:22;

};

    u32 present:1;

    u32 enabled:1;

    u32 show_in_ui:1;

    u32 functional:1;

    u32 battery_present:1;

    u32 reserved:27;

};

typedef unsigned long acpi_bus_address;

typedef char acpi_device_name[40];

typedef char acpi_device_class[20];

    struct list_head list;

    char *id;

};

{

    acpi_bus_id       bus_id;       /* Object name */

    acpi_bus_address  bus_address;  /* _ADR */

    char *unique_id;                /* _UID */

    struct list_head  ids;          /* _HID and _CIDs */

    acpi_device_name  device_name;  /* Driver-determined */

    acpi_device_class device_class; /*        "          */

};

{

    int device_type;

    ACPI_HANDLE handle;     /* no handle for fixed hardware */

    struct acpi_device *parent;

    struct list_head children;

    struct list_head node;

//    struct list_head wakeup_list;

    struct acpi_device_status status;

    struct acpi_device_flags flags;

    struct acpi_device_pnp pnp;

//    struct acpi_device_power power;

//    struct acpi_device_wakeup wakeup;

//    struct acpi_device_perf performance;

//    struct acpi_device_dir dir;

//    struct acpi_device_ops ops;

//    struct acpi_driver *driver;

    void *driver_data;

//    struct device dev;

    struct acpi_bus_ops bus_ops;    /* workaround for different code path for hotplug */

 //   enum acpi_bus_removal_type removal_type;    /* indicate for different removal type */

};

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_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 };

        return AE_BAD_PARAMETER;

    buffer.Pointer = &element;

    status = AcpiEvaluateObject(handle, pathname, arguments, &buffer);

    if (ACPI_FAILURE(status)) {

        acpi_util_eval_error(handle, pathname, status);

        return status;

    }

        acpi_util_eval_error(handle, pathname, AE_BAD_DATA);

        return AE_BAD_DATA;

    }

}

{

}

{

    ACPI_STATUS status = AE_OK;

    {

        return -EINVAL;

    };

    if (ACPI_FAILURE(status) || !*device) {

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

                  handle));

        return -ENODEV;

    }

    return 0;

}

                       unsigned long long *sta)

{

    ACPI_STATUS status;

    if (ACPI_SUCCESS(status))

    {

        return AE_OK;

    };

    {

        *sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |

               ACPI_STA_DEVICE_UI      | ACPI_STA_DEVICE_FUNCTIONING;

        return AE_OK;

    }

    return status;

}

                    unsigned long long *sta)

{

    ACPI_STATUS status;

    ACPI_OBJECT_TYPE acpi_type;

    if (ACPI_FAILURE(status))

    {

        return -ENODEV;

    };

    {

        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;

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

    }

}

{

    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;

    };

    {

        status = AcpiGetParent(handle, &handle);

        if (status == AE_NULL_ENTRY)

        {

            return NULL;

        };

        if (ACPI_FAILURE(status))

        {

            return acpi_root;

        };

        if (ret == 0)

        {

            return device;

        };

    } while (1);

}

{

    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;

    }

    {

        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;

    }

}

{

    ACPI_STATUS status = AE_OK;

    ACPI_HANDLE temp   = NULL;

    status = AcpiGetHandle(device->handle, "_STA", &temp);

    if (ACPI_SUCCESS(status))

        device->flags.dynamic_status = 1;

    status = AcpiGetHandle(device->handle, "_RMV", &temp);

    if (ACPI_SUCCESS(status))

        device->flags.removable = 1;

    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;

    }

    status = AcpiGetHandle(device->handle, "_LCK", &temp);

    if (ACPI_SUCCESS(status))

        device->flags.lockable = 1;

    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;

    status = AcpiGetHandle(device->handle, "_PRW", &temp);

    if (ACPI_SUCCESS(status))

        device->flags.wake_capable = 1;

}

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

    if (ACPI_FAILURE(status))

        return -ENODEV;

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

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

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

        return 0;

        return -ENODEV;

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

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

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

        return 0;

}

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

}

{

    struct acpi_hardware_id *hid;

    return hid->id;

}

{

    struct acpi_hardware_id *id;

    if (!id)

    {

        return;

    };

    if (!id->id) {

        kfree(id);

        return;

    }

}

#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

{

    ACPI_HANDLE h_dummy;

    long video_caps = 0;

        return 0;

    if (ACPI_SUCCESS(AcpiGetHandle(device->handle, "_DOD", &h_dummy)) ||

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

        video_caps |= ACPI_VIDEO_OUTPUT_SWITCHING;

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

        video_caps |= ACPI_VIDEO_ROM_AVAILABLE;

    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;

}

{

    ACPI_STATUS status;

    ACPI_DEVICE_INFO *info;

    ACPI_DEVICE_ID_LIST *cid_list;

    int i;

    {

        case ACPI_BUS_TYPE_DEVICE:

            if (ACPI_IS_ROOT_DEVICE(device))

            {

                acpi_add_id(device, ACPI_SYSTEM_HID);

                break;

            }

            if (ACPI_FAILURE(status)) {

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

                return;

            }

                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;

            }

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

        }

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

}

{

    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;

                  acpi_bus_data_handler, device);

    if (ACPI_SUCCESS(status))

        return 0;

    return -ENODEV;

}

{

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

    if (!new_bus_id) {

        dbgprintf(KERN_ERR "Memory allocation error\n");

        return -ENOMEM;

    }

    /*

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

    }

        list_add_tail(&device->node, &device->parent->children);

//    device->dev.release = &acpi_device_release;

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

//    if (result) {

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

//        goto end;

//    }

    return 0;

end:

    mutex_lock(&acpi_device_lock);

    if (device->parent)

        list_del(&device->node);

    mutex_unlock(&acpi_device_lock);

    return result;

}

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

    if (!device) {

        dbgprintf("%s: Memory allocation error\n", __FUNCTION__);

        return -ENOMEM;

    }

    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;

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

        goto end;

     * Bind _ADR-Based Devices when hot add

     */

//    if (device->flags.bus_address) {

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

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

//    }

    if (!result) {

        AcpiGetName(handle, ACPI_FULL_PATHNAME, &buffer);

        dbgprintf("Adding [%s]\n", (char *)buffer.Pointer);

        kfree(buffer.Pointer);

        *child = device;

    };

    return result;

}

                      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;

    {

        return AE_OK;

    };

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

    {

        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;

    }

*/

        *return_value = device;

}

             struct acpi_device **child)

{

    ACPI_STATUS status;

    void *device = NULL;

        AcpiWalkNamespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,

                    acpi_bus_check_add, NULL, ops, &device);

        *child = device;

        return 0;

    else

        return -ENODEV;

}

{

    int err;

    struct acpi_bus_ops ops;

    ops.acpi_op_add = 1;

    ops.acpi_op_start = 1;

};

{

    IO_PIC  = 0,

    IO_APIC

};

{

    ACPI_OBJECT arg1;

    ACPI_OBJECT_LIST args;

    ACPI_STATUS as;

    arg1.Integer.Value = mode;

    args.Count = 1;

    args.Pointer = &arg1;

    /*

     * We can silently ignore failure as it may not be implemented, ACPI should

     * provide us with correct information anyway

     */

    if (ACPI_SUCCESS(as))

        dbgprintf("ACPI: machine set to %s mode\n", mode ? "APIC" : "PIC");

}

{

    struct acpi_device *child;

    {

        print_device_tree(child);

    };

};

{

    u32_t retval;

        return 0;

    {

        printf("Can't open /rd/1/drivers/acpi.log\nExit\n");

        return 0;

    }

    if (ACPI_FAILURE(status)) {

        dbgprintf("Unable to reallocate ACPI tables\n");

        goto err;

    }

    if (status != AE_OK) {

          dbgprintf("AcpiInitializeSubsystem failed (%s)\n",

                     AcpiFormatException(status));

          goto err;

    }

    if (status != AE_OK) {

          dbgprintf("AcpiInitializeTables failed (%s)\n",

                     AcpiFormatException(status));

          goto err;

    }

    if (status != AE_OK) {

          dbgprintf("AcpiLoadTables failed (%s)\n",

                     AcpiFormatException(status));

          goto err;

    }

    if (status != AE_OK) {

        dbgprintf("AcpiEnableSubsystem failed (%s)\n",

            AcpiFormatException(status));

        goto err;

    }

    if (ACPI_FAILURE (status))

    {

        dbgprintf("AcpiInitializeObjects failed (%s)\n",

            AcpiFormatException(status));

        goto err;

    }

    scan_devices();

        bool retval = false;

        u32_t bus, last_bus;

            return retval;

        {

            u32_t dev;

            {

                u32_t fn;

                {

                    u32_t irq_bios, irq_acpi;

                    u32_t irq_pin;

                    u16_t pcicmd;

                    u32_t tmp;

                if (id == 0xffffffff || id == 0x00000000 ||

                    id == 0x0000ffff || id == 0xffff0000)

                    continue;

                if (! pcicmd & PCI_COMMAND_IO)

                    continue;

                irq_pin  = (tmp >> 8) & 0xFF;

                    dbgprintf("PCI: no ACPI IRQ routing for "

                    "device %d.%d.%d INT%c\n",bus,dev,fn,'A'+irq_pin-1);

                          "IRQ PIN %d BIOS IRQ %d ACPI IRQ %d\n",

                          id & 0xFFFF, id>>16, bus, dev, fn, irq_pin, irq_bios, irq_acpi);

                };

            }

        };

    };

#endif

    ACPI_HANDLE bus_handle;

    ACPI_HANDLE pci_root;

    dbgprintf("system bus handle %x\n", bus_handle);

    if (status != AE_OK) {

          dbgprintf("AcpiGetHandle failed (%s)\n",

                     AcpiFormatException(status));

          goto err;

    }

                      get_device_by_hid_callback, NULL, NULL, NULL);

*/

                      get_device_by_hid_callback, NULL, NULL, NULL);

    ACPI_HANDLE bus_handle;

    ACPI_HANDLE pci_root;

    dbgprintf("system bus handle %x\n", bus_handle);

        dbgprintf("AcpiGetHandle failed (%s)\n",

            AcpiFormatException(status));

        goto err;

    }