PCI: Work around Stratus ftServer broken PCIe hierarchy (fix DMI check)
[linux-3.10.git] / arch / x86 / pci / common.c
1 /*
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>
11 #include <linux/dmi.h>
12 #include <linux/slab.h>
13
14 #include <asm-generic/pci-bridge.h>
15 #include <asm/acpi.h>
16 #include <asm/segment.h>
17 #include <asm/io.h>
18 #include <asm/smp.h>
19 #include <asm/pci_x86.h>
20 #include <asm/setup.h>
21
22 unsigned int pci_probe = PCI_PROBE_BIOS | PCI_PROBE_CONF1 | PCI_PROBE_CONF2 |
23                                 PCI_PROBE_MMCONF;
24
25 unsigned int pci_early_dump_regs;
26 static int pci_bf_sort;
27 static int smbios_type_b1_flag;
28 int pci_routeirq;
29 int noioapicquirk;
30 #ifdef CONFIG_X86_REROUTE_FOR_BROKEN_BOOT_IRQS
31 int noioapicreroute = 0;
32 #else
33 int noioapicreroute = 1;
34 #endif
35 int pcibios_last_bus = -1;
36 unsigned long pirq_table_addr;
37 struct pci_bus *pci_root_bus;
38 const struct pci_raw_ops *__read_mostly raw_pci_ops;
39 const struct pci_raw_ops *__read_mostly raw_pci_ext_ops;
40
41 int raw_pci_read(unsigned int domain, unsigned int bus, unsigned int devfn,
42                                                 int reg, int len, u32 *val)
43 {
44         if (domain == 0 && reg < 256 && raw_pci_ops)
45                 return raw_pci_ops->read(domain, bus, devfn, reg, len, val);
46         if (raw_pci_ext_ops)
47                 return raw_pci_ext_ops->read(domain, bus, devfn, reg, len, val);
48         return -EINVAL;
49 }
50
51 int raw_pci_write(unsigned int domain, unsigned int bus, unsigned int devfn,
52                                                 int reg, int len, u32 val)
53 {
54         if (domain == 0 && reg < 256 && raw_pci_ops)
55                 return raw_pci_ops->write(domain, bus, devfn, reg, len, val);
56         if (raw_pci_ext_ops)
57                 return raw_pci_ext_ops->write(domain, bus, devfn, reg, len, val);
58         return -EINVAL;
59 }
60
61 static int pci_read(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *value)
62 {
63         return raw_pci_read(pci_domain_nr(bus), bus->number,
64                                  devfn, where, size, value);
65 }
66
67 static int pci_write(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 value)
68 {
69         return raw_pci_write(pci_domain_nr(bus), bus->number,
70                                   devfn, where, size, value);
71 }
72
73 struct pci_ops pci_root_ops = {
74         .read = pci_read,
75         .write = pci_write,
76 };
77
78 /*
79  * This interrupt-safe spinlock protects all accesses to PCI
80  * configuration space.
81  */
82 DEFINE_RAW_SPINLOCK(pci_config_lock);
83
84 static int __devinit can_skip_ioresource_align(const struct dmi_system_id *d)
85 {
86         pci_probe |= PCI_CAN_SKIP_ISA_ALIGN;
87         printk(KERN_INFO "PCI: %s detected, can skip ISA alignment\n", d->ident);
88         return 0;
89 }
90
91 static const struct dmi_system_id can_skip_pciprobe_dmi_table[] __devinitconst = {
92 /*
93  * Systems where PCI IO resource ISA alignment can be skipped
94  * when the ISA enable bit in the bridge control is not set
95  */
96         {
97                 .callback = can_skip_ioresource_align,
98                 .ident = "IBM System x3800",
99                 .matches = {
100                         DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
101                         DMI_MATCH(DMI_PRODUCT_NAME, "x3800"),
102                 },
103         },
104         {
105                 .callback = can_skip_ioresource_align,
106                 .ident = "IBM System x3850",
107                 .matches = {
108                         DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
109                         DMI_MATCH(DMI_PRODUCT_NAME, "x3850"),
110                 },
111         },
112         {
113                 .callback = can_skip_ioresource_align,
114                 .ident = "IBM System x3950",
115                 .matches = {
116                         DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
117                         DMI_MATCH(DMI_PRODUCT_NAME, "x3950"),
118                 },
119         },
120         {}
121 };
122
123 void __init dmi_check_skip_isa_align(void)
124 {
125         dmi_check_system(can_skip_pciprobe_dmi_table);
126 }
127
128 static void __devinit pcibios_fixup_device_resources(struct pci_dev *dev)
129 {
130         struct resource *rom_r = &dev->resource[PCI_ROM_RESOURCE];
131         struct resource *bar_r;
132         int bar;
133
134         if (pci_probe & PCI_NOASSIGN_BARS) {
135                 /*
136                 * If the BIOS did not assign the BAR, zero out the
137                 * resource so the kernel doesn't attmept to assign
138                 * it later on in pci_assign_unassigned_resources
139                 */
140                 for (bar = 0; bar <= PCI_STD_RESOURCE_END; bar++) {
141                         bar_r = &dev->resource[bar];
142                         if (bar_r->start == 0 && bar_r->end != 0) {
143                                 bar_r->flags = 0;
144                                 bar_r->end = 0;
145                         }
146                 }
147         }
148
149         if (pci_probe & PCI_NOASSIGN_ROMS) {
150                 if (rom_r->parent)
151                         return;
152                 if (rom_r->start) {
153                         /* we deal with BIOS assigned ROM later */
154                         return;
155                 }
156                 rom_r->start = rom_r->end = rom_r->flags = 0;
157         }
158 }
159
160 /*
161  *  Called after each bus is probed, but before its children
162  *  are examined.
163  */
164
165 void __devinit pcibios_fixup_bus(struct pci_bus *b)
166 {
167         struct pci_dev *dev;
168
169         pci_read_bridge_bases(b);
170         list_for_each_entry(dev, &b->devices, bus_list)
171                 pcibios_fixup_device_resources(dev);
172 }
173
174 /*
175  * Only use DMI information to set this if nothing was passed
176  * on the kernel command line (which was parsed earlier).
177  */
178
179 static int __devinit set_bf_sort(const struct dmi_system_id *d)
180 {
181         if (pci_bf_sort == pci_bf_sort_default) {
182                 pci_bf_sort = pci_dmi_bf;
183                 printk(KERN_INFO "PCI: %s detected, enabling pci=bfsort.\n", d->ident);
184         }
185         return 0;
186 }
187
188 static void __devinit read_dmi_type_b1(const struct dmi_header *dm,
189                                        void *private_data)
190 {
191         u8 *d = (u8 *)dm + 4;
192
193         if (dm->type != 0xB1)
194                 return;
195         switch (((*(u32 *)d) >> 9) & 0x03) {
196         case 0x00:
197                 printk(KERN_INFO "dmi type 0xB1 record - unknown flag\n");
198                 break;
199         case 0x01: /* set pci=bfsort */
200                 smbios_type_b1_flag = 1;
201                 break;
202         case 0x02: /* do not set pci=bfsort */
203                 smbios_type_b1_flag = 2;
204                 break;
205         default:
206                 break;
207         }
208 }
209
210 static int __devinit find_sort_method(const struct dmi_system_id *d)
211 {
212         dmi_walk(read_dmi_type_b1, NULL);
213
214         if (smbios_type_b1_flag == 1) {
215                 set_bf_sort(d);
216                 return 0;
217         }
218         return -1;
219 }
220
221 /*
222  * Enable renumbering of PCI bus# ranges to reach all PCI busses (Cardbus)
223  */
224 #ifdef __i386__
225 static int __devinit assign_all_busses(const struct dmi_system_id *d)
226 {
227         pci_probe |= PCI_ASSIGN_ALL_BUSSES;
228         printk(KERN_INFO "%s detected: enabling PCI bus# renumbering"
229                         " (pci=assign-busses)\n", d->ident);
230         return 0;
231 }
232 #endif
233
234 static int __devinit set_scan_all(const struct dmi_system_id *d)
235 {
236         printk(KERN_INFO "PCI: %s detected, enabling pci=pcie_scan_all\n",
237                d->ident);
238         pci_add_flags(PCI_SCAN_ALL_PCIE_DEVS);
239         return 0;
240 }
241
242 static const struct dmi_system_id __devinitconst pciprobe_dmi_table[] = {
243 #ifdef __i386__
244 /*
245  * Laptops which need pci=assign-busses to see Cardbus cards
246  */
247         {
248                 .callback = assign_all_busses,
249                 .ident = "Samsung X20 Laptop",
250                 .matches = {
251                         DMI_MATCH(DMI_SYS_VENDOR, "Samsung Electronics"),
252                         DMI_MATCH(DMI_PRODUCT_NAME, "SX20S"),
253                 },
254         },
255 #endif          /* __i386__ */
256         {
257                 .callback = set_bf_sort,
258                 .ident = "Dell PowerEdge 1950",
259                 .matches = {
260                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
261                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1950"),
262                 },
263         },
264         {
265                 .callback = set_bf_sort,
266                 .ident = "Dell PowerEdge 1955",
267                 .matches = {
268                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
269                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1955"),
270                 },
271         },
272         {
273                 .callback = set_bf_sort,
274                 .ident = "Dell PowerEdge 2900",
275                 .matches = {
276                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
277                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2900"),
278                 },
279         },
280         {
281                 .callback = set_bf_sort,
282                 .ident = "Dell PowerEdge 2950",
283                 .matches = {
284                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
285                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2950"),
286                 },
287         },
288         {
289                 .callback = set_bf_sort,
290                 .ident = "Dell PowerEdge R900",
291                 .matches = {
292                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
293                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge R900"),
294                 },
295         },
296         {
297                 .callback = find_sort_method,
298                 .ident = "Dell System",
299                 .matches = {
300                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
301                 },
302         },
303         {
304                 .callback = set_bf_sort,
305                 .ident = "HP ProLiant BL20p G3",
306                 .matches = {
307                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
308                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL20p G3"),
309                 },
310         },
311         {
312                 .callback = set_bf_sort,
313                 .ident = "HP ProLiant BL20p G4",
314                 .matches = {
315                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
316                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL20p G4"),
317                 },
318         },
319         {
320                 .callback = set_bf_sort,
321                 .ident = "HP ProLiant BL30p G1",
322                 .matches = {
323                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
324                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL30p G1"),
325                 },
326         },
327         {
328                 .callback = set_bf_sort,
329                 .ident = "HP ProLiant BL25p G1",
330                 .matches = {
331                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
332                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL25p G1"),
333                 },
334         },
335         {
336                 .callback = set_bf_sort,
337                 .ident = "HP ProLiant BL35p G1",
338                 .matches = {
339                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
340                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL35p G1"),
341                 },
342         },
343         {
344                 .callback = set_bf_sort,
345                 .ident = "HP ProLiant BL45p G1",
346                 .matches = {
347                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
348                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL45p G1"),
349                 },
350         },
351         {
352                 .callback = set_bf_sort,
353                 .ident = "HP ProLiant BL45p G2",
354                 .matches = {
355                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
356                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL45p G2"),
357                 },
358         },
359         {
360                 .callback = set_bf_sort,
361                 .ident = "HP ProLiant BL460c G1",
362                 .matches = {
363                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
364                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL460c G1"),
365                 },
366         },
367         {
368                 .callback = set_bf_sort,
369                 .ident = "HP ProLiant BL465c G1",
370                 .matches = {
371                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
372                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL465c G1"),
373                 },
374         },
375         {
376                 .callback = set_bf_sort,
377                 .ident = "HP ProLiant BL480c G1",
378                 .matches = {
379                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
380                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL480c G1"),
381                 },
382         },
383         {
384                 .callback = set_bf_sort,
385                 .ident = "HP ProLiant BL685c G1",
386                 .matches = {
387                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
388                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL685c G1"),
389                 },
390         },
391         {
392                 .callback = set_bf_sort,
393                 .ident = "HP ProLiant DL360",
394                 .matches = {
395                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
396                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL360"),
397                 },
398         },
399         {
400                 .callback = set_bf_sort,
401                 .ident = "HP ProLiant DL380",
402                 .matches = {
403                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
404                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL380"),
405                 },
406         },
407 #ifdef __i386__
408         {
409                 .callback = assign_all_busses,
410                 .ident = "Compaq EVO N800c",
411                 .matches = {
412                         DMI_MATCH(DMI_SYS_VENDOR, "Compaq"),
413                         DMI_MATCH(DMI_PRODUCT_NAME, "EVO N800c"),
414                 },
415         },
416 #endif
417         {
418                 .callback = set_bf_sort,
419                 .ident = "HP ProLiant DL385 G2",
420                 .matches = {
421                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
422                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL385 G2"),
423                 },
424         },
425         {
426                 .callback = set_bf_sort,
427                 .ident = "HP ProLiant DL585 G2",
428                 .matches = {
429                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
430                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL585 G2"),
431                 },
432         },
433         {
434                 .callback = set_scan_all,
435                 .ident = "Stratus/NEC ftServer",
436                 .matches = {
437                         DMI_MATCH(DMI_SYS_VENDOR, "Stratus"),
438                         DMI_MATCH(DMI_PRODUCT_NAME, "ftServer"),
439                 },
440         },
441         {}
442 };
443
444 void __init dmi_check_pciprobe(void)
445 {
446         dmi_check_system(pciprobe_dmi_table);
447 }
448
449 struct pci_bus * __devinit pcibios_scan_root(int busnum)
450 {
451         struct pci_bus *bus = NULL;
452
453         while ((bus = pci_find_next_bus(bus)) != NULL) {
454                 if (bus->number == busnum) {
455                         /* Already scanned */
456                         return bus;
457                 }
458         }
459
460         return pci_scan_bus_on_node(busnum, &pci_root_ops,
461                                         get_mp_bus_to_node(busnum));
462 }
463
464 void __init pcibios_set_cache_line_size(void)
465 {
466         struct cpuinfo_x86 *c = &boot_cpu_data;
467
468         /*
469          * Set PCI cacheline size to that of the CPU if the CPU has reported it.
470          * (For older CPUs that don't support cpuid, we se it to 32 bytes
471          * It's also good for 386/486s (which actually have 16)
472          * as quite a few PCI devices do not support smaller values.
473          */
474         if (c->x86_clflush_size > 0) {
475                 pci_dfl_cache_line_size = c->x86_clflush_size >> 2;
476                 printk(KERN_DEBUG "PCI: pci_cache_line_size set to %d bytes\n",
477                         pci_dfl_cache_line_size << 2);
478         } else {
479                 pci_dfl_cache_line_size = 32 >> 2;
480                 printk(KERN_DEBUG "PCI: Unknown cacheline size. Setting to 32 bytes\n");
481         }
482 }
483
484 int __init pcibios_init(void)
485 {
486         if (!raw_pci_ops) {
487                 printk(KERN_WARNING "PCI: System does not support PCI\n");
488                 return 0;
489         }
490
491         pcibios_set_cache_line_size();
492         pcibios_resource_survey();
493
494         if (pci_bf_sort >= pci_force_bf)
495                 pci_sort_breadthfirst();
496         return 0;
497 }
498
499 char * __init pcibios_setup(char *str)
500 {
501         if (!strcmp(str, "off")) {
502                 pci_probe = 0;
503                 return NULL;
504         } else if (!strcmp(str, "bfsort")) {
505                 pci_bf_sort = pci_force_bf;
506                 return NULL;
507         } else if (!strcmp(str, "nobfsort")) {
508                 pci_bf_sort = pci_force_nobf;
509                 return NULL;
510         }
511 #ifdef CONFIG_PCI_BIOS
512         else if (!strcmp(str, "bios")) {
513                 pci_probe = PCI_PROBE_BIOS;
514                 return NULL;
515         } else if (!strcmp(str, "nobios")) {
516                 pci_probe &= ~PCI_PROBE_BIOS;
517                 return NULL;
518         } else if (!strcmp(str, "biosirq")) {
519                 pci_probe |= PCI_BIOS_IRQ_SCAN;
520                 return NULL;
521         } else if (!strncmp(str, "pirqaddr=", 9)) {
522                 pirq_table_addr = simple_strtoul(str+9, NULL, 0);
523                 return NULL;
524         }
525 #endif
526 #ifdef CONFIG_PCI_DIRECT
527         else if (!strcmp(str, "conf1")) {
528                 pci_probe = PCI_PROBE_CONF1 | PCI_NO_CHECKS;
529                 return NULL;
530         }
531         else if (!strcmp(str, "conf2")) {
532                 pci_probe = PCI_PROBE_CONF2 | PCI_NO_CHECKS;
533                 return NULL;
534         }
535 #endif
536 #ifdef CONFIG_PCI_MMCONFIG
537         else if (!strcmp(str, "nommconf")) {
538                 pci_probe &= ~PCI_PROBE_MMCONF;
539                 return NULL;
540         }
541         else if (!strcmp(str, "check_enable_amd_mmconf")) {
542                 pci_probe |= PCI_CHECK_ENABLE_AMD_MMCONF;
543                 return NULL;
544         }
545 #endif
546         else if (!strcmp(str, "noacpi")) {
547                 acpi_noirq_set();
548                 return NULL;
549         }
550         else if (!strcmp(str, "noearly")) {
551                 pci_probe |= PCI_PROBE_NOEARLY;
552                 return NULL;
553         }
554 #ifndef CONFIG_X86_VISWS
555         else if (!strcmp(str, "usepirqmask")) {
556                 pci_probe |= PCI_USE_PIRQ_MASK;
557                 return NULL;
558         } else if (!strncmp(str, "irqmask=", 8)) {
559                 pcibios_irq_mask = simple_strtol(str+8, NULL, 0);
560                 return NULL;
561         } else if (!strncmp(str, "lastbus=", 8)) {
562                 pcibios_last_bus = simple_strtol(str+8, NULL, 0);
563                 return NULL;
564         }
565 #endif
566         else if (!strcmp(str, "rom")) {
567                 pci_probe |= PCI_ASSIGN_ROMS;
568                 return NULL;
569         } else if (!strcmp(str, "norom")) {
570                 pci_probe |= PCI_NOASSIGN_ROMS;
571                 return NULL;
572         } else if (!strcmp(str, "nobar")) {
573                 pci_probe |= PCI_NOASSIGN_BARS;
574                 return NULL;
575         } else if (!strcmp(str, "assign-busses")) {
576                 pci_probe |= PCI_ASSIGN_ALL_BUSSES;
577                 return NULL;
578         } else if (!strcmp(str, "use_crs")) {
579                 pci_probe |= PCI_USE__CRS;
580                 return NULL;
581         } else if (!strcmp(str, "nocrs")) {
582                 pci_probe |= PCI_ROOT_NO_CRS;
583                 return NULL;
584         } else if (!strcmp(str, "earlydump")) {
585                 pci_early_dump_regs = 1;
586                 return NULL;
587         } else if (!strcmp(str, "routeirq")) {
588                 pci_routeirq = 1;
589                 return NULL;
590         } else if (!strcmp(str, "skip_isa_align")) {
591                 pci_probe |= PCI_CAN_SKIP_ISA_ALIGN;
592                 return NULL;
593         } else if (!strcmp(str, "noioapicquirk")) {
594                 noioapicquirk = 1;
595                 return NULL;
596         } else if (!strcmp(str, "ioapicreroute")) {
597                 if (noioapicreroute != -1)
598                         noioapicreroute = 0;
599                 return NULL;
600         } else if (!strcmp(str, "noioapicreroute")) {
601                 if (noioapicreroute != -1)
602                         noioapicreroute = 1;
603                 return NULL;
604         }
605         return str;
606 }
607
608 unsigned int pcibios_assign_all_busses(void)
609 {
610         return (pci_probe & PCI_ASSIGN_ALL_BUSSES) ? 1 : 0;
611 }
612
613 int pcibios_add_device(struct pci_dev *dev)
614 {
615         struct setup_data *data;
616         struct pci_setup_rom *rom;
617         u64 pa_data;
618
619         pa_data = boot_params.hdr.setup_data;
620         while (pa_data) {
621                 data = phys_to_virt(pa_data);
622
623                 if (data->type == SETUP_PCI) {
624                         rom = (struct pci_setup_rom *)data;
625
626                         if ((pci_domain_nr(dev->bus) == rom->segment) &&
627                             (dev->bus->number == rom->bus) &&
628                             (PCI_SLOT(dev->devfn) == rom->device) &&
629                             (PCI_FUNC(dev->devfn) == rom->function) &&
630                             (dev->vendor == rom->vendor) &&
631                             (dev->device == rom->devid)) {
632                                 dev->rom = pa_data +
633                                       offsetof(struct pci_setup_rom, romdata);
634                                 dev->romlen = rom->pcilen;
635                         }
636                 }
637                 pa_data = data->next;
638         }
639         return 0;
640 }
641
642 int pcibios_enable_device(struct pci_dev *dev, int mask)
643 {
644         int err;
645
646         if ((err = pci_enable_resources(dev, mask)) < 0)
647                 return err;
648
649         if (!pci_dev_msi_enabled(dev))
650                 return pcibios_enable_irq(dev);
651         return 0;
652 }
653
654 void pcibios_disable_device (struct pci_dev *dev)
655 {
656         if (!pci_dev_msi_enabled(dev) && pcibios_disable_irq)
657                 pcibios_disable_irq(dev);
658 }
659
660 int pci_ext_cfg_avail(void)
661 {
662         if (raw_pci_ext_ops)
663                 return 1;
664         else
665                 return 0;
666 }
667
668 struct pci_bus * __devinit pci_scan_bus_on_node(int busno, struct pci_ops *ops, int node)
669 {
670         LIST_HEAD(resources);
671         struct pci_bus *bus = NULL;
672         struct pci_sysdata *sd;
673
674         /*
675          * Allocate per-root-bus (not per bus) arch-specific data.
676          * TODO: leak; this memory is never freed.
677          * It's arguable whether it's worth the trouble to care.
678          */
679         sd = kzalloc(sizeof(*sd), GFP_KERNEL);
680         if (!sd) {
681                 printk(KERN_ERR "PCI: OOM, skipping PCI bus %02x\n", busno);
682                 return NULL;
683         }
684         sd->node = node;
685         x86_pci_root_bus_resources(busno, &resources);
686         printk(KERN_DEBUG "PCI: Probing PCI hardware (bus %02x)\n", busno);
687         bus = pci_scan_root_bus(NULL, busno, ops, sd, &resources);
688         if (!bus) {
689                 pci_free_resource_list(&resources);
690                 kfree(sd);
691         }
692
693         return bus;
694 }
695
696 struct pci_bus * __devinit pci_scan_bus_with_sysdata(int busno)
697 {
698         return pci_scan_bus_on_node(busno, &pci_root_ops, -1);
699 }
700
701 /*
702  * NUMA info for PCI busses
703  *
704  * Early arch code is responsible for filling in reasonable values here.
705  * A node id of "-1" means "use current node".  In other words, if a bus
706  * has a -1 node id, it's not tightly coupled to any particular chunk
707  * of memory (as is the case on some Nehalem systems).
708  */
709 #ifdef CONFIG_NUMA
710
711 #define BUS_NR 256
712
713 #ifdef CONFIG_X86_64
714
715 static int mp_bus_to_node[BUS_NR] = {
716         [0 ... BUS_NR - 1] = -1
717 };
718
719 void set_mp_bus_to_node(int busnum, int node)
720 {
721         if (busnum >= 0 &&  busnum < BUS_NR)
722                 mp_bus_to_node[busnum] = node;
723 }
724
725 int get_mp_bus_to_node(int busnum)
726 {
727         int node = -1;
728
729         if (busnum < 0 || busnum > (BUS_NR - 1))
730                 return node;
731
732         node = mp_bus_to_node[busnum];
733
734         /*
735          * let numa_node_id to decide it later in dma_alloc_pages
736          * if there is no ram on that node
737          */
738         if (node != -1 && !node_online(node))
739                 node = -1;
740
741         return node;
742 }
743
744 #else /* CONFIG_X86_32 */
745
746 static int mp_bus_to_node[BUS_NR] = {
747         [0 ... BUS_NR - 1] = -1
748 };
749
750 void set_mp_bus_to_node(int busnum, int node)
751 {
752         if (busnum >= 0 &&  busnum < BUS_NR)
753         mp_bus_to_node[busnum] = (unsigned char) node;
754 }
755
756 int get_mp_bus_to_node(int busnum)
757 {
758         int node;
759
760         if (busnum < 0 || busnum > (BUS_NR - 1))
761                 return 0;
762         node = mp_bus_to_node[busnum];
763         return node;
764 }
765
766 #endif /* CONFIG_X86_32 */
767
768 #endif /* CONFIG_NUMA */