x86/PCI: Fix PCI config space for domains > 0
[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
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
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 int pci_routeirq;
26 int pcibios_last_bus = -1;
27 unsigned long pirq_table_addr;
28 struct pci_bus *pci_root_bus;
29 struct pci_raw_ops *raw_pci_ops;
30 struct pci_raw_ops *raw_pci_ext_ops;
31
32 int raw_pci_read(unsigned int domain, unsigned int bus, unsigned int devfn,
33                                                 int reg, int len, u32 *val)
34 {
35         if (domain == 0 && 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
42 int raw_pci_write(unsigned int domain, unsigned int bus, unsigned int devfn,
43                                                 int reg, int len, u32 val)
44 {
45         if (domain == 0 && 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 }
51
52 static int pci_read(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *value)
53 {
54         return raw_pci_read(pci_domain_nr(bus), bus->number,
55                                  devfn, where, size, value);
56 }
57
58 static int pci_write(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 value)
59 {
60         return raw_pci_write(pci_domain_nr(bus), bus->number,
61                                   devfn, where, size, value);
62 }
63
64 struct 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  */
73 int pcibios_scanned;
74
75 /*
76  * This interrupt-safe spinlock protects all accesses to PCI
77  * configuration space.
78  */
79 DEFINE_SPINLOCK(pci_config_lock);
80
81 static 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
88 static 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
120 void __init dmi_check_skip_isa_align(void)
121 {
122         dmi_check_system(can_skip_pciprobe_dmi_table);
123 }
124
125 static 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
140 /*
141  *  Called after each bus is probed, but before its children
142  *  are examined.
143  */
144
145 void __devinit  pcibios_fixup_bus(struct pci_bus *b)
146 {
147         struct pci_dev *dev;
148
149         pci_read_bridge_bases(b);
150         list_for_each_entry(dev, &b->devices, bus_list)
151                 pcibios_fixup_device_resources(dev);
152 }
153
154 /*
155  * Only use DMI information to set this if nothing was passed
156  * on the kernel command line (which was parsed earlier).
157  */
158
159 static int __devinit set_bf_sort(const struct dmi_system_id *d)
160 {
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 /*
169  * Enable renumbering of PCI bus# ranges to reach all PCI busses (Cardbus)
170  */
171 #ifdef __i386__
172 static int __devinit assign_all_busses(const struct dmi_system_id *d)
173 {
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
181 static struct dmi_system_id __devinitdata pciprobe_dmi_table[] = {
182 #ifdef __i386__
183 /*
184  * Laptops which need pci=assign-busses to see Cardbus cards
185  */
186         {
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__ */
195         {
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         },
227         {
228                 .callback = set_bf_sort,
229                 .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,
237                 .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         },
323         {
324                 .callback = set_bf_sort,
325                 .ident = "HP ProLiant DL360",
326                 .matches = {
327                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
328                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL360"),
329                 },
330         },
331         {
332                 .callback = set_bf_sort,
333                 .ident = "HP ProLiant DL380",
334                 .matches = {
335                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
336                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL380"),
337                 },
338         },
339 #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
349         {
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         },
365         {}
366 };
367
368 void __init dmi_check_pciprobe(void)
369 {
370         dmi_check_system(pciprobe_dmi_table);
371 }
372
373 struct pci_bus * __devinit pcibios_scan_root(int busnum)
374 {
375         struct pci_bus *bus = NULL;
376         struct pci_sysdata *sd;
377
378         while ((bus = pci_find_next_bus(bus)) != NULL) {
379                 if (bus->number == busnum) {
380                         /* Already scanned */
381                         return bus;
382                 }
383         }
384
385         /* 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
395         sd->node = get_mp_bus_to_node(busnum);
396
397         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;
403 }
404
405 extern u8 pci_cache_line_size;
406
407 static int __init pcibios_init(void)
408 {
409         struct cpuinfo_x86 *c = &boot_cpu_data;
410
411         if (!raw_pci_ops) {
412                 printk(KERN_WARNING "PCI: System does not support PCI\n");
413                 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
429         if (pci_bf_sort >= pci_force_bf)
430                 pci_sort_breadthfirst();
431         return 0;
432 }
433
434 subsys_initcall(pcibios_init);
435
436 char * __devinit  pcibios_setup(char *str)
437 {
438         if (!strcmp(str, "off")) {
439                 pci_probe = 0;
440                 return NULL;
441         } 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;
447         }
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;
455         } else if (!strcmp(str, "biosirq")) {
456                 pci_probe |= PCI_BIOS_IRQ_SCAN;
457                 return NULL;
458         } else if (!strncmp(str, "pirqaddr=", 9)) {
459                 pirq_table_addr = simple_strtoul(str+9, NULL, 0);
460                 return NULL;
461         }
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         }
478         else if (!strcmp(str, "check_enable_amd_mmconf")) {
479                 pci_probe |= PCI_CHECK_ENABLE_AMD_MMCONF;
480                 return NULL;
481         }
482 #endif
483         else if (!strcmp(str, "noacpi")) {
484                 acpi_noirq_set();
485                 return NULL;
486         }
487         else if (!strcmp(str, "noearly")) {
488                 pci_probe |= PCI_PROBE_NOEARLY;
489                 return NULL;
490         }
491 #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;
506         } else if (!strcmp(str, "norom")) {
507                 pci_probe |= PCI_NOASSIGN_ROMS;
508                 return NULL;
509         } else if (!strcmp(str, "assign-busses")) {
510                 pci_probe |= PCI_ASSIGN_ALL_BUSSES;
511                 return NULL;
512         } else if (!strcmp(str, "use_crs")) {
513                 pci_probe |= PCI_USE__CRS;
514                 return NULL;
515         } else if (!strcmp(str, "earlydump")) {
516                 pci_early_dump_regs = 1;
517                 return NULL;
518         } else if (!strcmp(str, "routeirq")) {
519                 pci_routeirq = 1;
520                 return NULL;
521         } else if (!strcmp(str, "skip_isa_align")) {
522                 pci_probe |= PCI_CAN_SKIP_ISA_ALIGN;
523                 return NULL;
524         }
525         return str;
526 }
527
528 unsigned int pcibios_assign_all_busses(void)
529 {
530         return (pci_probe & PCI_ASSIGN_ALL_BUSSES) ? 1 : 0;
531 }
532
533 int pcibios_enable_device(struct pci_dev *dev, int mask)
534 {
535         int err;
536
537         if ((err = pci_enable_resources(dev, mask)) < 0)
538                 return err;
539
540         if (!dev->msi_enabled)
541                 return pcibios_enable_irq(dev);
542         return 0;
543 }
544
545 void pcibios_disable_device (struct pci_dev *dev)
546 {
547         if (!dev->msi_enabled && pcibios_disable_irq)
548                 pcibios_disable_irq(dev);
549 }
550
551 struct pci_bus * __devinit pci_scan_bus_on_node(int busno, struct pci_ops *ops, int node)
552 {
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         }
566         sd->node = node;
567         bus = pci_scan_bus(busno, ops, sd);
568         if (!bus)
569                 kfree(sd);
570
571         return bus;
572 }
573
574 struct pci_bus * __devinit pci_scan_bus_with_sysdata(int busno)
575 {
576         return pci_scan_bus_on_node(busno, &pci_root_ops, -1);
577 }