blob: d19fd07bafd62d9927a0da675d80404b6db1136f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Low-Level PCI Support for PC
3 *
4 * (c) 1999--2000 Martin Mares <mj@ucw.cz>
5 */
6
7#include <linux/sched.h>
8#include <linux/pci.h>
9#include <linux/ioport.h>
10#include <linux/init.h>
Bernhard Kaindl8c4b2cf2006-02-18 01:36:55 -080011#include <linux/dmi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012
13#include <asm/acpi.h>
14#include <asm/segment.h>
15#include <asm/io.h>
16#include <asm/smp.h>
17
18#include "pci.h"
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020unsigned int pci_probe = PCI_PROBE_BIOS | PCI_PROBE_CONF1 | PCI_PROBE_CONF2 |
21 PCI_PROBE_MMCONF;
22
Yinghai Lue3f2bae2008-05-22 14:35:11 -070023unsigned int pci_early_dump_regs;
Adrian Bunk2b290da2006-11-16 13:16:23 +010024static int pci_bf_sort;
Linus Torvalds1da177e2005-04-16 15:20:36 -070025int pci_routeirq;
26int pcibios_last_bus = -1;
jayalk@intworks.biz120bb422005-03-21 20:20:42 -080027unsigned long pirq_table_addr;
28struct pci_bus *pci_root_bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -070029struct pci_raw_ops *raw_pci_ops;
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -050030struct pci_raw_ops *raw_pci_ext_ops;
31
32int raw_pci_read(unsigned int domain, unsigned int bus, unsigned int devfn,
33 int reg, int len, u32 *val)
34{
35 if (reg < 256 && raw_pci_ops)
36 return raw_pci_ops->read(domain, bus, devfn, reg, len, val);
37 if (raw_pci_ext_ops)
38 return raw_pci_ext_ops->read(domain, bus, devfn, reg, len, val);
39 return -EINVAL;
40}
41
42int raw_pci_write(unsigned int domain, unsigned int bus, unsigned int devfn,
43 int reg, int len, u32 val)
44{
45 if (reg < 256 && raw_pci_ops)
46 return raw_pci_ops->write(domain, bus, devfn, reg, len, val);
47 if (raw_pci_ext_ops)
48 return raw_pci_ext_ops->write(domain, bus, devfn, reg, len, val);
49 return -EINVAL;
50}
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
52static int pci_read(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *value)
53{
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -050054 return raw_pci_read(pci_domain_nr(bus), bus->number,
Jeff Garzika79e4192007-10-11 16:58:30 -040055 devfn, where, size, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056}
57
58static int pci_write(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 value)
59{
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -050060 return raw_pci_write(pci_domain_nr(bus), bus->number,
Jeff Garzika79e4192007-10-11 16:58:30 -040061 devfn, where, size, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -070062}
63
64struct pci_ops pci_root_ops = {
65 .read = pci_read,
66 .write = pci_write,
67};
68
69/*
70 * legacy, numa, and acpi all want to call pcibios_scan_root
71 * from their initcalls. This flag prevents that.
72 */
73int pcibios_scanned;
74
75/*
76 * This interrupt-safe spinlock protects all accesses to PCI
77 * configuration space.
78 */
79DEFINE_SPINLOCK(pci_config_lock);
80
Yinghai Lu13a6ddb2008-03-27 01:31:18 -070081static int __devinit can_skip_ioresource_align(const struct dmi_system_id *d)
82{
83 pci_probe |= PCI_CAN_SKIP_ISA_ALIGN;
84 printk(KERN_INFO "PCI: %s detected, can skip ISA alignment\n", d->ident);
85 return 0;
86}
87
88static struct dmi_system_id can_skip_pciprobe_dmi_table[] __devinitdata = {
89/*
90 * Systems where PCI IO resource ISA alignment can be skipped
91 * when the ISA enable bit in the bridge control is not set
92 */
93 {
94 .callback = can_skip_ioresource_align,
95 .ident = "IBM System x3800",
96 .matches = {
97 DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
98 DMI_MATCH(DMI_PRODUCT_NAME, "x3800"),
99 },
100 },
101 {
102 .callback = can_skip_ioresource_align,
103 .ident = "IBM System x3850",
104 .matches = {
105 DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
106 DMI_MATCH(DMI_PRODUCT_NAME, "x3850"),
107 },
108 },
109 {
110 .callback = can_skip_ioresource_align,
111 .ident = "IBM System x3950",
112 .matches = {
113 DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
114 DMI_MATCH(DMI_PRODUCT_NAME, "x3950"),
115 },
116 },
117 {}
118};
119
120void __init dmi_check_skip_isa_align(void)
121{
122 dmi_check_system(can_skip_pciprobe_dmi_table);
123}
124
Gary Hadebb71ad82008-05-12 13:57:46 -0700125static void __devinit pcibios_fixup_device_resources(struct pci_dev *dev)
126{
127 struct resource *rom_r = &dev->resource[PCI_ROM_RESOURCE];
128
129 if (pci_probe & PCI_NOASSIGN_ROMS) {
130 if (rom_r->parent)
131 return;
132 if (rom_r->start) {
133 /* we deal with BIOS assigned ROM later */
134 return;
135 }
136 rom_r->start = rom_r->end = rom_r->flags = 0;
137 }
138}
139
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140/*
141 * Called after each bus is probed, but before its children
142 * are examined.
143 */
144
145void __devinit pcibios_fixup_bus(struct pci_bus *b)
146{
Gary Hadebb71ad82008-05-12 13:57:46 -0700147 struct pci_dev *dev;
148
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 pci_read_bridge_bases(b);
Gary Hadebb71ad82008-05-12 13:57:46 -0700150 list_for_each_entry(dev, &b->devices, bus_list)
151 pcibios_fixup_device_resources(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152}
153
Bernhard Kaindl8c4b2cf2006-02-18 01:36:55 -0800154/*
Matt Domsch6b4b78f2006-09-29 15:23:23 -0500155 * Only use DMI information to set this if nothing was passed
156 * on the kernel command line (which was parsed earlier).
157 */
158
Jeff Garzik18552562007-10-03 15:15:40 -0400159static int __devinit set_bf_sort(const struct dmi_system_id *d)
Matt Domsch6b4b78f2006-09-29 15:23:23 -0500160{
161 if (pci_bf_sort == pci_bf_sort_default) {
162 pci_bf_sort = pci_dmi_bf;
163 printk(KERN_INFO "PCI: %s detected, enabling pci=bfsort.\n", d->ident);
164 }
165 return 0;
166}
167
168/*
Bernhard Kaindl8c4b2cf2006-02-18 01:36:55 -0800169 * Enable renumbering of PCI bus# ranges to reach all PCI busses (Cardbus)
170 */
171#ifdef __i386__
Jeff Garzik18552562007-10-03 15:15:40 -0400172static int __devinit assign_all_busses(const struct dmi_system_id *d)
Bernhard Kaindl8c4b2cf2006-02-18 01:36:55 -0800173{
174 pci_probe |= PCI_ASSIGN_ALL_BUSSES;
175 printk(KERN_INFO "%s detected: enabling PCI bus# renumbering"
176 " (pci=assign-busses)\n", d->ident);
177 return 0;
178}
179#endif
180
Matt Domsch6b4b78f2006-09-29 15:23:23 -0500181static struct dmi_system_id __devinitdata pciprobe_dmi_table[] = {
182#ifdef __i386__
Bernhard Kaindl8c4b2cf2006-02-18 01:36:55 -0800183/*
184 * Laptops which need pci=assign-busses to see Cardbus cards
185 */
Bernhard Kaindl8c4b2cf2006-02-18 01:36:55 -0800186 {
187 .callback = assign_all_busses,
188 .ident = "Samsung X20 Laptop",
189 .matches = {
190 DMI_MATCH(DMI_SYS_VENDOR, "Samsung Electronics"),
191 DMI_MATCH(DMI_PRODUCT_NAME, "SX20S"),
192 },
193 },
194#endif /* __i386__ */
Matt Domsch6b4b78f2006-09-29 15:23:23 -0500195 {
196 .callback = set_bf_sort,
197 .ident = "Dell PowerEdge 1950",
198 .matches = {
199 DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
200 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1950"),
201 },
202 },
203 {
204 .callback = set_bf_sort,
205 .ident = "Dell PowerEdge 1955",
206 .matches = {
207 DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
208 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1955"),
209 },
210 },
211 {
212 .callback = set_bf_sort,
213 .ident = "Dell PowerEdge 2900",
214 .matches = {
215 DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
216 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2900"),
217 },
218 },
219 {
220 .callback = set_bf_sort,
221 .ident = "Dell PowerEdge 2950",
222 .matches = {
223 DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
224 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2950"),
225 },
226 },
Andy Gospodarekf52383d2007-02-05 16:36:10 -0800227 {
228 .callback = set_bf_sort,
Matt Domschf7a9dae2007-03-23 23:58:07 -0500229 .ident = "Dell PowerEdge R900",
230 .matches = {
231 DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
232 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge R900"),
233 },
234 },
235 {
236 .callback = set_bf_sort,
Andy Gospodarekf52383d2007-02-05 16:36:10 -0800237 .ident = "HP ProLiant BL20p G3",
238 .matches = {
239 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
240 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL20p G3"),
241 },
242 },
243 {
244 .callback = set_bf_sort,
245 .ident = "HP ProLiant BL20p G4",
246 .matches = {
247 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
248 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL20p G4"),
249 },
250 },
251 {
252 .callback = set_bf_sort,
253 .ident = "HP ProLiant BL30p G1",
254 .matches = {
255 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
256 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL30p G1"),
257 },
258 },
259 {
260 .callback = set_bf_sort,
261 .ident = "HP ProLiant BL25p G1",
262 .matches = {
263 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
264 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL25p G1"),
265 },
266 },
267 {
268 .callback = set_bf_sort,
269 .ident = "HP ProLiant BL35p G1",
270 .matches = {
271 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
272 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL35p G1"),
273 },
274 },
275 {
276 .callback = set_bf_sort,
277 .ident = "HP ProLiant BL45p G1",
278 .matches = {
279 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
280 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL45p G1"),
281 },
282 },
283 {
284 .callback = set_bf_sort,
285 .ident = "HP ProLiant BL45p G2",
286 .matches = {
287 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
288 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL45p G2"),
289 },
290 },
291 {
292 .callback = set_bf_sort,
293 .ident = "HP ProLiant BL460c G1",
294 .matches = {
295 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
296 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL460c G1"),
297 },
298 },
299 {
300 .callback = set_bf_sort,
301 .ident = "HP ProLiant BL465c G1",
302 .matches = {
303 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
304 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL465c G1"),
305 },
306 },
307 {
308 .callback = set_bf_sort,
309 .ident = "HP ProLiant BL480c G1",
310 .matches = {
311 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
312 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL480c G1"),
313 },
314 },
315 {
316 .callback = set_bf_sort,
317 .ident = "HP ProLiant BL685c G1",
318 .matches = {
319 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
320 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL685c G1"),
321 },
322 },
Michal Schmidt8f8ae1a2007-10-17 18:04:35 +0200323 {
324 .callback = set_bf_sort,
Tony Camuso8d64c782008-05-15 14:40:14 -0400325 .ident = "HP ProLiant DL360",
Michal Schmidt8f8ae1a2007-10-17 18:04:35 +0200326 .matches = {
327 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
Tony Camuso8d64c782008-05-15 14:40:14 -0400328 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL360"),
Michal Schmidt8f8ae1a2007-10-17 18:04:35 +0200329 },
330 },
331 {
332 .callback = set_bf_sort,
Tony Camuso8d64c782008-05-15 14:40:14 -0400333 .ident = "HP ProLiant DL380",
Michal Schmidt8f8ae1a2007-10-17 18:04:35 +0200334 .matches = {
335 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
Tony Camuso8d64c782008-05-15 14:40:14 -0400336 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL380"),
Michal Schmidt8f8ae1a2007-10-17 18:04:35 +0200337 },
338 },
Juha Laiho5b1ea822007-09-13 21:21:34 +0300339#ifdef __i386__
340 {
341 .callback = assign_all_busses,
342 .ident = "Compaq EVO N800c",
343 .matches = {
344 DMI_MATCH(DMI_SYS_VENDOR, "Compaq"),
345 DMI_MATCH(DMI_PRODUCT_NAME, "EVO N800c"),
346 },
347 },
348#endif
Michal Schmidtc82bc5a2007-11-26 20:42:19 +0100349 {
350 .callback = set_bf_sort,
351 .ident = "HP ProLiant DL385 G2",
352 .matches = {
353 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
354 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL385 G2"),
355 },
356 },
357 {
358 .callback = set_bf_sort,
359 .ident = "HP ProLiant DL585 G2",
360 .matches = {
361 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
362 DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL585 G2"),
363 },
364 },
Bernhard Kaindl8c4b2cf2006-02-18 01:36:55 -0800365 {}
366};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
Yinghai Lu0df18ff2008-04-14 15:40:37 -0700368void __init dmi_check_pciprobe(void)
369{
370 dmi_check_system(pciprobe_dmi_table);
371}
372
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373struct pci_bus * __devinit pcibios_scan_root(int busnum)
374{
375 struct pci_bus *bus = NULL;
Muli Ben-Yehuda08f1c192007-07-22 00:23:39 +0300376 struct pci_sysdata *sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
378 while ((bus = pci_find_next_bus(bus)) != NULL) {
379 if (bus->number == busnum) {
380 /* Already scanned */
381 return bus;
382 }
383 }
384
Muli Ben-Yehuda08f1c192007-07-22 00:23:39 +0300385 /* Allocate per-root-bus (not per bus) arch-specific data.
386 * TODO: leak; this memory is never freed.
387 * It's arguable whether it's worth the trouble to care.
388 */
389 sd = kzalloc(sizeof(*sd), GFP_KERNEL);
390 if (!sd) {
391 printk(KERN_ERR "PCI: OOM, not probing PCI bus %02x\n", busnum);
392 return NULL;
393 }
394
Yinghai Lu871d5f82008-02-19 03:20:09 -0800395 sd->node = get_mp_bus_to_node(busnum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
Yinghai Lu871d5f82008-02-19 03:20:09 -0800397 printk(KERN_DEBUG "PCI: Probing PCI hardware (bus %02x)\n", busnum);
398 bus = pci_scan_bus_parented(NULL, busnum, &pci_root_ops, sd);
399 if (!bus)
400 kfree(sd);
401
402 return bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403}
404
405extern u8 pci_cache_line_size;
406
407static int __init pcibios_init(void)
408{
409 struct cpuinfo_x86 *c = &boot_cpu_data;
410
411 if (!raw_pci_ops) {
Daniel Marjamäkiadcb89072005-11-23 15:44:49 -0800412 printk(KERN_WARNING "PCI: System does not support PCI\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 return 0;
414 }
415
416 /*
417 * Assume PCI cacheline size of 32 bytes for all x86s except K7/K8
418 * and P4. It's also good for 386/486s (which actually have 16)
419 * as quite a few PCI devices do not support smaller values.
420 */
421 pci_cache_line_size = 32 >> 2;
422 if (c->x86 >= 6 && c->x86_vendor == X86_VENDOR_AMD)
423 pci_cache_line_size = 64 >> 2; /* K7 & K8 */
424 else if (c->x86 > 6 && c->x86_vendor == X86_VENDOR_INTEL)
425 pci_cache_line_size = 128 >> 2; /* P4 */
426
427 pcibios_resource_survey();
428
Matt Domsch6b4b78f2006-09-29 15:23:23 -0500429 if (pci_bf_sort >= pci_force_bf)
430 pci_sort_breadthfirst();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 return 0;
432}
433
434subsys_initcall(pcibios_init);
435
436char * __devinit pcibios_setup(char *str)
437{
438 if (!strcmp(str, "off")) {
439 pci_probe = 0;
440 return NULL;
Matt Domsch6b4b78f2006-09-29 15:23:23 -0500441 } else if (!strcmp(str, "bfsort")) {
442 pci_bf_sort = pci_force_bf;
443 return NULL;
444 } else if (!strcmp(str, "nobfsort")) {
445 pci_bf_sort = pci_force_nobf;
446 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 }
448#ifdef CONFIG_PCI_BIOS
449 else if (!strcmp(str, "bios")) {
450 pci_probe = PCI_PROBE_BIOS;
451 return NULL;
452 } else if (!strcmp(str, "nobios")) {
453 pci_probe &= ~PCI_PROBE_BIOS;
454 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 } else if (!strcmp(str, "biosirq")) {
456 pci_probe |= PCI_BIOS_IRQ_SCAN;
457 return NULL;
jayalk@intworks.biz120bb422005-03-21 20:20:42 -0800458 } else if (!strncmp(str, "pirqaddr=", 9)) {
459 pirq_table_addr = simple_strtoul(str+9, NULL, 0);
460 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 }
462#endif
463#ifdef CONFIG_PCI_DIRECT
464 else if (!strcmp(str, "conf1")) {
465 pci_probe = PCI_PROBE_CONF1 | PCI_NO_CHECKS;
466 return NULL;
467 }
468 else if (!strcmp(str, "conf2")) {
469 pci_probe = PCI_PROBE_CONF2 | PCI_NO_CHECKS;
470 return NULL;
471 }
472#endif
473#ifdef CONFIG_PCI_MMCONFIG
474 else if (!strcmp(str, "nommconf")) {
475 pci_probe &= ~PCI_PROBE_MMCONF;
476 return NULL;
477 }
Yinghai Lu5f0b2972008-04-14 16:08:25 -0700478 else if (!strcmp(str, "check_enable_amd_mmconf")) {
479 pci_probe |= PCI_CHECK_ENABLE_AMD_MMCONF;
480 return NULL;
481 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482#endif
483 else if (!strcmp(str, "noacpi")) {
484 acpi_noirq_set();
485 return NULL;
486 }
Andi Kleen0637a702006-09-26 10:52:41 +0200487 else if (!strcmp(str, "noearly")) {
488 pci_probe |= PCI_PROBE_NOEARLY;
489 return NULL;
490 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491#ifndef CONFIG_X86_VISWS
492 else if (!strcmp(str, "usepirqmask")) {
493 pci_probe |= PCI_USE_PIRQ_MASK;
494 return NULL;
495 } else if (!strncmp(str, "irqmask=", 8)) {
496 pcibios_irq_mask = simple_strtol(str+8, NULL, 0);
497 return NULL;
498 } else if (!strncmp(str, "lastbus=", 8)) {
499 pcibios_last_bus = simple_strtol(str+8, NULL, 0);
500 return NULL;
501 }
502#endif
503 else if (!strcmp(str, "rom")) {
504 pci_probe |= PCI_ASSIGN_ROMS;
505 return NULL;
Gary Hadebb71ad82008-05-12 13:57:46 -0700506 } else if (!strcmp(str, "norom")) {
507 pci_probe |= PCI_NOASSIGN_ROMS;
508 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 } else if (!strcmp(str, "assign-busses")) {
510 pci_probe |= PCI_ASSIGN_ALL_BUSSES;
511 return NULL;
Gary Hade62f420f2007-10-03 15:56:51 -0700512 } else if (!strcmp(str, "use_crs")) {
513 pci_probe |= PCI_USE__CRS;
514 return NULL;
Yinghai Lue3f2bae2008-05-22 14:35:11 -0700515 } else if (!strcmp(str, "earlydump")) {
516 pci_early_dump_regs = 1;
517 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 } else if (!strcmp(str, "routeirq")) {
519 pci_routeirq = 1;
520 return NULL;
Yinghai Lu13a6ddb2008-03-27 01:31:18 -0700521 } else if (!strcmp(str, "skip_isa_align")) {
522 pci_probe |= PCI_CAN_SKIP_ISA_ALIGN;
523 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 }
525 return str;
526}
527
528unsigned int pcibios_assign_all_busses(void)
529{
530 return (pci_probe & PCI_ASSIGN_ALL_BUSSES) ? 1 : 0;
531}
532
533int pcibios_enable_device(struct pci_dev *dev, int mask)
534{
535 int err;
536
Bjorn Helgaasb81d9882008-03-04 11:57:01 -0700537 if ((err = pci_enable_resources(dev, mask)) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 return err;
539
Eric W. Biedermanbba6f6f2007-03-28 15:36:09 +0200540 if (!dev->msi_enabled)
541 return pcibios_enable_irq(dev);
542 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543}
David Shaohua Li87bec662005-07-27 23:02:00 -0400544
545void pcibios_disable_device (struct pci_dev *dev)
546{
Eric W. Biedermanbba6f6f2007-03-28 15:36:09 +0200547 if (!dev->msi_enabled && pcibios_disable_irq)
David Shaohua Li87bec662005-07-27 23:02:00 -0400548 pcibios_disable_irq(dev);
549}
Muli Ben-Yehuda73c59af2007-08-10 13:01:19 -0700550
Sam Ravnborg98db6f12008-04-29 22:38:48 +0200551struct pci_bus * __devinit pci_scan_bus_on_node(int busno, struct pci_ops *ops, int node)
Muli Ben-Yehuda73c59af2007-08-10 13:01:19 -0700552{
553 struct pci_bus *bus = NULL;
554 struct pci_sysdata *sd;
555
556 /*
557 * Allocate per-root-bus (not per bus) arch-specific data.
558 * TODO: leak; this memory is never freed.
559 * It's arguable whether it's worth the trouble to care.
560 */
561 sd = kzalloc(sizeof(*sd), GFP_KERNEL);
562 if (!sd) {
563 printk(KERN_ERR "PCI: OOM, skipping PCI bus %02x\n", busno);
564 return NULL;
565 }
Yinghai Lu871d5f82008-02-19 03:20:09 -0800566 sd->node = node;
567 bus = pci_scan_bus(busno, ops, sd);
Muli Ben-Yehuda73c59af2007-08-10 13:01:19 -0700568 if (!bus)
569 kfree(sd);
570
571 return bus;
572}
Yinghai Lu871d5f82008-02-19 03:20:09 -0800573
Sam Ravnborg98db6f12008-04-29 22:38:48 +0200574struct pci_bus * __devinit pci_scan_bus_with_sysdata(int busno)
Yinghai Lu871d5f82008-02-19 03:20:09 -0800575{
576 return pci_scan_bus_on_node(busno, &pci_root_ops, -1);
577}