PCI: populate subsystem vendor and device IDs for PCI bridges
[linux-2.6.git] / drivers / pci / probe.c
1 /*
2  * probe.c - PCI detection and setup code
3  */
4
5 #include <linux/kernel.h>
6 #include <linux/delay.h>
7 #include <linux/init.h>
8 #include <linux/pci.h>
9 #include <linux/slab.h>
10 #include <linux/module.h>
11 #include <linux/cpumask.h>
12 #include <linux/pci-aspm.h>
13 #include <linux/iommu.h>
14 #include <acpi/acpi_hest.h>
15 #include <xen/xen.h>
16 #include "pci.h"
17
18 #define CARDBUS_LATENCY_TIMER   176     /* secondary latency timer */
19 #define CARDBUS_RESERVE_BUSNR   3
20
21 /* Ugh.  Need to stop exporting this to modules. */
22 LIST_HEAD(pci_root_buses);
23 EXPORT_SYMBOL(pci_root_buses);
24
25
26 static int find_anything(struct device *dev, void *data)
27 {
28         return 1;
29 }
30
31 /*
32  * Some device drivers need know if pci is initiated.
33  * Basically, we think pci is not initiated when there
34  * is no device to be found on the pci_bus_type.
35  */
36 int no_pci_devices(void)
37 {
38         struct device *dev;
39         int no_devices;
40
41         dev = bus_find_device(&pci_bus_type, NULL, NULL, find_anything);
42         no_devices = (dev == NULL);
43         put_device(dev);
44         return no_devices;
45 }
46 EXPORT_SYMBOL(no_pci_devices);
47
48 /*
49  * PCI Bus Class Devices
50  */
51 static ssize_t pci_bus_show_cpuaffinity(struct device *dev,
52                                         int type,
53                                         struct device_attribute *attr,
54                                         char *buf)
55 {
56         int ret;
57         const struct cpumask *cpumask;
58
59         cpumask = cpumask_of_pcibus(to_pci_bus(dev));
60         ret = type?
61                 cpulist_scnprintf(buf, PAGE_SIZE-2, cpumask) :
62                 cpumask_scnprintf(buf, PAGE_SIZE-2, cpumask);
63         buf[ret++] = '\n';
64         buf[ret] = '\0';
65         return ret;
66 }
67
68 static ssize_t inline pci_bus_show_cpumaskaffinity(struct device *dev,
69                                         struct device_attribute *attr,
70                                         char *buf)
71 {
72         return pci_bus_show_cpuaffinity(dev, 0, attr, buf);
73 }
74
75 static ssize_t inline pci_bus_show_cpulistaffinity(struct device *dev,
76                                         struct device_attribute *attr,
77                                         char *buf)
78 {
79         return pci_bus_show_cpuaffinity(dev, 1, attr, buf);
80 }
81
82 DEVICE_ATTR(cpuaffinity,     S_IRUGO, pci_bus_show_cpumaskaffinity, NULL);
83 DEVICE_ATTR(cpulistaffinity, S_IRUGO, pci_bus_show_cpulistaffinity, NULL);
84
85 /*
86  * PCI Bus Class
87  */
88 static void release_pcibus_dev(struct device *dev)
89 {
90         struct pci_bus *pci_bus = to_pci_bus(dev);
91
92         if (pci_bus->bridge)
93                 put_device(pci_bus->bridge);
94         kfree(pci_bus);
95 }
96
97 static struct class pcibus_class = {
98         .name           = "pci_bus",
99         .dev_release    = &release_pcibus_dev,
100 };
101
102 static int __init pcibus_class_init(void)
103 {
104         return class_register(&pcibus_class);
105 }
106 postcore_initcall(pcibus_class_init);
107
108 /*
109  * Translate the low bits of the PCI base
110  * to the resource type
111  */
112 static inline unsigned int pci_calc_resource_flags(unsigned int flags)
113 {
114         if (flags & PCI_BASE_ADDRESS_SPACE_IO)
115                 return IORESOURCE_IO;
116
117         if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
118                 return IORESOURCE_MEM | IORESOURCE_PREFETCH;
119
120         return IORESOURCE_MEM;
121 }
122
123 static u64 pci_size(u64 base, u64 maxbase, u64 mask)
124 {
125         u64 size = mask & maxbase;      /* Find the significant bits */
126         if (!size)
127                 return 0;
128
129         /* Get the lowest of them to find the decode size, and
130            from that the extent.  */
131         size = (size & ~(size-1)) - 1;
132
133         /* base == maxbase can be valid only if the BAR has
134            already been programmed with all 1s.  */
135         if (base == maxbase && ((base | size) & mask) != mask)
136                 return 0;
137
138         return size;
139 }
140
141 static inline enum pci_bar_type decode_bar(struct resource *res, u32 bar)
142 {
143         if ((bar & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO) {
144                 res->flags = bar & ~PCI_BASE_ADDRESS_IO_MASK;
145                 return pci_bar_io;
146         }
147
148         res->flags = bar & ~PCI_BASE_ADDRESS_MEM_MASK;
149
150         if (res->flags & PCI_BASE_ADDRESS_MEM_TYPE_64)
151                 return pci_bar_mem64;
152         return pci_bar_mem32;
153 }
154
155 /**
156  * pci_read_base - read a PCI BAR
157  * @dev: the PCI device
158  * @type: type of the BAR
159  * @res: resource buffer to be filled in
160  * @pos: BAR position in the config space
161  *
162  * Returns 1 if the BAR is 64-bit, or 0 if 32-bit.
163  */
164 int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
165                         struct resource *res, unsigned int pos)
166 {
167         u32 l, sz, mask;
168
169         mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
170
171         res->name = pci_name(dev);
172
173         pci_read_config_dword(dev, pos, &l);
174         pci_write_config_dword(dev, pos, l | mask);
175         pci_read_config_dword(dev, pos, &sz);
176         pci_write_config_dword(dev, pos, l);
177
178         /*
179          * All bits set in sz means the device isn't working properly.
180          * If the BAR isn't implemented, all bits must be 0.  If it's a
181          * memory BAR or a ROM, bit 0 must be clear; if it's an io BAR, bit
182          * 1 must be clear.
183          */
184         if (!sz || sz == 0xffffffff)
185                 goto fail;
186
187         /*
188          * I don't know how l can have all bits set.  Copied from old code.
189          * Maybe it fixes a bug on some ancient platform.
190          */
191         if (l == 0xffffffff)
192                 l = 0;
193
194         if (type == pci_bar_unknown) {
195                 type = decode_bar(res, l);
196                 res->flags |= pci_calc_resource_flags(l) | IORESOURCE_SIZEALIGN;
197                 if (type == pci_bar_io) {
198                         l &= PCI_BASE_ADDRESS_IO_MASK;
199                         mask = PCI_BASE_ADDRESS_IO_MASK & IO_SPACE_LIMIT;
200                 } else {
201                         l &= PCI_BASE_ADDRESS_MEM_MASK;
202                         mask = (u32)PCI_BASE_ADDRESS_MEM_MASK;
203                 }
204         } else {
205                 res->flags |= (l & IORESOURCE_ROM_ENABLE);
206                 l &= PCI_ROM_ADDRESS_MASK;
207                 mask = (u32)PCI_ROM_ADDRESS_MASK;
208         }
209
210         if (type == pci_bar_mem64) {
211                 u64 l64 = l;
212                 u64 sz64 = sz;
213                 u64 mask64 = mask | (u64)~0 << 32;
214
215                 pci_read_config_dword(dev, pos + 4, &l);
216                 pci_write_config_dword(dev, pos + 4, ~0);
217                 pci_read_config_dword(dev, pos + 4, &sz);
218                 pci_write_config_dword(dev, pos + 4, l);
219
220                 l64 |= ((u64)l << 32);
221                 sz64 |= ((u64)sz << 32);
222
223                 sz64 = pci_size(l64, sz64, mask64);
224
225                 if (!sz64)
226                         goto fail;
227
228                 res->flags |= IORESOURCE_MEM_64;
229
230                 if ((sizeof(resource_size_t) < 8) && (sz64 > 0x100000000ULL)) {
231                         dev_err(&dev->dev, "can't handle 64-bit BAR\n");
232                         goto fail;
233                 } else if ((sizeof(resource_size_t) < 8) && l) {
234                         /* Address above 32-bit boundary; disable the BAR */
235                         pci_write_config_dword(dev, pos, 0);
236                         pci_write_config_dword(dev, pos + 4, 0);
237                         res->start = 0;
238                         res->end = sz64;
239                 } else {
240                         res->start = l64;
241                         res->end = l64 + sz64;
242                         dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pRt\n",
243                                    pos, res);
244                 }
245         } else {
246                 sz = pci_size(l, sz, mask);
247
248                 if (!sz)
249                         goto fail;
250
251                 res->start = l;
252                 res->end = l + sz;
253
254                 dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pRt\n", pos, res);
255         }
256
257  out:
258         return (type == pci_bar_mem64) ? 1 : 0;
259  fail:
260         res->flags = 0;
261         goto out;
262 }
263
264 static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
265 {
266         unsigned int pos, reg;
267
268         for (pos = 0; pos < howmany; pos++) {
269                 struct resource *res = &dev->resource[pos];
270                 reg = PCI_BASE_ADDRESS_0 + (pos << 2);
271                 pos += __pci_read_base(dev, pci_bar_unknown, res, reg);
272         }
273
274         if (rom) {
275                 struct resource *res = &dev->resource[PCI_ROM_RESOURCE];
276                 dev->rom_base_reg = rom;
277                 res->flags = IORESOURCE_MEM | IORESOURCE_PREFETCH |
278                                 IORESOURCE_READONLY | IORESOURCE_CACHEABLE |
279                                 IORESOURCE_SIZEALIGN;
280                 __pci_read_base(dev, pci_bar_mem32, res, rom);
281         }
282 }
283
284 void __devinit pci_read_bridge_bases(struct pci_bus *child)
285 {
286         struct pci_dev *dev = child->self;
287         u8 io_base_lo, io_limit_lo;
288         u16 mem_base_lo, mem_limit_lo;
289         unsigned long base, limit;
290         struct resource *res;
291         int i;
292
293         if (pci_is_root_bus(child))     /* It's a host bus, nothing to read */
294                 return;
295
296         if (dev->transparent) {
297                 dev_info(&dev->dev, "transparent bridge\n");
298                 for(i = 3; i < PCI_BUS_NUM_RESOURCES; i++)
299                         child->resource[i] = child->parent->resource[i - 3];
300         }
301
302         res = child->resource[0];
303         pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
304         pci_read_config_byte(dev, PCI_IO_LIMIT, &io_limit_lo);
305         base = (io_base_lo & PCI_IO_RANGE_MASK) << 8;
306         limit = (io_limit_lo & PCI_IO_RANGE_MASK) << 8;
307
308         if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
309                 u16 io_base_hi, io_limit_hi;
310                 pci_read_config_word(dev, PCI_IO_BASE_UPPER16, &io_base_hi);
311                 pci_read_config_word(dev, PCI_IO_LIMIT_UPPER16, &io_limit_hi);
312                 base |= (io_base_hi << 16);
313                 limit |= (io_limit_hi << 16);
314         }
315
316         if (base <= limit) {
317                 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
318                 if (!res->start)
319                         res->start = base;
320                 if (!res->end)
321                         res->end = limit + 0xfff;
322                 dev_printk(KERN_DEBUG, &dev->dev, "bridge window: %pRt\n", res);
323         }
324
325         res = child->resource[1];
326         pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
327         pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
328         base = (mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
329         limit = (mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
330         if (base <= limit) {
331                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
332                 res->start = base;
333                 res->end = limit + 0xfffff;
334                 dev_printk(KERN_DEBUG, &dev->dev, "bridge window: %pRt\n", res);
335         }
336
337         res = child->resource[2];
338         pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
339         pci_read_config_word(dev, PCI_PREF_MEMORY_LIMIT, &mem_limit_lo);
340         base = (mem_base_lo & PCI_PREF_RANGE_MASK) << 16;
341         limit = (mem_limit_lo & PCI_PREF_RANGE_MASK) << 16;
342
343         if ((mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
344                 u32 mem_base_hi, mem_limit_hi;
345                 pci_read_config_dword(dev, PCI_PREF_BASE_UPPER32, &mem_base_hi);
346                 pci_read_config_dword(dev, PCI_PREF_LIMIT_UPPER32, &mem_limit_hi);
347
348                 /*
349                  * Some bridges set the base > limit by default, and some
350                  * (broken) BIOSes do not initialize them.  If we find
351                  * this, just assume they are not being used.
352                  */
353                 if (mem_base_hi <= mem_limit_hi) {
354 #if BITS_PER_LONG == 64
355                         base |= ((long) mem_base_hi) << 32;
356                         limit |= ((long) mem_limit_hi) << 32;
357 #else
358                         if (mem_base_hi || mem_limit_hi) {
359                                 dev_err(&dev->dev, "can't handle 64-bit "
360                                         "address space for bridge\n");
361                                 return;
362                         }
363 #endif
364                 }
365         }
366         if (base <= limit) {
367                 res->flags = (mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) |
368                                          IORESOURCE_MEM | IORESOURCE_PREFETCH;
369                 if (res->flags & PCI_PREF_RANGE_TYPE_64)
370                         res->flags |= IORESOURCE_MEM_64;
371                 res->start = base;
372                 res->end = limit + 0xfffff;
373                 dev_printk(KERN_DEBUG, &dev->dev, "bridge window: %pRt\n", res);
374         }
375 }
376
377 static struct pci_bus * pci_alloc_bus(void)
378 {
379         struct pci_bus *b;
380
381         b = kzalloc(sizeof(*b), GFP_KERNEL);
382         if (b) {
383                 INIT_LIST_HEAD(&b->node);
384                 INIT_LIST_HEAD(&b->children);
385                 INIT_LIST_HEAD(&b->devices);
386                 INIT_LIST_HEAD(&b->slots);
387         }
388         return b;
389 }
390
391 static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
392                                            struct pci_dev *bridge, int busnr)
393 {
394         struct pci_bus *child;
395         int i;
396
397         /*
398          * Allocate a new bus, and inherit stuff from the parent..
399          */
400         child = pci_alloc_bus();
401         if (!child)
402                 return NULL;
403
404         child->parent = parent;
405         child->ops = parent->ops;
406         child->sysdata = parent->sysdata;
407         child->bus_flags = parent->bus_flags;
408
409         /* initialize some portions of the bus device, but don't register it
410          * now as the parent is not properly set up yet.  This device will get
411          * registered later in pci_bus_add_devices()
412          */
413         child->dev.class = &pcibus_class;
414         dev_set_name(&child->dev, "%04x:%02x", pci_domain_nr(child), busnr);
415
416         /*
417          * Set up the primary, secondary and subordinate
418          * bus numbers.
419          */
420         child->number = child->secondary = busnr;
421         child->primary = parent->secondary;
422         child->subordinate = 0xff;
423
424         if (!bridge)
425                 return child;
426
427         child->self = bridge;
428         child->bridge = get_device(&bridge->dev);
429
430         /* Set up default resource pointers and names.. */
431         for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) {
432                 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
433                 child->resource[i]->name = child->name;
434         }
435         bridge->subordinate = child;
436
437         return child;
438 }
439
440 struct pci_bus *__ref pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr)
441 {
442         struct pci_bus *child;
443
444         child = pci_alloc_child_bus(parent, dev, busnr);
445         if (child) {
446                 down_write(&pci_bus_sem);
447                 list_add_tail(&child->node, &parent->children);
448                 up_write(&pci_bus_sem);
449         }
450         return child;
451 }
452
453 static void pci_fixup_parent_subordinate_busnr(struct pci_bus *child, int max)
454 {
455         struct pci_bus *parent = child->parent;
456
457         /* Attempts to fix that up are really dangerous unless
458            we're going to re-assign all bus numbers. */
459         if (!pcibios_assign_all_busses())
460                 return;
461
462         while (parent->parent && parent->subordinate < max) {
463                 parent->subordinate = max;
464                 pci_write_config_byte(parent->self, PCI_SUBORDINATE_BUS, max);
465                 parent = parent->parent;
466         }
467 }
468
469 /*
470  * If it's a bridge, configure it and scan the bus behind it.
471  * For CardBus bridges, we don't scan behind as the devices will
472  * be handled by the bridge driver itself.
473  *
474  * We need to process bridges in two passes -- first we scan those
475  * already configured by the BIOS and after we are done with all of
476  * them, we proceed to assigning numbers to the remaining buses in
477  * order to avoid overlaps between old and new bus numbers.
478  */
479 int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
480 {
481         struct pci_bus *child;
482         int is_cardbus = (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS);
483         u32 buses, i, j = 0;
484         u16 bctl;
485         int broken = 0;
486
487         pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
488
489         dev_dbg(&dev->dev, "scanning behind bridge, config %06x, pass %d\n",
490                 buses & 0xffffff, pass);
491
492         /* Check if setup is sensible at all */
493         if (!pass &&
494             ((buses & 0xff) != bus->number || ((buses >> 8) & 0xff) <= bus->number)) {
495                 dev_dbg(&dev->dev, "bus configuration invalid, reconfiguring\n");
496                 broken = 1;
497         }
498
499         /* Disable MasterAbortMode during probing to avoid reporting
500            of bus errors (in some architectures) */ 
501         pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl);
502         pci_write_config_word(dev, PCI_BRIDGE_CONTROL,
503                               bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT);
504
505         if ((buses & 0xffff00) && !pcibios_assign_all_busses() && !is_cardbus && !broken) {
506                 unsigned int cmax, busnr;
507                 /*
508                  * Bus already configured by firmware, process it in the first
509                  * pass and just note the configuration.
510                  */
511                 if (pass)
512                         goto out;
513                 busnr = (buses >> 8) & 0xFF;
514
515                 /*
516                  * If we already got to this bus through a different bridge,
517                  * don't re-add it. This can happen with the i450NX chipset.
518                  *
519                  * However, we continue to descend down the hierarchy and
520                  * scan remaining child buses.
521                  */
522                 child = pci_find_bus(pci_domain_nr(bus), busnr);
523                 if (!child) {
524                         child = pci_add_new_bus(bus, dev, busnr);
525                         if (!child)
526                                 goto out;
527                         child->primary = buses & 0xFF;
528                         child->subordinate = (buses >> 16) & 0xFF;
529                         child->bridge_ctl = bctl;
530                 }
531
532                 cmax = pci_scan_child_bus(child);
533                 if (cmax > max)
534                         max = cmax;
535                 if (child->subordinate > max)
536                         max = child->subordinate;
537         } else {
538                 /*
539                  * We need to assign a number to this bus which we always
540                  * do in the second pass.
541                  */
542                 if (!pass) {
543                         if (pcibios_assign_all_busses() || broken)
544                                 /* Temporarily disable forwarding of the
545                                    configuration cycles on all bridges in
546                                    this bus segment to avoid possible
547                                    conflicts in the second pass between two
548                                    bridges programmed with overlapping
549                                    bus ranges. */
550                                 pci_write_config_dword(dev, PCI_PRIMARY_BUS,
551                                                        buses & ~0xffffff);
552                         goto out;
553                 }
554
555                 /* Clear errors */
556                 pci_write_config_word(dev, PCI_STATUS, 0xffff);
557
558                 /* Prevent assigning a bus number that already exists.
559                  * This can happen when a bridge is hot-plugged */
560                 if (pci_find_bus(pci_domain_nr(bus), max+1))
561                         goto out;
562                 child = pci_add_new_bus(bus, dev, ++max);
563                 buses = (buses & 0xff000000)
564                       | ((unsigned int)(child->primary)     <<  0)
565                       | ((unsigned int)(child->secondary)   <<  8)
566                       | ((unsigned int)(child->subordinate) << 16);
567
568                 /*
569                  * yenta.c forces a secondary latency timer of 176.
570                  * Copy that behaviour here.
571                  */
572                 if (is_cardbus) {
573                         buses &= ~0xff000000;
574                         buses |= CARDBUS_LATENCY_TIMER << 24;
575                 }
576                         
577                 /*
578                  * We need to blast all three values with a single write.
579                  */
580                 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
581
582                 if (!is_cardbus) {
583                         child->bridge_ctl = bctl;
584                         /*
585                          * Adjust subordinate busnr in parent buses.
586                          * We do this before scanning for children because
587                          * some devices may not be detected if the bios
588                          * was lazy.
589                          */
590                         pci_fixup_parent_subordinate_busnr(child, max);
591                         /* Now we can scan all subordinate buses... */
592                         max = pci_scan_child_bus(child);
593                         /*
594                          * now fix it up again since we have found
595                          * the real value of max.
596                          */
597                         pci_fixup_parent_subordinate_busnr(child, max);
598                 } else {
599                         /*
600                          * For CardBus bridges, we leave 4 bus numbers
601                          * as cards with a PCI-to-PCI bridge can be
602                          * inserted later.
603                          */
604                         for (i=0; i<CARDBUS_RESERVE_BUSNR; i++) {
605                                 struct pci_bus *parent = bus;
606                                 if (pci_find_bus(pci_domain_nr(bus),
607                                                         max+i+1))
608                                         break;
609                                 while (parent->parent) {
610                                         if ((!pcibios_assign_all_busses()) &&
611                                             (parent->subordinate > max) &&
612                                             (parent->subordinate <= max+i)) {
613                                                 j = 1;
614                                         }
615                                         parent = parent->parent;
616                                 }
617                                 if (j) {
618                                         /*
619                                          * Often, there are two cardbus bridges
620                                          * -- try to leave one valid bus number
621                                          * for each one.
622                                          */
623                                         i /= 2;
624                                         break;
625                                 }
626                         }
627                         max += i;
628                         pci_fixup_parent_subordinate_busnr(child, max);
629                 }
630                 /*
631                  * Set the subordinate bus number to its real value.
632                  */
633                 child->subordinate = max;
634                 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
635         }
636
637         sprintf(child->name,
638                 (is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"),
639                 pci_domain_nr(bus), child->number);
640
641         /* Has only triggered on CardBus, fixup is in yenta_socket */
642         while (bus->parent) {
643                 if ((child->subordinate > bus->subordinate) ||
644                     (child->number > bus->subordinate) ||
645                     (child->number < bus->number) ||
646                     (child->subordinate < bus->number)) {
647                         pr_debug("PCI: Bus #%02x (-#%02x) is %s "
648                                 "hidden behind%s bridge #%02x (-#%02x)\n",
649                                 child->number, child->subordinate,
650                                 (bus->number > child->subordinate &&
651                                  bus->subordinate < child->number) ?
652                                         "wholly" : "partially",
653                                 bus->self->transparent ? " transparent" : "",
654                                 bus->number, bus->subordinate);
655                 }
656                 bus = bus->parent;
657         }
658
659 out:
660         pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
661
662         return max;
663 }
664
665 /*
666  * Read interrupt line and base address registers.
667  * The architecture-dependent code can tweak these, of course.
668  */
669 static void pci_read_irq(struct pci_dev *dev)
670 {
671         unsigned char irq;
672
673         pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq);
674         dev->pin = irq;
675         if (irq)
676                 pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
677         dev->irq = irq;
678 }
679
680 static void set_pcie_port_type(struct pci_dev *pdev)
681 {
682         int pos;
683         u16 reg16;
684
685         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
686         if (!pos)
687                 return;
688         pdev->is_pcie = 1;
689         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
690         pdev->pcie_type = (reg16 & PCI_EXP_FLAGS_TYPE) >> 4;
691 }
692
693 static void set_pcie_hotplug_bridge(struct pci_dev *pdev)
694 {
695         int pos;
696         u16 reg16;
697         u32 reg32;
698
699         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
700         if (!pos)
701                 return;
702         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
703         if (!(reg16 & PCI_EXP_FLAGS_SLOT))
704                 return;
705         pci_read_config_dword(pdev, pos + PCI_EXP_SLTCAP, &reg32);
706         if (reg32 & PCI_EXP_SLTCAP_HPC)
707                 pdev->is_hotplug_bridge = 1;
708 }
709
710 static void set_pci_aer_firmware_first(struct pci_dev *pdev)
711 {
712         if (acpi_hest_firmware_first_pci(pdev))
713                 pdev->aer_firmware_first = 1;
714 }
715
716 #define LEGACY_IO_RESOURCE      (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
717
718 /**
719  * pci_setup_device - fill in class and map information of a device
720  * @dev: the device structure to fill
721  *
722  * Initialize the device structure with information about the device's 
723  * vendor,class,memory and IO-space addresses,IRQ lines etc.
724  * Called at initialisation of the PCI subsystem and by CardBus services.
725  * Returns 0 on success and negative if unknown type of device (not normal,
726  * bridge or CardBus).
727  */
728 int pci_setup_device(struct pci_dev *dev)
729 {
730         u32 class;
731         u8 hdr_type;
732         struct pci_slot *slot;
733         int pos = 0;
734
735         if (pci_read_config_byte(dev, PCI_HEADER_TYPE, &hdr_type))
736                 return -EIO;
737
738         dev->sysdata = dev->bus->sysdata;
739         dev->dev.parent = dev->bus->bridge;
740         dev->dev.bus = &pci_bus_type;
741         dev->hdr_type = hdr_type & 0x7f;
742         dev->multifunction = !!(hdr_type & 0x80);
743         dev->error_state = pci_channel_io_normal;
744         set_pcie_port_type(dev);
745         set_pci_aer_firmware_first(dev);
746
747         list_for_each_entry(slot, &dev->bus->slots, list)
748                 if (PCI_SLOT(dev->devfn) == slot->number)
749                         dev->slot = slot;
750
751         /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
752            set this higher, assuming the system even supports it.  */
753         dev->dma_mask = 0xffffffff;
754
755         dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
756                      dev->bus->number, PCI_SLOT(dev->devfn),
757                      PCI_FUNC(dev->devfn));
758
759         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
760         dev->revision = class & 0xff;
761         class >>= 8;                                /* upper 3 bytes */
762         dev->class = class;
763         class >>= 8;
764
765         dev_dbg(&dev->dev, "found [%04x:%04x] class %06x header type %02x\n",
766                  dev->vendor, dev->device, class, dev->hdr_type);
767
768         /* need to have dev->class ready */
769         dev->cfg_size = pci_cfg_space_size(dev);
770
771         /* "Unknown power state" */
772         dev->current_state = PCI_UNKNOWN;
773
774         /* Early fixups, before probing the BARs */
775         pci_fixup_device(pci_fixup_early, dev);
776         /* device class may be changed after fixup */
777         class = dev->class >> 8;
778
779         switch (dev->hdr_type) {                    /* header type */
780         case PCI_HEADER_TYPE_NORMAL:                /* standard header */
781                 if (class == PCI_CLASS_BRIDGE_PCI)
782                         goto bad;
783                 pci_read_irq(dev);
784                 pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
785                 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
786                 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
787
788                 /*
789                  *      Do the ugly legacy mode stuff here rather than broken chip
790                  *      quirk code. Legacy mode ATA controllers have fixed
791                  *      addresses. These are not always echoed in BAR0-3, and
792                  *      BAR0-3 in a few cases contain junk!
793                  */
794                 if (class == PCI_CLASS_STORAGE_IDE) {
795                         u8 progif;
796                         pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
797                         if ((progif & 1) == 0) {
798                                 dev->resource[0].start = 0x1F0;
799                                 dev->resource[0].end = 0x1F7;
800                                 dev->resource[0].flags = LEGACY_IO_RESOURCE;
801                                 dev->resource[1].start = 0x3F6;
802                                 dev->resource[1].end = 0x3F6;
803                                 dev->resource[1].flags = LEGACY_IO_RESOURCE;
804                         }
805                         if ((progif & 4) == 0) {
806                                 dev->resource[2].start = 0x170;
807                                 dev->resource[2].end = 0x177;
808                                 dev->resource[2].flags = LEGACY_IO_RESOURCE;
809                                 dev->resource[3].start = 0x376;
810                                 dev->resource[3].end = 0x376;
811                                 dev->resource[3].flags = LEGACY_IO_RESOURCE;
812                         }
813                 }
814                 break;
815
816         case PCI_HEADER_TYPE_BRIDGE:                /* bridge header */
817                 if (class != PCI_CLASS_BRIDGE_PCI)
818                         goto bad;
819                 /* The PCI-to-PCI bridge spec requires that subtractive
820                    decoding (i.e. transparent) bridge must have programming
821                    interface code of 0x01. */ 
822                 pci_read_irq(dev);
823                 dev->transparent = ((dev->class & 0xff) == 1);
824                 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
825                 set_pcie_hotplug_bridge(dev);
826                 pos = pci_find_capability(dev, PCI_CAP_ID_SSVID);
827                 if (pos) {
828                         pci_read_config_word(dev, pos + PCI_SSVID_VENDOR_ID, &dev->subsystem_vendor);
829                         pci_read_config_word(dev, pos + PCI_SSVID_DEVICE_ID, &dev->subsystem_device);
830                 }
831                 break;
832
833         case PCI_HEADER_TYPE_CARDBUS:               /* CardBus bridge header */
834                 if (class != PCI_CLASS_BRIDGE_CARDBUS)
835                         goto bad;
836                 pci_read_irq(dev);
837                 pci_read_bases(dev, 1, 0);
838                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
839                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device);
840                 break;
841
842         default:                                    /* unknown header */
843                 dev_err(&dev->dev, "unknown header type %02x, "
844                         "ignoring device\n", dev->hdr_type);
845                 return -EIO;
846
847         bad:
848                 dev_err(&dev->dev, "ignoring class %02x (doesn't match header "
849                         "type %02x)\n", class, dev->hdr_type);
850                 dev->class = PCI_CLASS_NOT_DEFINED;
851         }
852
853         /* We found a fine healthy device, go go go... */
854         return 0;
855 }
856
857 static void pci_release_capabilities(struct pci_dev *dev)
858 {
859         pci_vpd_release(dev);
860         pci_iov_release(dev);
861 }
862
863 /**
864  * pci_release_dev - free a pci device structure when all users of it are finished.
865  * @dev: device that's been disconnected
866  *
867  * Will be called only by the device core when all users of this pci device are
868  * done.
869  */
870 static void pci_release_dev(struct device *dev)
871 {
872         struct pci_dev *pci_dev;
873
874         pci_dev = to_pci_dev(dev);
875         pci_release_capabilities(pci_dev);
876         kfree(pci_dev);
877 }
878
879 /**
880  * pci_cfg_space_size - get the configuration space size of the PCI device.
881  * @dev: PCI device
882  *
883  * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices
884  * have 4096 bytes.  Even if the device is capable, that doesn't mean we can
885  * access it.  Maybe we don't have a way to generate extended config space
886  * accesses, or the device is behind a reverse Express bridge.  So we try
887  * reading the dword at 0x100 which must either be 0 or a valid extended
888  * capability header.
889  */
890 int pci_cfg_space_size_ext(struct pci_dev *dev)
891 {
892         u32 status;
893         int pos = PCI_CFG_SPACE_SIZE;
894
895         if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL)
896                 goto fail;
897         if (status == 0xffffffff)
898                 goto fail;
899
900         return PCI_CFG_SPACE_EXP_SIZE;
901
902  fail:
903         return PCI_CFG_SPACE_SIZE;
904 }
905
906 int pci_cfg_space_size(struct pci_dev *dev)
907 {
908         int pos;
909         u32 status;
910         u16 class;
911
912         class = dev->class >> 8;
913         if (class == PCI_CLASS_BRIDGE_HOST)
914                 return pci_cfg_space_size_ext(dev);
915
916         pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
917         if (!pos) {
918                 pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
919                 if (!pos)
920                         goto fail;
921
922                 pci_read_config_dword(dev, pos + PCI_X_STATUS, &status);
923                 if (!(status & (PCI_X_STATUS_266MHZ | PCI_X_STATUS_533MHZ)))
924                         goto fail;
925         }
926
927         return pci_cfg_space_size_ext(dev);
928
929  fail:
930         return PCI_CFG_SPACE_SIZE;
931 }
932
933 static void pci_release_bus_bridge_dev(struct device *dev)
934 {
935         kfree(dev);
936 }
937
938 struct pci_dev *alloc_pci_dev(void)
939 {
940         struct pci_dev *dev;
941
942         dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
943         if (!dev)
944                 return NULL;
945
946         INIT_LIST_HEAD(&dev->bus_list);
947
948         return dev;
949 }
950 EXPORT_SYMBOL(alloc_pci_dev);
951
952 /*
953  * Read the config data for a PCI device, sanity-check it
954  * and fill in the dev structure...
955  */
956 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
957 {
958         struct pci_dev *dev;
959         u32 l;
960         int delay = 1;
961
962         if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
963                 return NULL;
964
965         /* some broken boards return 0 or ~0 if a slot is empty: */
966         if (l == 0xffffffff || l == 0x00000000 ||
967             l == 0x0000ffff || l == 0xffff0000)
968                 return NULL;
969
970         /* Configuration request Retry Status */
971         while (l == 0xffff0001) {
972                 msleep(delay);
973                 delay *= 2;
974                 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
975                         return NULL;
976                 /* Card hasn't responded in 60 seconds?  Must be stuck. */
977                 if (delay > 60 * 1000) {
978                         printk(KERN_WARNING "pci %04x:%02x:%02x.%d: not "
979                                         "responding\n", pci_domain_nr(bus),
980                                         bus->number, PCI_SLOT(devfn),
981                                         PCI_FUNC(devfn));
982                         return NULL;
983                 }
984         }
985
986         dev = alloc_pci_dev();
987         if (!dev)
988                 return NULL;
989
990         dev->bus = bus;
991         dev->devfn = devfn;
992         dev->vendor = l & 0xffff;
993         dev->device = (l >> 16) & 0xffff;
994
995         if (pci_setup_device(dev)) {
996                 kfree(dev);
997                 return NULL;
998         }
999
1000         return dev;
1001 }
1002
1003 static void pci_init_capabilities(struct pci_dev *dev)
1004 {
1005         /* MSI/MSI-X list */
1006         pci_msi_init_pci_dev(dev);
1007
1008         /* Buffers for saving PCIe and PCI-X capabilities */
1009         pci_allocate_cap_save_buffers(dev);
1010
1011         /* Power Management */
1012         pci_pm_init(dev);
1013         platform_pci_wakeup_init(dev);
1014
1015         /* Vital Product Data */
1016         pci_vpd_pci22_init(dev);
1017
1018         /* Alternative Routing-ID Forwarding */
1019         pci_enable_ari(dev);
1020
1021         /* Single Root I/O Virtualization */
1022         pci_iov_init(dev);
1023
1024         /* Enable ACS P2P upstream forwarding */
1025         if (iommu_found() || xen_initial_domain())
1026                 pci_enable_acs(dev);
1027 }
1028
1029 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
1030 {
1031         device_initialize(&dev->dev);
1032         dev->dev.release = pci_release_dev;
1033         pci_dev_get(dev);
1034
1035         dev->dev.dma_mask = &dev->dma_mask;
1036         dev->dev.dma_parms = &dev->dma_parms;
1037         dev->dev.coherent_dma_mask = 0xffffffffull;
1038
1039         pci_set_dma_max_seg_size(dev, 65536);
1040         pci_set_dma_seg_boundary(dev, 0xffffffff);
1041
1042         /* Fix up broken headers */
1043         pci_fixup_device(pci_fixup_header, dev);
1044
1045         /* Clear the state_saved flag. */
1046         dev->state_saved = false;
1047
1048         /* Initialize various capabilities */
1049         pci_init_capabilities(dev);
1050
1051         /*
1052          * Add the device to our list of discovered devices
1053          * and the bus list for fixup functions, etc.
1054          */
1055         down_write(&pci_bus_sem);
1056         list_add_tail(&dev->bus_list, &bus->devices);
1057         up_write(&pci_bus_sem);
1058 }
1059
1060 struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
1061 {
1062         struct pci_dev *dev;
1063
1064         dev = pci_get_slot(bus, devfn);
1065         if (dev) {
1066                 pci_dev_put(dev);
1067                 return dev;
1068         }
1069
1070         dev = pci_scan_device(bus, devfn);
1071         if (!dev)
1072                 return NULL;
1073
1074         pci_device_add(dev, bus);
1075
1076         return dev;
1077 }
1078 EXPORT_SYMBOL(pci_scan_single_device);
1079
1080 /**
1081  * pci_scan_slot - scan a PCI slot on a bus for devices.
1082  * @bus: PCI bus to scan
1083  * @devfn: slot number to scan (must have zero function.)
1084  *
1085  * Scan a PCI slot on the specified PCI bus for devices, adding
1086  * discovered devices to the @bus->devices list.  New devices
1087  * will not have is_added set.
1088  *
1089  * Returns the number of new devices found.
1090  */
1091 int pci_scan_slot(struct pci_bus *bus, int devfn)
1092 {
1093         int fn, nr = 0;
1094         struct pci_dev *dev;
1095
1096         dev = pci_scan_single_device(bus, devfn);
1097         if (dev && !dev->is_added)      /* new device? */
1098                 nr++;
1099
1100         if (dev && dev->multifunction) {
1101                 for (fn = 1; fn < 8; fn++) {
1102                         dev = pci_scan_single_device(bus, devfn + fn);
1103                         if (dev) {
1104                                 if (!dev->is_added)
1105                                         nr++;
1106                                 dev->multifunction = 1;
1107                         }
1108                 }
1109         }
1110
1111         /* only one slot has pcie device */
1112         if (bus->self && nr)
1113                 pcie_aspm_init_link_state(bus->self);
1114
1115         return nr;
1116 }
1117
1118 unsigned int __devinit pci_scan_child_bus(struct pci_bus *bus)
1119 {
1120         unsigned int devfn, pass, max = bus->secondary;
1121         struct pci_dev *dev;
1122
1123         pr_debug("PCI: Scanning bus %04x:%02x\n", pci_domain_nr(bus), bus->number);
1124
1125         /* Go find them, Rover! */
1126         for (devfn = 0; devfn < 0x100; devfn += 8)
1127                 pci_scan_slot(bus, devfn);
1128
1129         /* Reserve buses for SR-IOV capability. */
1130         max += pci_iov_bus_range(bus);
1131
1132         /*
1133          * After performing arch-dependent fixup of the bus, look behind
1134          * all PCI-to-PCI bridges on this bus.
1135          */
1136         if (!bus->is_added) {
1137                 pr_debug("PCI: Fixups for bus %04x:%02x\n",
1138                          pci_domain_nr(bus), bus->number);
1139                 pcibios_fixup_bus(bus);
1140                 if (pci_is_root_bus(bus))
1141                         bus->is_added = 1;
1142         }
1143
1144         for (pass=0; pass < 2; pass++)
1145                 list_for_each_entry(dev, &bus->devices, bus_list) {
1146                         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1147                             dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1148                                 max = pci_scan_bridge(bus, dev, max, pass);
1149                 }
1150
1151         /*
1152          * We've scanned the bus and so we know all about what's on
1153          * the other side of any bridges that may be on this bus plus
1154          * any devices.
1155          *
1156          * Return how far we've got finding sub-buses.
1157          */
1158         pr_debug("PCI: Bus scan for %04x:%02x returning with max=%02x\n",
1159                 pci_domain_nr(bus), bus->number, max);
1160         return max;
1161 }
1162
1163 struct pci_bus * pci_create_bus(struct device *parent,
1164                 int bus, struct pci_ops *ops, void *sysdata)
1165 {
1166         int error;
1167         struct pci_bus *b;
1168         struct device *dev;
1169
1170         b = pci_alloc_bus();
1171         if (!b)
1172                 return NULL;
1173
1174         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1175         if (!dev){
1176                 kfree(b);
1177                 return NULL;
1178         }
1179
1180         b->sysdata = sysdata;
1181         b->ops = ops;
1182
1183         if (pci_find_bus(pci_domain_nr(b), bus)) {
1184                 /* If we already got to this bus through a different bridge, ignore it */
1185                 pr_debug("PCI: Bus %04x:%02x already known\n", pci_domain_nr(b), bus);
1186                 goto err_out;
1187         }
1188
1189         down_write(&pci_bus_sem);
1190         list_add_tail(&b->node, &pci_root_buses);
1191         up_write(&pci_bus_sem);
1192
1193         dev->parent = parent;
1194         dev->release = pci_release_bus_bridge_dev;
1195         dev_set_name(dev, "pci%04x:%02x", pci_domain_nr(b), bus);
1196         error = device_register(dev);
1197         if (error)
1198                 goto dev_reg_err;
1199         b->bridge = get_device(dev);
1200
1201         if (!parent)
1202                 set_dev_node(b->bridge, pcibus_to_node(b));
1203
1204         b->dev.class = &pcibus_class;
1205         b->dev.parent = b->bridge;
1206         dev_set_name(&b->dev, "%04x:%02x", pci_domain_nr(b), bus);
1207         error = device_register(&b->dev);
1208         if (error)
1209                 goto class_dev_reg_err;
1210         error = device_create_file(&b->dev, &dev_attr_cpuaffinity);
1211         if (error)
1212                 goto dev_create_file_err;
1213
1214         /* Create legacy_io and legacy_mem files for this bus */
1215         pci_create_legacy_files(b);
1216
1217         b->number = b->secondary = bus;
1218         b->resource[0] = &ioport_resource;
1219         b->resource[1] = &iomem_resource;
1220
1221         return b;
1222
1223 dev_create_file_err:
1224         device_unregister(&b->dev);
1225 class_dev_reg_err:
1226         device_unregister(dev);
1227 dev_reg_err:
1228         down_write(&pci_bus_sem);
1229         list_del(&b->node);
1230         up_write(&pci_bus_sem);
1231 err_out:
1232         kfree(dev);
1233         kfree(b);
1234         return NULL;
1235 }
1236
1237 struct pci_bus * __devinit pci_scan_bus_parented(struct device *parent,
1238                 int bus, struct pci_ops *ops, void *sysdata)
1239 {
1240         struct pci_bus *b;
1241
1242         b = pci_create_bus(parent, bus, ops, sysdata);
1243         if (b)
1244                 b->subordinate = pci_scan_child_bus(b);
1245         return b;
1246 }
1247 EXPORT_SYMBOL(pci_scan_bus_parented);
1248
1249 #ifdef CONFIG_HOTPLUG
1250 /**
1251  * pci_rescan_bus - scan a PCI bus for devices.
1252  * @bus: PCI bus to scan
1253  *
1254  * Scan a PCI bus and child buses for new devices, adds them,
1255  * and enables them.
1256  *
1257  * Returns the max number of subordinate bus discovered.
1258  */
1259 unsigned int __ref pci_rescan_bus(struct pci_bus *bus)
1260 {
1261         unsigned int max;
1262         struct pci_dev *dev;
1263
1264         max = pci_scan_child_bus(bus);
1265
1266         down_read(&pci_bus_sem);
1267         list_for_each_entry(dev, &bus->devices, bus_list)
1268                 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1269                     dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1270                         if (dev->subordinate)
1271                                 pci_bus_size_bridges(dev->subordinate);
1272         up_read(&pci_bus_sem);
1273
1274         pci_bus_assign_resources(bus);
1275         pci_enable_bridges(bus);
1276         pci_bus_add_devices(bus);
1277
1278         return max;
1279 }
1280 EXPORT_SYMBOL_GPL(pci_rescan_bus);
1281
1282 EXPORT_SYMBOL(pci_add_new_bus);
1283 EXPORT_SYMBOL(pci_scan_slot);
1284 EXPORT_SYMBOL(pci_scan_bridge);
1285 EXPORT_SYMBOL_GPL(pci_scan_child_bus);
1286 #endif
1287
1288 static int __init pci_sort_bf_cmp(const struct device *d_a, const struct device *d_b)
1289 {
1290         const struct pci_dev *a = to_pci_dev(d_a);
1291         const struct pci_dev *b = to_pci_dev(d_b);
1292
1293         if      (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
1294         else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return  1;
1295
1296         if      (a->bus->number < b->bus->number) return -1;
1297         else if (a->bus->number > b->bus->number) return  1;
1298
1299         if      (a->devfn < b->devfn) return -1;
1300         else if (a->devfn > b->devfn) return  1;
1301
1302         return 0;
1303 }
1304
1305 void __init pci_sort_breadthfirst(void)
1306 {
1307         bus_sort_breadthfirst(&pci_bus_type, &pci_sort_bf_cmp);
1308 }