arch/x86/pci/acpi.c

   1 #include <linux/pci.h>
   2 #include <linux/acpi.h>
   3 #include <linux/init.h>
   4 #include <linux/irq.h>
   5 #include <linux/dmi.h>
   6 #include <asm/numa.h>
   7 #include "pci.h"
   8
   9 struct pci_root_info {
  10         char *name;
  11         unsigned int res_num;
  12         struct resource *res;
  13         struct pci_bus *bus;
  14         int busnum;
  15 };
  16
  17 static acpi_status
  18 resource_to_addr(struct acpi_resource *resource,
  19                         struct acpi_resource_address64 *addr)
  20 {
  21         acpi_status status;
  22
  23         status = acpi_resource_to_address64(resource, addr);
  24         if (ACPI_SUCCESS(status) &&
  25             (addr->resource_type == ACPI_MEMORY_RANGE ||
  26             addr->resource_type == ACPI_IO_RANGE) &&
  27             addr->address_length > 0 &&
  28             addr->producer_consumer == ACPI_PRODUCER) {
  29                 return AE_OK;
  30         }
  31         return AE_ERROR;
  32 }
  33
  34 static acpi_status
  35 count_resource(struct acpi_resource *acpi_res, void *data)
  36 {
  37         struct pci_root_info *info = data;
  38         struct acpi_resource_address64 addr;
  39         acpi_status status;
  40
  41         if (info->res_num >= PCI_BUS_NUM_RESOURCES)
  42                 return AE_OK;
  43
  44         status = resource_to_addr(acpi_res, &addr);
  45         if (ACPI_SUCCESS(status))
  46                 info->res_num++;
  47         return AE_OK;
  48 }
  49
  50 static acpi_status
  51 setup_resource(struct acpi_resource *acpi_res, void *data)
  52 {
  53         struct pci_root_info *info = data;
  54         struct resource *res;
  55         struct acpi_resource_address64 addr;
  56         acpi_status status;
  57         unsigned long flags;
  58         struct resource *root;
  59
  60         if (info->res_num >= PCI_BUS_NUM_RESOURCES)
  61                 return AE_OK;
  62
  63         status = resource_to_addr(acpi_res, &addr);
  64         if (!ACPI_SUCCESS(status))
  65                 return AE_OK;
  66
  67         if (addr.resource_type == ACPI_MEMORY_RANGE) {
  68                 root = &iomem_resource;
  69                 flags = IORESOURCE_MEM;
  70                 if (addr.info.mem.caching == ACPI_PREFETCHABLE_MEMORY)
  71                         flags |= IORESOURCE_PREFETCH;
  72         } else if (addr.resource_type == ACPI_IO_RANGE) {
  73                 root = &ioport_resource;
  74                 flags = IORESOURCE_IO;
  75         } else
  76                 return AE_OK;
  77
  78         res = &info->res[info->res_num];
  79         res->name = info->name;
  80         res->flags = flags;
  81         res->start = addr.minimum + addr.translation_offset;
  82         res->end = res->start + addr.address_length - 1;
  83         res->child = NULL;
  84
  85         if (insert_resource(root, res)) {
  86                 printk(KERN_ERR "PCI: Failed to allocate 0x%lx-0x%lx "
  87                         "from %s for %s\n", (unsigned long) res->start,
  88                         (unsigned long) res->end, root->name, info->name);
  89         } else {
  90                 info->bus->resource[info->res_num] = res;
  91                 info->res_num++;
  92         }
  93         return AE_OK;
  94 }
  95
  96 static void
  97 adjust_transparent_bridge_resources(struct pci_bus *bus)
  98 {
  99         struct pci_dev *dev;
 100
 101         list_for_each_entry(dev, &bus->devices, bus_list) {
 102                 int i;
 103                 u16 class = dev->class >> 8;
 104
 105                 if (class == PCI_CLASS_BRIDGE_PCI && dev->transparent) {
 106                         for(i = 3; i < PCI_BUS_NUM_RESOURCES; i++)
 107                                 dev->subordinate->resource[i] =
 108                                                 dev->bus->resource[i - 3];
 109                 }
 110         }
 111 }
 112
 113 static void
 114 get_current_resources(struct acpi_device *device, int busnum,
 115                         int domain, struct pci_bus *bus)
 116 {
 117         struct pci_root_info info;
 118         size_t size;
 119
 120         info.bus = bus;
 121         info.res_num = 0;
 122         acpi_walk_resources(device->handle, METHOD_NAME__CRS, count_resource,
 123                                 &info);
 124         if (!info.res_num)
 125                 return;
 126
 127         size = sizeof(*info.res) * info.res_num;
 128         info.res = kmalloc(size, GFP_KERNEL);
 129         if (!info.res)
 130                 goto res_alloc_fail;
 131
 132         info.name = kmalloc(16, GFP_KERNEL);
 133         if (!info.name)
 134                 goto name_alloc_fail;
 135         sprintf(info.name, "PCI Bus %04x:%02x", domain, busnum);
 136
 137         info.res_num = 0;
 138         acpi_walk_resources(device->handle, METHOD_NAME__CRS, setup_resource,
 139                                 &info);
 140         if (info.res_num)
 141                 adjust_transparent_bridge_resources(bus);
 142
 143         return;
 144
 145 name_alloc_fail:
 146         kfree(info.res);
 147 res_alloc_fail:
 148         return;
 149 }
 150
 151 struct pci_bus * __devinit pci_acpi_scan_root(struct acpi_device *device, int domain, int busnum)
 152 {
 153         struct pci_bus *bus;
 154         struct pci_sysdata *sd;
 155         int node;
 156 #ifdef CONFIG_ACPI_NUMA
 157         int pxm;
 158 #endif
 159
 160         if (domain && !pci_domains_supported) {
 161                 printk(KERN_WARNING "PCI: Multiple domains not supported "
 162                        "(dom %d, bus %d)\n", domain, busnum);
 163                 return NULL;
 164         }
 165
 166         node = -1;
 167 #ifdef CONFIG_ACPI_NUMA
 168         pxm = acpi_get_pxm(device->handle);
 169         if (pxm >= 0)
 170                 node = pxm_to_node(pxm);
 171         if (node != -1)
 172                 set_mp_bus_to_node(busnum, node);
 173         else
 174 #endif
 175                 node = get_mp_bus_to_node(busnum);
 176
 177         if (node != -1 && !node_online(node))
 178                 node = -1;
 179
 180         /* Allocate per-root-bus (not per bus) arch-specific data.
 181          * TODO: leak; this memory is never freed.
 182          * It's arguable whether it's worth the trouble to care.
 183          */
 184         sd = kzalloc(sizeof(*sd), GFP_KERNEL);
 185         if (!sd) {
 186                 printk(KERN_ERR "PCI: OOM, not probing PCI bus %02x\n", busnum);
 187                 return NULL;
 188         }
 189
 190         sd->domain = domain;
 191         sd->node = node;
 192         /*
 193          * Maybe the desired pci bus has been already scanned. In such case
 194          * it is unnecessary to scan the pci bus with the given domain,busnum.
 195          */
 196         bus = pci_find_bus(domain, busnum);
 197         if (bus) {
 198                 /*
 199                  * If the desired bus exits, the content of bus->sysdata will
 200                  * be replaced by sd.
 201                  */
 202                 memcpy(bus->sysdata, sd, sizeof(*sd));
 203                 kfree(sd);
 204         } else
 205                 bus = pci_scan_bus_parented(NULL, busnum, &pci_root_ops, sd);
 206
 207         if (!bus)
 208                 kfree(sd);
 209
 210         if (bus && node != -1) {
 211 #ifdef CONFIG_ACPI_NUMA
 212                 if (pxm >= 0)
 213                         printk(KERN_DEBUG "bus %02x -> pxm %d -> node %d\n",
 214                                 busnum, pxm, node);
 215 #else
 216                 printk(KERN_DEBUG "bus %02x -> node %d\n",
 217                         busnum, node);
 218 #endif
 219         }
 220
 221         if (bus && (pci_probe & PCI_USE__CRS))
 222                 get_current_resources(device, busnum, domain, bus);
 223         return bus;
 224 }
 225
 226 int __init pci_acpi_init(void)
 227 {
 228         struct pci_dev *dev = NULL;
 229
 230         if (pcibios_scanned)
 231                 return 0;
 232
 233         if (acpi_noirq)
 234                 return 0;
 235
 236         printk(KERN_INFO "PCI: Using ACPI for IRQ routing\n");
 237         acpi_irq_penalty_init();
 238         pcibios_scanned++;
 239         pcibios_enable_irq = acpi_pci_irq_enable;
 240         pcibios_disable_irq = acpi_pci_irq_disable;
 241
 242         if (pci_routeirq) {
 243                 /*
 244                  * PCI IRQ routing is set up by pci_enable_device(), but we
 245                  * also do it here in case there are still broken drivers that
 246                  * don't use pci_enable_device().
 247                  */
 248                 printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n");
 249                 for_each_pci_dev(dev)
 250                         acpi_pci_irq_enable(dev);
 251         }
 252
 253         return 0;
 254 }