common.c 17.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8
/*
 *	Low-Level PCI Support for PC
 *
 *	(c) 1999--2000 Martin Mares <mj@ucw.cz>
 */

#include <linux/sched.h>
#include <linux/pci.h>
9
#include <linux/pci-acpi.h>
L
Linus Torvalds 已提交
10 11
#include <linux/ioport.h>
#include <linux/init.h>
12
#include <linux/dmi.h>
13
#include <linux/slab.h>
L
Linus Torvalds 已提交
14 15 16 17 18

#include <asm/acpi.h>
#include <asm/segment.h>
#include <asm/io.h>
#include <asm/smp.h>
19
#include <asm/pci_x86.h>
M
Matthew Garrett 已提交
20
#include <asm/setup.h>
L
Linus Torvalds 已提交
21 22 23 24

unsigned int pci_probe = PCI_PROBE_BIOS | PCI_PROBE_CONF1 | PCI_PROBE_CONF2 |
				PCI_PROBE_MMCONF;

25
unsigned int pci_early_dump_regs;
26
static int pci_bf_sort;
27
static int smbios_type_b1_flag;
L
Linus Torvalds 已提交
28
int pci_routeirq;
29
int noioapicquirk;
30 31 32
#ifdef CONFIG_X86_REROUTE_FOR_BROKEN_BOOT_IRQS
int noioapicreroute = 0;
#else
33
int noioapicreroute = 1;
34
#endif
L
Linus Torvalds 已提交
35
int pcibios_last_bus = -1;
36
unsigned long pirq_table_addr;
J
Jan Beulich 已提交
37 38
const struct pci_raw_ops *__read_mostly raw_pci_ops;
const struct pci_raw_ops *__read_mostly raw_pci_ext_ops;
39 40 41 42

int raw_pci_read(unsigned int domain, unsigned int bus, unsigned int devfn,
						int reg, int len, u32 *val)
{
43
	if (domain == 0 && reg < 256 && raw_pci_ops)
44 45 46 47 48 49 50 51 52
		return raw_pci_ops->read(domain, bus, devfn, reg, len, val);
	if (raw_pci_ext_ops)
		return raw_pci_ext_ops->read(domain, bus, devfn, reg, len, val);
	return -EINVAL;
}

int raw_pci_write(unsigned int domain, unsigned int bus, unsigned int devfn,
						int reg, int len, u32 val)
{
53
	if (domain == 0 && reg < 256 && raw_pci_ops)
54 55 56 57 58
		return raw_pci_ops->write(domain, bus, devfn, reg, len, val);
	if (raw_pci_ext_ops)
		return raw_pci_ext_ops->write(domain, bus, devfn, reg, len, val);
	return -EINVAL;
}
L
Linus Torvalds 已提交
59 60 61

static int pci_read(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *value)
{
62
	return raw_pci_read(pci_domain_nr(bus), bus->number,
63
				 devfn, where, size, value);
L
Linus Torvalds 已提交
64 65 66 67
}

static int pci_write(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 value)
{
68
	return raw_pci_write(pci_domain_nr(bus), bus->number,
69
				  devfn, where, size, value);
L
Linus Torvalds 已提交
70 71 72 73 74 75 76 77 78 79 80
}

struct pci_ops pci_root_ops = {
	.read = pci_read,
	.write = pci_write,
};

/*
 * This interrupt-safe spinlock protects all accesses to PCI
 * configuration space.
 */
81
DEFINE_RAW_SPINLOCK(pci_config_lock);
L
Linus Torvalds 已提交
82

83
static int __init can_skip_ioresource_align(const struct dmi_system_id *d)
84 85 86 87 88 89
{
	pci_probe |= PCI_CAN_SKIP_ISA_ALIGN;
	printk(KERN_INFO "PCI: %s detected, can skip ISA alignment\n", d->ident);
	return 0;
}

90
static const struct dmi_system_id can_skip_pciprobe_dmi_table[] __initconst = {
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
/*
 * Systems where PCI IO resource ISA alignment can be skipped
 * when the ISA enable bit in the bridge control is not set
 */
	{
		.callback = can_skip_ioresource_align,
		.ident = "IBM System x3800",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
			DMI_MATCH(DMI_PRODUCT_NAME, "x3800"),
		},
	},
	{
		.callback = can_skip_ioresource_align,
		.ident = "IBM System x3850",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
			DMI_MATCH(DMI_PRODUCT_NAME, "x3850"),
		},
	},
	{
		.callback = can_skip_ioresource_align,
		.ident = "IBM System x3950",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
			DMI_MATCH(DMI_PRODUCT_NAME, "x3950"),
		},
	},
	{}
};

void __init dmi_check_skip_isa_align(void)
{
	dmi_check_system(can_skip_pciprobe_dmi_table);
}

127
static void pcibios_fixup_device_resources(struct pci_dev *dev)
128 129
{
	struct resource *rom_r = &dev->resource[PCI_ROM_RESOURCE];
130 131 132 133 134 135
	struct resource *bar_r;
	int bar;

	if (pci_probe & PCI_NOASSIGN_BARS) {
		/*
		* If the BIOS did not assign the BAR, zero out the
A
Andrea Gelmini 已提交
136
		* resource so the kernel doesn't attempt to assign
137 138 139 140 141 142 143 144 145 146
		* it later on in pci_assign_unassigned_resources
		*/
		for (bar = 0; bar <= PCI_STD_RESOURCE_END; bar++) {
			bar_r = &dev->resource[bar];
			if (bar_r->start == 0 && bar_r->end != 0) {
				bar_r->flags = 0;
				bar_r->end = 0;
			}
		}
	}
147 148 149 150 151 152 153 154 155 156 157 158

	if (pci_probe & PCI_NOASSIGN_ROMS) {
		if (rom_r->parent)
			return;
		if (rom_r->start) {
			/* we deal with BIOS assigned ROM later */
			return;
		}
		rom_r->start = rom_r->end = rom_r->flags = 0;
	}
}

L
Linus Torvalds 已提交
159 160 161 162 163
/*
 *  Called after each bus is probed, but before its children
 *  are examined.
 */

164
void pcibios_fixup_bus(struct pci_bus *b)
L
Linus Torvalds 已提交
165
{
166 167
	struct pci_dev *dev;

168
	pci_read_bridge_bases(b);
169 170
	list_for_each_entry(dev, &b->devices, bus_list)
		pcibios_fixup_device_resources(dev);
L
Linus Torvalds 已提交
171 172
}

173 174 175 176 177 178 179 180 181 182
void pcibios_add_bus(struct pci_bus *bus)
{
	acpi_pci_add_bus(bus);
}

void pcibios_remove_bus(struct pci_bus *bus)
{
	acpi_pci_remove_bus(bus);
}

183 184 185 186 187
/*
 * Only use DMI information to set this if nothing was passed
 * on the kernel command line (which was parsed earlier).
 */

188
static int __init set_bf_sort(const struct dmi_system_id *d)
189 190 191 192 193 194 195 196
{
	if (pci_bf_sort == pci_bf_sort_default) {
		pci_bf_sort = pci_dmi_bf;
		printk(KERN_INFO "PCI: %s detected, enabling pci=bfsort.\n", d->ident);
	}
	return 0;
}

197 198
static void __init read_dmi_type_b1(const struct dmi_header *dm,
				    void *private_data)
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
{
	u8 *d = (u8 *)dm + 4;

	if (dm->type != 0xB1)
		return;
	switch (((*(u32 *)d) >> 9) & 0x03) {
	case 0x00:
		printk(KERN_INFO "dmi type 0xB1 record - unknown flag\n");
		break;
	case 0x01: /* set pci=bfsort */
		smbios_type_b1_flag = 1;
		break;
	case 0x02: /* do not set pci=bfsort */
		smbios_type_b1_flag = 2;
		break;
	default:
		break;
	}
}

219
static int __init find_sort_method(const struct dmi_system_id *d)
220 221 222 223 224 225 226 227 228 229
{
	dmi_walk(read_dmi_type_b1, NULL);

	if (smbios_type_b1_flag == 1) {
		set_bf_sort(d);
		return 0;
	}
	return -1;
}

230 231 232 233
/*
 * Enable renumbering of PCI bus# ranges to reach all PCI busses (Cardbus)
 */
#ifdef __i386__
234
static int __init assign_all_busses(const struct dmi_system_id *d)
235 236 237 238 239 240 241 242
{
	pci_probe |= PCI_ASSIGN_ALL_BUSSES;
	printk(KERN_INFO "%s detected: enabling PCI bus# renumbering"
			" (pci=assign-busses)\n", d->ident);
	return 0;
}
#endif

243
static int __init set_scan_all(const struct dmi_system_id *d)
244 245 246 247 248 249 250
{
	printk(KERN_INFO "PCI: %s detected, enabling pci=pcie_scan_all\n",
	       d->ident);
	pci_add_flags(PCI_SCAN_ALL_PCIE_DEVS);
	return 0;
}

251
static const struct dmi_system_id pciprobe_dmi_table[] __initconst = {
252
#ifdef __i386__
253 254 255 256 257 258 259 260 261 262 263 264
/*
 * Laptops which need pci=assign-busses to see Cardbus cards
 */
	{
		.callback = assign_all_busses,
		.ident = "Samsung X20 Laptop",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Samsung Electronics"),
			DMI_MATCH(DMI_PRODUCT_NAME, "SX20S"),
		},
	},
#endif		/* __i386__ */
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
	{
		.callback = set_bf_sort,
		.ident = "Dell PowerEdge 1950",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
			DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1950"),
		},
	},
	{
		.callback = set_bf_sort,
		.ident = "Dell PowerEdge 1955",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
			DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1955"),
		},
	},
	{
		.callback = set_bf_sort,
		.ident = "Dell PowerEdge 2900",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
			DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2900"),
		},
	},
	{
		.callback = set_bf_sort,
		.ident = "Dell PowerEdge 2950",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
			DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2950"),
		},
	},
297 298 299 300 301 302 303 304
	{
		.callback = set_bf_sort,
		.ident = "Dell PowerEdge R900",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
			DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge R900"),
		},
	},
305 306 307 308 309 310 311
	{
		.callback = find_sort_method,
		.ident = "Dell System",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
		},
	},
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
	{
		.callback = set_bf_sort,
		.ident = "HP ProLiant BL20p G3",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL20p G3"),
		},
	},
	{
		.callback = set_bf_sort,
		.ident = "HP ProLiant BL20p G4",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL20p G4"),
		},
	},
	{
		.callback = set_bf_sort,
		.ident = "HP ProLiant BL30p G1",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL30p G1"),
		},
	},
	{
		.callback = set_bf_sort,
		.ident = "HP ProLiant BL25p G1",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL25p G1"),
		},
	},
	{
		.callback = set_bf_sort,
		.ident = "HP ProLiant BL35p G1",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL35p G1"),
		},
	},
	{
		.callback = set_bf_sort,
		.ident = "HP ProLiant BL45p G1",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL45p G1"),
		},
	},
	{
		.callback = set_bf_sort,
		.ident = "HP ProLiant BL45p G2",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL45p G2"),
		},
	},
	{
		.callback = set_bf_sort,
		.ident = "HP ProLiant BL460c G1",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL460c G1"),
		},
	},
	{
		.callback = set_bf_sort,
		.ident = "HP ProLiant BL465c G1",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL465c G1"),
		},
	},
	{
		.callback = set_bf_sort,
		.ident = "HP ProLiant BL480c G1",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL480c G1"),
		},
	},
	{
		.callback = set_bf_sort,
		.ident = "HP ProLiant BL685c G1",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL685c G1"),
		},
	},
400 401
	{
		.callback = set_bf_sort,
402
		.ident = "HP ProLiant DL360",
403 404
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
405
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL360"),
406 407 408 409
		},
	},
	{
		.callback = set_bf_sort,
410
		.ident = "HP ProLiant DL380",
411 412
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
413
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL380"),
414 415
		},
	},
416 417 418 419 420 421 422 423 424 425
#ifdef __i386__
	{
		.callback = assign_all_busses,
		.ident = "Compaq EVO N800c",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Compaq"),
			DMI_MATCH(DMI_PRODUCT_NAME, "EVO N800c"),
		},
	},
#endif
426 427
	{
		.callback = set_bf_sort,
428
		.ident = "HP ProLiant DL385 G2",
429 430
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
431
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL385 G2"),
432 433 434 435
		},
	},
	{
		.callback = set_bf_sort,
436
		.ident = "HP ProLiant DL585 G2",
437 438
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
439
			DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL585 G2"),
440 441
		},
	},
442 443 444 445
	{
		.callback = set_scan_all,
		.ident = "Stratus/NEC ftServer",
		.matches = {
446 447
			DMI_MATCH(DMI_SYS_VENDOR, "Stratus"),
			DMI_MATCH(DMI_PRODUCT_NAME, "ftServer"),
448 449
		},
	},
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465
        {
                .callback = set_scan_all,
                .ident = "Stratus/NEC ftServer",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Express5800/R32"),
                },
        },
        {
                .callback = set_scan_all,
                .ident = "Stratus/NEC ftServer",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Express5800/R31"),
                },
        },
466 467
	{}
};
L
Linus Torvalds 已提交
468

Y
Yinghai Lu 已提交
469 470 471 472 473
void __init dmi_check_pciprobe(void)
{
	dmi_check_system(pciprobe_dmi_table);
}

474
void pcibios_scan_root(int busnum)
L
Linus Torvalds 已提交
475
{
476 477 478 479 480 481 482
	struct pci_bus *bus;
	struct pci_sysdata *sd;
	LIST_HEAD(resources);

	sd = kzalloc(sizeof(*sd), GFP_KERNEL);
	if (!sd) {
		printk(KERN_ERR "PCI: OOM, skipping PCI bus %02x\n", busnum);
483
		return;
484
	}
485
	sd->node = x86_pci_root_bus_node(busnum);
486 487 488 489 490 491
	x86_pci_root_bus_resources(busnum, &resources);
	printk(KERN_DEBUG "PCI: Probing PCI hardware (bus %02x)\n", busnum);
	bus = pci_scan_root_bus(NULL, busnum, &pci_root_ops, sd, &resources);
	if (!bus) {
		pci_free_resource_list(&resources);
		kfree(sd);
492
		return;
493
	}
494
	pci_bus_add_devices(bus);
L
Linus Torvalds 已提交
495
}
496

A
Alex Nixon 已提交
497
void __init pcibios_set_cache_line_size(void)
L
Linus Torvalds 已提交
498 499 500 501
{
	struct cpuinfo_x86 *c = &boot_cpu_data;

	/*
502 503 504
	 * Set PCI cacheline size to that of the CPU if the CPU has reported it.
	 * (For older CPUs that don't support cpuid, we se it to 32 bytes
	 * It's also good for 386/486s (which actually have 16)
L
Linus Torvalds 已提交
505 506
	 * as quite a few PCI devices do not support smaller values.
	 */
507 508 509 510 511 512 513 514
	if (c->x86_clflush_size > 0) {
		pci_dfl_cache_line_size = c->x86_clflush_size >> 2;
		printk(KERN_DEBUG "PCI: pci_cache_line_size set to %d bytes\n",
			pci_dfl_cache_line_size << 2);
	} else {
 		pci_dfl_cache_line_size = 32 >> 2;
		printk(KERN_DEBUG "PCI: Unknown cacheline size. Setting to 32 bytes\n");
	}
A
Alex Nixon 已提交
515 516 517 518
}

int __init pcibios_init(void)
{
519
	if (!raw_pci_ops && !raw_pci_ext_ops) {
A
Alex Nixon 已提交
520 521 522
		printk(KERN_WARNING "PCI: System does not support PCI\n");
		return 0;
	}
L
Linus Torvalds 已提交
523

A
Alex Nixon 已提交
524
	pcibios_set_cache_line_size();
L
Linus Torvalds 已提交
525 526
	pcibios_resource_survey();

527 528
	if (pci_bf_sort >= pci_force_bf)
		pci_sort_breadthfirst();
L
Linus Torvalds 已提交
529 530 531
	return 0;
}

532
char *__init pcibios_setup(char *str)
L
Linus Torvalds 已提交
533 534 535 536
{
	if (!strcmp(str, "off")) {
		pci_probe = 0;
		return NULL;
537 538 539 540 541 542
	} else if (!strcmp(str, "bfsort")) {
		pci_bf_sort = pci_force_bf;
		return NULL;
	} else if (!strcmp(str, "nobfsort")) {
		pci_bf_sort = pci_force_nobf;
		return NULL;
L
Linus Torvalds 已提交
543 544 545 546 547 548 549 550 551 552 553
	}
#ifdef CONFIG_PCI_BIOS
	else if (!strcmp(str, "bios")) {
		pci_probe = PCI_PROBE_BIOS;
		return NULL;
	} else if (!strcmp(str, "nobios")) {
		pci_probe &= ~PCI_PROBE_BIOS;
		return NULL;
	} else if (!strcmp(str, "biosirq")) {
		pci_probe |= PCI_BIOS_IRQ_SCAN;
		return NULL;
554 555 556
	} else if (!strncmp(str, "pirqaddr=", 9)) {
		pirq_table_addr = simple_strtoul(str+9, NULL, 0);
		return NULL;
L
Linus Torvalds 已提交
557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573
	}
#endif
#ifdef CONFIG_PCI_DIRECT
	else if (!strcmp(str, "conf1")) {
		pci_probe = PCI_PROBE_CONF1 | PCI_NO_CHECKS;
		return NULL;
	}
	else if (!strcmp(str, "conf2")) {
		pci_probe = PCI_PROBE_CONF2 | PCI_NO_CHECKS;
		return NULL;
	}
#endif
#ifdef CONFIG_PCI_MMCONFIG
	else if (!strcmp(str, "nommconf")) {
		pci_probe &= ~PCI_PROBE_MMCONF;
		return NULL;
	}
574 575 576 577
	else if (!strcmp(str, "check_enable_amd_mmconf")) {
		pci_probe |= PCI_CHECK_ENABLE_AMD_MMCONF;
		return NULL;
	}
L
Linus Torvalds 已提交
578 579 580 581 582
#endif
	else if (!strcmp(str, "noacpi")) {
		acpi_noirq_set();
		return NULL;
	}
583 584 585 586
	else if (!strcmp(str, "noearly")) {
		pci_probe |= PCI_PROBE_NOEARLY;
		return NULL;
	}
L
Linus Torvalds 已提交
587 588 589 590 591 592 593 594 595
	else if (!strcmp(str, "usepirqmask")) {
		pci_probe |= PCI_USE_PIRQ_MASK;
		return NULL;
	} else if (!strncmp(str, "irqmask=", 8)) {
		pcibios_irq_mask = simple_strtol(str+8, NULL, 0);
		return NULL;
	} else if (!strncmp(str, "lastbus=", 8)) {
		pcibios_last_bus = simple_strtol(str+8, NULL, 0);
		return NULL;
596
	} else if (!strcmp(str, "rom")) {
L
Linus Torvalds 已提交
597 598
		pci_probe |= PCI_ASSIGN_ROMS;
		return NULL;
599 600 601
	} else if (!strcmp(str, "norom")) {
		pci_probe |= PCI_NOASSIGN_ROMS;
		return NULL;
602 603 604
	} else if (!strcmp(str, "nobar")) {
		pci_probe |= PCI_NOASSIGN_BARS;
		return NULL;
L
Linus Torvalds 已提交
605 606 607
	} else if (!strcmp(str, "assign-busses")) {
		pci_probe |= PCI_ASSIGN_ALL_BUSSES;
		return NULL;
608 609
	} else if (!strcmp(str, "use_crs")) {
		pci_probe |= PCI_USE__CRS;
610
		return NULL;
611 612 613
	} else if (!strcmp(str, "nocrs")) {
		pci_probe |= PCI_ROOT_NO_CRS;
		return NULL;
614 615 616
	} else if (!strcmp(str, "earlydump")) {
		pci_early_dump_regs = 1;
		return NULL;
L
Linus Torvalds 已提交
617 618 619
	} else if (!strcmp(str, "routeirq")) {
		pci_routeirq = 1;
		return NULL;
620 621 622
	} else if (!strcmp(str, "skip_isa_align")) {
		pci_probe |= PCI_CAN_SKIP_ISA_ALIGN;
		return NULL;
623 624 625
	} else if (!strcmp(str, "noioapicquirk")) {
		noioapicquirk = 1;
		return NULL;
626 627 628 629
	} else if (!strcmp(str, "ioapicreroute")) {
		if (noioapicreroute != -1)
			noioapicreroute = 0;
		return NULL;
630 631 632 633
	} else if (!strcmp(str, "noioapicreroute")) {
		if (noioapicreroute != -1)
			noioapicreroute = 1;
		return NULL;
L
Linus Torvalds 已提交
634 635 636 637 638 639 640 641 642
	}
	return str;
}

unsigned int pcibios_assign_all_busses(void)
{
	return (pci_probe & PCI_ASSIGN_ALL_BUSSES) ? 1 : 0;
}

643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669
#if defined(CONFIG_X86_DEV_DMA_OPS) && defined(CONFIG_PCI_DOMAINS)
static LIST_HEAD(dma_domain_list);
static DEFINE_SPINLOCK(dma_domain_list_lock);

void add_dma_domain(struct dma_domain *domain)
{
	spin_lock(&dma_domain_list_lock);
	list_add(&domain->node, &dma_domain_list);
	spin_unlock(&dma_domain_list_lock);
}
EXPORT_SYMBOL_GPL(add_dma_domain);

void del_dma_domain(struct dma_domain *domain)
{
	spin_lock(&dma_domain_list_lock);
	list_del(&domain->node);
	spin_unlock(&dma_domain_list_lock);
}
EXPORT_SYMBOL_GPL(del_dma_domain);

static void set_dma_domain_ops(struct pci_dev *pdev)
{
	struct dma_domain *domain;

	spin_lock(&dma_domain_list_lock);
	list_for_each_entry(domain, &dma_domain_list, node) {
		if (pci_domain_nr(pdev->bus) == domain->domain_nr) {
670
			pdev->dev.dma_ops = domain->dma_ops;
671 672 673 674 675 676 677 678 679
			break;
		}
	}
	spin_unlock(&dma_domain_list_lock);
}
#else
static void set_dma_domain_ops(struct pci_dev *pdev) {}
#endif

680 681 682 683 684 685
static void set_dev_domain_options(struct pci_dev *pdev)
{
	if (is_vmd(pdev->bus))
		pdev->hotplug_user_indicators = 1;
}

M
Matthew Garrett 已提交
686 687 688 689 690 691 692 693
int pcibios_add_device(struct pci_dev *dev)
{
	struct setup_data *data;
	struct pci_setup_rom *rom;
	u64 pa_data;

	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
694 695 696
		data = ioremap(pa_data, sizeof(*rom));
		if (!data)
			return -ENOMEM;
M
Matthew Garrett 已提交
697 698 699 700 701 702 703 704 705 706

		if (data->type == SETUP_PCI) {
			rom = (struct pci_setup_rom *)data;

			if ((pci_domain_nr(dev->bus) == rom->segment) &&
			    (dev->bus->number == rom->bus) &&
			    (PCI_SLOT(dev->devfn) == rom->device) &&
			    (PCI_FUNC(dev->devfn) == rom->function) &&
			    (dev->vendor == rom->vendor) &&
			    (dev->device == rom->devid)) {
707 708
				dev->rom = pa_data +
				      offsetof(struct pci_setup_rom, romdata);
M
Matthew Garrett 已提交
709 710 711 712
				dev->romlen = rom->pcilen;
			}
		}
		pa_data = data->next;
713
		iounmap(data);
M
Matthew Garrett 已提交
714
	}
715
	set_dma_domain_ops(dev);
716
	set_dev_domain_options(dev);
M
Matthew Garrett 已提交
717 718 719
	return 0;
}

720
int pcibios_enable_device(struct pci_dev *dev, int mask)
L
Linus Torvalds 已提交
721
{
722
	int err;
723

724 725 726 727 728 729
	if ((err = pci_enable_resources(dev, mask)) < 0)
		return err;

	if (!pci_dev_msi_enabled(dev))
		return pcibios_enable_irq(dev);
	return 0;
730 731
}

732
void pcibios_disable_device (struct pci_dev *dev)
733
{
734 735
	if (!pci_dev_msi_enabled(dev) && pcibios_disable_irq)
		pcibios_disable_irq(dev);
736 737
}

738 739 740 741 742 743 744 745 746
#ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
void pcibios_release_device(struct pci_dev *dev)
{
	if (atomic_dec_return(&dev->enable_cnt) >= 0)
		pcibios_disable_device(dev);

}
#endif

747
int pci_ext_cfg_avail(void)
748 749 750 751 752 753
{
	if (raw_pci_ext_ops)
		return 1;
	else
		return 0;
}