2 * probe.c - PCI detection and setup code
5 #include <linux/kernel.h>
6 #include <linux/delay.h>
7 #include <linux/init.h>
9 #include <linux/slab.h>
10 #include <linux/module.h>
11 #include <linux/cpumask.h>
12 #include <linux/pci-aspm.h>
15 #define CARDBUS_LATENCY_TIMER 176 /* secondary latency timer */
16 #define CARDBUS_RESERVE_BUSNR 3
18 static LIST_HEAD(pci_host_bridges);
20 /* Ugh. Need to stop exporting this to modules. */
21 LIST_HEAD(pci_root_buses);
22 EXPORT_SYMBOL(pci_root_buses);
25 static int find_anything(struct device *dev, void *data)
31 * Some device drivers need know if pci is initiated.
32 * Basically, we think pci is not initiated when there
33 * is no device to be found on the pci_bus_type.
35 int no_pci_devices(void)
40 dev = bus_find_device(&pci_bus_type, NULL, NULL, find_anything);
41 no_devices = (dev == NULL);
45 EXPORT_SYMBOL(no_pci_devices);
47 static struct pci_host_bridge *pci_host_bridge(struct pci_dev *dev)
50 struct pci_host_bridge *bridge;
56 list_for_each_entry(bridge, &pci_host_bridges, list) {
57 if (bridge->bus == bus)
64 static bool resource_contains(struct resource *res1, struct resource *res2)
66 return res1->start <= res2->start && res1->end >= res2->end;
69 void pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
72 struct pci_host_bridge *bridge = pci_host_bridge(dev);
73 struct pci_host_bridge_window *window;
74 resource_size_t offset = 0;
76 list_for_each_entry(window, &bridge->windows, list) {
77 if (resource_type(res) != resource_type(window->res))
80 if (resource_contains(window->res, res)) {
81 offset = window->offset;
86 region->start = res->start - offset;
87 region->end = res->end - offset;
89 EXPORT_SYMBOL(pcibios_resource_to_bus);
91 static bool region_contains(struct pci_bus_region *region1,
92 struct pci_bus_region *region2)
94 return region1->start <= region2->start && region1->end >= region2->end;
97 void pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
98 struct pci_bus_region *region)
100 struct pci_host_bridge *bridge = pci_host_bridge(dev);
101 struct pci_host_bridge_window *window;
102 struct pci_bus_region bus_region;
103 resource_size_t offset = 0;
105 list_for_each_entry(window, &bridge->windows, list) {
106 if (resource_type(res) != resource_type(window->res))
109 bus_region.start = window->res->start - window->offset;
110 bus_region.end = window->res->end - window->offset;
112 if (region_contains(&bus_region, region)) {
113 offset = window->offset;
118 res->start = region->start + offset;
119 res->end = region->end + offset;
121 EXPORT_SYMBOL(pcibios_bus_to_resource);
126 static void release_pcibus_dev(struct device *dev)
128 struct pci_bus *pci_bus = to_pci_bus(dev);
131 put_device(pci_bus->bridge);
132 pci_bus_remove_resources(pci_bus);
133 pci_release_bus_of_node(pci_bus);
137 static struct class pcibus_class = {
139 .dev_release = &release_pcibus_dev,
140 .dev_attrs = pcibus_dev_attrs,
143 static int __init pcibus_class_init(void)
145 return class_register(&pcibus_class);
147 postcore_initcall(pcibus_class_init);
149 static u64 pci_size(u64 base, u64 maxbase, u64 mask)
151 u64 size = mask & maxbase; /* Find the significant bits */
155 /* Get the lowest of them to find the decode size, and
156 from that the extent. */
157 size = (size & ~(size-1)) - 1;
159 /* base == maxbase can be valid only if the BAR has
160 already been programmed with all 1s. */
161 if (base == maxbase && ((base | size) & mask) != mask)
167 static inline unsigned long decode_bar(struct pci_dev *dev, u32 bar)
172 if ((bar & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO) {
173 flags = bar & ~PCI_BASE_ADDRESS_IO_MASK;
174 flags |= IORESOURCE_IO;
178 flags = bar & ~PCI_BASE_ADDRESS_MEM_MASK;
179 flags |= IORESOURCE_MEM;
180 if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
181 flags |= IORESOURCE_PREFETCH;
183 mem_type = bar & PCI_BASE_ADDRESS_MEM_TYPE_MASK;
185 case PCI_BASE_ADDRESS_MEM_TYPE_32:
187 case PCI_BASE_ADDRESS_MEM_TYPE_1M:
188 dev_info(&dev->dev, "1M mem BAR treated as 32-bit BAR\n");
190 case PCI_BASE_ADDRESS_MEM_TYPE_64:
191 flags |= IORESOURCE_MEM_64;
195 "mem unknown type %x treated as 32-bit BAR\n",
203 * pci_read_base - read a PCI BAR
204 * @dev: the PCI device
205 * @type: type of the BAR
206 * @res: resource buffer to be filled in
207 * @pos: BAR position in the config space
209 * Returns 1 if the BAR is 64-bit, or 0 if 32-bit.
211 int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
212 struct resource *res, unsigned int pos)
216 struct pci_bus_region region;
218 mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
220 if (!dev->mmio_always_on) {
221 pci_read_config_word(dev, PCI_COMMAND, &orig_cmd);
222 pci_write_config_word(dev, PCI_COMMAND,
223 orig_cmd & ~(PCI_COMMAND_MEMORY | PCI_COMMAND_IO));
226 res->name = pci_name(dev);
228 pci_read_config_dword(dev, pos, &l);
229 pci_write_config_dword(dev, pos, l | mask);
230 pci_read_config_dword(dev, pos, &sz);
231 pci_write_config_dword(dev, pos, l);
233 if (!dev->mmio_always_on)
234 pci_write_config_word(dev, PCI_COMMAND, orig_cmd);
237 * All bits set in sz means the device isn't working properly.
238 * If the BAR isn't implemented, all bits must be 0. If it's a
239 * memory BAR or a ROM, bit 0 must be clear; if it's an io BAR, bit
242 if (!sz || sz == 0xffffffff)
246 * I don't know how l can have all bits set. Copied from old code.
247 * Maybe it fixes a bug on some ancient platform.
252 if (type == pci_bar_unknown) {
253 res->flags = decode_bar(dev, l);
254 res->flags |= IORESOURCE_SIZEALIGN;
255 if (res->flags & IORESOURCE_IO) {
256 l &= PCI_BASE_ADDRESS_IO_MASK;
257 mask = PCI_BASE_ADDRESS_IO_MASK & (u32) IO_SPACE_LIMIT;
259 l &= PCI_BASE_ADDRESS_MEM_MASK;
260 mask = (u32)PCI_BASE_ADDRESS_MEM_MASK;
263 res->flags |= (l & IORESOURCE_ROM_ENABLE);
264 l &= PCI_ROM_ADDRESS_MASK;
265 mask = (u32)PCI_ROM_ADDRESS_MASK;
268 if (res->flags & IORESOURCE_MEM_64) {
271 u64 mask64 = mask | (u64)~0 << 32;
273 pci_read_config_dword(dev, pos + 4, &l);
274 pci_write_config_dword(dev, pos + 4, ~0);
275 pci_read_config_dword(dev, pos + 4, &sz);
276 pci_write_config_dword(dev, pos + 4, l);
278 l64 |= ((u64)l << 32);
279 sz64 |= ((u64)sz << 32);
281 sz64 = pci_size(l64, sz64, mask64);
286 if ((sizeof(resource_size_t) < 8) && (sz64 > 0x100000000ULL)) {
287 dev_err(&dev->dev, "reg %x: can't handle 64-bit BAR\n",
292 if ((sizeof(resource_size_t) < 8) && l) {
293 /* Address above 32-bit boundary; disable the BAR */
294 pci_write_config_dword(dev, pos, 0);
295 pci_write_config_dword(dev, pos + 4, 0);
298 pcibios_bus_to_resource(dev, res, ®ion);
301 region.end = l64 + sz64;
302 pcibios_bus_to_resource(dev, res, ®ion);
303 dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n",
307 sz = pci_size(l, sz, mask);
314 pcibios_bus_to_resource(dev, res, ®ion);
316 dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n", pos, res);
320 return (res->flags & IORESOURCE_MEM_64) ? 1 : 0;
326 static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
328 unsigned int pos, reg;
330 for (pos = 0; pos < howmany; pos++) {
331 struct resource *res = &dev->resource[pos];
332 reg = PCI_BASE_ADDRESS_0 + (pos << 2);
333 pos += __pci_read_base(dev, pci_bar_unknown, res, reg);
337 struct resource *res = &dev->resource[PCI_ROM_RESOURCE];
338 dev->rom_base_reg = rom;
339 res->flags = IORESOURCE_MEM | IORESOURCE_PREFETCH |
340 IORESOURCE_READONLY | IORESOURCE_CACHEABLE |
341 IORESOURCE_SIZEALIGN;
342 __pci_read_base(dev, pci_bar_mem32, res, rom);
346 static void __devinit pci_read_bridge_io(struct pci_bus *child)
348 struct pci_dev *dev = child->self;
349 u8 io_base_lo, io_limit_lo;
350 unsigned long base, limit;
351 struct pci_bus_region region;
352 struct resource *res, res2;
354 res = child->resource[0];
355 pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
356 pci_read_config_byte(dev, PCI_IO_LIMIT, &io_limit_lo);
357 base = (io_base_lo & PCI_IO_RANGE_MASK) << 8;
358 limit = (io_limit_lo & PCI_IO_RANGE_MASK) << 8;
360 if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
361 u16 io_base_hi, io_limit_hi;
362 pci_read_config_word(dev, PCI_IO_BASE_UPPER16, &io_base_hi);
363 pci_read_config_word(dev, PCI_IO_LIMIT_UPPER16, &io_limit_hi);
364 base |= (io_base_hi << 16);
365 limit |= (io_limit_hi << 16);
368 if (base && base <= limit) {
369 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
370 res2.flags = res->flags;
372 region.end = limit + 0xfff;
373 pcibios_bus_to_resource(dev, &res2, ®ion);
375 res->start = res2.start;
378 dev_printk(KERN_DEBUG, &dev->dev, " bridge window %pR\n", res);
382 static void __devinit pci_read_bridge_mmio(struct pci_bus *child)
384 struct pci_dev *dev = child->self;
385 u16 mem_base_lo, mem_limit_lo;
386 unsigned long base, limit;
387 struct pci_bus_region region;
388 struct resource *res;
390 res = child->resource[1];
391 pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
392 pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
393 base = (mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
394 limit = (mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
395 if (base && base <= limit) {
396 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
398 region.end = limit + 0xfffff;
399 pcibios_bus_to_resource(dev, res, ®ion);
400 dev_printk(KERN_DEBUG, &dev->dev, " bridge window %pR\n", res);
404 static void __devinit pci_read_bridge_mmio_pref(struct pci_bus *child)
406 struct pci_dev *dev = child->self;
407 u16 mem_base_lo, mem_limit_lo;
408 unsigned long base, limit;
409 struct pci_bus_region region;
410 struct resource *res;
412 res = child->resource[2];
413 pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
414 pci_read_config_word(dev, PCI_PREF_MEMORY_LIMIT, &mem_limit_lo);
415 base = (mem_base_lo & PCI_PREF_RANGE_MASK) << 16;
416 limit = (mem_limit_lo & PCI_PREF_RANGE_MASK) << 16;
418 if ((mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
419 u32 mem_base_hi, mem_limit_hi;
420 pci_read_config_dword(dev, PCI_PREF_BASE_UPPER32, &mem_base_hi);
421 pci_read_config_dword(dev, PCI_PREF_LIMIT_UPPER32, &mem_limit_hi);
424 * Some bridges set the base > limit by default, and some
425 * (broken) BIOSes do not initialize them. If we find
426 * this, just assume they are not being used.
428 if (mem_base_hi <= mem_limit_hi) {
429 #if BITS_PER_LONG == 64
430 base |= ((long) mem_base_hi) << 32;
431 limit |= ((long) mem_limit_hi) << 32;
433 if (mem_base_hi || mem_limit_hi) {
434 dev_err(&dev->dev, "can't handle 64-bit "
435 "address space for bridge\n");
441 if (base && base <= limit) {
442 res->flags = (mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) |
443 IORESOURCE_MEM | IORESOURCE_PREFETCH;
444 if (res->flags & PCI_PREF_RANGE_TYPE_64)
445 res->flags |= IORESOURCE_MEM_64;
447 region.end = limit + 0xfffff;
448 pcibios_bus_to_resource(dev, res, ®ion);
449 dev_printk(KERN_DEBUG, &dev->dev, " bridge window %pR\n", res);
453 void __devinit pci_read_bridge_bases(struct pci_bus *child)
455 struct pci_dev *dev = child->self;
456 struct resource *res;
459 if (pci_is_root_bus(child)) /* It's a host bus, nothing to read */
462 dev_info(&dev->dev, "PCI bridge to [bus %02x-%02x]%s\n",
463 child->secondary, child->subordinate,
464 dev->transparent ? " (subtractive decode)" : "");
466 pci_bus_remove_resources(child);
467 for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++)
468 child->resource[i] = &dev->resource[PCI_BRIDGE_RESOURCES+i];
470 pci_read_bridge_io(child);
471 pci_read_bridge_mmio(child);
472 pci_read_bridge_mmio_pref(child);
474 if (dev->transparent) {
475 pci_bus_for_each_resource(child->parent, res, i) {
477 pci_bus_add_resource(child, res,
478 PCI_SUBTRACTIVE_DECODE);
479 dev_printk(KERN_DEBUG, &dev->dev,
480 " bridge window %pR (subtractive decode)\n",
487 static struct pci_bus * pci_alloc_bus(void)
491 b = kzalloc(sizeof(*b), GFP_KERNEL);
493 INIT_LIST_HEAD(&b->node);
494 INIT_LIST_HEAD(&b->children);
495 INIT_LIST_HEAD(&b->devices);
496 INIT_LIST_HEAD(&b->slots);
497 INIT_LIST_HEAD(&b->resources);
498 b->max_bus_speed = PCI_SPEED_UNKNOWN;
499 b->cur_bus_speed = PCI_SPEED_UNKNOWN;
504 static unsigned char pcix_bus_speed[] = {
505 PCI_SPEED_UNKNOWN, /* 0 */
506 PCI_SPEED_66MHz_PCIX, /* 1 */
507 PCI_SPEED_100MHz_PCIX, /* 2 */
508 PCI_SPEED_133MHz_PCIX, /* 3 */
509 PCI_SPEED_UNKNOWN, /* 4 */
510 PCI_SPEED_66MHz_PCIX_ECC, /* 5 */
511 PCI_SPEED_100MHz_PCIX_ECC, /* 6 */
512 PCI_SPEED_133MHz_PCIX_ECC, /* 7 */
513 PCI_SPEED_UNKNOWN, /* 8 */
514 PCI_SPEED_66MHz_PCIX_266, /* 9 */
515 PCI_SPEED_100MHz_PCIX_266, /* A */
516 PCI_SPEED_133MHz_PCIX_266, /* B */
517 PCI_SPEED_UNKNOWN, /* C */
518 PCI_SPEED_66MHz_PCIX_533, /* D */
519 PCI_SPEED_100MHz_PCIX_533, /* E */
520 PCI_SPEED_133MHz_PCIX_533 /* F */
523 static unsigned char pcie_link_speed[] = {
524 PCI_SPEED_UNKNOWN, /* 0 */
525 PCIE_SPEED_2_5GT, /* 1 */
526 PCIE_SPEED_5_0GT, /* 2 */
527 PCIE_SPEED_8_0GT, /* 3 */
528 PCI_SPEED_UNKNOWN, /* 4 */
529 PCI_SPEED_UNKNOWN, /* 5 */
530 PCI_SPEED_UNKNOWN, /* 6 */
531 PCI_SPEED_UNKNOWN, /* 7 */
532 PCI_SPEED_UNKNOWN, /* 8 */
533 PCI_SPEED_UNKNOWN, /* 9 */
534 PCI_SPEED_UNKNOWN, /* A */
535 PCI_SPEED_UNKNOWN, /* B */
536 PCI_SPEED_UNKNOWN, /* C */
537 PCI_SPEED_UNKNOWN, /* D */
538 PCI_SPEED_UNKNOWN, /* E */
539 PCI_SPEED_UNKNOWN /* F */
542 void pcie_update_link_speed(struct pci_bus *bus, u16 linksta)
544 bus->cur_bus_speed = pcie_link_speed[linksta & 0xf];
546 EXPORT_SYMBOL_GPL(pcie_update_link_speed);
548 static unsigned char agp_speeds[] = {
556 static enum pci_bus_speed agp_speed(int agp3, int agpstat)
562 else if (agpstat & 2)
564 else if (agpstat & 1)
576 return agp_speeds[index];
580 static void pci_set_bus_speed(struct pci_bus *bus)
582 struct pci_dev *bridge = bus->self;
585 pos = pci_find_capability(bridge, PCI_CAP_ID_AGP);
587 pos = pci_find_capability(bridge, PCI_CAP_ID_AGP3);
591 pci_read_config_dword(bridge, pos + PCI_AGP_STATUS, &agpstat);
592 bus->max_bus_speed = agp_speed(agpstat & 8, agpstat & 7);
594 pci_read_config_dword(bridge, pos + PCI_AGP_COMMAND, &agpcmd);
595 bus->cur_bus_speed = agp_speed(agpstat & 8, agpcmd & 7);
598 pos = pci_find_capability(bridge, PCI_CAP_ID_PCIX);
601 enum pci_bus_speed max;
602 pci_read_config_word(bridge, pos + 2, &status);
604 if (status & 0x8000) {
605 max = PCI_SPEED_133MHz_PCIX_533;
606 } else if (status & 0x4000) {
607 max = PCI_SPEED_133MHz_PCIX_266;
608 } else if (status & 0x0002) {
609 if (((status >> 12) & 0x3) == 2) {
610 max = PCI_SPEED_133MHz_PCIX_ECC;
612 max = PCI_SPEED_133MHz_PCIX;
615 max = PCI_SPEED_66MHz_PCIX;
618 bus->max_bus_speed = max;
619 bus->cur_bus_speed = pcix_bus_speed[(status >> 6) & 0xf];
624 pos = pci_find_capability(bridge, PCI_CAP_ID_EXP);
629 pci_read_config_dword(bridge, pos + PCI_EXP_LNKCAP, &linkcap);
630 bus->max_bus_speed = pcie_link_speed[linkcap & 0xf];
632 pci_read_config_word(bridge, pos + PCI_EXP_LNKSTA, &linksta);
633 pcie_update_link_speed(bus, linksta);
638 static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
639 struct pci_dev *bridge, int busnr)
641 struct pci_bus *child;
645 * Allocate a new bus, and inherit stuff from the parent..
647 child = pci_alloc_bus();
651 child->parent = parent;
652 child->ops = parent->ops;
653 child->sysdata = parent->sysdata;
654 child->bus_flags = parent->bus_flags;
656 /* initialize some portions of the bus device, but don't register it
657 * now as the parent is not properly set up yet. This device will get
658 * registered later in pci_bus_add_devices()
660 child->dev.class = &pcibus_class;
661 dev_set_name(&child->dev, "%04x:%02x", pci_domain_nr(child), busnr);
664 * Set up the primary, secondary and subordinate
667 child->number = child->secondary = busnr;
668 child->primary = parent->secondary;
669 child->subordinate = 0xff;
674 child->self = bridge;
675 child->bridge = get_device(&bridge->dev);
676 pci_set_bus_of_node(child);
677 pci_set_bus_speed(child);
679 /* Set up default resource pointers and names.. */
680 for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) {
681 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
682 child->resource[i]->name = child->name;
684 bridge->subordinate = child;
689 struct pci_bus *__ref pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr)
691 struct pci_bus *child;
693 child = pci_alloc_child_bus(parent, dev, busnr);
695 down_write(&pci_bus_sem);
696 list_add_tail(&child->node, &parent->children);
697 up_write(&pci_bus_sem);
702 static void pci_fixup_parent_subordinate_busnr(struct pci_bus *child, int max)
704 struct pci_bus *parent = child->parent;
706 /* Attempts to fix that up are really dangerous unless
707 we're going to re-assign all bus numbers. */
708 if (!pcibios_assign_all_busses())
711 while (parent->parent && parent->subordinate < max) {
712 parent->subordinate = max;
713 pci_write_config_byte(parent->self, PCI_SUBORDINATE_BUS, max);
714 parent = parent->parent;
719 * If it's a bridge, configure it and scan the bus behind it.
720 * For CardBus bridges, we don't scan behind as the devices will
721 * be handled by the bridge driver itself.
723 * We need to process bridges in two passes -- first we scan those
724 * already configured by the BIOS and after we are done with all of
725 * them, we proceed to assigning numbers to the remaining buses in
726 * order to avoid overlaps between old and new bus numbers.
728 int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
730 struct pci_bus *child;
731 int is_cardbus = (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS);
734 u8 primary, secondary, subordinate;
737 pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
738 primary = buses & 0xFF;
739 secondary = (buses >> 8) & 0xFF;
740 subordinate = (buses >> 16) & 0xFF;
742 dev_dbg(&dev->dev, "scanning [bus %02x-%02x] behind bridge, pass %d\n",
743 secondary, subordinate, pass);
745 if (!primary && (primary != bus->number) && secondary && subordinate) {
746 dev_warn(&dev->dev, "Primary bus is hard wired to 0\n");
747 primary = bus->number;
750 /* Check if setup is sensible at all */
752 (primary != bus->number || secondary <= bus->number)) {
753 dev_dbg(&dev->dev, "bus configuration invalid, reconfiguring\n");
757 /* Disable MasterAbortMode during probing to avoid reporting
758 of bus errors (in some architectures) */
759 pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl);
760 pci_write_config_word(dev, PCI_BRIDGE_CONTROL,
761 bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT);
763 if ((secondary || subordinate) && !pcibios_assign_all_busses() &&
764 !is_cardbus && !broken) {
767 * Bus already configured by firmware, process it in the first
768 * pass and just note the configuration.
774 * If we already got to this bus through a different bridge,
775 * don't re-add it. This can happen with the i450NX chipset.
777 * However, we continue to descend down the hierarchy and
778 * scan remaining child buses.
780 child = pci_find_bus(pci_domain_nr(bus), secondary);
782 child = pci_add_new_bus(bus, dev, secondary);
785 child->primary = primary;
786 child->subordinate = subordinate;
787 child->bridge_ctl = bctl;
790 cmax = pci_scan_child_bus(child);
793 if (child->subordinate > max)
794 max = child->subordinate;
797 * We need to assign a number to this bus which we always
798 * do in the second pass.
801 if (pcibios_assign_all_busses() || broken)
802 /* Temporarily disable forwarding of the
803 configuration cycles on all bridges in
804 this bus segment to avoid possible
805 conflicts in the second pass between two
806 bridges programmed with overlapping
808 pci_write_config_dword(dev, PCI_PRIMARY_BUS,
814 pci_write_config_word(dev, PCI_STATUS, 0xffff);
816 /* Prevent assigning a bus number that already exists.
817 * This can happen when a bridge is hot-plugged, so in
818 * this case we only re-scan this bus. */
819 child = pci_find_bus(pci_domain_nr(bus), max+1);
821 child = pci_add_new_bus(bus, dev, ++max);
825 buses = (buses & 0xff000000)
826 | ((unsigned int)(child->primary) << 0)
827 | ((unsigned int)(child->secondary) << 8)
828 | ((unsigned int)(child->subordinate) << 16);
831 * yenta.c forces a secondary latency timer of 176.
832 * Copy that behaviour here.
835 buses &= ~0xff000000;
836 buses |= CARDBUS_LATENCY_TIMER << 24;
840 * We need to blast all three values with a single write.
842 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
845 child->bridge_ctl = bctl;
847 * Adjust subordinate busnr in parent buses.
848 * We do this before scanning for children because
849 * some devices may not be detected if the bios
852 pci_fixup_parent_subordinate_busnr(child, max);
853 /* Now we can scan all subordinate buses... */
854 max = pci_scan_child_bus(child);
856 * now fix it up again since we have found
857 * the real value of max.
859 pci_fixup_parent_subordinate_busnr(child, max);
862 * For CardBus bridges, we leave 4 bus numbers
863 * as cards with a PCI-to-PCI bridge can be
866 for (i=0; i<CARDBUS_RESERVE_BUSNR; i++) {
867 struct pci_bus *parent = bus;
868 if (pci_find_bus(pci_domain_nr(bus),
871 while (parent->parent) {
872 if ((!pcibios_assign_all_busses()) &&
873 (parent->subordinate > max) &&
874 (parent->subordinate <= max+i)) {
877 parent = parent->parent;
881 * Often, there are two cardbus bridges
882 * -- try to leave one valid bus number
890 pci_fixup_parent_subordinate_busnr(child, max);
893 * Set the subordinate bus number to its real value.
895 child->subordinate = max;
896 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
900 (is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"),
901 pci_domain_nr(bus), child->number);
903 /* Has only triggered on CardBus, fixup is in yenta_socket */
904 while (bus->parent) {
905 if ((child->subordinate > bus->subordinate) ||
906 (child->number > bus->subordinate) ||
907 (child->number < bus->number) ||
908 (child->subordinate < bus->number)) {
909 dev_info(&child->dev, "[bus %02x-%02x] %s "
910 "hidden behind%s bridge %s [bus %02x-%02x]\n",
911 child->number, child->subordinate,
912 (bus->number > child->subordinate &&
913 bus->subordinate < child->number) ?
914 "wholly" : "partially",
915 bus->self->transparent ? " transparent" : "",
917 bus->number, bus->subordinate);
923 pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
929 * Read interrupt line and base address registers.
930 * The architecture-dependent code can tweak these, of course.
932 static void pci_read_irq(struct pci_dev *dev)
936 pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq);
939 pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
943 void set_pcie_port_type(struct pci_dev *pdev)
948 pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
952 pdev->pcie_cap = pos;
953 pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, ®16);
954 pdev->pcie_type = (reg16 & PCI_EXP_FLAGS_TYPE) >> 4;
955 pci_read_config_word(pdev, pos + PCI_EXP_DEVCAP, ®16);
956 pdev->pcie_mpss = reg16 & PCI_EXP_DEVCAP_PAYLOAD;
959 void set_pcie_hotplug_bridge(struct pci_dev *pdev)
965 pos = pci_pcie_cap(pdev);
968 pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, ®16);
969 if (!(reg16 & PCI_EXP_FLAGS_SLOT))
971 pci_read_config_dword(pdev, pos + PCI_EXP_SLTCAP, ®32);
972 if (reg32 & PCI_EXP_SLTCAP_HPC)
973 pdev->is_hotplug_bridge = 1;
976 #define LEGACY_IO_RESOURCE (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
979 * pci_setup_device - fill in class and map information of a device
980 * @dev: the device structure to fill
982 * Initialize the device structure with information about the device's
983 * vendor,class,memory and IO-space addresses,IRQ lines etc.
984 * Called at initialisation of the PCI subsystem and by CardBus services.
985 * Returns 0 on success and negative if unknown type of device (not normal,
986 * bridge or CardBus).
988 int pci_setup_device(struct pci_dev *dev)
992 struct pci_slot *slot;
994 struct pci_bus_region region;
995 struct resource *res;
997 if (pci_read_config_byte(dev, PCI_HEADER_TYPE, &hdr_type))
1000 dev->sysdata = dev->bus->sysdata;
1001 dev->dev.parent = dev->bus->bridge;
1002 dev->dev.bus = &pci_bus_type;
1003 dev->hdr_type = hdr_type & 0x7f;
1004 dev->multifunction = !!(hdr_type & 0x80);
1005 dev->error_state = pci_channel_io_normal;
1006 set_pcie_port_type(dev);
1008 list_for_each_entry(slot, &dev->bus->slots, list)
1009 if (PCI_SLOT(dev->devfn) == slot->number)
1012 /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
1013 set this higher, assuming the system even supports it. */
1014 dev->dma_mask = 0xffffffff;
1016 dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
1017 dev->bus->number, PCI_SLOT(dev->devfn),
1018 PCI_FUNC(dev->devfn));
1020 pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
1021 dev->revision = class & 0xff;
1022 dev->class = class >> 8; /* upper 3 bytes */
1024 dev_printk(KERN_DEBUG, &dev->dev, "[%04x:%04x] type %02x class %#08x\n",
1025 dev->vendor, dev->device, dev->hdr_type, dev->class);
1027 /* need to have dev->class ready */
1028 dev->cfg_size = pci_cfg_space_size(dev);
1030 /* "Unknown power state" */
1031 dev->current_state = PCI_UNKNOWN;
1033 /* Early fixups, before probing the BARs */
1034 pci_fixup_device(pci_fixup_early, dev);
1035 /* device class may be changed after fixup */
1036 class = dev->class >> 8;
1038 switch (dev->hdr_type) { /* header type */
1039 case PCI_HEADER_TYPE_NORMAL: /* standard header */
1040 if (class == PCI_CLASS_BRIDGE_PCI)
1043 pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
1044 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
1045 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
1048 * Do the ugly legacy mode stuff here rather than broken chip
1049 * quirk code. Legacy mode ATA controllers have fixed
1050 * addresses. These are not always echoed in BAR0-3, and
1051 * BAR0-3 in a few cases contain junk!
1053 if (class == PCI_CLASS_STORAGE_IDE) {
1055 pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
1056 if ((progif & 1) == 0) {
1057 region.start = 0x1F0;
1059 res = &dev->resource[0];
1060 res->flags = LEGACY_IO_RESOURCE;
1061 pcibios_bus_to_resource(dev, res, ®ion);
1062 region.start = 0x3F6;
1064 res = &dev->resource[1];
1065 res->flags = LEGACY_IO_RESOURCE;
1066 pcibios_bus_to_resource(dev, res, ®ion);
1068 if ((progif & 4) == 0) {
1069 region.start = 0x170;
1071 res = &dev->resource[2];
1072 res->flags = LEGACY_IO_RESOURCE;
1073 pcibios_bus_to_resource(dev, res, ®ion);
1074 region.start = 0x376;
1076 res = &dev->resource[3];
1077 res->flags = LEGACY_IO_RESOURCE;
1078 pcibios_bus_to_resource(dev, res, ®ion);
1083 case PCI_HEADER_TYPE_BRIDGE: /* bridge header */
1084 if (class != PCI_CLASS_BRIDGE_PCI)
1086 /* The PCI-to-PCI bridge spec requires that subtractive
1087 decoding (i.e. transparent) bridge must have programming
1088 interface code of 0x01. */
1090 dev->transparent = ((dev->class & 0xff) == 1);
1091 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
1092 set_pcie_hotplug_bridge(dev);
1093 pos = pci_find_capability(dev, PCI_CAP_ID_SSVID);
1095 pci_read_config_word(dev, pos + PCI_SSVID_VENDOR_ID, &dev->subsystem_vendor);
1096 pci_read_config_word(dev, pos + PCI_SSVID_DEVICE_ID, &dev->subsystem_device);
1100 case PCI_HEADER_TYPE_CARDBUS: /* CardBus bridge header */
1101 if (class != PCI_CLASS_BRIDGE_CARDBUS)
1104 pci_read_bases(dev, 1, 0);
1105 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
1106 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device);
1109 default: /* unknown header */
1110 dev_err(&dev->dev, "unknown header type %02x, "
1111 "ignoring device\n", dev->hdr_type);
1115 dev_err(&dev->dev, "ignoring class %#08x (doesn't match header "
1116 "type %02x)\n", dev->class, dev->hdr_type);
1117 dev->class = PCI_CLASS_NOT_DEFINED;
1120 /* We found a fine healthy device, go go go... */
1124 static void pci_release_capabilities(struct pci_dev *dev)
1126 pci_vpd_release(dev);
1127 pci_iov_release(dev);
1128 pci_free_cap_save_buffers(dev);
1132 * pci_release_dev - free a pci device structure when all users of it are finished.
1133 * @dev: device that's been disconnected
1135 * Will be called only by the device core when all users of this pci device are
1138 static void pci_release_dev(struct device *dev)
1140 struct pci_dev *pci_dev;
1142 pci_dev = to_pci_dev(dev);
1143 pci_release_capabilities(pci_dev);
1144 pci_release_of_node(pci_dev);
1149 * pci_cfg_space_size - get the configuration space size of the PCI device.
1152 * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices
1153 * have 4096 bytes. Even if the device is capable, that doesn't mean we can
1154 * access it. Maybe we don't have a way to generate extended config space
1155 * accesses, or the device is behind a reverse Express bridge. So we try
1156 * reading the dword at 0x100 which must either be 0 or a valid extended
1157 * capability header.
1159 int pci_cfg_space_size_ext(struct pci_dev *dev)
1162 int pos = PCI_CFG_SPACE_SIZE;
1164 if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL)
1166 if (status == 0xffffffff)
1169 return PCI_CFG_SPACE_EXP_SIZE;
1172 return PCI_CFG_SPACE_SIZE;
1175 int pci_cfg_space_size(struct pci_dev *dev)
1181 class = dev->class >> 8;
1182 if (class == PCI_CLASS_BRIDGE_HOST)
1183 return pci_cfg_space_size_ext(dev);
1185 pos = pci_pcie_cap(dev);
1187 pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1191 pci_read_config_dword(dev, pos + PCI_X_STATUS, &status);
1192 if (!(status & (PCI_X_STATUS_266MHZ | PCI_X_STATUS_533MHZ)))
1196 return pci_cfg_space_size_ext(dev);
1199 return PCI_CFG_SPACE_SIZE;
1202 static void pci_release_bus_bridge_dev(struct device *dev)
1207 struct pci_dev *alloc_pci_dev(void)
1209 struct pci_dev *dev;
1211 dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
1215 INIT_LIST_HEAD(&dev->bus_list);
1219 EXPORT_SYMBOL(alloc_pci_dev);
1221 bool pci_bus_read_dev_vendor_id(struct pci_bus *bus, int devfn, u32 *l,
1226 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
1229 /* some broken boards return 0 or ~0 if a slot is empty: */
1230 if (*l == 0xffffffff || *l == 0x00000000 ||
1231 *l == 0x0000ffff || *l == 0xffff0000)
1234 /* Configuration request Retry Status */
1235 while (*l == 0xffff0001) {
1241 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
1243 /* Card hasn't responded in 60 seconds? Must be stuck. */
1244 if (delay > crs_timeout) {
1245 printk(KERN_WARNING "pci %04x:%02x:%02x.%d: not "
1246 "responding\n", pci_domain_nr(bus),
1247 bus->number, PCI_SLOT(devfn),
1255 EXPORT_SYMBOL(pci_bus_read_dev_vendor_id);
1258 * Read the config data for a PCI device, sanity-check it
1259 * and fill in the dev structure...
1261 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
1263 struct pci_dev *dev;
1266 if (!pci_bus_read_dev_vendor_id(bus, devfn, &l, 60*1000))
1269 dev = alloc_pci_dev();
1275 dev->vendor = l & 0xffff;
1276 dev->device = (l >> 16) & 0xffff;
1278 pci_set_of_node(dev);
1280 if (pci_setup_device(dev)) {
1288 static void pci_init_capabilities(struct pci_dev *dev)
1290 /* MSI/MSI-X list */
1291 pci_msi_init_pci_dev(dev);
1293 /* Buffers for saving PCIe and PCI-X capabilities */
1294 pci_allocate_cap_save_buffers(dev);
1296 /* Power Management */
1298 platform_pci_wakeup_init(dev);
1300 /* Vital Product Data */
1301 pci_vpd_pci22_init(dev);
1303 /* Alternative Routing-ID Forwarding */
1304 pci_enable_ari(dev);
1306 /* Single Root I/O Virtualization */
1309 /* Enable ACS P2P upstream forwarding */
1310 pci_enable_acs(dev);
1313 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
1315 device_initialize(&dev->dev);
1316 dev->dev.release = pci_release_dev;
1319 dev->dev.dma_mask = &dev->dma_mask;
1320 dev->dev.dma_parms = &dev->dma_parms;
1321 dev->dev.coherent_dma_mask = 0xffffffffull;
1323 pci_set_dma_max_seg_size(dev, 65536);
1324 pci_set_dma_seg_boundary(dev, 0xffffffff);
1326 /* Fix up broken headers */
1327 pci_fixup_device(pci_fixup_header, dev);
1329 /* moved out from quirk header fixup code */
1330 pci_reassigndev_resource_alignment(dev);
1332 /* Clear the state_saved flag. */
1333 dev->state_saved = false;
1335 /* Initialize various capabilities */
1336 pci_init_capabilities(dev);
1339 * Add the device to our list of discovered devices
1340 * and the bus list for fixup functions, etc.
1342 down_write(&pci_bus_sem);
1343 list_add_tail(&dev->bus_list, &bus->devices);
1344 up_write(&pci_bus_sem);
1347 struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
1349 struct pci_dev *dev;
1351 dev = pci_get_slot(bus, devfn);
1357 dev = pci_scan_device(bus, devfn);
1361 pci_device_add(dev, bus);
1365 EXPORT_SYMBOL(pci_scan_single_device);
1367 static unsigned next_ari_fn(struct pci_dev *dev, unsigned fn)
1370 unsigned pos, next_fn;
1375 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI);
1378 pci_read_config_word(dev, pos + 4, &cap);
1385 static unsigned next_trad_fn(struct pci_dev *dev, unsigned fn)
1387 return (fn + 1) % 8;
1390 static unsigned no_next_fn(struct pci_dev *dev, unsigned fn)
1395 static int only_one_child(struct pci_bus *bus)
1397 struct pci_dev *parent = bus->self;
1398 if (!parent || !pci_is_pcie(parent))
1400 if (parent->pcie_type == PCI_EXP_TYPE_ROOT_PORT ||
1401 parent->pcie_type == PCI_EXP_TYPE_DOWNSTREAM)
1407 * pci_scan_slot - scan a PCI slot on a bus for devices.
1408 * @bus: PCI bus to scan
1409 * @devfn: slot number to scan (must have zero function.)
1411 * Scan a PCI slot on the specified PCI bus for devices, adding
1412 * discovered devices to the @bus->devices list. New devices
1413 * will not have is_added set.
1415 * Returns the number of new devices found.
1417 int pci_scan_slot(struct pci_bus *bus, int devfn)
1419 unsigned fn, nr = 0;
1420 struct pci_dev *dev;
1421 unsigned (*next_fn)(struct pci_dev *, unsigned) = no_next_fn;
1423 if (only_one_child(bus) && (devfn > 0))
1424 return 0; /* Already scanned the entire slot */
1426 dev = pci_scan_single_device(bus, devfn);
1432 if (pci_ari_enabled(bus))
1433 next_fn = next_ari_fn;
1434 else if (dev->multifunction)
1435 next_fn = next_trad_fn;
1437 for (fn = next_fn(dev, 0); fn > 0; fn = next_fn(dev, fn)) {
1438 dev = pci_scan_single_device(bus, devfn + fn);
1442 dev->multifunction = 1;
1446 /* only one slot has pcie device */
1447 if (bus->self && nr)
1448 pcie_aspm_init_link_state(bus->self);
1453 static int pcie_find_smpss(struct pci_dev *dev, void *data)
1457 if (!pci_is_pcie(dev))
1460 /* For PCIE hotplug enabled slots not connected directly to a
1461 * PCI-E root port, there can be problems when hotplugging
1462 * devices. This is due to the possibility of hotplugging a
1463 * device into the fabric with a smaller MPS that the devices
1464 * currently running have configured. Modifying the MPS on the
1465 * running devices could cause a fatal bus error due to an
1466 * incoming frame being larger than the newly configured MPS.
1467 * To work around this, the MPS for the entire fabric must be
1468 * set to the minimum size. Any devices hotplugged into this
1469 * fabric will have the minimum MPS set. If the PCI hotplug
1470 * slot is directly connected to the root port and there are not
1471 * other devices on the fabric (which seems to be the most
1472 * common case), then this is not an issue and MPS discovery
1473 * will occur as normal.
1475 if (dev->is_hotplug_bridge && (!list_is_singular(&dev->bus->devices) ||
1477 dev->bus->self->pcie_type != PCI_EXP_TYPE_ROOT_PORT)))
1480 if (*smpss > dev->pcie_mpss)
1481 *smpss = dev->pcie_mpss;
1486 static void pcie_write_mps(struct pci_dev *dev, int mps)
1490 if (pcie_bus_config == PCIE_BUS_PERFORMANCE) {
1491 mps = 128 << dev->pcie_mpss;
1493 if (dev->pcie_type != PCI_EXP_TYPE_ROOT_PORT && dev->bus->self)
1494 /* For "Performance", the assumption is made that
1495 * downstream communication will never be larger than
1496 * the MRRS. So, the MPS only needs to be configured
1497 * for the upstream communication. This being the case,
1498 * walk from the top down and set the MPS of the child
1499 * to that of the parent bus.
1501 * Configure the device MPS with the smaller of the
1502 * device MPSS or the bridge MPS (which is assumed to be
1503 * properly configured at this point to the largest
1504 * allowable MPS based on its parent bus).
1506 mps = min(mps, pcie_get_mps(dev->bus->self));
1509 rc = pcie_set_mps(dev, mps);
1511 dev_err(&dev->dev, "Failed attempting to set the MPS\n");
1514 static void pcie_write_mrrs(struct pci_dev *dev)
1518 /* In the "safe" case, do not configure the MRRS. There appear to be
1519 * issues with setting MRRS to 0 on a number of devices.
1521 if (pcie_bus_config != PCIE_BUS_PERFORMANCE)
1524 /* For Max performance, the MRRS must be set to the largest supported
1525 * value. However, it cannot be configured larger than the MPS the
1526 * device or the bus can support. This should already be properly
1527 * configured by a prior call to pcie_write_mps.
1529 mrrs = pcie_get_mps(dev);
1531 /* MRRS is a R/W register. Invalid values can be written, but a
1532 * subsequent read will verify if the value is acceptable or not.
1533 * If the MRRS value provided is not acceptable (e.g., too large),
1534 * shrink the value until it is acceptable to the HW.
1536 while (mrrs != pcie_get_readrq(dev) && mrrs >= 128) {
1537 rc = pcie_set_readrq(dev, mrrs);
1541 dev_warn(&dev->dev, "Failed attempting to set the MRRS\n");
1546 dev_err(&dev->dev, "MRRS was unable to be configured with a "
1547 "safe value. If problems are experienced, try running "
1548 "with pci=pcie_bus_safe.\n");
1551 static int pcie_bus_configure_set(struct pci_dev *dev, void *data)
1555 if (!pci_is_pcie(dev))
1558 mps = 128 << *(u8 *)data;
1559 orig_mps = pcie_get_mps(dev);
1561 pcie_write_mps(dev, mps);
1562 pcie_write_mrrs(dev);
1564 dev_info(&dev->dev, "PCI-E Max Payload Size set to %4d/%4d (was %4d), "
1565 "Max Read Rq %4d\n", pcie_get_mps(dev), 128 << dev->pcie_mpss,
1566 orig_mps, pcie_get_readrq(dev));
1571 /* pcie_bus_configure_settings requires that pci_walk_bus work in a top-down,
1572 * parents then children fashion. If this changes, then this code will not
1575 void pcie_bus_configure_settings(struct pci_bus *bus, u8 mpss)
1579 if (!pci_is_pcie(bus->self))
1582 if (pcie_bus_config == PCIE_BUS_TUNE_OFF)
1585 /* FIXME - Peer to peer DMA is possible, though the endpoint would need
1586 * to be aware to the MPS of the destination. To work around this,
1587 * simply force the MPS of the entire system to the smallest possible.
1589 if (pcie_bus_config == PCIE_BUS_PEER2PEER)
1592 if (pcie_bus_config == PCIE_BUS_SAFE) {
1595 pcie_find_smpss(bus->self, &smpss);
1596 pci_walk_bus(bus, pcie_find_smpss, &smpss);
1599 pcie_bus_configure_set(bus->self, &smpss);
1600 pci_walk_bus(bus, pcie_bus_configure_set, &smpss);
1602 EXPORT_SYMBOL_GPL(pcie_bus_configure_settings);
1604 unsigned int __devinit pci_scan_child_bus(struct pci_bus *bus)
1606 unsigned int devfn, pass, max = bus->secondary;
1607 struct pci_dev *dev;
1609 dev_dbg(&bus->dev, "scanning bus\n");
1611 /* Go find them, Rover! */
1612 for (devfn = 0; devfn < 0x100; devfn += 8)
1613 pci_scan_slot(bus, devfn);
1615 /* Reserve buses for SR-IOV capability. */
1616 max += pci_iov_bus_range(bus);
1619 * After performing arch-dependent fixup of the bus, look behind
1620 * all PCI-to-PCI bridges on this bus.
1622 if (!bus->is_added) {
1623 dev_dbg(&bus->dev, "fixups for bus\n");
1624 pcibios_fixup_bus(bus);
1625 if (pci_is_root_bus(bus))
1629 for (pass=0; pass < 2; pass++)
1630 list_for_each_entry(dev, &bus->devices, bus_list) {
1631 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1632 dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1633 max = pci_scan_bridge(bus, dev, max, pass);
1637 * We've scanned the bus and so we know all about what's on
1638 * the other side of any bridges that may be on this bus plus
1641 * Return how far we've got finding sub-buses.
1643 dev_dbg(&bus->dev, "bus scan returning with max=%02x\n", max);
1647 struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
1648 struct pci_ops *ops, void *sysdata, struct list_head *resources)
1651 struct pci_host_bridge *bridge;
1652 struct pci_bus *b, *b2;
1654 struct pci_host_bridge_window *window, *n;
1655 struct resource *res;
1656 resource_size_t offset;
1660 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
1664 b = pci_alloc_bus();
1668 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1672 b->sysdata = sysdata;
1675 b2 = pci_find_bus(pci_domain_nr(b), bus);
1677 /* If we already got to this bus through a different bridge, ignore it */
1678 dev_dbg(&b2->dev, "bus already known\n");
1682 dev->parent = parent;
1683 dev->release = pci_release_bus_bridge_dev;
1684 dev_set_name(dev, "pci%04x:%02x", pci_domain_nr(b), bus);
1685 error = device_register(dev);
1688 b->bridge = get_device(dev);
1689 device_enable_async_suspend(b->bridge);
1690 pci_set_bus_of_node(b);
1693 set_dev_node(b->bridge, pcibus_to_node(b));
1695 b->dev.class = &pcibus_class;
1696 b->dev.parent = b->bridge;
1697 dev_set_name(&b->dev, "%04x:%02x", pci_domain_nr(b), bus);
1698 error = device_register(&b->dev);
1700 goto class_dev_reg_err;
1702 /* Create legacy_io and legacy_mem files for this bus */
1703 pci_create_legacy_files(b);
1705 b->number = b->secondary = bus;
1708 INIT_LIST_HEAD(&bridge->windows);
1711 dev_info(parent, "PCI host bridge to bus %s\n", dev_name(&b->dev));
1713 printk(KERN_INFO "PCI host bridge to bus %s\n", dev_name(&b->dev));
1715 /* Add initial resources to the bus */
1716 list_for_each_entry_safe(window, n, resources, list) {
1717 list_move_tail(&window->list, &bridge->windows);
1719 offset = window->offset;
1720 pci_bus_add_resource(b, res, 0);
1722 if (resource_type(res) == IORESOURCE_IO)
1723 fmt = " (bus address [%#06llx-%#06llx])";
1725 fmt = " (bus address [%#010llx-%#010llx])";
1726 snprintf(bus_addr, sizeof(bus_addr), fmt,
1727 (unsigned long long) (res->start - offset),
1728 (unsigned long long) (res->end - offset));
1731 dev_info(&b->dev, "root bus resource %pR%s\n", res, bus_addr);
1734 down_write(&pci_bus_sem);
1735 list_add_tail(&bridge->list, &pci_host_bridges);
1736 list_add_tail(&b->node, &pci_root_buses);
1737 up_write(&pci_bus_sem);
1742 device_unregister(dev);
1744 down_write(&pci_bus_sem);
1745 list_del(&bridge->list);
1747 up_write(&pci_bus_sem);
1757 struct pci_bus * __devinit pci_scan_root_bus(struct device *parent, int bus,
1758 struct pci_ops *ops, void *sysdata, struct list_head *resources)
1762 b = pci_create_root_bus(parent, bus, ops, sysdata, resources);
1766 b->subordinate = pci_scan_child_bus(b);
1767 pci_bus_add_devices(b);
1770 EXPORT_SYMBOL(pci_scan_root_bus);
1772 /* Deprecated; use pci_scan_root_bus() instead */
1773 struct pci_bus * __devinit pci_scan_bus_parented(struct device *parent,
1774 int bus, struct pci_ops *ops, void *sysdata)
1776 LIST_HEAD(resources);
1779 pci_add_resource(&resources, &ioport_resource);
1780 pci_add_resource(&resources, &iomem_resource);
1781 b = pci_create_root_bus(parent, bus, ops, sysdata, &resources);
1783 b->subordinate = pci_scan_child_bus(b);
1785 pci_free_resource_list(&resources);
1788 EXPORT_SYMBOL(pci_scan_bus_parented);
1790 struct pci_bus * __devinit pci_scan_bus(int bus, struct pci_ops *ops,
1793 LIST_HEAD(resources);
1796 pci_add_resource(&resources, &ioport_resource);
1797 pci_add_resource(&resources, &iomem_resource);
1798 b = pci_create_root_bus(NULL, bus, ops, sysdata, &resources);
1800 b->subordinate = pci_scan_child_bus(b);
1801 pci_bus_add_devices(b);
1803 pci_free_resource_list(&resources);
1807 EXPORT_SYMBOL(pci_scan_bus);
1809 #ifdef CONFIG_HOTPLUG
1811 * pci_rescan_bus_bridge_resize - scan a PCI bus for devices.
1812 * @bridge: PCI bridge for the bus to scan
1814 * Scan a PCI bus and child buses for new devices, add them,
1815 * and enable them, resizing bridge mmio/io resource if necessary
1816 * and possible. The caller must ensure the child devices are already
1817 * removed for resizing to occur.
1819 * Returns the max number of subordinate bus discovered.
1821 unsigned int __ref pci_rescan_bus_bridge_resize(struct pci_dev *bridge)
1824 struct pci_bus *bus = bridge->subordinate;
1826 max = pci_scan_child_bus(bus);
1828 pci_assign_unassigned_bridge_resources(bridge);
1830 pci_bus_add_devices(bus);
1835 EXPORT_SYMBOL(pci_add_new_bus);
1836 EXPORT_SYMBOL(pci_scan_slot);
1837 EXPORT_SYMBOL(pci_scan_bridge);
1838 EXPORT_SYMBOL_GPL(pci_scan_child_bus);
1841 static int __init pci_sort_bf_cmp(const struct device *d_a, const struct device *d_b)
1843 const struct pci_dev *a = to_pci_dev(d_a);
1844 const struct pci_dev *b = to_pci_dev(d_b);
1846 if (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
1847 else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return 1;
1849 if (a->bus->number < b->bus->number) return -1;
1850 else if (a->bus->number > b->bus->number) return 1;
1852 if (a->devfn < b->devfn) return -1;
1853 else if (a->devfn > b->devfn) return 1;
1858 void __init pci_sort_breadthfirst(void)
1860 bus_sort_breadthfirst(&pci_bus_type, &pci_sort_bf_cmp);