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