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