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