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 void
  63 align_resource(struct acpi_device *bridge, struct resource *res)
  64 {
  65         int align = (res->flags & IORESOURCE_MEM) ? 16 : 4;
  66
  67         /*
  68          * Host bridge windows are not BARs, but the decoders on the PCI side
  69          * that claim this address space have starting alignment and length
  70          * constraints, so fix any obvious BIOS goofs.
  71          */
  72         if (!IS_ALIGNED(res->start, align)) {
  73                 dev_printk(KERN_DEBUG, &bridge->dev,
  74                            "host bridge window %pR invalid; "
  75                            "aligning start to %d-byte boundary\n", res, align);
  76                 res->start &= ~(align - 1);
  77         }
  78         if (!IS_ALIGNED(res->end + 1, align)) {
  79                 dev_printk(KERN_DEBUG, &bridge->dev,
  80                            "host bridge window %pR invalid; "
  81                            "aligning end to %d-byte boundary\n", res, align);
  82                 res->end = ALIGN(res->end, align) - 1;
  83         }
  84 }
  85
  86 static acpi_status
  87 setup_resource(struct acpi_resource *acpi_res, void *data)
  88 {
  89         struct pci_root_info *info = data;
  90         struct resource *res;
  91         struct acpi_resource_address64 addr;
  92         acpi_status status;
  93         unsigned long flags;
  94         struct resource *root;
  95         int max_root_bus_resources = PCI_BUS_NUM_RESOURCES;
  96         u64 start, end;
  97
  98         if (bus_has_transparent_bridge(info->bus))
  99                 max_root_bus_resources -= 3;
 100
 101         status = resource_to_addr(acpi_res, &addr);
 102         if (!ACPI_SUCCESS(status))
 103                 return AE_OK;
 104
 105         if (addr.resource_type == ACPI_MEMORY_RANGE) {
 106                 root = &iomem_resource;
 107                 flags = IORESOURCE_MEM;
 108                 if (addr.info.mem.caching == ACPI_PREFETCHABLE_MEMORY)
 109                         flags |= IORESOURCE_PREFETCH;
 110         } else if (addr.resource_type == ACPI_IO_RANGE) {
 111                 root = &ioport_resource;
 112                 flags = IORESOURCE_IO;
 113         } else
 114                 return AE_OK;
 115
 116         start = addr.minimum + addr.translation_offset;
 117         end = start + addr.address_length - 1;
 118         if (info->res_num >= max_root_bus_resources) {
 119                 if (pci_probe & PCI_USE__CRS)
 120                         printk(KERN_WARNING "PCI: Failed to allocate "
 121                                "0x%lx-0x%lx from %s for %s due to _CRS "
 122                                "returning more than %d resource descriptors\n",
 123                                (unsigned long) start, (unsigned long) end,
 124                                root->name, info->name, max_root_bus_resources);
 125                 return AE_OK;
 126         }
 127
 128         res = &info->res[info->res_num];
 129         res->name = info->name;
 130         res->flags = flags;
 131         res->start = start;
 132         res->end = end;
 133         res->child = NULL;
 134         align_resource(info->bridge, res);
 135
 136         if (!(pci_probe & PCI_USE__CRS)) {
 137                 dev_printk(KERN_DEBUG, &info->bridge->dev,
 138                            "host bridge window %pR (ignored)\n", res);
 139                 return AE_OK;
 140         }
 141
 142         if (insert_resource(root, res)) {
 143                 dev_err(&info->bridge->dev,
 144                         "can't allocate host bridge window %pR\n", res);
 145         } else {
 146                 info->bus->resource[info->res_num] = res;
 147                 info->res_num++;
 148                 if (addr.translation_offset)
 149                         dev_info(&info->bridge->dev, "host bridge window %pR "
 150                                  "(PCI address [%#llx-%#llx])\n",
 151                                  res, res->start - addr.translation_offset,
 152                                  res->end - addr.translation_offset);
 153                 else
 154                         dev_info(&info->bridge->dev,
 155                                  "host bridge window %pR\n", res);
 156         }
 157         return AE_OK;
 158 }
 159
 160 static void
 161 get_current_resources(struct acpi_device *device, int busnum,
 162                         int domain, struct pci_bus *bus)
 163 {
 164         struct pci_root_info info;
 165         size_t size;
 166
 167         if (!(pci_probe & PCI_USE__CRS))
 168                 dev_info(&device->dev,
 169                          "ignoring host bridge windows from ACPI; "
 170                          "boot with \"pci=use_crs\" to use them\n");
 171
 172         info.bridge = device;
 173         info.bus = bus;
 174         info.res_num = 0;
 175         acpi_walk_resources(device->handle, METHOD_NAME__CRS, count_resource,
 176                                 &info);
 177         if (!info.res_num)
 178                 return;
 179
 180         size = sizeof(*info.res) * info.res_num;
 181         info.res = kmalloc(size, GFP_KERNEL);
 182         if (!info.res)
 183                 goto res_alloc_fail;
 184
 185         info.name = kmalloc(16, GFP_KERNEL);
 186         if (!info.name)
 187                 goto name_alloc_fail;
 188         sprintf(info.name, "PCI Bus %04x:%02x", domain, busnum);
 189
 190         info.res_num = 0;
 191         acpi_walk_resources(device->handle, METHOD_NAME__CRS, setup_resource,
 192                                 &info);
 193
 194         return;
 195
 196 name_alloc_fail:
 197         kfree(info.res);
 198 res_alloc_fail:
 199         return;
 200 }
 201
 202 struct pci_bus * __devinit pci_acpi_scan_root(struct acpi_device *device, int domain, int busnum)
 203 {
 204         struct pci_bus *bus;
 205         struct pci_sysdata *sd;
 206         int node;
 207 #ifdef CONFIG_ACPI_NUMA
 208         int pxm;
 209 #endif
 210
 211         if (domain && !pci_domains_supported) {
 212                 printk(KERN_WARNING "pci_bus %04x:%02x: "
 213                        "ignored (multiple domains not supported)\n",
 214                        domain, busnum);
 215                 return NULL;
 216         }
 217
 218         node = -1;
 219 #ifdef CONFIG_ACPI_NUMA
 220         pxm = acpi_get_pxm(device->handle);
 221         if (pxm >= 0)
 222                 node = pxm_to_node(pxm);
 223         if (node != -1)
 224                 set_mp_bus_to_node(busnum, node);
 225         else
 226 #endif
 227                 node = get_mp_bus_to_node(busnum);
 228
 229         if (node != -1 && !node_online(node))
 230                 node = -1;
 231
 232         /* Allocate per-root-bus (not per bus) arch-specific data.
 233          * TODO: leak; this memory is never freed.
 234          * It's arguable whether it's worth the trouble to care.
 235          */
 236         sd = kzalloc(sizeof(*sd), GFP_KERNEL);
 237         if (!sd) {
 238                 printk(KERN_WARNING "pci_bus %04x:%02x: "
 239                        "ignored (out of memory)\n", domain, busnum);
 240                 return NULL;
 241         }
 242
 243         sd->domain = domain;
 244         sd->node = node;
 245         /*
 246          * Maybe the desired pci bus has been already scanned. In such case
 247          * it is unnecessary to scan the pci bus with the given domain,busnum.
 248          */
 249         bus = pci_find_bus(domain, busnum);
 250         if (bus) {
 251                 /*
 252                  * If the desired bus exits, the content of bus->sysdata will
 253                  * be replaced by sd.
 254                  */
 255                 memcpy(bus->sysdata, sd, sizeof(*sd));
 256                 kfree(sd);
 257         } else {
 258                 bus = pci_create_bus(NULL, busnum, &pci_root_ops, sd);
 259                 if (bus) {
 260                         get_current_resources(device, busnum, domain, bus);
 261                         bus->subordinate = pci_scan_child_bus(bus);
 262                 }
 263         }
 264
 265         if (!bus)
 266                 kfree(sd);
 267
 268         if (bus && node != -1) {
 269 #ifdef CONFIG_ACPI_NUMA
 270                 if (pxm >= 0)
 271                         dev_printk(KERN_DEBUG, &bus->dev,
 272                                    "on NUMA node %d (pxm %d)\n", node, pxm);
 273 #else
 274                 dev_printk(KERN_DEBUG, &bus->dev, "on NUMA node %d\n", node);
 275 #endif
 276         }
 277
 278         return bus;
 279 }
 280
 281 int __init pci_acpi_init(void)
 282 {
 283         struct pci_dev *dev = NULL;
 284
 285         if (pcibios_scanned)
 286                 return 0;
 287
 288         if (acpi_noirq)
 289                 return 0;
 290
 291         printk(KERN_INFO "PCI: Using ACPI for IRQ routing\n");
 292         acpi_irq_penalty_init();
 293         pcibios_scanned++;
 294         pcibios_enable_irq = acpi_pci_irq_enable;
 295         pcibios_disable_irq = acpi_pci_irq_disable;
 296
 297         if (pci_routeirq) {
 298                 /*
 299                  * PCI IRQ routing is set up by pci_enable_device(), but we
 300                  * also do it here in case there are still broken drivers that
 301                  * don't use pci_enable_device().
 302                  */
 303                 printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n");
 304                 for_each_pci_dev(dev)
 305                         acpi_pci_irq_enable(dev);
 306         }
 307
 308         return 0;
 309 }