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