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