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