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


#include 
#include 
#include 
#include 
#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)
 
LIST_HEAD(acpi_device_list);
LIST_HEAD(acpi_bus_id_list);
LIST_HEAD(dmdev_tree);
 
 
struct acpi_device_bus_id
{
    char bus_id[15];
    unsigned int instance_no;
    struct list_head node;
};
 
 
#define ACPI_NS_ROOT_PATH       "\\"
#define ACPI_NS_SYSTEM_BUS      "_SB_"
 
enum acpi_irq_model_id {
	ACPI_IRQ_MODEL_PIC = 0,
	ACPI_IRQ_MODEL_IOAPIC,
	ACPI_IRQ_MODEL_IOSAPIC,
	ACPI_IRQ_MODEL_PLATFORM,
	ACPI_IRQ_MODEL_COUNT
};
 
enum acpi_bus_removal_type {
    ACPI_BUS_REMOVAL_NORMAL = 0,
    ACPI_BUS_REMOVAL_EJECT,
    ACPI_BUS_REMOVAL_SUPRISE,
    ACPI_BUS_REMOVAL_TYPE_COUNT
};
 
 
#define PCI_MAX_DEVICES 32
#define PCI_MAX_PINS    4
 
#define IRQ_TABLE_ENTRIES   (PCI_MAX_DEVICES * PCI_MAX_PINS)
 
static int irqtable[IRQ_TABLE_ENTRIES];
static ACPI_HANDLE pci_root_handle;
 
 
#define  addr_offset(addr, off) \
    (addr_t)((addr_t)(addr) + (addr_t)(off))
 
//#define acpi_remap( addr ) \
//    (addr_t)((addr_t)(addr) + OS_BASE)
 
#define acpi_remap( addr ) MapIoMem((void*)(addr),4096, 0x01)
 
char* strdup(const char *str);
int sprintf(char *buf, const char *fmt, ...);
 
void print_pci_irqs();
 
 
struct acpi_device *acpi_root;
 
extern struct resource iomem_resource;
extern struct resource ioport_resource;
 
enum pic_mode
{
    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();
 
int write_device_dat(char *path);
 
 
static void set_pic_mode(enum pic_mode mode)
{
    ACPI_OBJECT arg1;
    ACPI_OBJECT_LIST args;
    ACPI_STATUS as;
 
    arg1.Type = ACPI_TYPE_INTEGER;
    arg1.Integer.Value = mode;
    args.Count = 1;
    args.Pointer = &arg1;
 
    as = AcpiEvaluateObject(ACPI_ROOT_OBJECT, "_PIC", &args, NULL);
    /*
     * 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");
}
 
 
 
static bool pci_use_crs = false;
 
#define IORESOURCE_BUS      0x00001000
 
 
extern struct list_head acpi_pci_roots;
 
#define ACPI_PCI_ROOT_CLASS     "pci_bridge"
#define ACPI_PCI_ROOT_DEVICE_NAME   "PCI Root Bridge"
 
static ACPI_STATUS
get_root_bridge_busnr_callback(ACPI_RESOURCE *resource, void *data)
{
    struct resource *res = data;
    ACPI_RESOURCE_ADDRESS64 address;
 
    if (resource->Type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
        resource->Type != ACPI_RESOURCE_TYPE_ADDRESS32 &&
        resource->Type != ACPI_RESOURCE_TYPE_ADDRESS64)
        return AE_OK;
 
    AcpiResourceToAddress64(resource, &address);
    if ((address.AddressLength > 0) &&
        (address.ResourceType == ACPI_BUS_NUMBER_RANGE)) {
        res->start = address.Minimum;
        res->end = address.Minimum + address.AddressLength - 1;
    }
 
    return AE_OK;
}
 
 
 
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;
    if (res->start == -1)
        return AE_ERROR;
    return AE_OK;
}
 
 
static void acpi_pci_bridge_scan(struct acpi_device *device)
{
    int status;
    struct acpi_device *child = NULL;
 
    if (device->flags.bus_address)
        if (device->parent && device->parent->ops.bind) {
            status = device->parent->ops.bind(device);
            if (!status) {
                list_for_each_entry(child, &device->children, node)
                    acpi_pci_bridge_scan(child);
            }
        }
}
 
 
 
struct pci_root_info
{
    struct acpi_device *bridge;
    char *name;
    unsigned int res_num;
    struct resource *res;
    struct pci_bus *bus;
    int busnum;
};
 
 
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));
    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;
}
 
 
static ACPI_STATUS
count_resource(ACPI_RESOURCE *acpi_res, void *data)
{
    struct pci_root_info *info = data;
    ACPI_RESOURCE_ADDRESS64 addr;
    ACPI_STATUS status;
 
    status = resource_to_addr(acpi_res, &addr);
    if (ACPI_SUCCESS(status))
        info->res_num++;
    return AE_OK;
}
 
 
static ACPI_STATUS setup_resource(ACPI_RESOURCE *acpi_res, void *data)
{
    struct pci_root_info *info = data;
    struct resource *res;
    struct acpi_resource_address64 addr;
    ACPI_STATUS status;
    unsigned long flags;
    u64 start, end;
 
    status = resource_to_addr(acpi_res, &addr);
    if (!ACPI_SUCCESS(status))
        return AE_OK;
 
    if (addr.ResourceType == ACPI_MEMORY_RANGE)
    {
        flags = IORESOURCE_MEM;
        if (addr.Info.Mem.Caching == ACPI_PREFETCHABLE_MEMORY)
            flags |= IORESOURCE_PREFETCH;
    }
    else if (addr.ResourceType == ACPI_IO_RANGE)
    {
        flags = IORESOURCE_IO;
    } else
        return AE_OK;
 
    start = addr.Minimum + addr.TranslationOffset;
    end = addr.Maximum + addr.TranslationOffset;
 
    res = &info->res[info->res_num];
    res->name = info->name;
    res->flags = flags;
    res->start = start;
    res->end = end;
    res->child = NULL;
 
    if (!pci_use_crs) {
        printk("host bridge window %pR (ignored)\n", res);
        return AE_OK;
    }
 
    info->res_num++;
    if (addr.TranslationOffset)
        dev_info(NULL, "host bridge window %pR "
             "(PCI address [%#llx-%#llx])\n",
             res, res->start - addr.TranslationOffset,
             res->end - addr.TranslationOffset);
    else
        dev_info(NULL,
             "host bridge window %pR\n", res);
 
    return AE_OK;
}
 
 
 
static void
get_current_resources(struct acpi_device *device, int busnum,
            int domain, struct pci_bus *bus)
{
    struct pci_root_info info;
    size_t size;
 
    char buf[64];
 
//    if (pci_use_crs)
//        pci_bus_remove_resources(bus);
 
    info.bridge = device;
    info.bus = bus;
    info.res_num = 0;
    AcpiWalkResources(device->handle, METHOD_NAME__CRS, count_resource,
                &info);
    if (!info.res_num)
        return;
 
    size = sizeof(*info.res) * info.res_num;
    info.res = kmalloc(size, GFP_KERNEL);
    if (!info.res)
        goto res_alloc_fail;
 
    sprintf(buf,"PCI Bus %04x:%02x", domain, busnum);
 
    info.name = strdup(buf);
 
    if (!info.name)
        goto name_alloc_fail;
 
    info.res_num = 0;
    AcpiWalkResources(device->handle, METHOD_NAME__CRS, setup_resource,
                &info);
 
    return;
 
name_alloc_fail:
    kfree(info.res);
res_alloc_fail:
    return;
}
 
 
struct pci_ops pci_root_ops = {
    .read = NULL,
    .write = NULL,
};
 
 
struct pci_bus*  pci_acpi_scan_root(struct acpi_pci_root *root)
{
    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;
 
    if (domain ) {
        printk(KERN_WARNING "pci_bus %04x:%02x: "
               "ignored (multiple domains not supported)\n",
               domain, busnum);
        return NULL;
    }
 
	node = -1;
    /* 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.
     */
    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->domain = domain;
    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);
        }
    }
 
    if (!bus)
        kfree(sd);
 
    if (bus && node != -1) {
        printk("on NUMA node %d\n", node);
    }
 
    return bus;
}
 
 
 
static int acpi_pci_root_add(struct acpi_device *device)
{
    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;
 
    root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
    if (!root)
        return -ENOMEM;
 
    segment = 0;
    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;
    }
 
    /* Check _CRS first, then _BBN.  If no _BBN, default to zero. */
    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;
        }
    }
 
    INIT_LIST_HEAD(&root->node);
    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.
     */
 
    /* TBD: Locking */
    list_add_tail(&root->node, &acpi_pci_roots);
 
    printk(KERN_INFO PREFIX "%s [%s] (domain %04x %pR)\n",
           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).
     */
 
    root->bus = pci_acpi_scan_root(root);
    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);
 
    return 0;
 
end:
    if (!list_empty(&root->node))
        list_del(&root->node);
    kfree(root);
    return result;
}
 
 
static const struct acpi_device_ids root_device_ids[] =
{
    {"PNP0A03", 0},
    {"",        0},
};
 
void acpi_init_pci(struct acpi_device *device)
{
    struct acpi_device *child;
 
    if ( !acpi_match_device_ids(device, root_device_ids) )
    {
        dbgprintf(PREFIX "PCI root %s\n", device->pnp.bus_id);
        acpi_pci_root_add(device);
    };
 
    list_for_each_entry(child, &device->children, node)
    {
        acpi_init_pci(child);
    };
 
};
 
 
u32_t drvEntry(int action, char *cmdline)
{
    u32_t retval;
 
    ACPI_STATUS status;
 
    int i;
 
    if(action != 1)
        return 0;
 
    if( !dbg_open("/rd/1/drivers/acpi.log") )
    {
        printf("Can't open /rd/1/drivers/acpi.log\nExit\n");
        return 0;
    }
 
 
 
 
 
 
 
    status = AcpiInitializeSubsystem();
    if (status != AE_OK) {
          dbgprintf("AcpiInitializeSubsystem failed (%s)\n",
                     AcpiFormatException(status));
          goto err;
    }
 
    status = AcpiInitializeTables (NULL, 16, FALSE);
    if (status != AE_OK) {
          dbgprintf("AcpiInitializeTables failed (%s)\n",
                     AcpiFormatException(status));
          goto err;
    }
 
    status = AcpiLoadTables();
    if (status != AE_OK) {
          dbgprintf("AcpiLoadTables failed (%s)\n",
                     AcpiFormatException(status));
          goto err;
    }
 
//    u32_t mode = ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE;
 
    status = AcpiEnableSubsystem(ACPI_NO_HANDLER_INIT | ACPI_NO_HARDWARE_INIT);
    if (status != AE_OK) {
        dbgprintf("AcpiEnableSubsystem failed (%s)\n",
            AcpiFormatException(status));
        goto err;
    }
 
    status = AcpiInitializeObjects (ACPI_FULL_INITIALIZATION);
    if (ACPI_FAILURE (status))
    {
        dbgprintf("AcpiInitializeObjects failed (%s)\n",
            AcpiFormatException(status));
        goto err;
    }
 
 
    set_pic_mode(IO_APIC);
 
    acpi_scan();
 
    acpi_init_pci(acpi_root);
 
    print_pci_irqs();
 
    create_dm_list();
 
    print_dm_list();
 
    write_device_dat("/RD/1/DRIVERS/DEVICES.DAT");
 
err:
 
    return 0;
 
};
 
char* strdup(const char *str)
{
    size_t len = strlen (str) + 1;
    char *copy = malloc(len);
    if (copy)
    {
        memcpy (copy, str, len);
    }
    return copy;
}
 
 
static void dm_add_pci_bus(struct pci_bus *bus)
{
    struct pci_bus *tbus;
    struct pci_dev *dev;
    dmdev_t        *dmdev;
 
    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);
 
    list_for_each_entry(dev, &bus->devices, bus_list)
    {
        dmdev = (dmdev_t*)kzalloc(sizeof(dmdev_t),GFP_KERNEL);
 
        INIT_LIST_HEAD(&dmdev->list);
        dmdev->type = 1;
        dmdev->acpi_dev = dev->acpi_dev;
        dmdev->pci_dev = dev;
        list_add_tail(&dmdev->list, &dmdev_tree);
    };
 
    list_for_each_entry(tbus, &bus->children, node)
    {
        dm_add_pci_bus(tbus);
    };
 
};
 
static ACPI_STATUS
count_dev_resources(ACPI_RESOURCE *acpi_res, void *data)
{
    (*(int*)data)++;
    return AE_OK;
}
 
 
static void dm_add_acpi(struct acpi_device *device)
{
    struct acpi_device *child;
    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)
        {
            kfree(info);
            return;
        };
    };
 
    kfree(info);
 
    if(device->pci_dev == NULL)
    {
        AcpiWalkResources(device->handle, METHOD_NAME__CRS,
                          count_dev_resources, &res_num);
 
        if(res_num != 0)
        {
            dmdev = (dmdev_t*)kzalloc(sizeof(dmdev_t),GFP_KERNEL);
 
            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)
    {
        dm_add_acpi(child);
    };
};
 
static void create_dm_list()
{
    struct acpi_pci_root *root;
 
 
    list_for_each_entry(root, &acpi_pci_roots, node)
    {
        struct pci_bus *pbus, *tbus;
        struct pci_dev *dev;
 
        pbus = root->bus;
 
        dm_add_pci_bus(pbus);
    };
 
    dm_add_acpi(acpi_root);
};
 
static void print_pci_resource(struct resource *res)
{
    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
print_acpi_resource(ACPI_RESOURCE *acpi_res, void *data)
{
    ACPI_RESOURCE_ADDRESS64 addr;
    ACPI_STATUS status;
    int i;
 
    switch (acpi_res->Type)
    {
        case ACPI_RESOURCE_TYPE_IRQ:
        {
            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;
 
        case ACPI_RESOURCE_TYPE_DMA:
        {
            ACPI_RESOURCE_DMA *dma_data = (ACPI_RESOURCE_DMA*) &acpi_res->Data;
            for(i=0; i < dma_data->ChannelCount; i++)
            {
                dbgprintf(" DMA %s channel %d\n",
                          dma_data->Type == ACPI_TYPE_A ? "Type A":
                          dma_data->Type == ACPI_TYPE_B ? "Type B" :
                          dma_data->Type == ACPI_TYPE_F ? "Type F" : "",
                          dma_data->Channels[i]);
            }
        };
        break;
 
        case ACPI_RESOURCE_TYPE_IO:
        {
            ACPI_RESOURCE_IO *io_data = (ACPI_RESOURCE_IO*) &acpi_res->Data;
 
            dbgprintf(" IO range 0%x-0%x\n",io_data->Minimum,
                       io_data->Minimum+io_data->AddressLength-1);
        }
        break;
 
        case ACPI_RESOURCE_TYPE_FIXED_IO:
        {
            ACPI_RESOURCE_FIXED_IO *io_data = (ACPI_RESOURCE_FIXED_IO*) &acpi_res->Data;
            dbgprintf(" Fixed IO range 0%x-0%x\n",io_data->Address,
                       io_data->Address+io_data->AddressLength-1);
        };
        break;
 
        case ACPI_RESOURCE_TYPE_MEMORY24:
        case ACPI_RESOURCE_TYPE_MEMORY32:
        case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
        {
            ACPI_RESOURCE_ADDRESS64 addr64;
            resource_to_addr(acpi_res, &addr64);
            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:
        {
            ACPI_RESOURCE_ADDRESS64 addr64;
            ACPI_STATUS status;
 
            status = AcpiResourceToAddress64(acpi_res, &addr64);
            if (ACPI_SUCCESS(status))
            {
                dbgprintf(" Address range 0%x-0%x\n",
                       (uint32_t)addr64.Minimum, (uint32_t)addr64.Maximum);
            }
        };
        break;
    };
 
    return AE_OK;
};
 
 
static void print_dm_list()
{
    struct pci_dev     *pcidev;
    struct acpi_device *acpidev;
    dmdev_t  *dmdev;
    uint32_t  i;
 
    dbgprintf("\nDevices:\n");
 
    list_for_each_entry(dmdev, &dmdev_tree, list)
    {
        switch(dmdev->type)
        {
            case 0:
               if(dmdev->acpi_dev != NULL)
               {
                    acpidev = dmdev->acpi_dev;
                    dbgprintf("\n%s\n", acpidev->pnp.bus_id);
                    AcpiWalkResources(acpidev->handle, METHOD_NAME__CRS,
                                      print_acpi_resource, NULL);
               };
               break;
 
            case 1:
               if(dmdev->pci_dev != NULL)
               {
                   pcidev = dmdev->pci_dev;
                   dbgprintf("\nPCI_%x_%x bus:%d devfn: %x\n",
                               pcidev->vendor, pcidev->device,
                               pcidev->busnr, pcidev->devfn);
 
                   for(i = 0; i < DEVICE_COUNT_RESOURCE; i++)
                       print_pci_resource(&pcidev->resource[i]);
 
                   if(pcidev->pin)
                       dbgprintf("  APIC IRQ: %d\n", acpi_get_irq(pcidev));
               };
               break;
        };
    };
};
 
 
typedef struct
{
    uint32_t  busaddr;
    uint32_t  devid;
    uint32_t  irq;
    uint32_t  unused;
}devinfo_t;
 
#pragma pack(push, 1)
typedef struct
{
  char sec;
  char min;
  char hour;
  char rsv;
}detime_t;
 
typedef struct
{
  char  day;
  char  month;
  short year;
}dedate_t;
 
typedef struct
{
  unsigned    attr;
  unsigned    flags;
  union
  {
     detime_t  ctime;
     unsigned  cr_time;
  };
  union
  {
     dedate_t  cdate;
     unsigned  cr_date;
  };
  union
  {
     detime_t  atime;
     unsigned  acc_time;
  };
  union
  {
     dedate_t  adate;
     unsigned  acc_date;
  };
  union
  {
     detime_t  mtime;
     unsigned  mod_time;
  };
  union
  {
     dedate_t  mdate;
     unsigned  mod_date;
  };
  unsigned    size;
  unsigned    size_high;
} FILEINFO;
 
#pragma pack(pop)
 
 
int write_device_dat(char *path)
{
    struct pci_dev   *pcidev;
    dmdev_t          *dmdev;
    devinfo_t        *data;
    int               writes;
    int               len;
    int i = 0;
 
    list_for_each_entry(dmdev, &dmdev_tree, list)
    {
        if(dmdev->type ==1)
        {
            if(dmdev->pci_dev != NULL)
            {
                pcidev = dmdev->pci_dev;
                if(pcidev->pin)
                    i++;
            };
        };
    };
 
    len = sizeof(devinfo_t)*i + 4;
    data = (devinfo_t*)malloc(len);
 
    i = 0;
 
    list_for_each_entry(dmdev, &dmdev_tree, list)
    {
        if(dmdev->type == 1)
        {
 
            if(dmdev->pci_dev != NULL)
            {
                pcidev = dmdev->pci_dev;
                if(pcidev->pin && (acpi_get_irq(pcidev) != -1) )
                {
                    data[i].busaddr = (pcidev->busnr<<8)|pcidev->devfn;
                    data[i].devid   = ((uint32_t)pcidev->device<<16) |
                                       pcidev->vendor;
                    data[i].irq     =  acpi_get_irq(pcidev);
                    data[i].unused  =  0;
                    i++;
                }
            };
        };
    };
 
    data[i].busaddr = -1;
 
    FILEINFO info;
 
    int offset = 0;
 
    if(get_fileinfo(path,&info))
    {
        if( create_file(path))
        {
            free(data);
            return false;
        }
    }
    else
        set_file_size(path, 0);
 
    write_file(path, data, 0, len, &writes);
 
    return true;
};

Rev 2187	Rev 2216
1	#include	1	#include
2	#include	2	#include
3	#include	3	#include
4	#include	4	#include
5	#include	5	#include
6		6
7	#include "acpi.h"	7	#include "acpi.h"
8	#include "acpi_bus.h"	8	#include "acpi_bus.h"
9	#include "dmdev.h"	9	#include "dmdev.h"
10		10
11	#define PREFIX "ACPI: "	11	#define PREFIX "ACPI: "
12		12
13	#define ACPI_BUS_CLASS "system_bus"	13	#define ACPI_BUS_CLASS "system_bus"
14	#define ACPI_BUS_HID "KLBSYBUS"	14	#define ACPI_BUS_HID "KLBSYBUS"
15	#define ACPI_BUS_DEVICE_NAME "System Bus"	15	#define ACPI_BUS_DEVICE_NAME "System Bus"
16		16
17		17
18	#define ACPI_IS_ROOT_DEVICE(device) (!(device)->parent)	18	#define ACPI_IS_ROOT_DEVICE(device) (!(device)->parent)
19		19
20	LIST_HEAD(acpi_device_list);	20	LIST_HEAD(acpi_device_list);
21	LIST_HEAD(acpi_bus_id_list);	21	LIST_HEAD(acpi_bus_id_list);
22	LIST_HEAD(dmdev_tree);	22	LIST_HEAD(dmdev_tree);
23		23
24		24
25	struct acpi_device_bus_id	25	struct acpi_device_bus_id
26	{	26	{
27	char bus_id[15];	27	char bus_id[15];
28	unsigned int instance_no;	28	unsigned int instance_no;
29	struct list_head node;	29	struct list_head node;
30	};	30	};
31		31
32		32
33	#define ACPI_NS_ROOT_PATH "\\"	33	#define ACPI_NS_ROOT_PATH "\\"
34	#define ACPI_NS_SYSTEM_BUS "_SB_"	34	#define ACPI_NS_SYSTEM_BUS "_SB_"
35		35
36	enum acpi_irq_model_id {	36	enum acpi_irq_model_id {
37	ACPI_IRQ_MODEL_PIC = 0,	37	ACPI_IRQ_MODEL_PIC = 0,
38	ACPI_IRQ_MODEL_IOAPIC,	38	ACPI_IRQ_MODEL_IOAPIC,
39	ACPI_IRQ_MODEL_IOSAPIC,	39	ACPI_IRQ_MODEL_IOSAPIC,
40	ACPI_IRQ_MODEL_PLATFORM,	40	ACPI_IRQ_MODEL_PLATFORM,
41	ACPI_IRQ_MODEL_COUNT	41	ACPI_IRQ_MODEL_COUNT
42	};	42	};
43		43
44	enum acpi_bus_removal_type {	44	enum acpi_bus_removal_type {
45	ACPI_BUS_REMOVAL_NORMAL = 0,	45	ACPI_BUS_REMOVAL_NORMAL = 0,
46	ACPI_BUS_REMOVAL_EJECT,	46	ACPI_BUS_REMOVAL_EJECT,
47	ACPI_BUS_REMOVAL_SUPRISE,	47	ACPI_BUS_REMOVAL_SUPRISE,
48	ACPI_BUS_REMOVAL_TYPE_COUNT	48	ACPI_BUS_REMOVAL_TYPE_COUNT
49	};	49	};
50		50
51		51
52	#define PCI_MAX_DEVICES 32	52	#define PCI_MAX_DEVICES 32
53	#define PCI_MAX_PINS 4	53	#define PCI_MAX_PINS 4
54		54
55	#define IRQ_TABLE_ENTRIES (PCI_MAX_DEVICES * PCI_MAX_PINS)	55	#define IRQ_TABLE_ENTRIES (PCI_MAX_DEVICES * PCI_MAX_PINS)
56		56
57	static int irqtable[IRQ_TABLE_ENTRIES];	57	static int irqtable[IRQ_TABLE_ENTRIES];
58	static ACPI_HANDLE pci_root_handle;	58	static ACPI_HANDLE pci_root_handle;
59		59
60		60
61	#define addr_offset(addr, off) \	61	#define addr_offset(addr, off) \
62	(addr_t)((addr_t)(addr) + (addr_t)(off))	62	(addr_t)((addr_t)(addr) + (addr_t)(off))
63		63
64	//#define acpi_remap( addr ) \	64	//#define acpi_remap( addr ) \
65	// (addr_t)((addr_t)(addr) + OS_BASE)	65	// (addr_t)((addr_t)(addr) + OS_BASE)
66		66
67	#define acpi_remap( addr ) MapIoMem((void*)(addr),4096, 0x01)	67	#define acpi_remap( addr ) MapIoMem((void*)(addr),4096, 0x01)
68		68
69	char* strdup(const char *str);	69	char* strdup(const char *str);
70		70	int sprintf(char buf, const char fmt, ...);
-		71
71	void print_pci_irqs();	72	void print_pci_irqs();
72		73
73		74
74	struct acpi_device *acpi_root;	75	struct acpi_device *acpi_root;
75		76
76	extern struct resource iomem_resource;	77	extern struct resource iomem_resource;
77	extern struct resource ioport_resource;	78	extern struct resource ioport_resource;
78		79
79	enum pic_mode	80	enum pic_mode
80	{	81	{
81	IO_PIC = 0,	82	IO_PIC = 0,
82	IO_APIC	83	IO_APIC
83	};	84	};
84		85
85	static ACPI_STATUS	86	static ACPI_STATUS
86	resource_to_addr(ACPI_RESOURCE resource, ACPI_RESOURCE_ADDRESS64 addr);	87	resource_to_addr(ACPI_RESOURCE resource, ACPI_RESOURCE_ADDRESS64 addr);
87		88
88	static void create_dm_list();	89	static void create_dm_list();
89		90
90	static void print_dm_list();	91	static void print_dm_list();
91		92
92	int write_device_dat(char *path);	93	int write_device_dat(char *path);
93		94
94		95
95	static void set_pic_mode(enum pic_mode mode)	96	static void set_pic_mode(enum pic_mode mode)
96	{	97	{
97	ACPI_OBJECT arg1;	98	ACPI_OBJECT arg1;
98	ACPI_OBJECT_LIST args;	99	ACPI_OBJECT_LIST args;
99	ACPI_STATUS as;	100	ACPI_STATUS as;
100		101
101	arg1.Type = ACPI_TYPE_INTEGER;	102	arg1.Type = ACPI_TYPE_INTEGER;
102	arg1.Integer.Value = mode;	103	arg1.Integer.Value = mode;
103	args.Count = 1;	104	args.Count = 1;
104	args.Pointer = &arg1;	105	args.Pointer = &arg1;
105		106
106	as = AcpiEvaluateObject(ACPI_ROOT_OBJECT, "_PIC", &args, NULL);	107	as = AcpiEvaluateObject(ACPI_ROOT_OBJECT, "_PIC", &args, NULL);
107	/*	108	/*
108	* We can silently ignore failure as it may not be implemented, ACPI should	109	* We can silently ignore failure as it may not be implemented, ACPI should
109	* provide us with correct information anyway	110	* provide us with correct information anyway
110	*/	111	*/
111	if (ACPI_SUCCESS(as))	112	if (ACPI_SUCCESS(as))
112	dbgprintf(PREFIX "machine set to %s mode\n", mode ? "APIC" : "PIC");	113	dbgprintf(PREFIX "machine set to %s mode\n", mode ? "APIC" : "PIC");
113	}	114	}
114		115
115		116
116		117
117	static bool pci_use_crs = false;	118	static bool pci_use_crs = false;
118		119
119	#define IORESOURCE_BUS 0x00001000	120	#define IORESOURCE_BUS 0x00001000
120		121
121		122
122	extern struct list_head acpi_pci_roots;	123	extern struct list_head acpi_pci_roots;
123		124
124	#define ACPI_PCI_ROOT_CLASS "pci_bridge"	125	#define ACPI_PCI_ROOT_CLASS "pci_bridge"
125	#define ACPI_PCI_ROOT_DEVICE_NAME "PCI Root Bridge"	126	#define ACPI_PCI_ROOT_DEVICE_NAME "PCI Root Bridge"
126		127
127	static ACPI_STATUS	128	static ACPI_STATUS
128	get_root_bridge_busnr_callback(ACPI_RESOURCE resource, void data)	129	get_root_bridge_busnr_callback(ACPI_RESOURCE resource, void data)
129	{	130	{
130	struct resource *res = data;	131	struct resource *res = data;
131	ACPI_RESOURCE_ADDRESS64 address;	132	ACPI_RESOURCE_ADDRESS64 address;
132		133
133	if (resource->Type != ACPI_RESOURCE_TYPE_ADDRESS16 &&	134	if (resource->Type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
134	resource->Type != ACPI_RESOURCE_TYPE_ADDRESS32 &&	135	resource->Type != ACPI_RESOURCE_TYPE_ADDRESS32 &&
135	resource->Type != ACPI_RESOURCE_TYPE_ADDRESS64)	136	resource->Type != ACPI_RESOURCE_TYPE_ADDRESS64)
136	return AE_OK;	137	return AE_OK;
137		138
138	AcpiResourceToAddress64(resource, &address);	139	AcpiResourceToAddress64(resource, &address);
139	if ((address.AddressLength > 0) &&	140	if ((address.AddressLength > 0) &&
140	(address.ResourceType == ACPI_BUS_NUMBER_RANGE)) {	141	(address.ResourceType == ACPI_BUS_NUMBER_RANGE)) {
141	res->start = address.Minimum;	142	res->start = address.Minimum;
142	res->end = address.Minimum + address.AddressLength - 1;	143	res->end = address.Minimum + address.AddressLength - 1;
143	}	144	}
144		145
145	return AE_OK;	146	return AE_OK;
146	}	147	}
147		148
148		149
149		150
150	static ACPI_STATUS try_get_root_bridge_busnr(ACPI_HANDLE handle,	151	static ACPI_STATUS try_get_root_bridge_busnr(ACPI_HANDLE handle,
151	struct resource *res)	152	struct resource *res)
152	{	153	{
153	ACPI_STATUS status;	154	ACPI_STATUS status;
154		155
155	res->start = -1;	156	res->start = -1;
156	status =	157	status =
157	AcpiWalkResources(handle, METHOD_NAME__CRS,	158	AcpiWalkResources(handle, METHOD_NAME__CRS,
158	get_root_bridge_busnr_callback, res);	159	get_root_bridge_busnr_callback, res);
159	if (ACPI_FAILURE(status))	160	if (ACPI_FAILURE(status))
160	return status;	161	return status;
161	if (res->start == -1)	162	if (res->start == -1)
162	return AE_ERROR;	163	return AE_ERROR;
163	return AE_OK;	164	return AE_OK;
164	}	165	}
165		166
166		167
167	static void acpi_pci_bridge_scan(struct acpi_device *device)	168	static void acpi_pci_bridge_scan(struct acpi_device *device)
168	{	169	{
169	int status;	170	int status;
170	struct acpi_device *child = NULL;	171	struct acpi_device *child = NULL;
171		172
172	if (device->flags.bus_address)	173	if (device->flags.bus_address)
173	if (device->parent && device->parent->ops.bind) {	174	if (device->parent && device->parent->ops.bind) {
174	status = device->parent->ops.bind(device);	175	status = device->parent->ops.bind(device);
175	if (!status) {	176	if (!status) {
176	list_for_each_entry(child, &device->children, node)	177	list_for_each_entry(child, &device->children, node)
177	acpi_pci_bridge_scan(child);	178	acpi_pci_bridge_scan(child);
178	}	179	}
179	}	180	}
180	}	181	}
181		182
182		183
183		184
184	struct pci_root_info	185	struct pci_root_info
185	{	186	{
186	struct acpi_device *bridge;	187	struct acpi_device *bridge;
187	char *name;	188	char *name;
188	unsigned int res_num;	189	unsigned int res_num;
189	struct resource *res;	190	struct resource *res;
190	struct pci_bus *bus;	191	struct pci_bus *bus;
191	int busnum;	192	int busnum;
192	};	193	};
193		194
194		195
195	static ACPI_STATUS	196	static ACPI_STATUS
196	resource_to_addr(ACPI_RESOURCE resource, ACPI_RESOURCE_ADDRESS64 addr)	197	resource_to_addr(ACPI_RESOURCE resource, ACPI_RESOURCE_ADDRESS64 addr)
197	{	198	{
198	ACPI_STATUS status;	199	ACPI_STATUS status;
199	struct acpi_resource_memory24 *memory24;	200	struct acpi_resource_memory24 *memory24;
200	struct acpi_resource_memory32 *memory32;	201	struct acpi_resource_memory32 *memory32;
201	struct acpi_resource_fixed_memory32 *fixed_memory32;	202	struct acpi_resource_fixed_memory32 *fixed_memory32;
202		203
203	memset(addr, 0, sizeof(*addr));	204	memset(addr, 0, sizeof(*addr));
204	switch (resource->Type) {	205	switch (resource->Type) {
205	case ACPI_RESOURCE_TYPE_MEMORY24:	206	case ACPI_RESOURCE_TYPE_MEMORY24:
206	memory24 = &resource->Data.Memory24;	207	memory24 = &resource->Data.Memory24;
207	addr->ResourceType = ACPI_MEMORY_RANGE;	208	addr->ResourceType = ACPI_MEMORY_RANGE;
208	addr->Minimum = memory24->Minimum;	209	addr->Minimum = memory24->Minimum;
209	addr->AddressLength = memory24->AddressLength;	210	addr->AddressLength = memory24->AddressLength;
210	addr->Maximum = addr->Minimum + addr->AddressLength - 1;	211	addr->Maximum = addr->Minimum + addr->AddressLength - 1;
211	return AE_OK;	212	return AE_OK;
212	case ACPI_RESOURCE_TYPE_MEMORY32:	213	case ACPI_RESOURCE_TYPE_MEMORY32:
213	memory32 = &resource->Data.Memory32;	214	memory32 = &resource->Data.Memory32;
214	addr->ResourceType = ACPI_MEMORY_RANGE;	215	addr->ResourceType = ACPI_MEMORY_RANGE;
215	addr->Minimum = memory32->Minimum;	216	addr->Minimum = memory32->Minimum;
216	addr->AddressLength = memory32->AddressLength;	217	addr->AddressLength = memory32->AddressLength;
217	addr->Maximum = addr->Minimum + addr->AddressLength - 1;	218	addr->Maximum = addr->Minimum + addr->AddressLength - 1;
218	return AE_OK;	219	return AE_OK;
219	case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:	220	case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
220	fixed_memory32 = &resource->Data.FixedMemory32;	221	fixed_memory32 = &resource->Data.FixedMemory32;
221	addr->ResourceType = ACPI_MEMORY_RANGE;	222	addr->ResourceType = ACPI_MEMORY_RANGE;
222	addr->Minimum = fixed_memory32->Address;	223	addr->Minimum = fixed_memory32->Address;
223	addr->AddressLength = fixed_memory32->AddressLength;	224	addr->AddressLength = fixed_memory32->AddressLength;
224	addr->Maximum = addr->Minimum + addr->AddressLength - 1;	225	addr->Maximum = addr->Minimum + addr->AddressLength - 1;
225	return AE_OK;	226	return AE_OK;
226	case ACPI_RESOURCE_TYPE_ADDRESS16:	227	case ACPI_RESOURCE_TYPE_ADDRESS16:
227	case ACPI_RESOURCE_TYPE_ADDRESS32:	228	case ACPI_RESOURCE_TYPE_ADDRESS32:
228	case ACPI_RESOURCE_TYPE_ADDRESS64:	229	case ACPI_RESOURCE_TYPE_ADDRESS64:
229	status = AcpiResourceToAddress64(resource, addr);	230	status = AcpiResourceToAddress64(resource, addr);
230	if (ACPI_SUCCESS(status) &&	231	if (ACPI_SUCCESS(status) &&
231	(addr->ResourceType == ACPI_MEMORY_RANGE \|\|	232	(addr->ResourceType == ACPI_MEMORY_RANGE \|\|
232	addr->ResourceType == ACPI_IO_RANGE) &&	233	addr->ResourceType == ACPI_IO_RANGE) &&
233	addr->AddressLength > 0) {	234	addr->AddressLength > 0) {
234	return AE_OK;	235	return AE_OK;
235	}	236	}
236	break;	237	break;
237	}	238	}
238	return AE_ERROR;	239	return AE_ERROR;
239	}	240	}
240		241
241		242
242	static ACPI_STATUS	243	static ACPI_STATUS
243	count_resource(ACPI_RESOURCE acpi_res, void data)	244	count_resource(ACPI_RESOURCE acpi_res, void data)
244	{	245	{
245	struct pci_root_info *info = data;	246	struct pci_root_info *info = data;
246	ACPI_RESOURCE_ADDRESS64 addr;	247	ACPI_RESOURCE_ADDRESS64 addr;
247	ACPI_STATUS status;	248	ACPI_STATUS status;
248		249
249	status = resource_to_addr(acpi_res, &addr);	250	status = resource_to_addr(acpi_res, &addr);
250	if (ACPI_SUCCESS(status))	251	if (ACPI_SUCCESS(status))
251	info->res_num++;	252	info->res_num++;
252	return AE_OK;	253	return AE_OK;
253	}	254	}
254		255
255		256
256	static ACPI_STATUS setup_resource(ACPI_RESOURCE acpi_res, void data)	257	static ACPI_STATUS setup_resource(ACPI_RESOURCE acpi_res, void data)
257	{	258	{
258	struct pci_root_info *info = data;	259	struct pci_root_info *info = data;
259	struct resource *res;	260	struct resource *res;
260	struct acpi_resource_address64 addr;	261	struct acpi_resource_address64 addr;
261	ACPI_STATUS status;	262	ACPI_STATUS status;
262	unsigned long flags;	263	unsigned long flags;
263	u64 start, end;	264	u64 start, end;
264		265
265	status = resource_to_addr(acpi_res, &addr);	266	status = resource_to_addr(acpi_res, &addr);
266	if (!ACPI_SUCCESS(status))	267	if (!ACPI_SUCCESS(status))
267	return AE_OK;	268	return AE_OK;
268		269
269	if (addr.ResourceType == ACPI_MEMORY_RANGE)	270	if (addr.ResourceType == ACPI_MEMORY_RANGE)
270	{	271	{
271	flags = IORESOURCE_MEM;	272	flags = IORESOURCE_MEM;
272	if (addr.Info.Mem.Caching == ACPI_PREFETCHABLE_MEMORY)	273	if (addr.Info.Mem.Caching == ACPI_PREFETCHABLE_MEMORY)
273	flags \|= IORESOURCE_PREFETCH;	274	flags \|= IORESOURCE_PREFETCH;
274	}	275	}
275	else if (addr.ResourceType == ACPI_IO_RANGE)	276	else if (addr.ResourceType == ACPI_IO_RANGE)
276	{	277	{
277	flags = IORESOURCE_IO;	278	flags = IORESOURCE_IO;
278	} else	279	} else
279	return AE_OK;	280	return AE_OK;
280		281
281	start = addr.Minimum + addr.TranslationOffset;	282	start = addr.Minimum + addr.TranslationOffset;
282	end = addr.Maximum + addr.TranslationOffset;	283	end = addr.Maximum + addr.TranslationOffset;
283		284
284	res = &info->res[info->res_num];	285	res = &info->res[info->res_num];
285	res->name = info->name;	286	res->name = info->name;
286	res->flags = flags;	287	res->flags = flags;
287	res->start = start;	288	res->start = start;
288	res->end = end;	289	res->end = end;
289	res->child = NULL;	290	res->child = NULL;
290		291
291	if (!pci_use_crs) {	292	if (!pci_use_crs) {
292	printk("host bridge window %pR (ignored)\n", res);	293	printk("host bridge window %pR (ignored)\n", res);
293	return AE_OK;	294	return AE_OK;
294	}	295	}
295		296
296	info->res_num++;	297	info->res_num++;
297	if (addr.TranslationOffset)	298	if (addr.TranslationOffset)
298	dev_info(NULL, "host bridge window %pR "	299	dev_info(NULL, "host bridge window %pR "
299	"(PCI address [%#llx-%#llx])\n",	300	"(PCI address [%#llx-%#llx])\n",
300	res, res->start - addr.TranslationOffset,	301	res, res->start - addr.TranslationOffset,
301	res->end - addr.TranslationOffset);	302	res->end - addr.TranslationOffset);
302	else	303	else
303	dev_info(NULL,	304	dev_info(NULL,
304	"host bridge window %pR\n", res);	305	"host bridge window %pR\n", res);
305		306
306	return AE_OK;	307	return AE_OK;
307	}	308	}
308		309
309		310
310		311
311	static void	312	static void
312	get_current_resources(struct acpi_device *device, int busnum,	313	get_current_resources(struct acpi_device *device, int busnum,
313	int domain, struct pci_bus *bus)	314	int domain, struct pci_bus *bus)
314	{	315	{
315	struct pci_root_info info;	316	struct pci_root_info info;
316	size_t size;	317	size_t size;
317		318
318	char buf[64];	319	char buf[64];
319		320
320	// if (pci_use_crs)	321	// if (pci_use_crs)
321	// pci_bus_remove_resources(bus);	322	// pci_bus_remove_resources(bus);
322		323
323	info.bridge = device;	324	info.bridge = device;
324	info.bus = bus;	325	info.bus = bus;
325	info.res_num = 0;	326	info.res_num = 0;
326	AcpiWalkResources(device->handle, METHOD_NAME__CRS, count_resource,	327	AcpiWalkResources(device->handle, METHOD_NAME__CRS, count_resource,
327	&info);	328	&info);
328	if (!info.res_num)	329	if (!info.res_num)
329	return;	330	return;
330		331
331	size = sizeof(info.res) info.res_num;	332	size = sizeof(info.res) info.res_num;
332	info.res = kmalloc(size, GFP_KERNEL);	333	info.res = kmalloc(size, GFP_KERNEL);
333	if (!info.res)	334	if (!info.res)
334	goto res_alloc_fail;	335	goto res_alloc_fail;
335		336
336	vsprintf(buf,"PCI Bus %04x:%02x", domain, busnum);	337	sprintf(buf,"PCI Bus %04x:%02x", domain, busnum);
-		338
337	info.name = strdup(buf);	339	info.name = strdup(buf);
338		340
339	if (!info.name)	341	if (!info.name)
340	goto name_alloc_fail;	342	goto name_alloc_fail;
341		343
342	info.res_num = 0;	344	info.res_num = 0;
343	AcpiWalkResources(device->handle, METHOD_NAME__CRS, setup_resource,	345	AcpiWalkResources(device->handle, METHOD_NAME__CRS, setup_resource,
344	&info);	346	&info);
345		347
346	return;	348	return;
347		349
348	name_alloc_fail:	350	name_alloc_fail:
349	kfree(info.res);	351	kfree(info.res);
350	res_alloc_fail:	352	res_alloc_fail:
351	return;	353	return;
352	}	354	}
353		355
354		356
355	struct pci_ops pci_root_ops = {	357	struct pci_ops pci_root_ops = {
356	.read = NULL,	358	.read = NULL,
357	.write = NULL,	359	.write = NULL,
358	};	360	};
359		361
360		362
361	struct pci_bus* pci_acpi_scan_root(struct acpi_pci_root *root)	363	struct pci_bus* pci_acpi_scan_root(struct acpi_pci_root *root)
362	{	364	{
363	struct acpi_device *device = root->device;	365	struct acpi_device *device = root->device;
364	int domain = root->segment;	366	int domain = root->segment;
365	int busnum = root->secondary.start;	367	int busnum = root->secondary.start;
366	struct pci_bus *bus;	368	struct pci_bus *bus;
367	struct pci_sysdata *sd;	369	struct pci_sysdata *sd;
368	int node = 0;	370	int node = 0;
369		371
370	if (domain ) {	372	if (domain ) {
371	printk(KERN_WARNING "pci_bus %04x:%02x: "	373	printk(KERN_WARNING "pci_bus %04x:%02x: "
372	"ignored (multiple domains not supported)\n",	374	"ignored (multiple domains not supported)\n",
373	domain, busnum);	375	domain, busnum);
374	return NULL;	376	return NULL;
375	}	377	}
376		378
377	node = -1;	379	node = -1;
378	/* Allocate per-root-bus (not per bus) arch-specific data.	380	/* Allocate per-root-bus (not per bus) arch-specific data.
379	* TODO: leak; this memory is never freed.	381	* TODO: leak; this memory is never freed.
380	* It's arguable whether it's worth the trouble to care.	382	* It's arguable whether it's worth the trouble to care.
381	*/	383	*/
382	sd = kzalloc(sizeof(*sd), GFP_KERNEL);	384	sd = kzalloc(sizeof(*sd), GFP_KERNEL);
383	if (!sd) {	385	if (!sd) {
384	printk(KERN_WARNING "pci_bus %04x:%02x: "	386	printk(KERN_WARNING "pci_bus %04x:%02x: "
385	"ignored (out of memory)\n", domain, busnum);	387	"ignored (out of memory)\n", domain, busnum);
386	return NULL;	388	return NULL;
387	}	389	}
388		390
389	sd->domain = domain;	391	sd->domain = domain;
390	sd->node = node;	392	sd->node = node;
391	/*	393	/*
392	* Maybe the desired pci bus has been already scanned. In such case	394	* Maybe the desired pci bus has been already scanned. In such case
393	* it is unnecessary to scan the pci bus with the given domain,busnum.	395	* it is unnecessary to scan the pci bus with the given domain,busnum.
394	*/	396	*/
395	bus = pci_find_bus(domain, busnum);	397	bus = pci_find_bus(domain, busnum);
396	if (bus) {	398	if (bus) {
397	/*	399	/*
398	* If the desired bus exits, the content of bus->sysdata will	400	* If the desired bus exits, the content of bus->sysdata will
399	* be replaced by sd.	401	* be replaced by sd.
400	*/	402	*/
401	memcpy(bus->sysdata, sd, sizeof(*sd));	403	memcpy(bus->sysdata, sd, sizeof(*sd));
402	kfree(sd);	404	kfree(sd);
403	} else {	405	} else {
404	bus = pci_create_bus(busnum, &pci_root_ops, sd);	406	bus = pci_create_bus(busnum, &pci_root_ops, sd);
405	if (bus) {	407	if (bus) {
406	get_current_resources(device, busnum, domain, bus);	408	get_current_resources(device, busnum, domain, bus);
407	bus->subordinate = pci_scan_child_bus(bus);	409	bus->subordinate = pci_scan_child_bus(bus);
408	}	410	}
409	}	411	}
410		412
411	if (!bus)	413	if (!bus)
412	kfree(sd);	414	kfree(sd);
413		415
414	if (bus && node != -1) {	416	if (bus && node != -1) {
415	printk("on NUMA node %d\n", node);	417	printk("on NUMA node %d\n", node);
416	}	418	}
417		419
418	return bus;	420	return bus;
419	}	421	}
420		422
421		423
422		424
423	static int acpi_pci_root_add(struct acpi_device *device)	425	static int acpi_pci_root_add(struct acpi_device *device)
424	{	426	{
425	unsigned long long segment, bus;	427	unsigned long long segment, bus;
426	ACPI_STATUS status;	428	ACPI_STATUS status;
427	int result;	429	int result;
428	struct acpi_pci_root *root;	430	struct acpi_pci_root *root;
429	ACPI_HANDLE handle;	431	ACPI_HANDLE handle;
430	struct acpi_device *child;	432	struct acpi_device *child;
431	u32 flags, base_flags;	433	u32 flags, base_flags;
432		434
433	root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);	435	root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
434	if (!root)	436	if (!root)
435	return -ENOMEM;	437	return -ENOMEM;
436		438
437	segment = 0;	439	segment = 0;
438	status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL,	440	status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL,
439	&segment);	441	&segment);
440	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {	442	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
441	printk(KERN_ERR PREFIX "can't evaluate _SEG\n");	443	printk(KERN_ERR PREFIX "can't evaluate _SEG\n");
442	result = -ENODEV;	444	result = -ENODEV;
443	goto end;	445	goto end;
444	}	446	}
445		447
446	/* Check _CRS first, then _BBN. If no _BBN, default to zero. */	448	/* Check _CRS first, then _BBN. If no _BBN, default to zero. */
447	root->secondary.flags = IORESOURCE_BUS;	449	root->secondary.flags = IORESOURCE_BUS;
448	status = try_get_root_bridge_busnr(device->handle, &root->secondary);	450	status = try_get_root_bridge_busnr(device->handle, &root->secondary);
449	if (ACPI_FAILURE(status))	451	if (ACPI_FAILURE(status))
450	{	452	{
451	/*	453	/*
452	* We need both the start and end of the downstream bus range	454	* We need both the start and end of the downstream bus range
453	* to interpret _CBA (MMCONFIG base address), so it really is	455	* to interpret _CBA (MMCONFIG base address), so it really is
454	* supposed to be in _CRS. If we don't find it there, all we	456	* supposed to be in _CRS. If we don't find it there, all we
455	* can do is assume [_BBN-0xFF] or [0-0xFF].	457	* can do is assume [_BBN-0xFF] or [0-0xFF].
456	*/	458	*/
457	root->secondary.end = 0xFF;	459	root->secondary.end = 0xFF;
458	printk(KERN_WARNING PREFIX	460	printk(KERN_WARNING PREFIX
459	"no secondary bus range in _CRS\n");	461	"no secondary bus range in _CRS\n");
460	status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN, NULL, &bus);	462	status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN, NULL, &bus);
461	if (ACPI_SUCCESS(status))	463	if (ACPI_SUCCESS(status))
462	root->secondary.start = bus;	464	root->secondary.start = bus;
463	else if (status == AE_NOT_FOUND)	465	else if (status == AE_NOT_FOUND)
464	root->secondary.start = 0;	466	root->secondary.start = 0;
465	else {	467	else {
466	printk(KERN_ERR PREFIX "can't evaluate _BBN\n");	468	printk(KERN_ERR PREFIX "can't evaluate _BBN\n");
467	result = -ENODEV;	469	result = -ENODEV;
468	goto end;	470	goto end;
469	}	471	}
470	}	472	}
471		473
472	INIT_LIST_HEAD(&root->node);	474	INIT_LIST_HEAD(&root->node);
473	root->device = device;	475	root->device = device;
474	root->segment = segment & 0xFFFF;	476	root->segment = segment & 0xFFFF;
475	strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);	477	strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);
476	strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);	478	strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);
477	device->driver_data = root;	479	device->driver_data = root;
478		480
479	/*	481	/*
480	* All supported architectures that use ACPI have support for	482	* All supported architectures that use ACPI have support for
481	* PCI domains, so we indicate this in _OSC support capabilities.	483	* PCI domains, so we indicate this in _OSC support capabilities.
482	*/	484	*/
483	// flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT;	485	// flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT;
484	// acpi_pci_osc_support(root, flags);	486	// acpi_pci_osc_support(root, flags);
485		487
486	/*	488	/*
487	* TBD: Need PCI interface for enumeration/configuration of roots.	489	* TBD: Need PCI interface for enumeration/configuration of roots.
488	*/	490	*/
489		491
490	/* TBD: Locking */	492	/* TBD: Locking */
491	list_add_tail(&root->node, &acpi_pci_roots);	493	list_add_tail(&root->node, &acpi_pci_roots);
492		494
493	printk(KERN_INFO PREFIX "%s [%s] (domain %04x %pR)\n",	495	printk(KERN_INFO PREFIX "%s [%s] (domain %04x %pR)\n",
494	acpi_device_name(device), acpi_device_bid(device),	496	acpi_device_name(device), acpi_device_bid(device),
495	root->segment, &root->secondary);	497	root->segment, &root->secondary);
496		498
497	/*	499	/*
498	* Scan the Root Bridge	500	* Scan the Root Bridge

Subversion Repositories Kolibri OS

(root)/drivers/devman/acpi.c @ 2175 – Rev 2187 → 2216