acpi.c 14.9 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3
#include <linux/pci.h>
#include <linux/acpi.h>
#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>
Linus Torvalds's avatar
Linus Torvalds committed
9

10
struct pci_root_info {
11
	struct acpi_device *bridge;
12
	char name[16];
13 14
	unsigned int res_num;
	struct resource *res;
15
	resource_size_t *res_offset;
16
	struct pci_sysdata sd;
17 18 19 20 21 22
#ifdef	CONFIG_PCI_MMCONFIG
	bool mcfg_added;
	u16 segment;
	u8 start_bus;
	u8 end_bus;
#endif
23 24
};

25
static bool pci_use_crs = true;
26
static bool pci_ignore_seg = false;
27 28 29 30 31 32 33

static int __init set_use_crs(const struct dmi_system_id *id)
{
	pci_use_crs = true;
	return 0;
}

34 35 36 37 38 39
static int __init set_nouse_crs(const struct dmi_system_id *id)
{
	pci_use_crs = false;
	return 0;
}

40 41 42 43 44 45 46 47
static int __init set_ignore_seg(const struct dmi_system_id *id)
{
	printk(KERN_INFO "PCI: %s detected: ignoring ACPI _SEG\n", id->ident);
	pci_ignore_seg = true;
	return 0;
}

static const struct dmi_system_id pci_crs_quirks[] __initconst = {
48 49 50 51 52 53 54 55 56
	/* http://bugzilla.kernel.org/show_bug.cgi?id=14183 */
	{
		.callback = set_use_crs,
		.ident = "IBM System x3800",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
			DMI_MATCH(DMI_PRODUCT_NAME, "x3800"),
		},
	},
57 58 59 60 61 62 63 64 65
	/* https://bugzilla.kernel.org/show_bug.cgi?id=16007 */
	/* 2006 AMD HT/VIA system with two host bridges */
        {
		.callback = set_use_crs,
		.ident = "ASRock ALiveSATA2-GLAN",
		.matches = {
			DMI_MATCH(DMI_PRODUCT_NAME, "ALiveSATA2-GLAN"),
                },
        },
66 67 68 69 70 71 72 73 74 75 76
	/* https://bugzilla.kernel.org/show_bug.cgi?id=30552 */
	/* 2006 AMD HT/VIA system with two host bridges */
	{
		.callback = set_use_crs,
		.ident = "ASUS M2V-MX SE",
		.matches = {
			DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
			DMI_MATCH(DMI_BOARD_NAME, "M2V-MX SE"),
			DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."),
		},
	},
77 78 79 80 81 82 83 84 85 86
	/* https://bugzilla.kernel.org/show_bug.cgi?id=42619 */
	{
		.callback = set_use_crs,
		.ident = "MSI MS-7253",
		.matches = {
			DMI_MATCH(DMI_BOARD_VENDOR, "MICRO-STAR INTERNATIONAL CO., LTD"),
			DMI_MATCH(DMI_BOARD_NAME, "MS-7253"),
			DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"),
		},
	},
87

88 89 90 91 92 93 94 95 96 97 98 99
	/* Now for the blacklist.. */

	/* https://bugzilla.redhat.com/show_bug.cgi?id=769657 */
	{
		.callback = set_nouse_crs,
		.ident = "Dell Studio 1557",
		.matches = {
			DMI_MATCH(DMI_BOARD_VENDOR, "Dell Inc."),
			DMI_MATCH(DMI_PRODUCT_NAME, "Studio 1557"),
			DMI_MATCH(DMI_BIOS_VERSION, "A09"),
		},
	},
100 101 102 103 104 105 106 107 108 109
	/* https://bugzilla.redhat.com/show_bug.cgi?id=769657 */
	{
		.callback = set_nouse_crs,
		.ident = "Thinkpad SL510",
		.matches = {
			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_BOARD_NAME, "2847DFG"),
			DMI_MATCH(DMI_BIOS_VERSION, "6JET85WW (1.43 )"),
		},
	},
110 111 112 113 114 115 116 117 118 119

	/* https://bugzilla.kernel.org/show_bug.cgi?id=15362 */
	{
		.callback = set_ignore_seg,
		.ident = "HP xw9300",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
			DMI_MATCH(DMI_PRODUCT_NAME, "HP xw9300 Workstation"),
		},
	},
120 121 122 123 124 125 126 127 128 129
	{}
};

void __init pci_acpi_crs_quirks(void)
{
	int year;

	if (dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL) && year < 2008)
		pci_use_crs = false;

130
	dmi_check_system(pci_crs_quirks);
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146

	/*
	 * If the user specifies "pci=use_crs" or "pci=nocrs" explicitly, that
	 * takes precedence over anything we figured out above.
	 */
	if (pci_probe & PCI_ROOT_NO_CRS)
		pci_use_crs = false;
	else if (pci_probe & PCI_USE__CRS)
		pci_use_crs = true;

	printk(KERN_INFO "PCI: %s host bridge windows from ACPI; "
	       "if necessary, use \"pci=%s\" and report a bug\n",
	       pci_use_crs ? "Using" : "Ignoring",
	       pci_use_crs ? "nocrs" : "use_crs");
}

147
#ifdef	CONFIG_PCI_MMCONFIG
148
static int check_segment(u16 seg, struct device *dev, char *estr)
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
{
	if (seg) {
		dev_err(dev,
			"%s can't access PCI configuration "
			"space under this host bridge.\n",
			estr);
		return -EIO;
	}

	/*
	 * Failure in adding MMCFG information is not fatal,
	 * just can't access extended configuration space of
	 * devices under this host bridge.
	 */
	dev_warn(dev,
		 "%s can't access extended PCI configuration "
		 "space under this bridge.\n",
		 estr);

	return 0;
}

171 172
static int setup_mcfg_map(struct pci_root_info *info, u16 seg, u8 start,
			  u8 end, phys_addr_t addr)
173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
{
	int result;
	struct device *dev = &info->bridge->dev;

	info->start_bus = start;
	info->end_bus = end;
	info->mcfg_added = false;

	/* return success if MMCFG is not in use */
	if (raw_pci_ext_ops && raw_pci_ext_ops != &pci_mmcfg)
		return 0;

	if (!(pci_probe & PCI_PROBE_MMCONF))
		return check_segment(seg, dev, "MMCONFIG is disabled,");

	result = pci_mmconfig_insert(dev, seg, start, end, addr);
	if (result == 0) {
		/* enable MMCFG if it hasn't been enabled yet */
		if (raw_pci_ext_ops == NULL)
			raw_pci_ext_ops = &pci_mmcfg;
		info->mcfg_added = true;
	} else if (result != -EEXIST)
		return check_segment(seg, dev,
			 "fail to add MMCONFIG information,");

	return 0;
}

static void teardown_mcfg_map(struct pci_root_info *info)
{
	if (info->mcfg_added) {
		pci_mmconfig_delete(info->segment, info->start_bus,
				    info->end_bus);
		info->mcfg_added = false;
	}
}
#else
210
static int setup_mcfg_map(struct pci_root_info *info,
211 212 213 214 215 216 217 218 219 220
				    u16 seg, u8 start, u8 end,
				    phys_addr_t addr)
{
	return 0;
}
static void teardown_mcfg_map(struct pci_root_info *info)
{
}
#endif

221 222 223 224 225
static acpi_status
resource_to_addr(struct acpi_resource *resource,
			struct acpi_resource_address64 *addr)
{
	acpi_status status;
226 227 228
	struct acpi_resource_memory24 *memory24;
	struct acpi_resource_memory32 *memory32;
	struct acpi_resource_fixed_memory32 *fixed_memory32;
229

230 231 232 233 234 235 236 237
	memset(addr, 0, sizeof(*addr));
	switch (resource->type) {
	case ACPI_RESOURCE_TYPE_MEMORY24:
		memory24 = &resource->data.memory24;
		addr->resource_type = ACPI_MEMORY_RANGE;
		addr->minimum = memory24->minimum;
		addr->address_length = memory24->address_length;
		addr->maximum = addr->minimum + addr->address_length - 1;
238
		return AE_OK;
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
	case ACPI_RESOURCE_TYPE_MEMORY32:
		memory32 = &resource->data.memory32;
		addr->resource_type = ACPI_MEMORY_RANGE;
		addr->minimum = memory32->minimum;
		addr->address_length = memory32->address_length;
		addr->maximum = addr->minimum + addr->address_length - 1;
		return AE_OK;
	case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
		fixed_memory32 = &resource->data.fixed_memory32;
		addr->resource_type = ACPI_MEMORY_RANGE;
		addr->minimum = fixed_memory32->address;
		addr->address_length = fixed_memory32->address_length;
		addr->maximum = addr->minimum + addr->address_length - 1;
		return AE_OK;
	case ACPI_RESOURCE_TYPE_ADDRESS16:
	case ACPI_RESOURCE_TYPE_ADDRESS32:
	case ACPI_RESOURCE_TYPE_ADDRESS64:
		status = acpi_resource_to_address64(resource, addr);
		if (ACPI_SUCCESS(status) &&
		    (addr->resource_type == ACPI_MEMORY_RANGE ||
		    addr->resource_type == ACPI_IO_RANGE) &&
		    addr->address_length > 0) {
			return AE_OK;
		}
		break;
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
	}
	return AE_ERROR;
}

static acpi_status
count_resource(struct acpi_resource *acpi_res, void *data)
{
	struct pci_root_info *info = data;
	struct acpi_resource_address64 addr;
	acpi_status status;

	status = resource_to_addr(acpi_res, &addr);
	if (ACPI_SUCCESS(status))
		info->res_num++;
	return AE_OK;
}

static acpi_status
setup_resource(struct acpi_resource *acpi_res, void *data)
{
	struct pci_root_info *info = data;
	struct resource *res;
	struct acpi_resource_address64 addr;
	acpi_status status;
	unsigned long flags;
289
	u64 start, orig_end, end;
290

291 292 293 294 295 296 297 298 299 300 301 302 303
	status = resource_to_addr(acpi_res, &addr);
	if (!ACPI_SUCCESS(status))
		return AE_OK;

	if (addr.resource_type == ACPI_MEMORY_RANGE) {
		flags = IORESOURCE_MEM;
		if (addr.info.mem.caching == ACPI_PREFETCHABLE_MEMORY)
			flags |= IORESOURCE_PREFETCH;
	} else if (addr.resource_type == ACPI_IO_RANGE) {
		flags = IORESOURCE_IO;
	} else
		return AE_OK;

304
	start = addr.minimum + addr.translation_offset;
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
	orig_end = end = addr.maximum + addr.translation_offset;

	/* Exclude non-addressable range or non-addressable portion of range */
	end = min(end, (u64)iomem_resource.end);
	if (end <= start) {
		dev_info(&info->bridge->dev,
			"host bridge window [%#llx-%#llx] "
			"(ignored, not CPU addressable)\n", start, orig_end);
		return AE_OK;
	} else if (orig_end != end) {
		dev_info(&info->bridge->dev,
			"host bridge window [%#llx-%#llx] "
			"([%#llx-%#llx] ignored, not CPU addressable)\n", 
			start, orig_end, end + 1, orig_end);
	}
320

321 322 323 324 325
	res = &info->res[info->res_num];
	res->name = info->name;
	res->flags = flags;
	res->start = start;
	res->end = end;
326
	info->res_offset[info->res_num] = addr.translation_offset;
327

328
	if (!pci_use_crs) {
329 330 331 332 333
		dev_printk(KERN_DEBUG, &info->bridge->dev,
			   "host bridge window %pR (ignored)\n", res);
		return AE_OK;
	}

334 335 336 337 338
	info->res_num++;

	return AE_OK;
}

339
static void coalesce_windows(struct pci_root_info *info, unsigned long type)
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
{
	int i, j;
	struct resource *res1, *res2;

	for (i = 0; i < info->res_num; i++) {
		res1 = &info->res[i];
		if (!(res1->flags & type))
			continue;

		for (j = i + 1; j < info->res_num; j++) {
			res2 = &info->res[j];
			if (!(res2->flags & type))
				continue;

			/*
			 * I don't like throwing away windows because then
			 * our resources no longer match the ACPI _CRS, but
			 * the kernel resource tree doesn't allow overlaps.
			 */
Wei Yang's avatar
Wei Yang committed
359
			if (resource_overlaps(res1, res2)) {
360 361 362 363 364 365 366 367 368 369 370
				res1->start = min(res1->start, res2->start);
				res1->end = max(res1->end, res2->end);
				dev_info(&info->bridge->dev,
					 "host bridge window expanded to %pR; %pR ignored\n",
					 res1, res2);
				res2->flags = 0;
			}
		}
	}
}

371 372
static void add_resources(struct pci_root_info *info,
			  struct list_head *resources)
373 374 375 376 377 378 379 380 381 382 383 384 385 386
{
	int i;
	struct resource *res, *root, *conflict;

	coalesce_windows(info, IORESOURCE_MEM);
	coalesce_windows(info, IORESOURCE_IO);

	for (i = 0; i < info->res_num; i++) {
		res = &info->res[i];

		if (res->flags & IORESOURCE_MEM)
			root = &iomem_resource;
		else if (res->flags & IORESOURCE_IO)
			root = &ioport_resource;
387
		else
388 389 390 391
			continue;

		conflict = insert_resource_conflict(root, res);
		if (conflict)
392 393 394
			dev_info(&info->bridge->dev,
				 "ignoring host bridge window %pR (conflicts with %s %pR)\n",
				 res, conflict->name, conflict);
395
		else
396 397
			pci_add_resource_offset(resources, res,
					info->res_offset[i]);
398 399 400
	}
}

401
static void free_pci_root_info_res(struct pci_root_info *info)
402 403
{
	kfree(info->res);
404
	info->res = NULL;
405 406
	kfree(info->res_offset);
	info->res_offset = NULL;
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
	info->res_num = 0;
}

static void __release_pci_root_info(struct pci_root_info *info)
{
	int i;
	struct resource *res;

	for (i = 0; i < info->res_num; i++) {
		res = &info->res[i];

		if (!res->parent)
			continue;

		if (!(res->flags & (IORESOURCE_MEM | IORESOURCE_IO)))
			continue;

		release_resource(res);
	}

	free_pci_root_info_res(info);

429 430
	teardown_mcfg_map(info);

431 432
	kfree(info);
}
433

434 435 436 437 438
static void release_pci_root_info(struct pci_host_bridge *bridge)
{
	struct pci_root_info *info = bridge->release_data;

	__release_pci_root_info(info);
439 440
}

441
static void
442 443
probe_pci_root_info(struct pci_root_info *info, struct acpi_device *device,
		    int busnum, int domain)
444 445 446
{
	size_t size;

447
	sprintf(info->name, "PCI Bus %04x:%02x", domain, busnum);
448
	info->bridge = device;
449

450
	info->res_num = 0;
451
	acpi_walk_resources(device->handle, METHOD_NAME__CRS, count_resource,
452 453
				info);
	if (!info->res_num)
454 455
		return;

456
	size = sizeof(*info->res) * info->res_num;
457
	info->res = kzalloc(size, GFP_KERNEL);
458 459 460 461 462 463 464 465 466 467 468
	if (!info->res) {
		info->res_num = 0;
		return;
	}

	size = sizeof(*info->res_offset) * info->res_num;
	info->res_num = 0;
	info->res_offset = kzalloc(size, GFP_KERNEL);
	if (!info->res_offset) {
		kfree(info->res);
		info->res = NULL;
469
		return;
470
	}
471 472

	acpi_walk_resources(device->handle, METHOD_NAME__CRS, setup_resource,
473
				info);
474 475
}

476
struct pci_bus *pci_acpi_scan_root(struct acpi_pci_root *root)
Linus Torvalds's avatar
Linus Torvalds committed
477
{
478
	struct acpi_device *device = root->device;
479
	struct pci_root_info *info = NULL;
480 481
	int domain = root->segment;
	int busnum = root->secondary.start;
482
	LIST_HEAD(resources);
483
	struct pci_bus *bus = NULL;
484
	struct pci_sysdata *sd;
Yinghai Lu's avatar
Yinghai Lu committed
485 486
	int node;
#ifdef CONFIG_ACPI_NUMA
487
	int pxm;
Yinghai Lu's avatar
Yinghai Lu committed
488
#endif
489

490 491 492
	if (pci_ignore_seg)
		domain = 0;

493
	if (domain && !pci_domains_supported) {
494 495 496
		printk(KERN_WARNING "pci_bus %04x:%02x: "
		       "ignored (multiple domains not supported)\n",
		       domain, busnum);
497 498 499
		return NULL;
	}

Yinghai Lu's avatar
Yinghai Lu committed
500 501 502 503 504 505 506 507 508 509
	node = -1;
#ifdef CONFIG_ACPI_NUMA
	pxm = acpi_get_pxm(device->handle);
	if (pxm >= 0)
		node = pxm_to_node(pxm);
	if (node != -1)
		set_mp_bus_to_node(busnum, node);
	else
#endif
		node = get_mp_bus_to_node(busnum);
510 511 512

	if (node != -1 && !node_online(node))
		node = -1;
Yinghai Lu's avatar
Yinghai Lu committed
513

514 515
	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info) {
516 517
		printk(KERN_WARNING "pci_bus %04x:%02x: "
		       "ignored (out of memory)\n", domain, busnum);
518 519
		return NULL;
	}
520

521
	sd = &info->sd;
522
	sd->domain = domain;
Yinghai Lu's avatar
Yinghai Lu committed
523
	sd->node = node;
524 525 526 527 528 529 530 531 532 533 534
	/*
	 * Maybe the desired pci bus has been already scanned. In such case
	 * it is unnecessary to scan the pci bus with the given domain,busnum.
	 */
	bus = pci_find_bus(domain, busnum);
	if (bus) {
		/*
		 * If the desired bus exits, the content of bus->sysdata will
		 * be replaced by sd.
		 */
		memcpy(bus->sysdata, sd, sizeof(*sd));
535
		kfree(info);
536
	} else {
537
		probe_pci_root_info(info, device, busnum, domain);
538

539 540
		/* insert busn res at first */
		pci_add_resource(&resources,  &root->secondary);
541 542 543 544
		/*
		 * _CRS with no apertures is normal, so only fall back to
		 * defaults or native bridge info if we're ignoring _CRS.
		 */
545
		if (pci_use_crs)
546
			add_resources(info, &resources);
547
		else {
548
			free_pci_root_info_res(info);
549
			x86_pci_root_bus_resources(busnum, &resources);
550
		}
551

552 553 554 555 556
		if (!setup_mcfg_map(info, domain, (u8)root->secondary.start,
				    (u8)root->secondary.end, root->mcfg_addr))
			bus = pci_create_root_bus(NULL, busnum, &pci_root_ops,
						  sd, &resources);

557
		if (bus) {
558
			pci_scan_child_bus(bus);
559 560 561 562
			pci_set_host_bridge_release(
				to_pci_host_bridge(bus->bridge),
				release_pci_root_info, info);
		} else {
563
			pci_free_resource_list(&resources);
564 565
			__release_pci_root_info(info);
		}
566
	}
567

568 569 570 571 572
	/* After the PCI-E bus has been walked and all devices discovered,
	 * configure any settings of the fabric that might be necessary.
	 */
	if (bus) {
		struct pci_bus *child;
573 574 575 576 577 578 579
		list_for_each_entry(child, &bus->children, node) {
			struct pci_dev *self = child->self;
			if (!self)
				continue;

			pcie_bus_configure_settings(child, self->pcie_mpss);
		}
580 581
	}

Yinghai Lu's avatar
Yinghai Lu committed
582
	if (bus && node != -1) {
583
#ifdef CONFIG_ACPI_NUMA
Yinghai Lu's avatar
Yinghai Lu committed
584
		if (pxm >= 0)
585 586
			dev_printk(KERN_DEBUG, &bus->dev,
				   "on NUMA node %d (pxm %d)\n", node, pxm);
Yinghai Lu's avatar
Yinghai Lu committed
587
#else
588
		dev_printk(KERN_DEBUG, &bus->dev, "on NUMA node %d\n", node);
589
#endif
Yinghai Lu's avatar
Yinghai Lu committed
590
	}
591

592
	return bus;
Linus Torvalds's avatar
Linus Torvalds committed
593 594
}

595
int __init pci_acpi_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
596 597 598 599
{
	struct pci_dev *dev = NULL;

	if (acpi_noirq)
600
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
601 602 603 604

	printk(KERN_INFO "PCI: Using ACPI for IRQ routing\n");
	acpi_irq_penalty_init();
	pcibios_enable_irq = acpi_pci_irq_enable;
605
	pcibios_disable_irq = acpi_pci_irq_disable;
606
	x86_init.pci.init_irq = x86_init_noop;
Linus Torvalds's avatar
Linus Torvalds committed
607 608 609 610 611 612 613 614

	if (pci_routeirq) {
		/*
		 * PCI IRQ routing is set up by pci_enable_device(), but we
		 * also do it here in case there are still broken drivers that
		 * don't use pci_enable_device().
		 */
		printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n");
615
		for_each_pci_dev(dev)
Linus Torvalds's avatar
Linus Torvalds committed
616
			acpi_pci_irq_enable(dev);
617
	}
Linus Torvalds's avatar
Linus Torvalds committed
618 619 620

	return 0;
}