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