Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#include "acpi_bus.h"

#define ACPI_BUS_HID            "KLBSYBUS"

#define ACPI_BUS_DEVICE_NAME    "System Bus"

static LIST_HEAD(acpi_bus_id_list);

{

    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

};

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

extern struct resource ioport_resource;

{

    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(PREFIX "machine set to %s mode\n", mode ? "APIC" : "PIC");

}

{

    struct acpi_device *child;

    {

        print_device_tree(child);

    };

};

int acpi_pci_bind_root(struct acpi_device *device)

{

    device->ops.bind = acpi_pci_bind;

    device->ops.unbind = acpi_pci_unbind;

}

*/

    struct list_head node;

    struct acpi_device * device;

    struct acpi_pci_id id;

    struct pci_bus *bus;

    u16 segment;

    struct resource secondary;      /* downstream bus range */

#define ACPI_PCI_ROOT_DEVICE_NAME   "PCI Root Bridge"

get_root_bridge_busnr_callback(ACPI_RESOURCE *resource, void *data)

{

    struct resource *res = data;

    ACPI_RESOURCE_ADDRESS64 address;

        resource->Type != ACPI_RESOURCE_TYPE_ADDRESS32 &&

        resource->Type != ACPI_RESOURCE_TYPE_ADDRESS64)

        return AE_OK;

    if ((address.AddressLength > 0) &&

        (address.ResourceType == ACPI_BUS_NUMBER_RANGE)) {

        res->start = address.Minimum;

        res->end = address.Minimum + address.AddressLength - 1;

    }

}

                         struct resource *res)

{

    ACPI_STATUS status;

    status =

        AcpiWalkResources(handle, METHOD_NAME__CRS,

                get_root_bridge_busnr_callback, res);

    if (ACPI_FAILURE(status))

        return status;

    if (res->start == -1)

        return AE_ERROR;

    return AE_OK;

}

{

    struct acpi_device *bridge;

    char *name;

    unsigned int res_num;

    struct resource *res;

    struct pci_bus *bus;

    int busnum;

};

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;

    switch (resource->Type) {

    case ACPI_RESOURCE_TYPE_MEMORY24:

        memory24 = &resource->Data.Memory24;

        addr->ResourceType = ACPI_MEMORY_RANGE;

        addr->Minimum = memory24->Minimum;

        addr->AddressLength = memory24->AddressLength;

        addr->Maximum = addr->Minimum + addr->AddressLength - 1;

        return AE_OK;

    case ACPI_RESOURCE_TYPE_MEMORY32:

        memory32 = &resource->Data.Memory32;

        addr->ResourceType = ACPI_MEMORY_RANGE;

        addr->Minimum = memory32->Minimum;

        addr->AddressLength = memory32->AddressLength;

        addr->Maximum = addr->Minimum + addr->AddressLength - 1;

        return AE_OK;

    case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:

        fixed_memory32 = &resource->Data.FixedMemory32;

        addr->ResourceType = ACPI_MEMORY_RANGE;

        addr->Minimum = fixed_memory32->Address;

        addr->AddressLength = fixed_memory32->AddressLength;

        addr->Maximum = addr->Minimum + addr->AddressLength - 1;

        return AE_OK;

    case ACPI_RESOURCE_TYPE_ADDRESS16:

    case ACPI_RESOURCE_TYPE_ADDRESS32:

    case ACPI_RESOURCE_TYPE_ADDRESS64:

        status = AcpiResourceToAddress64(resource, addr);

        if (ACPI_SUCCESS(status) &&

            (addr->ResourceType == ACPI_MEMORY_RANGE ||

            addr->ResourceType == ACPI_IO_RANGE) &&

            addr->AddressLength > 0) {

            return AE_OK;

        }

        break;

    }

    return AE_ERROR;

}

count_resource(ACPI_RESOURCE *acpi_res, void *data)

{

    struct pci_root_info *info = data;

    ACPI_RESOURCE_ADDRESS64 addr;

    ACPI_STATUS status;

    if (ACPI_SUCCESS(status))

        info->res_num++;

    return AE_OK;

}

{

    struct pci_root_info *info = data;

    struct resource *res;

    struct acpi_resource_address64 addr;

    ACPI_STATUS status;

    unsigned long flags;

    struct resource *root, *conflict;

    u64 start, end;

    if (!ACPI_SUCCESS(status))

        return AE_OK;

    {

        root = &iomem_resource;

        flags = IORESOURCE_MEM;

        if (addr.Info.Mem.Caching == ACPI_PREFETCHABLE_MEMORY)

            flags |= IORESOURCE_PREFETCH;

    }

    else if (addr.ResourceType == ACPI_IO_RANGE)

    {

        root = &ioport_resource;

        flags = IORESOURCE_IO;

    } else

        return AE_OK;

    end = addr.Maximum + addr.TranslationOffset;

    res->name = info->name;

    res->flags = flags;

    res->start = start;

    res->end = end;

    res->child = NULL;

        printk("host bridge window %pR (ignored)\n", res);

        return AE_OK;

    }

    conflict = insert_resource_conflict(root, res);

    if (conflict) {

        dev_err(&info->bridge->dev,

            "address space collision: host bridge window %pR "

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

                 res, res->start - addr.translation_offset,

                 res->end - addr.translation_offset);

        else

            dev_info(&info->bridge->dev,

                 "host bridge window %pR\n", res);

    }

    return AE_OK;

#endif

}

get_current_resources(struct acpi_device *device, int busnum,

            int domain, struct pci_bus *bus)

{

    struct pci_root_info info;

    size_t size;

//        pci_bus_remove_resources(bus);

    info.bus = bus;

    info.res_num = 0;

    AcpiWalkResources(device->handle, METHOD_NAME__CRS, count_resource,

                &info);

    if (!info.res_num)

        return;

    info.res = kmalloc(size, GFP_KERNEL);

    if (!info.res)

        goto res_alloc_fail;

    info.name = strdup(buf);

        goto name_alloc_fail;

    AcpiWalkResources(device->handle, METHOD_NAME__CRS, setup_resource,

                &info);

    kfree(info.res);

res_alloc_fail:

    return;

}

    .read = NULL,

    .write = NULL,

};

{

    struct acpi_device *device = root->device;

    int domain = root->segment;

    int busnum = root->secondary.start;

    struct pci_bus *bus;

    struct pci_sysdata *sd;

    int node = 0;

        printk(KERN_WARNING "pci_bus %04x:%02x: "

               "ignored (multiple domains not supported)\n",

               domain, busnum);

        return NULL;

    }

     * TODO: leak; this memory is never freed.

     * It's arguable whether it's worth the trouble to care.

     */

    sd = kzalloc(sizeof(*sd), GFP_KERNEL);

    if (!sd) {

        printk(KERN_WARNING "pci_bus %04x:%02x: "

               "ignored (out of memory)\n", domain, busnum);

        return NULL;

    }

    sd->node = node;

    /*

     * Maybe the desired pci bus has been already scanned. In such case

     * it is unnecessary to scan the pci bus with the given domain,busnum.

     */

    bus = pci_find_bus(domain, busnum);

    if (bus) {

        /*

         * If the desired bus exits, the content of bus->sysdata will

         * be replaced by sd.

         */

        memcpy(bus->sysdata, sd, sizeof(*sd));

        kfree(sd);

    } else {

        bus = pci_create_bus(busnum, &pci_root_ops, sd);

        if (bus) {

            get_current_resources(device, busnum, domain, bus);

//            bus->subordinate = pci_scan_child_bus(bus);

        }

    }

        kfree(sd);

        printk("on NUMA node %d\n", node);

    }

}

{

    unsigned long long segment, bus;

    ACPI_STATUS status;

    int result;

    struct acpi_pci_root *root;

    ACPI_HANDLE handle;

    struct acpi_device *child;

    u32 flags, base_flags;

    if (!root)

        return -ENOMEM;

    status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL,

                       &segment);

    if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {

        printk(KERN_ERR PREFIX "can't evaluate _SEG\n");

        result = -ENODEV;

        goto end;

    }

    root->secondary.flags = IORESOURCE_BUS;

    status = try_get_root_bridge_busnr(device->handle, &root->secondary);

    if (ACPI_FAILURE(status))

    {

        /*

         * We need both the start and end of the downstream bus range

         * to interpret _CBA (MMCONFIG base address), so it really is

         * supposed to be in _CRS.  If we don't find it there, all we

         * can do is assume [_BBN-0xFF] or [0-0xFF].

         */

        root->secondary.end = 0xFF;

        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)

            root->secondary.start = 0;

        else {

            printk(KERN_ERR PREFIX "can't evaluate _BBN\n");

            result = -ENODEV;

            goto end;

        }

    }

    root->device = device;

    root->segment = segment & 0xFFFF;

    strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);

    strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);

    device->driver_data = root;

     * All supported architectures that use ACPI have support for

     * PCI domains, so we indicate this in _OSC support capabilities.

     */

//    flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT;

//    acpi_pci_osc_support(root, flags);

     * TBD: Need PCI interface for enumeration/configuration of roots.

     */

    list_add_tail(&root->node, &acpi_pci_roots);

           acpi_device_name(device), acpi_device_bid(device),

           root->segment, &root->secondary);

     * Scan the Root Bridge

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

     * Must do this prior to any attempt to bind the root device, as the

     * PCI namespace does not get created until this call is made (and

     * thus the root bridge's pci_dev does not exist).

     */

    if (!root->bus) {

        printk(KERN_ERR PREFIX

                "Bus %04x:%02x not present in PCI namespace\n",

                root->segment, (unsigned int)root->secondary.start);

        result = -ENODEV;

        goto end;

    }

     * Attach ACPI-PCI Context

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

     * Thus binding the ACPI and PCI devices.

     */

//    result = acpi_pci_bind_root(device);

//    if (result)

//        goto end;

     * PCI Routing Table

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

     * Evaluate and parse _PRT, if exists.

     */

    status = AcpiGetHandle(device->handle, METHOD_NAME__PRT, &handle);

    if (ACPI_SUCCESS(status))

        result = acpi_pci_irq_add_prt(device->handle, root->bus);

     * Scan and bind all _ADR-Based Devices

     */

//    list_for_each_entry(child, &device->children, node)

//        acpi_pci_bridge_scan(child);

    if (!list_empty(&root->node))

        list_del(&root->node);

    kfree(root);

    return result;

}

{

    {"PNP0A03", 0},

    {"",        0},

};

{

    struct acpi_device *child;

    {

        dbgprintf(PREFIX "PCI root %s\n", device->pnp.bus_id);

        acpi_pci_root_add(device);

    };

    {

        acpi_init_pci(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;

    }

    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;

    }

    prt_buffer.Pointer = NULL;

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

            AcpiFormatException(status));

        goto err;

    }

    ACPI_OBJECT_LIST arg_list = { 1, &arg };

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

            AcpiFormatException(status));

 //       goto err;

    }

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

            AcpiFormatException(status));

        goto err;

    }

    dbgprintf("bus 0 device 31 function 1 pin %d\n", pin-1);

    dbgprintf("bus 0 device 31 function 2 pin %d\n", pin-1);

    dbgprintf("bus 0 device 31 function 3 pin %d\n", pin-1);

    dbgprintf("bus 0 device 31 function 4 pin %d\n", pin-1);

    dbgprintf("bus 0 device 31 function 5 pin %d\n", pin-1);

    dbgprintf("bus 0 device 31 function 6 pin %d\n", pin-1);

    dbgprintf("bus 0 device 31 function 7 pin %d\n", pin-1);

#endif

    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

get_device_by_hid_callback(ACPI_HANDLE obj, u32_t depth, void* context,

    void** retval)

{

    static u32_t counter = 0;

    static char buff[256];

    buffer.Pointer = buff;

    if (status != AE_OK) {

        return AE_CTRL_TERMINATE;

    }

    {

        if (info->Valid & ACPI_VALID_HID)

            dbgprintf (" HID: %s", info->HardwareId.String);

    counter++;

}

{

    ACPI_PCI_ROUTING_TABLE *entry;

    char *prtptr;

    if (prt == NULL || prt->Pointer == NULL)

        return;

    prtptr = prt->Pointer;

    entry = (ACPI_PCI_ROUTING_TABLE *)prtptr;

    while (entry->Length != 0)

    {

                  (u32_t)entry->Address);

        dbgprintf("pin: %d  index: %d  source: %s\n",

                   entry->Pin,

                   entry->SourceIndex,

                   entry->Source);

        prtptr += entry->Length;

        entry = (ACPI_PCI_ROUTING_TABLE *)prtptr;

    }

}

{

//    assert(dev < PCI_MAX_DEVICES && pin < PCI_MAX_PINS);

}

{

    ACPI_PCI_ROUTING_TABLE *tbl = (ACPI_PCI_ROUTING_TABLE *) context;

    {

        ACPI_RESOURCE_IRQ *irq;

        add_irq(tbl->Address >> 16, tbl->Pin,

                irq->Interrupts[tbl->SourceIndex]);

    } else if (res->Type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ)

    {

        ACPI_RESOURCE_EXTENDED_IRQ *irq;

                irq->Interrupts[tbl->SourceIndex]);

    }

}

{

    ACPI_STATUS status;

    ACPI_BUFFER abuff;

    ACPI_PCI_ROUTING_TABLE *tbl;

    abuff.Pointer = buff;

    if (ACPI_FAILURE(status)) {

        return AE_OK;

    }

            tbl = (ACPI_PCI_ROUTING_TABLE *)

            ((char *)tbl + tbl->Length))

    {

        ACPI_HANDLE src_handle;

            add_irq(tbl->Address >> 16, tbl->Pin, tbl->SourceIndex);

            continue;

        }

        if (ACPI_FAILURE(status)) {

            printf("Failed AcpiGetHandle\n");

            continue;

        }

        status = AcpiWalkResources(src_handle, METHOD_NAME__CRS,

                get_irq_resource, tbl);

        if (ACPI_FAILURE(status)) {

            printf("Failed IRQ resource\n");

            continue;

        }

    }

}

                UINT32 level,

                void *context,

                void **retval)

{

    int i;

    static unsigned called;

        dbgprintf("ACPI: Warning! Multi rooted PCI is not supported!\n");

        return AE_OK;

    }

        irqtable[i] = -1;

}

                UINT32 level,

                void *context,

                void **retval)

{

    /* skip pci root when we get to it again */

    if (handle == pci_root_handle)

        return AE_OK;

}

{

    ACPI_STATUS status;

    status = AcpiGetDevices("PNP0A03", add_pci_root_dev, NULL, NULL);

    if (status != AE_OK) {

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

                   AcpiFormatException(status));

          return;

    }

    status = AcpiGetDevices(NULL, add_pci_dev, NULL, NULL);

//    assert(ACPI_SUCCESS(status));

}

{

    size_t len = strlen (str) + 1;

    char *copy = malloc(len);

    if (copy)

    {

        memcpy (copy, str, len);

    }

    return copy;

}