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

Subversion Repositories Kolibri OS

(root)/drivers/devman/acpi.c – Rev 9499 → 9583