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

 #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 ACPI_IS_ROOT_DEVICE(device)    (!(device)->parent)
 static LIST_HEAD(acpi_device_list);
 static LIST_HEAD(acpi_bus_id_list);
 DEFINE_MUTEX(acpi_device_lock);
     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_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_POWER_HID              "KLBPOWER"
-#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"
-#define STRUCT_TO_INT(s)        (*((int*)&s))
-#define ACPI_STA_DEFAULT (ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED | \
-              ACPI_STA_DEVICE_UI      | ACPI_STA_DEVICE_FUNCTIONING)
 #define PCI_MAX_DEVICES 32
 #define PCI_MAX_PINS    4
 #define acpi_remap( addr ) MapIoMem((void*)(addr),4096, 0x01)
-struct acpi_bus_ops
-{
-    u32_t acpi_op_add:1;
-    u32_t acpi_op_start:1;
-};
-struct acpi_device_flags {
-    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;
-};
-struct acpi_device_status {
-    u32 present:1;
-    u32 enabled:1;
-    u32 show_in_ui:1;
-    u32 functional:1;
-    u32 battery_present:1;
-    u32 reserved:27;
-};
-typedef char acpi_bus_id[8];
-typedef unsigned long acpi_bus_address;
-typedef char acpi_device_name[40];
-typedef char acpi_device_class[20];
+struct acpi_device *acpi_root;
-struct acpi_hardware_id {
-    struct list_head list;
-    char *id;
+extern struct resource iomem_resource;
-};
+extern struct resource ioport_resource;
-struct acpi_device_pnp
-{
-    acpi_bus_id       bus_id;       /* Object name */
-    acpi_bus_address  bus_address;  /* _ADR */
-    char *unique_id;                /* _UID */
+enum pic_mode
-    struct list_head  ids;          /* _HID and _CIDs */
-    acpi_device_name  device_name;  /* Driver-determined */
+{
-    acpi_device_class device_class; /*        "          */
+    IO_PIC  = 0,
-};
+    IO_APIC
-struct acpi_device
-{
+};
-    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;
+static void set_pic_mode(enum pic_mode mode)
+{
+    ACPI_OBJECT arg1;
+    ACPI_OBJECT_LIST args;
-    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_STATUS as;
-};
-struct acpi_device *acpi_root;
-static void
+    arg1.Type = ACPI_TYPE_INTEGER;
-acpi_util_eval_error(ACPI_HANDLE h, ACPI_STRING p, ACPI_STATUS s)
+    arg1.Integer.Value = mode;
-{
+    args.Count = 1;
-#ifdef ACPI_DEBUG_OUTPUT
+    args.Pointer = &arg1;
-    char prefix[80] = {'\0'};
-    ACPI_BUFFER buffer = {sizeof(prefix), prefix};
+    as = AcpiEvaluateObject(ACPI_ROOT_OBJECT, "_PIC", &args, NULL);
-    AcpiGetName(h, ACPI_FULL_PATHNAME, &buffer);
-    ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluate [%s.%s]: %s\n",
+    /*
-        (char *) prefix, p, AcpiFormatException(s)));
-#else
+     * We can silently ignore failure as it may not be implemented, ACPI should
-    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;
+     * provide us with correct information anyway
-    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 (ACPI_SUCCESS(as))
+        dbgprintf(PREFIX "machine set to %s mode\n", mode ? "APIC" : "PIC");
+}
+void print_device_tree(struct acpi_device *device)
-    }
+{
-    if (element.Type != ACPI_TYPE_INTEGER) {
+    struct acpi_device *child;
         acpi_util_eval_error(handle, pathname, AE_BAD_DATA);
+    dbgprintf("%s\n", device->pnp.bus_id);
-        return AE_BAD_DATA;
-    }
+    list_for_each_entry(child, &device->children, node)
     *data = element.Integer.Value;
+        print_device_tree(child);
+    };
-    ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%llu]\n", *data));
+};
-    return AE_OK;
+/*
-}
+int acpi_pci_bind_root(struct acpi_device *device)
+{
-void acpi_bus_data_handler(ACPI_HANDLE handle, void *context)
+    device->ops.bind = acpi_pci_bind;
+    device->ops.unbind = acpi_pci_unbind;
-{
-    /* TBD */
+    return 0;
-    return;
-}
-int acpi_bus_get_device(ACPI_HANDLE handle, struct acpi_device **device)
+}
+*/
-{
-    ACPI_STATUS status = AE_OK;
+static bool pci_use_crs = false;
+#define IORESOURCE_BUS      0x00001000
-    if (!device)
+struct acpi_pci_root {
-    {
+    struct list_head node;
-        return -EINVAL;
+    struct acpi_device * device;
-    };
     struct acpi_pci_id id;
-    /* TBD: Support fixed-feature devices */
+    struct pci_bus *bus;
-    status = AcpiGetData(handle, acpi_bus_data_handler, (void **)device);
-    if (ACPI_FAILURE(status) || !*device) {
+    u16 segment;
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
+    struct resource secondary;      /* downstream bus range */
-                  handle));
+};
         return -ENODEV;
+static LIST_HEAD(acpi_pci_roots);
-    }
-    return 0;
+#define ACPI_PCI_ROOT_CLASS     "pci_bridge"
-}
+#define ACPI_PCI_ROOT_DEVICE_NAME   "PCI Root Bridge"
 static ACPI_STATUS
-ACPI_STATUS acpi_bus_get_status_handle(ACPI_HANDLE handle,
+get_root_bridge_busnr_callback(ACPI_RESOURCE *resource, void *data)
-                       unsigned long long *sta)
+{
+    struct resource *res = data;
-{
+    ACPI_RESOURCE_ADDRESS64 address;
-    ACPI_STATUS status;
+    if (resource->Type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
-    status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
+        resource->Type != ACPI_RESOURCE_TYPE_ADDRESS32 &&
-    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;
-}
-static int acpi_bus_type_and_status(ACPI_HANDLE handle, int *type,
-                    unsigned long long *sta)
-{
-    ACPI_STATUS status;
+        resource->Type != ACPI_RESOURCE_TYPE_ADDRESS64)
-    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:
+        return AE_OK;
-            *type = ACPI_BUS_TYPE_DEVICE;
-            status = acpi_bus_get_status_handle(handle, sta);
-            if (ACPI_FAILURE(status))
     AcpiResourceToAddress64(resource, &address);
-                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;
+    if ((address.AddressLength > 0) &&
-        case ACPI_TYPE_POWER:
+        (address.ResourceType == ACPI_BUS_NUMBER_RANGE)) {
-            *type = ACPI_BUS_TYPE_POWER;
+        res->start = address.Minimum;
+        res->end = address.Minimum + address.AddressLength - 1;
-            *sta = ACPI_STA_DEFAULT;
+    }
-            break;
-        default:
+    return AE_OK;
+}
             return -ENODEV;
-    }
-    return 0;
-}
-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 ACPI_STATUS try_get_root_bridge_busnr(ACPI_HANDLE handle,
+                         struct resource *res)
+{
+    ACPI_STATUS status;
+    res->start = -1;
+    status =
+        AcpiWalkResources(handle, METHOD_NAME__CRS,
+                get_root_bridge_busnr_callback, res);
+    if (ACPI_FAILURE(status))
+        return status;
-static void acpi_device_get_busid(struct acpi_device *device)
+    if (res->start == -1)
+        return AE_ERROR;
+    return AE_OK;
+}
+struct pci_root_info
 {
+    struct acpi_device *bridge;
+    char *name;
+    unsigned int res_num;
+    struct resource *res;
+    struct pci_bus *bus;
+    int busnum;
+};
-    char bus_id[5] = { '?', 0 };
+static ACPI_STATUS
+resource_to_addr(ACPI_RESOURCE *resource, ACPI_RESOURCE_ADDRESS64 *addr)
+{
+    ACPI_STATUS status;
+    struct acpi_resource_memory24 *memory24;
+    struct acpi_resource_memory32 *memory32;
+    struct acpi_resource_fixed_memory32 *fixed_memory32;
+    memset(addr, 0, sizeof(*addr));
-    struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
+    switch (resource->Type) {
-    int i = 0;
+    case ACPI_RESOURCE_TYPE_MEMORY24:
-    /*
+        memory24 = &resource->Data.Memory24;
-     * Bus ID
+        addr->ResourceType = ACPI_MEMORY_RANGE;
+        addr->Minimum = memory24->Minimum;
-     * ------
+        addr->AddressLength = memory24->AddressLength;
+        addr->Maximum = addr->Minimum + addr->AddressLength - 1;
-     * The device's Bus ID is simply the object name.
+        return AE_OK;
-     * TBD: Shouldn't this value be unique (within the ACPI namespace)?
+    case ACPI_RESOURCE_TYPE_MEMORY32:
-     */
-    if (ACPI_IS_ROOT_DEVICE(device)) {
+        memory32 = &resource->Data.Memory32;
-        strcpy(device->pnp.bus_id, "ACPI");
-        return;
-    }
+        addr->ResourceType = ACPI_MEMORY_RANGE;
-    switch (device->device_type)
-    {
-        case ACPI_BUS_TYPE_POWER_BUTTON:
-            strcpy(device->pnp.bus_id, "PWRF");
-            break;
+        addr->Minimum = memory32->Minimum;
-        case ACPI_BUS_TYPE_SLEEP_BUTTON:
-            strcpy(device->pnp.bus_id, "SLPF");
-            break;
+        addr->AddressLength = memory32->AddressLength;
-        default:
+        addr->Maximum = addr->Minimum + addr->AddressLength - 1;
-            AcpiGetName(device->handle, ACPI_SINGLE_NAME, &buffer);
+        return AE_OK;
-        /* Clean up trailing underscores (if any) */
+    case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
-            for (i = 3; i > 1; i--)
-            {
-                if (bus_id[i] == '_')
-                    bus_id[i] = '\0';
+        fixed_memory32 = &resource->Data.FixedMemory32;
-                else
-                    break;
-            }
-            strcpy(device->pnp.bus_id, bus_id);
-            break;
-    }
-}
-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;
+        addr->ResourceType = ACPI_MEMORY_RANGE;
+        addr->Minimum = fixed_memory32->Address;
-    /* Presence of _EJD|_EJ0 indicates 'ejectable' */
+        addr->AddressLength = fixed_memory32->AddressLength;
-    status = AcpiGetHandle(device->handle, "_EJD", &temp);
+        addr->Maximum = addr->Minimum + addr->AddressLength - 1;
-    if (ACPI_SUCCESS(status))
-        device->flags.ejectable = 1;
+        return AE_OK;
-    else {
+    case ACPI_RESOURCE_TYPE_ADDRESS16:
-        status = AcpiGetHandle(device->handle, "_EJ0", &temp);
+    case ACPI_RESOURCE_TYPE_ADDRESS32:
-        if (ACPI_SUCCESS(status))
+    case ACPI_RESOURCE_TYPE_ADDRESS64:
-            device->flags.ejectable = 1;
+        status = AcpiResourceToAddress64(resource, addr);
-    }
-    /* Presence of _LCK indicates 'lockable' */
+        if (ACPI_SUCCESS(status) &&
-    status = AcpiGetHandle(device->handle, "_LCK", &temp);
+            (addr->ResourceType == ACPI_MEMORY_RANGE ||
-    if (ACPI_SUCCESS(status))
+            addr->ResourceType == ACPI_IO_RANGE) &&
-        device->flags.lockable = 1;
+            addr->AddressLength > 0) {
+            return AE_OK;
+        }
+        break;
+    }
-    /* Presence of _PS0|_PR0 indicates 'power manageable' */
+    return AE_ERROR;
+}
-    status = AcpiGetHandle(device->handle, "_PS0", &temp);
+static ACPI_STATUS
+count_resource(ACPI_RESOURCE *acpi_res, void *data)
+{
-    if (ACPI_FAILURE(status))
+    struct pci_root_info *info = data;
-        status = AcpiGetHandle(device->handle, "_PR0", &temp);
+    ACPI_RESOURCE_ADDRESS64 addr;
-    if (ACPI_SUCCESS(status))
+    ACPI_STATUS status;
-        device->flags.power_manageable = 1;
+    status = resource_to_addr(acpi_res, &addr);
-    /* Presence of _PRW indicates wake capable */
+    if (ACPI_SUCCESS(status))
-    status = AcpiGetHandle(device->handle, "_PRW", &temp);
+        info->res_num++;
-    if (ACPI_SUCCESS(status))
+    return AE_OK;
+}
-        device->flags.wake_capable = 1;
+static ACPI_STATUS setup_resource(ACPI_RESOURCE *acpi_res, void *data)
+{
-    /* TBD: Performance management */
+    struct pci_root_info *info = data;
+    struct resource *res;
-    return 0;
+    struct acpi_resource_address64 addr;
+    ACPI_STATUS status;
+    unsigned long flags;
+    struct resource *root, *conflict;
-}
+    u64 start, end;
+    status = resource_to_addr(acpi_res, &addr);
-/*
+    if (!ACPI_SUCCESS(status))
+        return AE_OK;
+    if (addr.ResourceType == ACPI_MEMORY_RANGE)
+    {
+        root = &iomem_resource;
+        flags = IORESOURCE_MEM;
+        if (addr.Info.Mem.Caching == ACPI_PREFETCHABLE_MEMORY)
- * acpi_bay_match - see if a device is an ejectable driver bay
+            flags |= IORESOURCE_PREFETCH;
+    }
- * 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){
+    else if (addr.ResourceType == ACPI_IO_RANGE)
-    ACPI_STATUS status;
-    ACPI_HANDLE handle;
-    ACPI_HANDLE tmp;
+    {
-    ACPI_HANDLE phandle;
+        root = &ioport_resource;
+        flags = IORESOURCE_IO;
+    } else
+        return AE_OK;
     handle = device->handle;
+    start = addr.Minimum + addr.TranslationOffset;
+    end = addr.Maximum + addr.TranslationOffset;
+    res = &info->res[info->res_num];
+    res->name = info->name;
-    status = AcpiGetHandle(handle, "_EJ0", &tmp);
+    res->flags = flags;
+    res->start = start;
+    res->end = end;
-    if (ACPI_FAILURE(status))
+    res->child = NULL;
-        return -ENODEV;
+    if (!pci_use_crs) {
+        printk("host bridge window %pR (ignored)\n", res);
+        return AE_OK;
+    }
-    if ((ACPI_SUCCESS(AcpiGetHandle(handle, "_GTF", &tmp))) ||
+#if 0
+    conflict = insert_resource_conflict(root, res);
+    if (conflict) {
+        dev_err(&info->bridge->dev,
+            "address space collision: host bridge window %pR "
-        (ACPI_SUCCESS(AcpiGetHandle(handle, "_GTM", &tmp))) ||
+            "conflicts with %s %pR\n",
+            res, conflict->name, conflict);
+    } else {
+        pci_bus_add_resource(info->bus, res, 0);
+        info->res_num++;
+        if (addr.translation_offset)
+            dev_info(&info->bridge->dev, "host bridge window %pR "
+                 "(PCI address [%#llx-%#llx])\n",
-        (ACPI_SUCCESS(AcpiGetHandle(handle, "_STM", &tmp))) ||
-        (ACPI_SUCCESS(AcpiGetHandle(handle, "_SDD", &tmp))))
-        return 0;
                  res, res->start - addr.translation_offset,
-    if (AcpiGetParent(handle, &phandle))
-        return -ENODEV;
+                 res->end - addr.translation_offset);
-    if ((ACPI_SUCCESS(AcpiGetHandle(phandle, "_GTF", &tmp))) ||
+        else
+            dev_info(&info->bridge->dev,
+                 "host bridge window %pR\n", res);
         (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);
+    return AE_OK;
+#endif
+}
-    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
+get_current_resources(struct acpi_device *device, int busnum,
+            int domain, struct pci_bus *bus)
-#define ACPI_VIDEO_OUTPUT_SWITCHING         0x0001
+{
+    struct pci_root_info info;
-#define ACPI_VIDEO_DEVICE_POSTING           0x0002
+    size_t size;
-#define ACPI_VIDEO_ROM_AVAILABLE            0x0004
-#define ACPI_VIDEO_BACKLIGHT                0x0008
+    char buf[64];
-#define ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR       0x0010
-#define ACPI_VIDEO_BACKLIGHT_FORCE_VIDEO        0x0020
+//    if (pci_use_crs)
+//        pci_bus_remove_resources(bus);
 #define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VENDOR    0x0040
-#define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VIDEO     0x0080
+    info.bridge = device;
-#define ACPI_VIDEO_BACKLIGHT_DMI_VENDOR         0x0100
+    info.bus = bus;
-#define ACPI_VIDEO_BACKLIGHT_DMI_VIDEO          0x0200
+    info.res_num = 0;
-#define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VENDOR      0x0400
+    AcpiWalkResources(device->handle, METHOD_NAME__CRS, count_resource,
-#define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VIDEO       0x0800
+                &info);
-long acpi_is_video_device(struct acpi_device *device)
+    if (!info.res_num)
-{
+        return;
-    ACPI_HANDLE h_dummy;
-    long video_caps = 0;
+    size = sizeof(*info.res) * info.res_num;
     info.res = kmalloc(size, GFP_KERNEL);
+    if (!info.res)
-    if (!device)
+        goto res_alloc_fail;
-        return 0;
-    /* Is this device able to support video switching ? */
+    vsprintf(buf,"PCI Bus %04x:%02x", domain, busnum);
-    if (ACPI_SUCCESS(AcpiGetHandle(device->handle, "_DOD", &h_dummy)) ||
+    info.name = strdup(buf);
         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)))
+    if (!info.name)
-        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;
-}
-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);
+        goto name_alloc_fail;
-                break;
-            }
-            status = AcpiGetObjectInfo(device->handle, &info);
-            if (ACPI_FAILURE(status)) {
+    info.res_num = 0;
-                printk(KERN_ERR "%s: Error reading device info\n", __func__);
-                return;
-            }
+    AcpiWalkResources(device->handle, METHOD_NAME__CRS, setup_resource,
                 &info);
-            if (info->Valid & ACPI_VALID_HID)
+    return;
+name_alloc_fail:
+    kfree(info.res);
-                acpi_add_id(device, info->HardwareId.String);
+res_alloc_fail:
+    return;
+}
             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;
-            }
+struct pci_ops pci_root_ops = {
-            kfree(info);
+    .read = NULL,
-        /*
-         * 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);
+    .write = NULL,
-        else if (ACPI_SUCCESS(acpi_dock_match(device)))
+};
-            acpi_add_id(device, ACPI_DOCK_HID);
-        else if (!acpi_device_hid(device) &&
+struct pci_bus*  pci_acpi_scan_root(struct acpi_pci_root *root)
+{
+    struct acpi_device *device = root->device;
-             ACPI_IS_ROOT_DEVICE(device->parent)) {
+    int domain = root->segment;
-            acpi_add_id(device, ACPI_BUS_HID); /* \_SB, LNXSYBUS */
+    int busnum = root->secondary.start;
-            strcpy(device->pnp.device_name, ACPI_BUS_DEVICE_NAME);
+    struct pci_bus *bus;
-            strcpy(device->pnp.device_class, ACPI_BUS_CLASS);
-        }
-        break;
-    case ACPI_BUS_TYPE_POWER:
-        acpi_add_id(device, ACPI_POWER_HID);
-        break;
+    struct pci_sysdata *sd;
-    case ACPI_BUS_TYPE_PROCESSOR:
+    int node = 0;
-        acpi_add_id(device, ACPI_PROCESSOR_OBJECT_HID);
-        break;
+    if (domain ) {
-    case ACPI_BUS_TYPE_THERMAL:
-        acpi_add_id(device, ACPI_THERMAL_HID);
+        printk(KERN_WARNING "pci_bus %04x:%02x: "
+               "ignored (multiple domains not supported)\n",
+               domain, busnum);
+        return NULL;
+    }
+    /* Allocate per-root-bus (not per bus) arch-specific data.
+     * TODO: leak; this memory is never freed.
+     * It's arguable whether it's worth the trouble to care.
-        break;
+     */
+    sd = kzalloc(sizeof(*sd), GFP_KERNEL);
-    case ACPI_BUS_TYPE_POWER_BUTTON:
+    if (!sd) {
+        printk(KERN_WARNING "pci_bus %04x:%02x: "
+               "ignored (out of memory)\n", domain, busnum);
+        return NULL;
         acpi_add_id(device, ACPI_BUTTON_HID_POWERF);
-        break;
+    sd->domain = domain;
-    case ACPI_BUS_TYPE_SLEEP_BUTTON:
+    sd->node = node;
+    /*
-        acpi_add_id(device, ACPI_BUTTON_HID_SLEEPF);
+     * Maybe the desired pci bus has been already scanned. In such case
-        break;
+     * it is unnecessary to scan the pci bus with the given domain,busnum.
-    }
+     */
+    bus = pci_find_bus(domain, busnum);
-    /*
+    if (bus) {
-     * 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,
+         * If the desired bus exits, the content of bus->sysdata will
-     * but we do use them indirectly by traversing the acpi_device tree.
+         * be replaced by sd.
-     * This generic ID isn't useful for driver binding, but it provides
+         */
-     * the useful property that "every acpi_device has an ID."
+        memcpy(bus->sysdata, sd, sizeof(*sd));
-     */
-    if (list_empty(&device->pnp.ids))
-        acpi_add_id(device, "device");
-}
+        kfree(sd);
+    } else {
-static int acpi_device_set_context(struct acpi_device *device)
+        bus = pci_create_bus(busnum, &pci_root_ops, sd);
         if (bus) {
-    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;
-    dbgprintf(KERN_ERR "Error attaching device data\n");
-    return -ENODEV;
-}
-static int acpi_device_register(struct acpi_device *device)
-{
-    int result;
-    struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
+            get_current_resources(device, busnum, domain, bus);
-    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) {
-        dbgprintf(KERN_ERR "Memory allocation error\n");
-        return -ENOMEM;
-    }
-    mutex_lock(&acpi_device_lock);
-    /*
+//            bus->subordinate = pci_scan_child_bus(bus);
-     * 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 (!bus)
-        if (!strcmp(acpi_device_bus_id->bus_id, acpi_device_hid(device)))
-        {
+        kfree(sd);
             acpi_device_bus_id->instance_no++;
-            found = 1;
-            kfree(new_bus_id);
-            break;
+    if (bus && node != -1) {
-        }
+        printk("on NUMA node %d\n", node);
+    }
-    if (!found)
-    {
-        acpi_device_bus_id = new_bus_id;
+    return bus;
         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);
+static int acpi_pci_root_add(struct acpi_device *device)
+{
-    if (device->parent)
+    unsigned long long segment, bus;
-        list_add_tail(&device->node, &device->parent->children);
+    ACPI_STATUS status;
-    mutex_unlock(&acpi_device_lock);
+    int result;
+    struct acpi_pci_root *root;
+    ACPI_HANDLE handle;
+    struct acpi_device *child;
+    u32 flags, base_flags;
-//    device->dev.bus = &acpi_bus_type;
+    root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
-//    device->dev.release = &acpi_device_release;
-//    result = device_register(&device->dev);
-//    if (result) {
-//        dev_err(&device->dev, "Error registering device\n");
-//        goto end;
+    if (!root)
-//    }
+        return -ENOMEM;
+    segment = 0;
-//    device->removal_type = ACPI_BUS_REMOVAL_NORMAL;
+    status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL,
-    return 0;
+                       &segment);
-end:
-    mutex_lock(&acpi_device_lock);
+    if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
-    if (device->parent)
+        printk(KERN_ERR PREFIX "can't evaluate _SEG\n");
-        list_del(&device->node);
-    mutex_unlock(&acpi_device_lock);
-    return result;
-}
-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 };
-    device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
-    if (!device) {
-        dbgprintf("%s: Memory allocation error\n", __FUNCTION__);
-        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 */
+        result = -ENODEV;
-    STRUCT_TO_INT(device->status) = sta;
+        goto end;
+    }
-    acpi_device_get_busid(device);
+    /* Check _CRS first, then _BBN.  If no _BBN, default to zero. */
-    /*
+    root->secondary.flags = IORESOURCE_BUS;
-     * Flags
+    status = try_get_root_bridge_busnr(device->handle, &root->secondary);
-     * -----
+    if (ACPI_FAILURE(status))
-     * 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;
+        /*
-    /*
+         * We need both the start and end of the downstream bus range
-     * Initialize Device
+         * to interpret _CBA (MMCONFIG base address), so it really is
-     * -----------------
-     * TBD: Synch with Core's enumeration/initialization process.
+         * supposed to be in _CRS.  If we don't find it there, all we
-     */
-    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:
+         * can do is assume [_BBN-0xFF] or [0-0xFF].
-    if (!result) {
-        AcpiGetName(handle, ACPI_FULL_PATHNAME, &buffer);
+         */
-        dbgprintf("Adding [%s]\n", (char *)buffer.Pointer);
-        kfree(buffer.Pointer);
+        root->secondary.end = 0xFF;
-        *child = device;
-    };
-    return result;
+        printk(KERN_WARNING PREFIX
+               "no secondary bus range in _CRS\n");
-}
+        status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN,                           NULL, &bus);
+        if (ACPI_SUCCESS(status))
+            root->secondary.start = bus;
         else if (status == AE_NOT_FOUND)
-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)
-    {
+            root->secondary.start = 0;
+        else {
+            printk(KERN_ERR PREFIX "can't evaluate _BBN\n");
+            result = -ENODEV;
-        return AE_OK;
+            goto end;
-    };
+        }
+    }
     if (!(sta & ACPI_STA_DEVICE_PRESENT) &&
-        !(sta & ACPI_STA_DEVICE_FUNCTIONING))
+    INIT_LIST_HEAD(&root->node);
-    {
+    root->device = device;
-        return AE_CTRL_DEPTH;
+    root->segment = segment & 0xFFFF;
-    };
-    /*
-     * 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;
-    }
+    strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);
-*/
+    strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);
     device->driver_data = root;
+    /*
-    if (!*return_value)
+     * All supported architectures that use ACPI have support for
+     * PCI domains, so we indicate this in _OSC support capabilities.
+     */
-        *return_value = device;
+//    flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT;
 //    acpi_pci_osc_support(root, flags);
-    return AE_OK;
     /*
+     * TBD: Need PCI interface for enumeration/configuration of roots.
      */
     /* TBD: Locking */
     list_add_tail(&root->node, &acpi_pci_roots);
 static int acpi_bus_scan(ACPI_HANDLE handle, struct acpi_bus_ops *ops,
-             struct acpi_device **child)
+    printk(KERN_INFO PREFIX "%s [%s] (domain %04x %pR)\n",
-    set_pic_mode(IO_APIC);
-#if 0
-    scan_devices();
-    {
-        bool retval = false;
-        u32_t bus, last_bus;
-        if( (last_bus = PciApi(1))==-1)
-            return retval;
-        dbgprintf("last bus %x\n", last_bus);
-        for(bus=0; bus <= last_bus; bus++)
-        {
-            u32_t dev;
-            for(dev = 0; dev < 32; dev++)
-            {
-                u32_t fn;
-                for(fn = 0; fn < 8; fn++)
-                {
-                    u32_t id;
-                    u32_t irq_bios, irq_acpi;
-                    u32_t irq_pin;
-                    u16_t pcicmd;
-                    u32_t tmp;
-                    u32_t devfn = (dev<<3 )|fn;
-                    id = PciRead32(bus,devfn, PCI_VENDOR_ID);
-    /* some broken boards return 0 or ~0 if a slot is empty: */
-                if (id == 0xffffffff || id == 0x00000000 ||
-                    id == 0x0000ffff || id == 0xffff0000)
-                    continue;
-                pcicmd = PciRead16(bus,devfn, PCI_COMMAND);
-                if (! pcicmd & PCI_COMMAND_IO)
-                    continue;
-                tmp = PciRead32(bus,devfn, 0x3C);
-                irq_bios = tmp & 0xFF;
-                irq_pin  = (tmp >> 8) & 0xFF;
-                int slot = (fn >> 3) & 0x1f;
-                irq_acpi = irqtable[ dev * PCI_MAX_PINS +(irq_pin-1) ];
-                if( irq_acpi < 0)
-                    dbgprintf("PCI: no ACPI IRQ routing for "
-                    "device %d.%d.%d INT%c\n",bus,dev,fn,'A'+irq_pin-1);
-                dbgprintf("pci device %x_%x bus %d dev %d fn %d,"
-                          "IRQ PIN %d BIOS IRQ %d ACPI IRQ %d\n",
-                          id & 0xFFFF, id>>16, bus, dev, fn, irq_pin, irq_bios, irq_acpi);
-                };
-            }
-        };
-    };
-#endif
+    set_pic_mode(IO_APIC);
+    acpi_scan();
-    acpi_scan();
+//    print_device_tree(acpi_root);
-    print_device_tree(acpi_root);
+    acpi_init_pci(acpi_root);
     return 0;
+};
+#if 0
+    scan_devices();
+    {
+        bool retval = false;
+        u32_t bus, last_bus;
+        if( (last_bus = PciApi(1))==-1)
+            return retval;
+        dbgprintf("last bus %x\n", last_bus);
+        for(bus=0; bus <= last_bus; bus++)
+        {
+            u32_t dev;
+            for(dev = 0; dev < 32; dev++)
+            {
+                u32_t fn;
+                for(fn = 0; fn < 8; fn++)
+                {
+                    u32_t id;
+                    u32_t irq_bios, irq_acpi;
+                    u32_t irq_pin;
+                    u16_t pcicmd;
+                    u32_t tmp;
+                    u32_t devfn = (dev<<3 )|fn;
+                    id = PciRead32(bus,devfn, PCI_VENDOR_ID);
+    /* some broken boards return 0 or ~0 if a slot is empty: */
+                if (id == 0xffffffff || id == 0x00000000 ||
+                    id == 0x0000ffff || id == 0xffff0000)
+                    continue;
+                pcicmd = PciRead16(bus,devfn, PCI_COMMAND);
+                if (! pcicmd & PCI_COMMAND_IO)
+                    continue;
+                tmp = PciRead32(bus,devfn, 0x3C);
+                irq_bios = tmp & 0xFF;
+                irq_pin  = (tmp >> 8) & 0xFF;
+                int slot = (fn >> 3) & 0x1f;
+                irq_acpi = irqtable[ dev * PCI_MAX_PINS +(irq_pin-1) ];
+                if( irq_acpi < 0)
+                    dbgprintf("PCI: no ACPI IRQ routing for "
+                    "device %d.%d.%d INT%c\n",bus,dev,fn,'A'+irq_pin-1);
+                dbgprintf("pci device %x_%x bus %d dev %d fn %d,"
+                          "IRQ PIN %d BIOS IRQ %d ACPI IRQ %d\n",
+                          id & 0xFFFF, id>>16, bus, dev, fn, irq_pin, irq_bios, irq_acpi);
+                };
+            }
+        };
+    };
-};
+#endif
 //    assert(ACPI_SUCCESS(status));
+}
 #endif
+char* strdup(const char *str)
+{
+    size_t len = strlen (str) + 1;
+    char *copy = malloc(len);
+    if (copy)
+    {
+        memcpy (copy, str, len);
+    }
+    return copy;
+}

Subversion Repositories Kolibri OS

(root)/drivers/devman/acpi.c @ 1625 – Rev 1625 → 1627