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

 #include
 #include "acpi.h"
 #include "acpi_bus.h"
+#include "dmdev.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)
 LIST_HEAD(acpi_device_list);
 //    (addr_t)((addr_t)(addr) + OS_BASE)
 #define acpi_remap( addr ) MapIoMem((void*)(addr),4096, 0x01)
+char* strdup(const char *str);
 void print_pci_irqs();
     IO_PIC  = 0,
     IO_APIC
 };
+static ACPI_STATUS
+resource_to_addr(ACPI_RESOURCE *resource, ACPI_RESOURCE_ADDRESS64 *addr);
+static void create_dm_list();
+static void print_dm_list();
 static void set_pic_mode(enum pic_mode mode)
+{
     ACPI_OBJECT arg1;
     ACPI_OBJECT_LIST args;
     ACPI_STATUS as;
     if (ACPI_SUCCESS(as))
         dbgprintf(PREFIX "machine set to %s mode\n", mode ? "APIC" : "PIC");
+}
-void print_device_tree(struct acpi_device *device)
-{
-    struct acpi_device *child;
-    dbgprintf("%s\n", device->pnp.bus_id);
-    list_for_each_entry(child, &device->children, node)
-    {
-        print_device_tree(child);
     };
     set_pic_mode(IO_APIC);
-    acpi_scan();
-//    print_device_tree(acpi_root);
+    acpi_scan();
-    acpi_init_pci(acpi_root);
-    print_pci_irqs();
-/*
-    ACPI_HANDLE bus_handle;
-    ACPI_HANDLE pci_root;
-    status = AcpiGetHandle(0, "\\_SB_", &bus_handle);
-    dbgprintf("system bus handle %x\n", bus_handle);
-    status = AcpiGetHandle(bus_handle, "PCI0", &pci_root);
+    acpi_init_pci(acpi_root);
-    if (status != AE_OK) {
-          dbgprintf("AcpiGetHandle failed (%s)\n",
-                     AcpiFormatException(status));
-          goto err;
-    }
-    AcpiWalkNamespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 100,
-                      get_device_by_hid_callback, NULL, NULL, NULL);
-*/
+    print_pci_irqs();
-#if 0
-    AcpiWalkNamespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 4,
-                      get_device_by_hid_callback, NULL, NULL, NULL);
+    create_dm_list();
-    ACPI_OBJECT obj;
+    print_dm_list();
-    ACPI_HANDLE bus_handle;
-    ACPI_HANDLE pci_root;
+err:
+    return 0;
-    status = AcpiGetHandle(0, "\\_SB_", &bus_handle);
+};
-    dbgprintf("system bus handle %x\n", bus_handle);
-    status = AcpiGetHandle(bus_handle, "PCI0", &pci_root);
-    if (status != AE_OK) {
-        dbgprintf("AcpiGetHandle failed (%s)\n",
-            AcpiFormatException(status));
-        goto err;
-    }
-    dbgprintf("pci root handle %x\n\n", pci_root);
-    ACPI_BUFFER prt_buffer;
-    prt_buffer.Length = ACPI_ALLOCATE_BUFFER;
+char* strdup(const char *str)
-    prt_buffer.Pointer = NULL;
+{
+    size_t len = strlen (str) + 1;
+    char *copy = malloc(len);
+    if (copy)
+    {
-    status = AcpiGetIrqRoutingTable(pci_root, &prt_buffer);
-    if (status != AE_OK) {
+        memcpy (copy, str, len);
+    }
+    return copy;
+}
-        dbgprintf("AcpiGetIrqRoutingTable failed (%s)\n",
+static void dm_add_pci_bus(struct pci_bus *bus)
+{
-            AcpiFormatException(status));
+    struct pci_bus *tbus;
-        goto err;
+    struct pci_dev *dev;
-    }
+    dmdev_t        *dmdev;
-    prt_walk_table(&prt_buffer);
+    dmdev = (dmdev_t*)kzalloc(sizeof(dmdev_t),GFP_KERNEL);
+//    INIT_LIST_HEAD(&dmdev->list);
+//    dmdev->type = 1;
+//    dmdev->acpi_dev = bus->self->acpi_dev;
+//    dmdev->pci_dev = bus->self;
+//    list_add_tail(&dmdev->list, &dmdev_tree);
-    ACPI_OBJECT arg = { ACPI_TYPE_INTEGER };
+    list_for_each_entry(dev, &bus->devices, bus_list)
-    ACPI_OBJECT_LIST arg_list = { 1, &arg };
+    {
+        dmdev = (dmdev_t*)kzalloc(sizeof(dmdev_t),GFP_KERNEL);
-    arg.Integer.Value = ACPI_IRQ_MODEL_IOAPIC;
+        INIT_LIST_HEAD(&dmdev->list);
         dmdev->type = 1;
-    dbgprintf("\nset ioapic mode\n\n");
-    status = AcpiEvaluateObject(NULL, "\\_PIC", &arg_list, NULL);
-    if (ACPI_FAILURE(status)) {
-        dbgprintf("AcpiEvaluateObject failed (%s)\n",
-            AcpiFormatException(status));
- //       goto err;
-    }
-    status = AcpiGetIrqRoutingTable(pci_root, &prt_buffer);
-    if (status != AE_OK) {
-        dbgprintf("AcpiGetIrqRoutingTable failed (%s)\n",
-            AcpiFormatException(status));
-        goto err;
-    }
-    prt_walk_table(&prt_buffer);
-    u8_t pin = PciRead8 (0, (31<<3) | 1, 0x3D);
-    dbgprintf("bus 0 device 31 function 1 pin %d\n", pin-1);
-    pin = PciRead8 (0, (31<<3) | 2, 0x3D);
-    dbgprintf("bus 0 device 31 function 2 pin %d\n", pin-1);
-    pin = PciRead8 (0, (31<<3) | 3, 0x3D);
-    dbgprintf("bus 0 device 31 function 3 pin %d\n", pin-1);
-    pin = PciRead8 (0, (31<<3) | 4, 0x3D);
-    dbgprintf("bus 0 device 31 function 4 pin %d\n", pin-1);
+        dmdev->acpi_dev = dev->acpi_dev;
-    pin = PciRead8 (0, (31<<3) | 5, 0x3D);
-    dbgprintf("bus 0 device 31 function 5 pin %d\n", pin-1);
+        dmdev->pci_dev = dev;
+        list_add_tail(&dmdev->list, &dmdev_tree);
-    pin = PciRead8 (0, (31<<3) | 6, 0x3D);
+    };
-    dbgprintf("bus 0 device 31 function 6 pin %d\n", pin-1);
-    pin = PciRead8 (0, (31<<3) | 7, 0x3D);
+    list_for_each_entry(tbus, &bus->children, node)
-    dbgprintf("bus 0 device 31 function 7 pin %d\n", pin-1);
-#endif
+    {
-err:
-    return 0;
-};
+        dm_add_pci_bus(tbus);
-#if 0
+    };
+};
-ACPI_STATUS
+static ACPI_STATUS
+count_dev_resources(ACPI_RESOURCE *acpi_res, void *data)
+{
+    (*(int*)data)++;
-get_device_by_hid_callback(ACPI_HANDLE obj, u32_t depth, void* context,
+    return AE_OK;
+}
-    void** retval)
+static void dm_add_acpi(struct acpi_device *device)
 {
-    static u32_t counter = 0;
+    struct acpi_device *child;
-    static char buff[256];
+    ACPI_DEVICE_INFO *info = NULL;
+    ACPI_STATUS status;
+    dmdev_t  *dmdev;
+    uint32_t  res_num = 0;
+    status = AcpiGetObjectInfo(device->handle, &info);
+    if ( (status == AE_OK) && (info->Valid & ACPI_VALID_HID))
+    {
+        if( strcmp(info->HardwareId.String,"PNP0C0F") == 0)
+        {
-    ACPI_STATUS status;
+            kfree(info);
-    ACPI_BUFFER buffer;
-    ACPI_DEVICE_INFO *info;
-   // *retval = NULL;
+            return;
-    buffer.Length = 255;
+        };
-    buffer.Pointer = buff;
+    };
-    status = AcpiGetName(obj, ACPI_FULL_PATHNAME, &buffer);
-    if (status != AE_OK) {
-        return AE_CTRL_TERMINATE;
-    }
-    buff[buffer.Length] = '\0';
-    dbgprintf("device %d %s ", counter, buff);
+    kfree(info);
+    if(device->pci_dev == NULL)
-    status = AcpiGetObjectInfo(obj, &info);
-    if (ACPI_SUCCESS (status))
+    {
-    {
-        if (info->Valid & ACPI_VALID_HID)
-            dbgprintf (" HID: %s", info->HardwareId.String);
+        AcpiWalkResources(device->handle, METHOD_NAME__CRS,
-    };
+                          count_dev_resources, &res_num);
-    dbgprintf("\n");
+        if(res_num != 0)
-    counter++;
+        {
             dmdev = (dmdev_t*)kzalloc(sizeof(dmdev_t),GFP_KERNEL);
-    return AE_OK;
-}
-prt_walk_table(ACPI_BUFFER *prt)
-{
-    ACPI_PCI_ROUTING_TABLE *entry;
-    char *prtptr;
+            INIT_LIST_HEAD(&dmdev->list);
+            dmdev->type = 0;
+            dmdev->acpi_dev = device;
+            dmdev->pci_dev = NULL;
+            list_add_tail(&dmdev->list, &dmdev_tree);
+        };
+    };
+    list_for_each_entry(child, &device->children, node)
+    {
-    /* First check to see if there is a table to walk. */
+        dm_add_acpi(child);
-    if (prt == NULL || prt->Pointer == NULL)
+    };
-        return;
+};
+static void create_dm_list()
+{
-    /* Walk the table executing the handler function for each entry. */
-    prtptr = prt->Pointer;
-    entry = (ACPI_PCI_ROUTING_TABLE *)prtptr;
-    while (entry->Length != 0)
+    struct acpi_pci_root *root;
-    {
-        dbgprintf("adress: %x %x  ", (u32_t)(entry->Address>>32),
-                  (u32_t)entry->Address);
-        dbgprintf("pin: %d  index: %d  source: %s\n",
-                   entry->Pin,
-                   entry->SourceIndex,
-                   entry->Source);
-//      handler(entry, arg);
-        prtptr += entry->Length;
-        entry = (ACPI_PCI_ROUTING_TABLE *)prtptr;
+    list_for_each_entry(root, &acpi_pci_roots, node)
-}
+    {
+        struct pci_bus *pbus, *tbus;
+        struct pci_dev *dev;
-static void add_irq(unsigned dev, unsigned pin, u8_t irq)
+        pbus = root->bus;
+        dm_add_pci_bus(pbus);
+    };
-{
-//    assert(dev < PCI_MAX_DEVICES && pin < PCI_MAX_PINS);
+    dm_add_acpi(acpi_root);
+};
+static void print_pci_resource(struct resource *res)
-    irqtable[dev * PCI_MAX_PINS + pin] = irq;
+{
+    if(res->flags !=0 )
+    {
+        if(res->flags & IORESOURCE_IO)
+            dbgprintf("  IO range ");
+        else if(res->flags & IORESOURCE_MEM)
             dbgprintf("  MMIO range ");
+        dbgprintf("%x - %x\n", res->start, res->end);
+    };
-static ACPI_STATUS get_irq_resource(ACPI_RESOURCE *res, void *context)
+};
-{
     ACPI_PCI_ROUTING_TABLE *tbl = (ACPI_PCI_ROUTING_TABLE *) context;
+static ACPI_STATUS
-    if (res->Type == ACPI_RESOURCE_TYPE_IRQ)
+print_acpi_resource(ACPI_RESOURCE *acpi_res, void *data)
-    {
+{
-        ACPI_RESOURCE_IRQ *irq;
     ACPI_RESOURCE_ADDRESS64 addr;
+    ACPI_STATUS status;
-        irq = &res->Data.Irq;
-        add_irq(tbl->Address >> 16, tbl->Pin,
+    int i;
-                irq->Interrupts[tbl->SourceIndex]);
-    } else if (res->Type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ)
-    {
-        ACPI_RESOURCE_EXTENDED_IRQ *irq;
+    switch (acpi_res->Type)
+    {
-        add_irq(tbl->Address >> 16, tbl->Pin,
-                irq->Interrupts[tbl->SourceIndex]);
+        case ACPI_RESOURCE_TYPE_IRQ:
-    }
+        {
-    return AE_OK;
+            ACPI_RESOURCE_IRQ *irq_data = (ACPI_RESOURCE_IRQ*)&acpi_res->Data;
+            dbgprintf(" IRQ %d\n", irq_data->Interrupts[0]);
+        };
+        break;
-}
+        case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
+        {
+            ACPI_RESOURCE_EXTENDED_IRQ *irq_data = (ACPI_RESOURCE_EXTENDED_IRQ*)&acpi_res->Data;
+            dbgprintf(" IRQ %d\n", irq_data->Interrupts[0]);
         };
+        break;
-char buff[4096];
-static ACPI_STATUS get_pci_irq_routing(ACPI_HANDLE handle)
+        case ACPI_RESOURCE_TYPE_DMA:
-{
+        {
-    ACPI_STATUS status;
+            ACPI_RESOURCE_DMA *dma_data = (ACPI_RESOURCE_DMA*) &acpi_res->Data;
-    ACPI_BUFFER abuff;
+            for(i=0; i < dma_data->ChannelCount; i++)
-    ACPI_PCI_ROUTING_TABLE *tbl;
+            {
+                dbgprintf(" DMA %s channel %d\n",
+                          dma_data->Type == ACPI_TYPE_A ? "Type A":
+                          dma_data->Type == ACPI_TYPE_B ? "Type B" :
-    abuff.Length = sizeof(buff);
+                          dma_data->Type == ACPI_TYPE_F ? "Type F" : "",
-    abuff.Pointer = buff;
+                          dma_data->Channels[i]);
+            }
+        };
+        break;
-    status = AcpiGetIrqRoutingTable(handle, &abuff);
-    if (ACPI_FAILURE(status)) {
+        case ACPI_RESOURCE_TYPE_IO:
+        {
-        return AE_OK;
-    }
-    for (tbl = (ACPI_PCI_ROUTING_TABLE *)abuff.Pointer; tbl->Length;
-            tbl = (ACPI_PCI_ROUTING_TABLE *)
-            ((char *)tbl + tbl->Length))
+            ACPI_RESOURCE_IO *io_data = (ACPI_RESOURCE_IO*) &acpi_res->Data;
-        ACPI_HANDLE src_handle;
+            dbgprintf(" IO range 0%x-0%x\n",io_data->Minimum,
+                       io_data->Minimum+io_data->AddressLength-1);
-        if (*(char*)tbl->Source == '\0') {
+        }
+        break;
-            add_irq(tbl->Address >> 16, tbl->Pin, tbl->SourceIndex);
-            continue;
-        }
+        case ACPI_RESOURCE_TYPE_FIXED_IO:
+        {
-        status = AcpiGetHandle(handle, tbl->Source, &src_handle);
+            ACPI_RESOURCE_FIXED_IO *io_data = (ACPI_RESOURCE_FIXED_IO*) &acpi_res->Data;
-        if (ACPI_FAILURE(status)) {
+            dbgprintf(" Fixed IO range 0%x-0%x\n",io_data->Address,
-            printf("Failed AcpiGetHandle\n");
+                       io_data->Address+io_data->AddressLength-1);
-            continue;
+        };
-        }
+        break;
-        status = AcpiWalkResources(src_handle, METHOD_NAME__CRS,
-                get_irq_resource, tbl);
+        case ACPI_RESOURCE_TYPE_MEMORY24:
+        case ACPI_RESOURCE_TYPE_MEMORY32:
+        case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
-        if (ACPI_FAILURE(status)) {
+        {
-            printf("Failed IRQ resource\n");
+            ACPI_RESOURCE_ADDRESS64 addr64;
+            resource_to_addr(acpi_res, &addr64);
-            continue;
+            dbgprintf(" Memory range 0%x-0%x\n",
+                       (uint32_t)addr64.Minimum, (uint32_t)addr64.Maximum);
+        }
+        break;
+        case ACPI_RESOURCE_TYPE_ADDRESS16:
-        }
+        case ACPI_RESOURCE_TYPE_ADDRESS32:
-    }
+        case ACPI_RESOURCE_TYPE_ADDRESS64:
-    return AE_OK;
+        {
+            ACPI_RESOURCE_ADDRESS64 addr64;
+            ACPI_STATUS status;
+            status = AcpiResourceToAddress64(acpi_res, &addr64);
-}
+            if (ACPI_SUCCESS(status))
+            {
-static ACPI_STATUS add_pci_root_dev(ACPI_HANDLE handle,
-                UINT32 level,
-                void *context,
-                void **retval)
-{
-    int i;
-    static unsigned called;
-    if (++called > 1) {

Subversion Repositories Kolibri OS

(root)/drivers/devman/acpi.c – Rev 1633 → 1867