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 <linux/slab.h> 7 #include <asm/numa.h> 8 #include <asm/pci_x86.h> 9 10 struct pci_root_info { 11 struct acpi_device *bridge; 12 char *name; 13 unsigned int res_num; 14 struct resource *res; 15 struct pci_bus *bus; 16 int busnum; 17 }; 18 19 static bool pci_use_crs = true; 20 21 static int __init set_use_crs(const struct dmi_system_id *id) 22 { 23 pci_use_crs = true; 24 return 0; 25 } 26 27 static const struct dmi_system_id pci_use_crs_table[] __initconst = { 28 /* http://bugzilla.kernel.org/show_bug.cgi?id=14183 */ 29 { 30 .callback = set_use_crs, 31 .ident = "IBM System x3800", 32 .matches = { 33 DMI_MATCH(DMI_SYS_VENDOR, "IBM"), 34 DMI_MATCH(DMI_PRODUCT_NAME, "x3800"), 35 }, 36 }, 37 /* https://bugzilla.kernel.org/show_bug.cgi?id=16007 */ 38 /* 2006 AMD HT/VIA system with two host bridges */ 39 { 40 .callback = set_use_crs, 41 .ident = "ASRock ALiveSATA2-GLAN", 42 .matches = { 43 DMI_MATCH(DMI_PRODUCT_NAME, "ALiveSATA2-GLAN"), 44 }, 45 }, 46 {} 47 }; 48 49 void __init pci_acpi_crs_quirks(void) 50 { 51 int year; 52 53 if (dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL) && year < 2008) 54 pci_use_crs = false; 55 56 dmi_check_system(pci_use_crs_table); 57 58 /* 59 * If the user specifies "pci=use_crs" or "pci=nocrs" explicitly, that 60 * takes precedence over anything we figured out above. 61 */ 62 if (pci_probe & PCI_ROOT_NO_CRS) 63 pci_use_crs = false; 64 else if (pci_probe & PCI_USE__CRS) 65 pci_use_crs = true; 66 67 printk(KERN_INFO "PCI: %s host bridge windows from ACPI; " 68 "if necessary, use \"pci=%s\" and report a bug\n", 69 pci_use_crs ? "Using" : "Ignoring", 70 pci_use_crs ? "nocrs" : "use_crs"); 71 } 72 73 static acpi_status 74 resource_to_addr(struct acpi_resource *resource, 75 struct acpi_resource_address64 *addr) 76 { 77 acpi_status status; 78 struct acpi_resource_memory24 *memory24; 79 struct acpi_resource_memory32 *memory32; 80 struct acpi_resource_fixed_memory32 *fixed_memory32; 81 82 memset(addr, 0, sizeof(*addr)); 83 switch (resource->type) { 84 case ACPI_RESOURCE_TYPE_MEMORY24: 85 memory24 = &resource->data.memory24; 86 addr->resource_type = ACPI_MEMORY_RANGE; 87 addr->minimum = memory24->minimum; 88 addr->address_length = memory24->address_length; 89 addr->maximum = addr->minimum + addr->address_length - 1; 90 return AE_OK; 91 case ACPI_RESOURCE_TYPE_MEMORY32: 92 memory32 = &resource->data.memory32; 93 addr->resource_type = ACPI_MEMORY_RANGE; 94 addr->minimum = memory32->minimum; 95 addr->address_length = memory32->address_length; 96 addr->maximum = addr->minimum + addr->address_length - 1; 97 return AE_OK; 98 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: 99 fixed_memory32 = &resource->data.fixed_memory32; 100 addr->resource_type = ACPI_MEMORY_RANGE; 101 addr->minimum = fixed_memory32->address; 102 addr->address_length = fixed_memory32->address_length; 103 addr->maximum = addr->minimum + addr->address_length - 1; 104 return AE_OK; 105 case ACPI_RESOURCE_TYPE_ADDRESS16: 106 case ACPI_RESOURCE_TYPE_ADDRESS32: 107 case ACPI_RESOURCE_TYPE_ADDRESS64: 108 status = acpi_resource_to_address64(resource, addr); 109 if (ACPI_SUCCESS(status) && 110 (addr->resource_type == ACPI_MEMORY_RANGE || 111 addr->resource_type == ACPI_IO_RANGE) && 112 addr->address_length > 0) { 113 return AE_OK; 114 } 115 break; 116 } 117 return AE_ERROR; 118 } 119 120 static acpi_status 121 count_resource(struct acpi_resource *acpi_res, void *data) 122 { 123 struct pci_root_info *info = data; 124 struct acpi_resource_address64 addr; 125 acpi_status status; 126 127 status = resource_to_addr(acpi_res, &addr); 128 if (ACPI_SUCCESS(status)) 129 info->res_num++; 130 return AE_OK; 131 } 132 133 static acpi_status 134 setup_resource(struct acpi_resource *acpi_res, void *data) 135 { 136 struct pci_root_info *info = data; 137 struct resource *res; 138 struct acpi_resource_address64 addr; 139 acpi_status status; 140 unsigned long flags; 141 u64 start, end; 142 143 status = resource_to_addr(acpi_res, &addr); 144 if (!ACPI_SUCCESS(status)) 145 return AE_OK; 146 147 if (addr.resource_type == ACPI_MEMORY_RANGE) { 148 flags = IORESOURCE_MEM; 149 if (addr.info.mem.caching == ACPI_PREFETCHABLE_MEMORY) 150 flags |= IORESOURCE_PREFETCH; 151 } else if (addr.resource_type == ACPI_IO_RANGE) { 152 flags = IORESOURCE_IO; 153 } else 154 return AE_OK; 155 156 start = addr.minimum + addr.translation_offset; 157 end = addr.maximum + addr.translation_offset; 158 159 res = &info->res[info->res_num]; 160 res->name = info->name; 161 res->flags = flags; 162 res->start = start; 163 res->end = end; 164 res->child = NULL; 165 166 if (!pci_use_crs) { 167 dev_printk(KERN_DEBUG, &info->bridge->dev, 168 "host bridge window %pR (ignored)\n", res); 169 return AE_OK; 170 } 171 172 info->res_num++; 173 if (addr.translation_offset) 174 dev_info(&info->bridge->dev, "host bridge window %pR " 175 "(PCI address [%#llx-%#llx])\n", 176 res, res->start - addr.translation_offset, 177 res->end - addr.translation_offset); 178 else 179 dev_info(&info->bridge->dev, "host bridge window %pR\n", res); 180 181 return AE_OK; 182 } 183 184 static bool resource_contains(struct resource *res, resource_size_t point) 185 { 186 if (res->start <= point && point <= res->end) 187 return true; 188 return false; 189 } 190 191 static void coalesce_windows(struct pci_root_info *info, unsigned long type) 192 { 193 int i, j; 194 struct resource *res1, *res2; 195 196 for (i = 0; i < info->res_num; i++) { 197 res1 = &info->res[i]; 198 if (!(res1->flags & type)) 199 continue; 200 201 for (j = i + 1; j < info->res_num; j++) { 202 res2 = &info->res[j]; 203 if (!(res2->flags & type)) 204 continue; 205 206 /* 207 * I don't like throwing away windows because then 208 * our resources no longer match the ACPI _CRS, but 209 * the kernel resource tree doesn't allow overlaps. 210 */ 211 if (resource_contains(res1, res2->start) || 212 resource_contains(res1, res2->end) || 213 resource_contains(res2, res1->start) || 214 resource_contains(res2, res1->end)) { 215 res1->start = min(res1->start, res2->start); 216 res1->end = max(res1->end, res2->end); 217 dev_info(&info->bridge->dev, 218 "host bridge window expanded to %pR; %pR ignored\n", 219 res1, res2); 220 res2->flags = 0; 221 } 222 } 223 } 224 } 225 226 static void add_resources(struct pci_root_info *info) 227 { 228 int i; 229 struct resource *res, *root, *conflict; 230 231 if (!pci_use_crs) 232 return; 233 234 coalesce_windows(info, IORESOURCE_MEM); 235 coalesce_windows(info, IORESOURCE_IO); 236 237 for (i = 0; i < info->res_num; i++) { 238 res = &info->res[i]; 239 240 if (res->flags & IORESOURCE_MEM) 241 root = &iomem_resource; 242 else if (res->flags & IORESOURCE_IO) 243 root = &ioport_resource; 244 else 245 continue; 246 247 conflict = insert_resource_conflict(root, res); 248 if (conflict) 249 dev_info(&info->bridge->dev, 250 "ignoring host bridge window %pR (conflicts with %s %pR)\n", 251 res, conflict->name, conflict); 252 else 253 pci_bus_add_resource(info->bus, res, 0); 254 } 255 } 256 257 static void 258 get_current_resources(struct acpi_device *device, int busnum, 259 int domain, struct pci_bus *bus) 260 { 261 struct pci_root_info info; 262 size_t size; 263 264 if (pci_use_crs) 265 pci_bus_remove_resources(bus); 266 267 info.bridge = device; 268 info.bus = bus; 269 info.res_num = 0; 270 acpi_walk_resources(device->handle, METHOD_NAME__CRS, count_resource, 271 &info); 272 if (!info.res_num) 273 return; 274 275 size = sizeof(*info.res) * info.res_num; 276 info.res = kmalloc(size, GFP_KERNEL); 277 if (!info.res) 278 goto res_alloc_fail; 279 280 info.name = kasprintf(GFP_KERNEL, "PCI Bus %04x:%02x", domain, busnum); 281 if (!info.name) 282 goto name_alloc_fail; 283 284 info.res_num = 0; 285 acpi_walk_resources(device->handle, METHOD_NAME__CRS, setup_resource, 286 &info); 287 288 add_resources(&info); 289 return; 290 291 name_alloc_fail: 292 kfree(info.res); 293 res_alloc_fail: 294 return; 295 } 296 297 struct pci_bus * __devinit pci_acpi_scan_root(struct acpi_pci_root *root) 298 { 299 struct acpi_device *device = root->device; 300 int domain = root->segment; 301 int busnum = root->secondary.start; 302 struct pci_bus *bus; 303 struct pci_sysdata *sd; 304 int node; 305 #ifdef CONFIG_ACPI_NUMA 306 int pxm; 307 #endif 308 309 if (domain && !pci_domains_supported) { 310 printk(KERN_WARNING "pci_bus %04x:%02x: " 311 "ignored (multiple domains not supported)\n", 312 domain, busnum); 313 return NULL; 314 } 315 316 node = -1; 317 #ifdef CONFIG_ACPI_NUMA 318 pxm = acpi_get_pxm(device->handle); 319 if (pxm >= 0) 320 node = pxm_to_node(pxm); 321 if (node != -1) 322 set_mp_bus_to_node(busnum, node); 323 else 324 #endif 325 node = get_mp_bus_to_node(busnum); 326 327 if (node != -1 && !node_online(node)) 328 node = -1; 329 330 /* Allocate per-root-bus (not per bus) arch-specific data. 331 * TODO: leak; this memory is never freed. 332 * It's arguable whether it's worth the trouble to care. 333 */ 334 sd = kzalloc(sizeof(*sd), GFP_KERNEL); 335 if (!sd) { 336 printk(KERN_WARNING "pci_bus %04x:%02x: " 337 "ignored (out of memory)\n", domain, busnum); 338 return NULL; 339 } 340 341 sd->domain = domain; 342 sd->node = node; 343 /* 344 * Maybe the desired pci bus has been already scanned. In such case 345 * it is unnecessary to scan the pci bus with the given domain,busnum. 346 */ 347 bus = pci_find_bus(domain, busnum); 348 if (bus) { 349 /* 350 * If the desired bus exits, the content of bus->sysdata will 351 * be replaced by sd. 352 */ 353 memcpy(bus->sysdata, sd, sizeof(*sd)); 354 kfree(sd); 355 } else { 356 bus = pci_create_bus(NULL, busnum, &pci_root_ops, sd); 357 if (bus) { 358 get_current_resources(device, busnum, domain, bus); 359 bus->subordinate = pci_scan_child_bus(bus); 360 } 361 } 362 363 /* After the PCI-E bus has been walked and all devices discovered, 364 * configure any settings of the fabric that might be necessary. 365 */ 366 if (bus) { 367 struct pci_bus *child; 368 list_for_each_entry(child, &bus->children, node) { 369 struct pci_dev *self = child->self; 370 if (!self) 371 continue; 372 373 pcie_bus_configure_settings(child, self->pcie_mpss); 374 } 375 } 376 377 if (!bus) 378 kfree(sd); 379 380 if (bus && node != -1) { 381 #ifdef CONFIG_ACPI_NUMA 382 if (pxm >= 0) 383 dev_printk(KERN_DEBUG, &bus->dev, 384 "on NUMA node %d (pxm %d)\n", node, pxm); 385 #else 386 dev_printk(KERN_DEBUG, &bus->dev, "on NUMA node %d\n", node); 387 #endif 388 } 389 390 return bus; 391 } 392 393 int __init pci_acpi_init(void) 394 { 395 struct pci_dev *dev = NULL; 396 397 if (acpi_noirq) 398 return -ENODEV; 399 400 printk(KERN_INFO "PCI: Using ACPI for IRQ routing\n"); 401 acpi_irq_penalty_init(); 402 pcibios_enable_irq = acpi_pci_irq_enable; 403 pcibios_disable_irq = acpi_pci_irq_disable; 404 x86_init.pci.init_irq = x86_init_noop; 405 406 if (pci_routeirq) { 407 /* 408 * PCI IRQ routing is set up by pci_enable_device(), but we 409 * also do it here in case there are still broken drivers that 410 * don't use pci_enable_device(). 411 */ 412 printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n"); 413 for_each_pci_dev(dev) 414 acpi_pci_irq_enable(dev); 415 } 416 417 return 0; 418 } 419