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>
13 #include <asm-generic/pci-bridge.h>
16 #define CARDBUS_LATENCY_TIMER 176 /* secondary latency timer */
17 #define CARDBUS_RESERVE_BUSNR 3
19 struct resource busn_resource = {
23 .flags = IORESOURCE_BUS,
26 /* Ugh. Need to stop exporting this to modules. */
27 LIST_HEAD(pci_root_buses);
28 EXPORT_SYMBOL(pci_root_buses);
30 static LIST_HEAD(pci_domain_busn_res_list);
32 struct pci_domain_busn_res {
33 struct list_head list;
38 static struct resource *get_pci_domain_busn_res(int domain_nr)
40 struct pci_domain_busn_res *r;
42 list_for_each_entry(r, &pci_domain_busn_res_list, list)
43 if (r->domain_nr == domain_nr)
46 r = kzalloc(sizeof(*r), GFP_KERNEL);
50 r->domain_nr = domain_nr;
53 r->res.flags = IORESOURCE_BUS | IORESOURCE_PCI_FIXED;
55 list_add_tail(&r->list, &pci_domain_busn_res_list);
60 static int find_anything(struct device *dev, void *data)
66 * Some device drivers need know if pci is initiated.
67 * Basically, we think pci is not initiated when there
68 * is no device to be found on the pci_bus_type.
70 int no_pci_devices(void)
75 dev = bus_find_device(&pci_bus_type, NULL, NULL, find_anything);
76 no_devices = (dev == NULL);
80 EXPORT_SYMBOL(no_pci_devices);
85 static void release_pcibus_dev(struct device *dev)
87 struct pci_bus *pci_bus = to_pci_bus(dev);
90 put_device(pci_bus->bridge);
91 pci_bus_remove_resources(pci_bus);
92 pci_release_bus_of_node(pci_bus);
96 static struct class pcibus_class = {
98 .dev_release = &release_pcibus_dev,
99 .dev_groups = pcibus_groups,
102 static int __init pcibus_class_init(void)
104 return class_register(&pcibus_class);
106 postcore_initcall(pcibus_class_init);
108 static u64 pci_size(u64 base, u64 maxbase, u64 mask)
110 u64 size = mask & maxbase; /* Find the significant bits */
114 /* Get the lowest of them to find the decode size, and
115 from that the extent. */
116 size = (size & ~(size-1)) - 1;
118 /* base == maxbase can be valid only if the BAR has
119 already been programmed with all 1s. */
120 if (base == maxbase && ((base | size) & mask) != mask)
126 static inline unsigned long decode_bar(struct pci_dev *dev, u32 bar)
131 if ((bar & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO) {
132 flags = bar & ~PCI_BASE_ADDRESS_IO_MASK;
133 flags |= IORESOURCE_IO;
137 flags = bar & ~PCI_BASE_ADDRESS_MEM_MASK;
138 flags |= IORESOURCE_MEM;
139 if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
140 flags |= IORESOURCE_PREFETCH;
142 mem_type = bar & PCI_BASE_ADDRESS_MEM_TYPE_MASK;
144 case PCI_BASE_ADDRESS_MEM_TYPE_32:
146 case PCI_BASE_ADDRESS_MEM_TYPE_1M:
147 /* 1M mem BAR treated as 32-bit BAR */
149 case PCI_BASE_ADDRESS_MEM_TYPE_64:
150 flags |= IORESOURCE_MEM_64;
153 /* mem unknown type treated as 32-bit BAR */
159 #define PCI_COMMAND_DECODE_ENABLE (PCI_COMMAND_MEMORY | PCI_COMMAND_IO)
162 * pci_read_base - read a PCI BAR
163 * @dev: the PCI device
164 * @type: type of the BAR
165 * @res: resource buffer to be filled in
166 * @pos: BAR position in the config space
168 * Returns 1 if the BAR is 64-bit, or 0 if 32-bit.
170 int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
171 struct resource *res, unsigned int pos)
175 struct pci_bus_region region, inverted_region;
176 bool bar_too_big = false, bar_disabled = false;
178 mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
180 /* No printks while decoding is disabled! */
181 if (!dev->mmio_always_on) {
182 pci_read_config_word(dev, PCI_COMMAND, &orig_cmd);
183 if (orig_cmd & PCI_COMMAND_DECODE_ENABLE) {
184 pci_write_config_word(dev, PCI_COMMAND,
185 orig_cmd & ~PCI_COMMAND_DECODE_ENABLE);
189 res->name = pci_name(dev);
191 pci_read_config_dword(dev, pos, &l);
192 pci_write_config_dword(dev, pos, l | mask);
193 pci_read_config_dword(dev, pos, &sz);
194 pci_write_config_dword(dev, pos, l);
197 * All bits set in sz means the device isn't working properly.
198 * If the BAR isn't implemented, all bits must be 0. If it's a
199 * memory BAR or a ROM, bit 0 must be clear; if it's an io BAR, bit
202 if (!sz || sz == 0xffffffff)
206 * I don't know how l can have all bits set. Copied from old code.
207 * Maybe it fixes a bug on some ancient platform.
212 if (type == pci_bar_unknown) {
213 res->flags = decode_bar(dev, l);
214 res->flags |= IORESOURCE_SIZEALIGN;
215 if (res->flags & IORESOURCE_IO) {
216 l &= PCI_BASE_ADDRESS_IO_MASK;
217 mask = PCI_BASE_ADDRESS_IO_MASK & (u32) IO_SPACE_LIMIT;
219 l &= PCI_BASE_ADDRESS_MEM_MASK;
220 mask = (u32)PCI_BASE_ADDRESS_MEM_MASK;
223 res->flags |= (l & IORESOURCE_ROM_ENABLE);
224 l &= PCI_ROM_ADDRESS_MASK;
225 mask = (u32)PCI_ROM_ADDRESS_MASK;
228 if (res->flags & IORESOURCE_MEM_64) {
231 u64 mask64 = mask | (u64)~0 << 32;
233 pci_read_config_dword(dev, pos + 4, &l);
234 pci_write_config_dword(dev, pos + 4, ~0);
235 pci_read_config_dword(dev, pos + 4, &sz);
236 pci_write_config_dword(dev, pos + 4, l);
238 l64 |= ((u64)l << 32);
239 sz64 |= ((u64)sz << 32);
241 sz64 = pci_size(l64, sz64, mask64);
246 if ((sizeof(resource_size_t) < 8) && (sz64 > 0x100000000ULL)) {
251 if ((sizeof(resource_size_t) < 8) && l) {
252 /* Address above 32-bit boundary; disable the BAR */
253 pci_write_config_dword(dev, pos, 0);
254 pci_write_config_dword(dev, pos + 4, 0);
260 region.end = l64 + sz64;
263 sz = pci_size(l, sz, mask);
272 pcibios_bus_to_resource(dev, res, ®ion);
273 pcibios_resource_to_bus(dev, &inverted_region, res);
276 * If "A" is a BAR value (a bus address), "bus_to_resource(A)" is
277 * the corresponding resource address (the physical address used by
278 * the CPU. Converting that resource address back to a bus address
279 * should yield the original BAR value:
281 * resource_to_bus(bus_to_resource(A)) == A
283 * If it doesn't, CPU accesses to "bus_to_resource(A)" will not
284 * be claimed by the device.
286 if (inverted_region.start != region.start) {
287 dev_info(&dev->dev, "reg 0x%x: initial BAR value %pa invalid; forcing reassignment\n",
289 res->flags |= IORESOURCE_UNSET;
290 res->end -= res->start;
300 if (!dev->mmio_always_on &&
301 (orig_cmd & PCI_COMMAND_DECODE_ENABLE))
302 pci_write_config_word(dev, PCI_COMMAND, orig_cmd);
305 dev_err(&dev->dev, "reg 0x%x: can't handle 64-bit BAR\n", pos);
306 if (res->flags && !bar_disabled)
307 dev_printk(KERN_DEBUG, &dev->dev, "reg 0x%x: %pR\n", pos, res);
309 return (res->flags & IORESOURCE_MEM_64) ? 1 : 0;
312 static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
314 unsigned int pos, reg;
316 for (pos = 0; pos < howmany; pos++) {
317 struct resource *res = &dev->resource[pos];
318 reg = PCI_BASE_ADDRESS_0 + (pos << 2);
319 pos += __pci_read_base(dev, pci_bar_unknown, res, reg);
323 struct resource *res = &dev->resource[PCI_ROM_RESOURCE];
324 dev->rom_base_reg = rom;
325 res->flags = IORESOURCE_MEM | IORESOURCE_PREFETCH |
326 IORESOURCE_READONLY | IORESOURCE_CACHEABLE |
327 IORESOURCE_SIZEALIGN;
328 __pci_read_base(dev, pci_bar_mem32, res, rom);
332 static void pci_read_bridge_io(struct pci_bus *child)
334 struct pci_dev *dev = child->self;
335 u8 io_base_lo, io_limit_lo;
336 unsigned long io_mask, io_granularity, base, limit;
337 struct pci_bus_region region;
338 struct resource *res;
340 io_mask = PCI_IO_RANGE_MASK;
341 io_granularity = 0x1000;
342 if (dev->io_window_1k) {
343 /* Support 1K I/O space granularity */
344 io_mask = PCI_IO_1K_RANGE_MASK;
345 io_granularity = 0x400;
348 res = child->resource[0];
349 pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
350 pci_read_config_byte(dev, PCI_IO_LIMIT, &io_limit_lo);
351 base = (io_base_lo & io_mask) << 8;
352 limit = (io_limit_lo & io_mask) << 8;
354 if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
355 u16 io_base_hi, io_limit_hi;
357 pci_read_config_word(dev, PCI_IO_BASE_UPPER16, &io_base_hi);
358 pci_read_config_word(dev, PCI_IO_LIMIT_UPPER16, &io_limit_hi);
359 base |= ((unsigned long) io_base_hi << 16);
360 limit |= ((unsigned long) io_limit_hi << 16);
364 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
366 region.end = limit + io_granularity - 1;
367 pcibios_bus_to_resource(dev, res, ®ion);
368 dev_printk(KERN_DEBUG, &dev->dev, " bridge window %pR\n", res);
372 static void pci_read_bridge_mmio(struct pci_bus *child)
374 struct pci_dev *dev = child->self;
375 u16 mem_base_lo, mem_limit_lo;
376 unsigned long base, limit;
377 struct pci_bus_region region;
378 struct resource *res;
380 res = child->resource[1];
381 pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
382 pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
383 base = ((unsigned long) mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
384 limit = ((unsigned long) mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
386 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
388 region.end = limit + 0xfffff;
389 pcibios_bus_to_resource(dev, res, ®ion);
390 dev_printk(KERN_DEBUG, &dev->dev, " bridge window %pR\n", res);
394 static void pci_read_bridge_mmio_pref(struct pci_bus *child)
396 struct pci_dev *dev = child->self;
397 u16 mem_base_lo, mem_limit_lo;
398 unsigned long base, limit;
399 struct pci_bus_region region;
400 struct resource *res;
402 res = child->resource[2];
403 pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
404 pci_read_config_word(dev, PCI_PREF_MEMORY_LIMIT, &mem_limit_lo);
405 base = ((unsigned long) mem_base_lo & PCI_PREF_RANGE_MASK) << 16;
406 limit = ((unsigned long) mem_limit_lo & PCI_PREF_RANGE_MASK) << 16;
408 if ((mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
409 u32 mem_base_hi, mem_limit_hi;
411 pci_read_config_dword(dev, PCI_PREF_BASE_UPPER32, &mem_base_hi);
412 pci_read_config_dword(dev, PCI_PREF_LIMIT_UPPER32, &mem_limit_hi);
415 * Some bridges set the base > limit by default, and some
416 * (broken) BIOSes do not initialize them. If we find
417 * this, just assume they are not being used.
419 if (mem_base_hi <= mem_limit_hi) {
420 #if BITS_PER_LONG == 64
421 base |= ((unsigned long) mem_base_hi) << 32;
422 limit |= ((unsigned long) mem_limit_hi) << 32;
424 if (mem_base_hi || mem_limit_hi) {
425 dev_err(&dev->dev, "can't handle 64-bit "
426 "address space for bridge\n");
433 res->flags = (mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) |
434 IORESOURCE_MEM | IORESOURCE_PREFETCH;
435 if (res->flags & PCI_PREF_RANGE_TYPE_64)
436 res->flags |= IORESOURCE_MEM_64;
438 region.end = limit + 0xfffff;
439 pcibios_bus_to_resource(dev, res, ®ion);
440 dev_printk(KERN_DEBUG, &dev->dev, " bridge window %pR\n", res);
444 void pci_read_bridge_bases(struct pci_bus *child)
446 struct pci_dev *dev = child->self;
447 struct resource *res;
450 if (pci_is_root_bus(child)) /* It's a host bus, nothing to read */
453 dev_info(&dev->dev, "PCI bridge to %pR%s\n",
455 dev->transparent ? " (subtractive decode)" : "");
457 pci_bus_remove_resources(child);
458 for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++)
459 child->resource[i] = &dev->resource[PCI_BRIDGE_RESOURCES+i];
461 pci_read_bridge_io(child);
462 pci_read_bridge_mmio(child);
463 pci_read_bridge_mmio_pref(child);
465 if (dev->transparent) {
466 pci_bus_for_each_resource(child->parent, res, i) {
468 pci_bus_add_resource(child, res,
469 PCI_SUBTRACTIVE_DECODE);
470 dev_printk(KERN_DEBUG, &dev->dev,
471 " bridge window %pR (subtractive decode)\n",
478 static struct pci_bus *pci_alloc_bus(void)
482 b = kzalloc(sizeof(*b), GFP_KERNEL);
486 INIT_LIST_HEAD(&b->node);
487 INIT_LIST_HEAD(&b->children);
488 INIT_LIST_HEAD(&b->devices);
489 INIT_LIST_HEAD(&b->slots);
490 INIT_LIST_HEAD(&b->resources);
491 b->max_bus_speed = PCI_SPEED_UNKNOWN;
492 b->cur_bus_speed = PCI_SPEED_UNKNOWN;
496 static void pci_release_host_bridge_dev(struct device *dev)
498 struct pci_host_bridge *bridge = to_pci_host_bridge(dev);
500 if (bridge->release_fn)
501 bridge->release_fn(bridge);
503 pci_free_resource_list(&bridge->windows);
508 static struct pci_host_bridge *pci_alloc_host_bridge(struct pci_bus *b)
510 struct pci_host_bridge *bridge;
512 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
516 INIT_LIST_HEAD(&bridge->windows);
521 const unsigned char pcix_bus_speed[] = {
522 PCI_SPEED_UNKNOWN, /* 0 */
523 PCI_SPEED_66MHz_PCIX, /* 1 */
524 PCI_SPEED_100MHz_PCIX, /* 2 */
525 PCI_SPEED_133MHz_PCIX, /* 3 */
526 PCI_SPEED_UNKNOWN, /* 4 */
527 PCI_SPEED_66MHz_PCIX_ECC, /* 5 */
528 PCI_SPEED_100MHz_PCIX_ECC, /* 6 */
529 PCI_SPEED_133MHz_PCIX_ECC, /* 7 */
530 PCI_SPEED_UNKNOWN, /* 8 */
531 PCI_SPEED_66MHz_PCIX_266, /* 9 */
532 PCI_SPEED_100MHz_PCIX_266, /* A */
533 PCI_SPEED_133MHz_PCIX_266, /* B */
534 PCI_SPEED_UNKNOWN, /* C */
535 PCI_SPEED_66MHz_PCIX_533, /* D */
536 PCI_SPEED_100MHz_PCIX_533, /* E */
537 PCI_SPEED_133MHz_PCIX_533 /* F */
540 const unsigned char pcie_link_speed[] = {
541 PCI_SPEED_UNKNOWN, /* 0 */
542 PCIE_SPEED_2_5GT, /* 1 */
543 PCIE_SPEED_5_0GT, /* 2 */
544 PCIE_SPEED_8_0GT, /* 3 */
545 PCI_SPEED_UNKNOWN, /* 4 */
546 PCI_SPEED_UNKNOWN, /* 5 */
547 PCI_SPEED_UNKNOWN, /* 6 */
548 PCI_SPEED_UNKNOWN, /* 7 */
549 PCI_SPEED_UNKNOWN, /* 8 */
550 PCI_SPEED_UNKNOWN, /* 9 */
551 PCI_SPEED_UNKNOWN, /* A */
552 PCI_SPEED_UNKNOWN, /* B */
553 PCI_SPEED_UNKNOWN, /* C */
554 PCI_SPEED_UNKNOWN, /* D */
555 PCI_SPEED_UNKNOWN, /* E */
556 PCI_SPEED_UNKNOWN /* F */
559 void pcie_update_link_speed(struct pci_bus *bus, u16 linksta)
561 bus->cur_bus_speed = pcie_link_speed[linksta & PCI_EXP_LNKSTA_CLS];
563 EXPORT_SYMBOL_GPL(pcie_update_link_speed);
565 static unsigned char agp_speeds[] = {
573 static enum pci_bus_speed agp_speed(int agp3, int agpstat)
579 else if (agpstat & 2)
581 else if (agpstat & 1)
593 return agp_speeds[index];
597 static void pci_set_bus_speed(struct pci_bus *bus)
599 struct pci_dev *bridge = bus->self;
602 pos = pci_find_capability(bridge, PCI_CAP_ID_AGP);
604 pos = pci_find_capability(bridge, PCI_CAP_ID_AGP3);
608 pci_read_config_dword(bridge, pos + PCI_AGP_STATUS, &agpstat);
609 bus->max_bus_speed = agp_speed(agpstat & 8, agpstat & 7);
611 pci_read_config_dword(bridge, pos + PCI_AGP_COMMAND, &agpcmd);
612 bus->cur_bus_speed = agp_speed(agpstat & 8, agpcmd & 7);
615 pos = pci_find_capability(bridge, PCI_CAP_ID_PCIX);
618 enum pci_bus_speed max;
620 pci_read_config_word(bridge, pos + PCI_X_BRIDGE_SSTATUS,
623 if (status & PCI_X_SSTATUS_533MHZ) {
624 max = PCI_SPEED_133MHz_PCIX_533;
625 } else if (status & PCI_X_SSTATUS_266MHZ) {
626 max = PCI_SPEED_133MHz_PCIX_266;
627 } else if (status & PCI_X_SSTATUS_133MHZ) {
628 if ((status & PCI_X_SSTATUS_VERS) == PCI_X_SSTATUS_V2) {
629 max = PCI_SPEED_133MHz_PCIX_ECC;
631 max = PCI_SPEED_133MHz_PCIX;
634 max = PCI_SPEED_66MHz_PCIX;
637 bus->max_bus_speed = max;
638 bus->cur_bus_speed = pcix_bus_speed[
639 (status & PCI_X_SSTATUS_FREQ) >> 6];
644 if (pci_is_pcie(bridge)) {
648 pcie_capability_read_dword(bridge, PCI_EXP_LNKCAP, &linkcap);
649 bus->max_bus_speed = pcie_link_speed[linkcap & PCI_EXP_LNKCAP_SLS];
651 pcie_capability_read_word(bridge, PCI_EXP_LNKSTA, &linksta);
652 pcie_update_link_speed(bus, linksta);
657 static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
658 struct pci_dev *bridge, int busnr)
660 struct pci_bus *child;
665 * Allocate a new bus, and inherit stuff from the parent..
667 child = pci_alloc_bus();
671 child->parent = parent;
672 child->ops = parent->ops;
673 child->msi = parent->msi;
674 child->sysdata = parent->sysdata;
675 child->bus_flags = parent->bus_flags;
677 /* initialize some portions of the bus device, but don't register it
678 * now as the parent is not properly set up yet.
680 child->dev.class = &pcibus_class;
681 dev_set_name(&child->dev, "%04x:%02x", pci_domain_nr(child), busnr);
684 * Set up the primary, secondary and subordinate
687 child->number = child->busn_res.start = busnr;
688 child->primary = parent->busn_res.start;
689 child->busn_res.end = 0xff;
692 child->dev.parent = parent->bridge;
696 child->self = bridge;
697 child->bridge = get_device(&bridge->dev);
698 child->dev.parent = child->bridge;
699 pci_set_bus_of_node(child);
700 pci_set_bus_speed(child);
702 /* Set up default resource pointers and names.. */
703 for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) {
704 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
705 child->resource[i]->name = child->name;
707 bridge->subordinate = child;
710 ret = device_register(&child->dev);
713 pcibios_add_bus(child);
715 /* Create legacy_io and legacy_mem files for this bus */
716 pci_create_legacy_files(child);
721 struct pci_bus *__ref pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr)
723 struct pci_bus *child;
725 child = pci_alloc_child_bus(parent, dev, busnr);
727 down_write(&pci_bus_sem);
728 list_add_tail(&child->node, &parent->children);
729 up_write(&pci_bus_sem);
734 static void pci_fixup_parent_subordinate_busnr(struct pci_bus *child, int max)
736 struct pci_bus *parent = child->parent;
738 /* Attempts to fix that up are really dangerous unless
739 we're going to re-assign all bus numbers. */
740 if (!pcibios_assign_all_busses())
743 while (parent->parent && parent->busn_res.end < max) {
744 parent->busn_res.end = max;
745 pci_write_config_byte(parent->self, PCI_SUBORDINATE_BUS, max);
746 parent = parent->parent;
751 * If it's a bridge, configure it and scan the bus behind it.
752 * For CardBus bridges, we don't scan behind as the devices will
753 * be handled by the bridge driver itself.
755 * We need to process bridges in two passes -- first we scan those
756 * already configured by the BIOS and after we are done with all of
757 * them, we proceed to assigning numbers to the remaining buses in
758 * order to avoid overlaps between old and new bus numbers.
760 int pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
762 struct pci_bus *child;
763 int is_cardbus = (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS);
766 u8 primary, secondary, subordinate;
769 pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
770 primary = buses & 0xFF;
771 secondary = (buses >> 8) & 0xFF;
772 subordinate = (buses >> 16) & 0xFF;
774 dev_dbg(&dev->dev, "scanning [bus %02x-%02x] behind bridge, pass %d\n",
775 secondary, subordinate, pass);
777 if (!primary && (primary != bus->number) && secondary && subordinate) {
778 dev_warn(&dev->dev, "Primary bus is hard wired to 0\n");
779 primary = bus->number;
782 /* Check if setup is sensible at all */
784 (primary != bus->number || secondary <= bus->number ||
785 secondary > subordinate)) {
786 dev_info(&dev->dev, "bridge configuration invalid ([bus %02x-%02x]), reconfiguring\n",
787 secondary, subordinate);
791 /* Disable MasterAbortMode during probing to avoid reporting
792 of bus errors (in some architectures) */
793 pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl);
794 pci_write_config_word(dev, PCI_BRIDGE_CONTROL,
795 bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT);
797 if ((secondary || subordinate) && !pcibios_assign_all_busses() &&
798 !is_cardbus && !broken) {
801 * Bus already configured by firmware, process it in the first
802 * pass and just note the configuration.
808 * If we already got to this bus through a different bridge,
809 * don't re-add it. This can happen with the i450NX chipset.
811 * However, we continue to descend down the hierarchy and
812 * scan remaining child buses.
814 child = pci_find_bus(pci_domain_nr(bus), secondary);
816 child = pci_add_new_bus(bus, dev, secondary);
819 child->primary = primary;
820 pci_bus_insert_busn_res(child, secondary, subordinate);
821 child->bridge_ctl = bctl;
824 cmax = pci_scan_child_bus(child);
827 if (child->busn_res.end > max)
828 max = child->busn_res.end;
831 * We need to assign a number to this bus which we always
832 * do in the second pass.
835 if (pcibios_assign_all_busses() || broken)
836 /* Temporarily disable forwarding of the
837 configuration cycles on all bridges in
838 this bus segment to avoid possible
839 conflicts in the second pass between two
840 bridges programmed with overlapping
842 pci_write_config_dword(dev, PCI_PRIMARY_BUS,
848 pci_write_config_word(dev, PCI_STATUS, 0xffff);
850 /* Prevent assigning a bus number that already exists.
851 * This can happen when a bridge is hot-plugged, so in
852 * this case we only re-scan this bus. */
853 child = pci_find_bus(pci_domain_nr(bus), max+1);
855 child = pci_add_new_bus(bus, dev, ++max);
858 pci_bus_insert_busn_res(child, max, 0xff);
860 buses = (buses & 0xff000000)
861 | ((unsigned int)(child->primary) << 0)
862 | ((unsigned int)(child->busn_res.start) << 8)
863 | ((unsigned int)(child->busn_res.end) << 16);
866 * yenta.c forces a secondary latency timer of 176.
867 * Copy that behaviour here.
870 buses &= ~0xff000000;
871 buses |= CARDBUS_LATENCY_TIMER << 24;
875 * We need to blast all three values with a single write.
877 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
880 child->bridge_ctl = bctl;
882 * Adjust subordinate busnr in parent buses.
883 * We do this before scanning for children because
884 * some devices may not be detected if the bios
887 pci_fixup_parent_subordinate_busnr(child, max);
888 /* Now we can scan all subordinate buses... */
889 max = pci_scan_child_bus(child);
891 * now fix it up again since we have found
892 * the real value of max.
894 pci_fixup_parent_subordinate_busnr(child, max);
897 * For CardBus bridges, we leave 4 bus numbers
898 * as cards with a PCI-to-PCI bridge can be
901 for (i=0; i<CARDBUS_RESERVE_BUSNR; i++) {
902 struct pci_bus *parent = bus;
903 if (pci_find_bus(pci_domain_nr(bus),
906 while (parent->parent) {
907 if ((!pcibios_assign_all_busses()) &&
908 (parent->busn_res.end > max) &&
909 (parent->busn_res.end <= max+i)) {
912 parent = parent->parent;
916 * Often, there are two cardbus bridges
917 * -- try to leave one valid bus number
925 pci_fixup_parent_subordinate_busnr(child, max);
928 * Set the subordinate bus number to its real value.
930 pci_bus_update_busn_res_end(child, max);
931 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
935 (is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"),
936 pci_domain_nr(bus), child->number);
938 /* Has only triggered on CardBus, fixup is in yenta_socket */
939 while (bus->parent) {
940 if ((child->busn_res.end > bus->busn_res.end) ||
941 (child->number > bus->busn_res.end) ||
942 (child->number < bus->number) ||
943 (child->busn_res.end < bus->number)) {
944 dev_info(&child->dev, "%pR %s "
945 "hidden behind%s bridge %s %pR\n",
947 (bus->number > child->busn_res.end &&
948 bus->busn_res.end < child->number) ?
949 "wholly" : "partially",
950 bus->self->transparent ? " transparent" : "",
958 pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
964 * Read interrupt line and base address registers.
965 * The architecture-dependent code can tweak these, of course.
967 static void pci_read_irq(struct pci_dev *dev)
971 pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq);
974 pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
978 void set_pcie_port_type(struct pci_dev *pdev)
983 pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
986 pdev->pcie_cap = pos;
987 pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, ®16);
988 pdev->pcie_flags_reg = reg16;
989 pci_read_config_word(pdev, pos + PCI_EXP_DEVCAP, ®16);
990 pdev->pcie_mpss = reg16 & PCI_EXP_DEVCAP_PAYLOAD;
993 void set_pcie_hotplug_bridge(struct pci_dev *pdev)
997 pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, ®32);
998 if (reg32 & PCI_EXP_SLTCAP_HPC)
999 pdev->is_hotplug_bridge = 1;
1002 #define LEGACY_IO_RESOURCE (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
1005 * pci_setup_device - fill in class and map information of a device
1006 * @dev: the device structure to fill
1008 * Initialize the device structure with information about the device's
1009 * vendor,class,memory and IO-space addresses,IRQ lines etc.
1010 * Called at initialisation of the PCI subsystem and by CardBus services.
1011 * Returns 0 on success and negative if unknown type of device (not normal,
1012 * bridge or CardBus).
1014 int pci_setup_device(struct pci_dev *dev)
1018 struct pci_slot *slot;
1020 struct pci_bus_region region;
1021 struct resource *res;
1023 if (pci_read_config_byte(dev, PCI_HEADER_TYPE, &hdr_type))
1026 dev->sysdata = dev->bus->sysdata;
1027 dev->dev.parent = dev->bus->bridge;
1028 dev->dev.bus = &pci_bus_type;
1029 dev->hdr_type = hdr_type & 0x7f;
1030 dev->multifunction = !!(hdr_type & 0x80);
1031 dev->error_state = pci_channel_io_normal;
1032 set_pcie_port_type(dev);
1034 list_for_each_entry(slot, &dev->bus->slots, list)
1035 if (PCI_SLOT(dev->devfn) == slot->number)
1038 /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
1039 set this higher, assuming the system even supports it. */
1040 dev->dma_mask = 0xffffffff;
1042 dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
1043 dev->bus->number, PCI_SLOT(dev->devfn),
1044 PCI_FUNC(dev->devfn));
1046 pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
1047 dev->revision = class & 0xff;
1048 dev->class = class >> 8; /* upper 3 bytes */
1050 dev_printk(KERN_DEBUG, &dev->dev, "[%04x:%04x] type %02x class %#08x\n",
1051 dev->vendor, dev->device, dev->hdr_type, dev->class);
1053 /* need to have dev->class ready */
1054 dev->cfg_size = pci_cfg_space_size(dev);
1056 /* "Unknown power state" */
1057 dev->current_state = PCI_UNKNOWN;
1059 /* Early fixups, before probing the BARs */
1060 pci_fixup_device(pci_fixup_early, dev);
1061 /* device class may be changed after fixup */
1062 class = dev->class >> 8;
1064 switch (dev->hdr_type) { /* header type */
1065 case PCI_HEADER_TYPE_NORMAL: /* standard header */
1066 if (class == PCI_CLASS_BRIDGE_PCI)
1069 pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
1070 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
1071 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
1074 * Do the ugly legacy mode stuff here rather than broken chip
1075 * quirk code. Legacy mode ATA controllers have fixed
1076 * addresses. These are not always echoed in BAR0-3, and
1077 * BAR0-3 in a few cases contain junk!
1079 if (class == PCI_CLASS_STORAGE_IDE) {
1081 pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
1082 if ((progif & 1) == 0) {
1083 region.start = 0x1F0;
1085 res = &dev->resource[0];
1086 res->flags = LEGACY_IO_RESOURCE;
1087 pcibios_bus_to_resource(dev, res, ®ion);
1088 region.start = 0x3F6;
1090 res = &dev->resource[1];
1091 res->flags = LEGACY_IO_RESOURCE;
1092 pcibios_bus_to_resource(dev, res, ®ion);
1094 if ((progif & 4) == 0) {
1095 region.start = 0x170;
1097 res = &dev->resource[2];
1098 res->flags = LEGACY_IO_RESOURCE;
1099 pcibios_bus_to_resource(dev, res, ®ion);
1100 region.start = 0x376;
1102 res = &dev->resource[3];
1103 res->flags = LEGACY_IO_RESOURCE;
1104 pcibios_bus_to_resource(dev, res, ®ion);
1109 case PCI_HEADER_TYPE_BRIDGE: /* bridge header */
1110 if (class != PCI_CLASS_BRIDGE_PCI)
1112 /* The PCI-to-PCI bridge spec requires that subtractive
1113 decoding (i.e. transparent) bridge must have programming
1114 interface code of 0x01. */
1116 dev->transparent = ((dev->class & 0xff) == 1);
1117 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
1118 set_pcie_hotplug_bridge(dev);
1119 pos = pci_find_capability(dev, PCI_CAP_ID_SSVID);
1121 pci_read_config_word(dev, pos + PCI_SSVID_VENDOR_ID, &dev->subsystem_vendor);
1122 pci_read_config_word(dev, pos + PCI_SSVID_DEVICE_ID, &dev->subsystem_device);
1126 case PCI_HEADER_TYPE_CARDBUS: /* CardBus bridge header */
1127 if (class != PCI_CLASS_BRIDGE_CARDBUS)
1130 pci_read_bases(dev, 1, 0);
1131 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
1132 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device);
1135 default: /* unknown header */
1136 dev_err(&dev->dev, "unknown header type %02x, "
1137 "ignoring device\n", dev->hdr_type);
1141 dev_err(&dev->dev, "ignoring class %#08x (doesn't match header "
1142 "type %02x)\n", dev->class, dev->hdr_type);
1143 dev->class = PCI_CLASS_NOT_DEFINED;
1146 /* We found a fine healthy device, go go go... */
1150 static void pci_release_capabilities(struct pci_dev *dev)
1152 pci_vpd_release(dev);
1153 pci_iov_release(dev);
1154 pci_free_cap_save_buffers(dev);
1158 * pci_release_dev - free a pci device structure when all users of it are finished.
1159 * @dev: device that's been disconnected
1161 * Will be called only by the device core when all users of this pci device are
1164 static void pci_release_dev(struct device *dev)
1166 struct pci_dev *pci_dev;
1168 pci_dev = to_pci_dev(dev);
1169 pci_release_capabilities(pci_dev);
1170 pci_release_of_node(pci_dev);
1171 pcibios_release_device(pci_dev);
1172 pci_bus_put(pci_dev->bus);
1177 * pci_cfg_space_size - get the configuration space size of the PCI device.
1180 * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices
1181 * have 4096 bytes. Even if the device is capable, that doesn't mean we can
1182 * access it. Maybe we don't have a way to generate extended config space
1183 * accesses, or the device is behind a reverse Express bridge. So we try
1184 * reading the dword at 0x100 which must either be 0 or a valid extended
1185 * capability header.
1187 int pci_cfg_space_size_ext(struct pci_dev *dev)
1190 int pos = PCI_CFG_SPACE_SIZE;
1192 if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL)
1194 if (status == 0xffffffff)
1197 return PCI_CFG_SPACE_EXP_SIZE;
1200 return PCI_CFG_SPACE_SIZE;
1203 int pci_cfg_space_size(struct pci_dev *dev)
1209 class = dev->class >> 8;
1210 if (class == PCI_CLASS_BRIDGE_HOST)
1211 return pci_cfg_space_size_ext(dev);
1213 if (!pci_is_pcie(dev)) {
1214 pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1218 pci_read_config_dword(dev, pos + PCI_X_STATUS, &status);
1219 if (!(status & (PCI_X_STATUS_266MHZ | PCI_X_STATUS_533MHZ)))
1223 return pci_cfg_space_size_ext(dev);
1226 return PCI_CFG_SPACE_SIZE;
1229 struct pci_dev *pci_alloc_dev(struct pci_bus *bus)
1231 struct pci_dev *dev;
1233 dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
1237 INIT_LIST_HEAD(&dev->bus_list);
1238 dev->dev.type = &pci_dev_type;
1239 dev->bus = pci_bus_get(bus);
1243 EXPORT_SYMBOL(pci_alloc_dev);
1245 bool pci_bus_read_dev_vendor_id(struct pci_bus *bus, int devfn, u32 *l,
1250 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
1253 /* some broken boards return 0 or ~0 if a slot is empty: */
1254 if (*l == 0xffffffff || *l == 0x00000000 ||
1255 *l == 0x0000ffff || *l == 0xffff0000)
1258 /* Configuration request Retry Status */
1259 while (*l == 0xffff0001) {
1265 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
1267 /* Card hasn't responded in 60 seconds? Must be stuck. */
1268 if (delay > crs_timeout) {
1269 printk(KERN_WARNING "pci %04x:%02x:%02x.%d: not "
1270 "responding\n", pci_domain_nr(bus),
1271 bus->number, PCI_SLOT(devfn),
1279 EXPORT_SYMBOL(pci_bus_read_dev_vendor_id);
1282 * Read the config data for a PCI device, sanity-check it
1283 * and fill in the dev structure...
1285 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
1287 struct pci_dev *dev;
1290 if (!pci_bus_read_dev_vendor_id(bus, devfn, &l, 60*1000))
1293 dev = pci_alloc_dev(bus);
1298 dev->vendor = l & 0xffff;
1299 dev->device = (l >> 16) & 0xffff;
1301 pci_set_of_node(dev);
1303 if (pci_setup_device(dev)) {
1304 pci_bus_put(dev->bus);
1312 static void pci_init_capabilities(struct pci_dev *dev)
1314 /* MSI/MSI-X list */
1315 pci_msi_init_pci_dev(dev);
1317 /* Buffers for saving PCIe and PCI-X capabilities */
1318 pci_allocate_cap_save_buffers(dev);
1320 /* Power Management */
1323 /* Vital Product Data */
1324 pci_vpd_pci22_init(dev);
1326 /* Alternative Routing-ID Forwarding */
1327 pci_configure_ari(dev);
1329 /* Single Root I/O Virtualization */
1332 /* Enable ACS P2P upstream forwarding */
1333 pci_enable_acs(dev);
1336 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
1340 device_initialize(&dev->dev);
1341 dev->dev.release = pci_release_dev;
1343 set_dev_node(&dev->dev, pcibus_to_node(bus));
1344 dev->dev.dma_mask = &dev->dma_mask;
1345 dev->dev.dma_parms = &dev->dma_parms;
1346 dev->dev.coherent_dma_mask = 0xffffffffull;
1348 pci_set_dma_max_seg_size(dev, 65536);
1349 pci_set_dma_seg_boundary(dev, 0xffffffff);
1351 /* Fix up broken headers */
1352 pci_fixup_device(pci_fixup_header, dev);
1354 /* moved out from quirk header fixup code */
1355 pci_reassigndev_resource_alignment(dev);
1357 /* Clear the state_saved flag. */
1358 dev->state_saved = false;
1360 /* Initialize various capabilities */
1361 pci_init_capabilities(dev);
1364 * Add the device to our list of discovered devices
1365 * and the bus list for fixup functions, etc.
1367 down_write(&pci_bus_sem);
1368 list_add_tail(&dev->bus_list, &bus->devices);
1369 up_write(&pci_bus_sem);
1371 ret = pcibios_add_device(dev);
1374 /* Notifier could use PCI capabilities */
1375 dev->match_driver = false;
1376 ret = device_add(&dev->dev);
1379 pci_proc_attach_device(dev);
1382 struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
1384 struct pci_dev *dev;
1386 dev = pci_get_slot(bus, devfn);
1392 dev = pci_scan_device(bus, devfn);
1396 pci_device_add(dev, bus);
1400 EXPORT_SYMBOL(pci_scan_single_device);
1402 static unsigned next_fn(struct pci_bus *bus, struct pci_dev *dev, unsigned fn)
1408 if (pci_ari_enabled(bus)) {
1411 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI);
1415 pci_read_config_word(dev, pos + PCI_ARI_CAP, &cap);
1416 next_fn = PCI_ARI_CAP_NFN(cap);
1418 return 0; /* protect against malformed list */
1423 /* dev may be NULL for non-contiguous multifunction devices */
1424 if (!dev || dev->multifunction)
1425 return (fn + 1) % 8;
1430 static int only_one_child(struct pci_bus *bus)
1432 struct pci_dev *parent = bus->self;
1434 if (!parent || !pci_is_pcie(parent))
1436 if (pci_pcie_type(parent) == PCI_EXP_TYPE_ROOT_PORT)
1438 if (pci_pcie_type(parent) == PCI_EXP_TYPE_DOWNSTREAM &&
1439 !pci_has_flag(PCI_SCAN_ALL_PCIE_DEVS))
1445 * pci_scan_slot - scan a PCI slot on a bus for devices.
1446 * @bus: PCI bus to scan
1447 * @devfn: slot number to scan (must have zero function.)
1449 * Scan a PCI slot on the specified PCI bus for devices, adding
1450 * discovered devices to the @bus->devices list. New devices
1451 * will not have is_added set.
1453 * Returns the number of new devices found.
1455 int pci_scan_slot(struct pci_bus *bus, int devfn)
1457 unsigned fn, nr = 0;
1458 struct pci_dev *dev;
1460 if (only_one_child(bus) && (devfn > 0))
1461 return 0; /* Already scanned the entire slot */
1463 dev = pci_scan_single_device(bus, devfn);
1469 for (fn = next_fn(bus, dev, 0); fn > 0; fn = next_fn(bus, dev, fn)) {
1470 dev = pci_scan_single_device(bus, devfn + fn);
1474 dev->multifunction = 1;
1478 /* only one slot has pcie device */
1479 if (bus->self && nr)
1480 pcie_aspm_init_link_state(bus->self);
1485 static int pcie_find_smpss(struct pci_dev *dev, void *data)
1489 if (!pci_is_pcie(dev))
1493 * We don't have a way to change MPS settings on devices that have
1494 * drivers attached. A hot-added device might support only the minimum
1495 * MPS setting (MPS=128). Therefore, if the fabric contains a bridge
1496 * where devices may be hot-added, we limit the fabric MPS to 128 so
1497 * hot-added devices will work correctly.
1499 * However, if we hot-add a device to a slot directly below a Root
1500 * Port, it's impossible for there to be other existing devices below
1501 * the port. We don't limit the MPS in this case because we can
1502 * reconfigure MPS on both the Root Port and the hot-added device,
1503 * and there are no other devices involved.
1505 * Note that this PCIE_BUS_SAFE path assumes no peer-to-peer DMA.
1507 if (dev->is_hotplug_bridge &&
1508 pci_pcie_type(dev) != PCI_EXP_TYPE_ROOT_PORT)
1511 if (*smpss > dev->pcie_mpss)
1512 *smpss = dev->pcie_mpss;
1517 static void pcie_write_mps(struct pci_dev *dev, int mps)
1521 if (pcie_bus_config == PCIE_BUS_PERFORMANCE) {
1522 mps = 128 << dev->pcie_mpss;
1524 if (pci_pcie_type(dev) != PCI_EXP_TYPE_ROOT_PORT &&
1526 /* For "Performance", the assumption is made that
1527 * downstream communication will never be larger than
1528 * the MRRS. So, the MPS only needs to be configured
1529 * for the upstream communication. This being the case,
1530 * walk from the top down and set the MPS of the child
1531 * to that of the parent bus.
1533 * Configure the device MPS with the smaller of the
1534 * device MPSS or the bridge MPS (which is assumed to be
1535 * properly configured at this point to the largest
1536 * allowable MPS based on its parent bus).
1538 mps = min(mps, pcie_get_mps(dev->bus->self));
1541 rc = pcie_set_mps(dev, mps);
1543 dev_err(&dev->dev, "Failed attempting to set the MPS\n");
1546 static void pcie_write_mrrs(struct pci_dev *dev)
1550 /* In the "safe" case, do not configure the MRRS. There appear to be
1551 * issues with setting MRRS to 0 on a number of devices.
1553 if (pcie_bus_config != PCIE_BUS_PERFORMANCE)
1556 /* For Max performance, the MRRS must be set to the largest supported
1557 * value. However, it cannot be configured larger than the MPS the
1558 * device or the bus can support. This should already be properly
1559 * configured by a prior call to pcie_write_mps.
1561 mrrs = pcie_get_mps(dev);
1563 /* MRRS is a R/W register. Invalid values can be written, but a
1564 * subsequent read will verify if the value is acceptable or not.
1565 * If the MRRS value provided is not acceptable (e.g., too large),
1566 * shrink the value until it is acceptable to the HW.
1568 while (mrrs != pcie_get_readrq(dev) && mrrs >= 128) {
1569 rc = pcie_set_readrq(dev, mrrs);
1573 dev_warn(&dev->dev, "Failed attempting to set the MRRS\n");
1578 dev_err(&dev->dev, "MRRS was unable to be configured with a "
1579 "safe value. If problems are experienced, try running "
1580 "with pci=pcie_bus_safe.\n");
1583 static void pcie_bus_detect_mps(struct pci_dev *dev)
1585 struct pci_dev *bridge = dev->bus->self;
1591 mps = pcie_get_mps(dev);
1592 p_mps = pcie_get_mps(bridge);
1595 dev_warn(&dev->dev, "Max Payload Size %d, but upstream %s set to %d; if necessary, use \"pci=pcie_bus_safe\" and report a bug\n",
1596 mps, pci_name(bridge), p_mps);
1599 static int pcie_bus_configure_set(struct pci_dev *dev, void *data)
1603 if (!pci_is_pcie(dev))
1606 if (pcie_bus_config == PCIE_BUS_TUNE_OFF) {
1607 pcie_bus_detect_mps(dev);
1611 mps = 128 << *(u8 *)data;
1612 orig_mps = pcie_get_mps(dev);
1614 pcie_write_mps(dev, mps);
1615 pcie_write_mrrs(dev);
1617 dev_info(&dev->dev, "Max Payload Size set to %4d/%4d (was %4d), "
1618 "Max Read Rq %4d\n", pcie_get_mps(dev), 128 << dev->pcie_mpss,
1619 orig_mps, pcie_get_readrq(dev));
1624 /* pcie_bus_configure_settings requires that pci_walk_bus work in a top-down,
1625 * parents then children fashion. If this changes, then this code will not
1628 void pcie_bus_configure_settings(struct pci_bus *bus)
1635 if (!pci_is_pcie(bus->self))
1638 /* FIXME - Peer to peer DMA is possible, though the endpoint would need
1639 * to be aware of the MPS of the destination. To work around this,
1640 * simply force the MPS of the entire system to the smallest possible.
1642 if (pcie_bus_config == PCIE_BUS_PEER2PEER)
1645 if (pcie_bus_config == PCIE_BUS_SAFE) {
1646 smpss = bus->self->pcie_mpss;
1648 pcie_find_smpss(bus->self, &smpss);
1649 pci_walk_bus(bus, pcie_find_smpss, &smpss);
1652 pcie_bus_configure_set(bus->self, &smpss);
1653 pci_walk_bus(bus, pcie_bus_configure_set, &smpss);
1655 EXPORT_SYMBOL_GPL(pcie_bus_configure_settings);
1657 unsigned int pci_scan_child_bus(struct pci_bus *bus)
1659 unsigned int devfn, pass, max = bus->busn_res.start;
1660 struct pci_dev *dev;
1662 dev_dbg(&bus->dev, "scanning bus\n");
1664 /* Go find them, Rover! */
1665 for (devfn = 0; devfn < 0x100; devfn += 8)
1666 pci_scan_slot(bus, devfn);
1668 /* Reserve buses for SR-IOV capability. */
1669 max += pci_iov_bus_range(bus);
1672 * After performing arch-dependent fixup of the bus, look behind
1673 * all PCI-to-PCI bridges on this bus.
1675 if (!bus->is_added) {
1676 dev_dbg(&bus->dev, "fixups for bus\n");
1677 pcibios_fixup_bus(bus);
1681 for (pass=0; pass < 2; pass++)
1682 list_for_each_entry(dev, &bus->devices, bus_list) {
1683 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1684 dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1685 max = pci_scan_bridge(bus, dev, max, pass);
1689 * We've scanned the bus and so we know all about what's on
1690 * the other side of any bridges that may be on this bus plus
1693 * Return how far we've got finding sub-buses.
1695 dev_dbg(&bus->dev, "bus scan returning with max=%02x\n", max);
1700 * pcibios_root_bridge_prepare - Platform-specific host bridge setup.
1701 * @bridge: Host bridge to set up.
1703 * Default empty implementation. Replace with an architecture-specific setup
1704 * routine, if necessary.
1706 int __weak pcibios_root_bridge_prepare(struct pci_host_bridge *bridge)
1711 void __weak pcibios_add_bus(struct pci_bus *bus)
1715 void __weak pcibios_remove_bus(struct pci_bus *bus)
1719 struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
1720 struct pci_ops *ops, void *sysdata, struct list_head *resources)
1723 struct pci_host_bridge *bridge;
1724 struct pci_bus *b, *b2;
1725 struct pci_host_bridge_window *window, *n;
1726 struct resource *res;
1727 resource_size_t offset;
1731 b = pci_alloc_bus();
1735 b->sysdata = sysdata;
1737 b->number = b->busn_res.start = bus;
1738 b2 = pci_find_bus(pci_domain_nr(b), bus);
1740 /* If we already got to this bus through a different bridge, ignore it */
1741 dev_dbg(&b2->dev, "bus already known\n");
1745 bridge = pci_alloc_host_bridge(b);
1749 bridge->dev.parent = parent;
1750 bridge->dev.release = pci_release_host_bridge_dev;
1751 dev_set_name(&bridge->dev, "pci%04x:%02x", pci_domain_nr(b), bus);
1752 error = pcibios_root_bridge_prepare(bridge);
1758 error = device_register(&bridge->dev);
1760 put_device(&bridge->dev);
1763 b->bridge = get_device(&bridge->dev);
1764 device_enable_async_suspend(b->bridge);
1765 pci_set_bus_of_node(b);
1768 set_dev_node(b->bridge, pcibus_to_node(b));
1770 b->dev.class = &pcibus_class;
1771 b->dev.parent = b->bridge;
1772 dev_set_name(&b->dev, "%04x:%02x", pci_domain_nr(b), bus);
1773 error = device_register(&b->dev);
1775 goto class_dev_reg_err;
1779 /* Create legacy_io and legacy_mem files for this bus */
1780 pci_create_legacy_files(b);
1783 dev_info(parent, "PCI host bridge to bus %s\n", dev_name(&b->dev));
1785 printk(KERN_INFO "PCI host bridge to bus %s\n", dev_name(&b->dev));
1787 /* Add initial resources to the bus */
1788 list_for_each_entry_safe(window, n, resources, list) {
1789 list_move_tail(&window->list, &bridge->windows);
1791 offset = window->offset;
1792 if (res->flags & IORESOURCE_BUS)
1793 pci_bus_insert_busn_res(b, bus, res->end);
1795 pci_bus_add_resource(b, res, 0);
1797 if (resource_type(res) == IORESOURCE_IO)
1798 fmt = " (bus address [%#06llx-%#06llx])";
1800 fmt = " (bus address [%#010llx-%#010llx])";
1801 snprintf(bus_addr, sizeof(bus_addr), fmt,
1802 (unsigned long long) (res->start - offset),
1803 (unsigned long long) (res->end - offset));
1806 dev_info(&b->dev, "root bus resource %pR%s\n", res, bus_addr);
1809 down_write(&pci_bus_sem);
1810 list_add_tail(&b->node, &pci_root_buses);
1811 up_write(&pci_bus_sem);
1816 put_device(&bridge->dev);
1817 device_unregister(&bridge->dev);
1823 int pci_bus_insert_busn_res(struct pci_bus *b, int bus, int bus_max)
1825 struct resource *res = &b->busn_res;
1826 struct resource *parent_res, *conflict;
1830 res->flags = IORESOURCE_BUS;
1832 if (!pci_is_root_bus(b))
1833 parent_res = &b->parent->busn_res;
1835 parent_res = get_pci_domain_busn_res(pci_domain_nr(b));
1836 res->flags |= IORESOURCE_PCI_FIXED;
1839 conflict = insert_resource_conflict(parent_res, res);
1842 dev_printk(KERN_DEBUG, &b->dev,
1843 "busn_res: can not insert %pR under %s%pR (conflicts with %s %pR)\n",
1844 res, pci_is_root_bus(b) ? "domain " : "",
1845 parent_res, conflict->name, conflict);
1847 return conflict == NULL;
1850 int pci_bus_update_busn_res_end(struct pci_bus *b, int bus_max)
1852 struct resource *res = &b->busn_res;
1853 struct resource old_res = *res;
1854 resource_size_t size;
1857 if (res->start > bus_max)
1860 size = bus_max - res->start + 1;
1861 ret = adjust_resource(res, res->start, size);
1862 dev_printk(KERN_DEBUG, &b->dev,
1863 "busn_res: %pR end %s updated to %02x\n",
1864 &old_res, ret ? "can not be" : "is", bus_max);
1866 if (!ret && !res->parent)
1867 pci_bus_insert_busn_res(b, res->start, res->end);
1872 void pci_bus_release_busn_res(struct pci_bus *b)
1874 struct resource *res = &b->busn_res;
1877 if (!res->flags || !res->parent)
1880 ret = release_resource(res);
1881 dev_printk(KERN_DEBUG, &b->dev,
1882 "busn_res: %pR %s released\n",
1883 res, ret ? "can not be" : "is");
1886 struct pci_bus *pci_scan_root_bus(struct device *parent, int bus,
1887 struct pci_ops *ops, void *sysdata, struct list_head *resources)
1889 struct pci_host_bridge_window *window;
1894 list_for_each_entry(window, resources, list)
1895 if (window->res->flags & IORESOURCE_BUS) {
1900 b = pci_create_root_bus(parent, bus, ops, sysdata, resources);
1906 "No busn resource found for root bus, will use [bus %02x-ff]\n",
1908 pci_bus_insert_busn_res(b, bus, 255);
1911 max = pci_scan_child_bus(b);
1914 pci_bus_update_busn_res_end(b, max);
1916 pci_bus_add_devices(b);
1919 EXPORT_SYMBOL(pci_scan_root_bus);
1921 /* Deprecated; use pci_scan_root_bus() instead */
1922 struct pci_bus *pci_scan_bus_parented(struct device *parent,
1923 int bus, struct pci_ops *ops, void *sysdata)
1925 LIST_HEAD(resources);
1928 pci_add_resource(&resources, &ioport_resource);
1929 pci_add_resource(&resources, &iomem_resource);
1930 pci_add_resource(&resources, &busn_resource);
1931 b = pci_create_root_bus(parent, bus, ops, sysdata, &resources);
1933 pci_scan_child_bus(b);
1935 pci_free_resource_list(&resources);
1938 EXPORT_SYMBOL(pci_scan_bus_parented);
1940 struct pci_bus *pci_scan_bus(int bus, struct pci_ops *ops,
1943 LIST_HEAD(resources);
1946 pci_add_resource(&resources, &ioport_resource);
1947 pci_add_resource(&resources, &iomem_resource);
1948 pci_add_resource(&resources, &busn_resource);
1949 b = pci_create_root_bus(NULL, bus, ops, sysdata, &resources);
1951 pci_scan_child_bus(b);
1952 pci_bus_add_devices(b);
1954 pci_free_resource_list(&resources);
1958 EXPORT_SYMBOL(pci_scan_bus);
1961 * pci_rescan_bus_bridge_resize - scan a PCI bus for devices.
1962 * @bridge: PCI bridge for the bus to scan
1964 * Scan a PCI bus and child buses for new devices, add them,
1965 * and enable them, resizing bridge mmio/io resource if necessary
1966 * and possible. The caller must ensure the child devices are already
1967 * removed for resizing to occur.
1969 * Returns the max number of subordinate bus discovered.
1971 unsigned int __ref pci_rescan_bus_bridge_resize(struct pci_dev *bridge)
1974 struct pci_bus *bus = bridge->subordinate;
1976 max = pci_scan_child_bus(bus);
1978 pci_assign_unassigned_bridge_resources(bridge);
1980 pci_bus_add_devices(bus);
1986 * pci_rescan_bus - scan a PCI bus for devices.
1987 * @bus: PCI bus to scan
1989 * Scan a PCI bus and child buses for new devices, adds them,
1992 * Returns the max number of subordinate bus discovered.
1994 unsigned int __ref pci_rescan_bus(struct pci_bus *bus)
1998 max = pci_scan_child_bus(bus);
1999 pci_assign_unassigned_bus_resources(bus);
2000 pci_bus_add_devices(bus);
2004 EXPORT_SYMBOL_GPL(pci_rescan_bus);
2006 EXPORT_SYMBOL(pci_add_new_bus);
2007 EXPORT_SYMBOL(pci_scan_slot);
2008 EXPORT_SYMBOL(pci_scan_bridge);
2009 EXPORT_SYMBOL_GPL(pci_scan_child_bus);
2011 static int __init pci_sort_bf_cmp(const struct device *d_a, const struct device *d_b)
2013 const struct pci_dev *a = to_pci_dev(d_a);
2014 const struct pci_dev *b = to_pci_dev(d_b);
2016 if (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
2017 else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return 1;
2019 if (a->bus->number < b->bus->number) return -1;
2020 else if (a->bus->number > b->bus->number) return 1;
2022 if (a->devfn < b->devfn) return -1;
2023 else if (a->devfn > b->devfn) return 1;
2028 void __init pci_sort_breadthfirst(void)
2030 bus_sort_breadthfirst(&pci_bus_type, &pci_sort_bf_cmp);