ptrace: cleanup arch_ptrace() and friends on Blackfin
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / pci / probe.c
blob12625d90f8b573785f1a05a0a719fad46aa3155f
1 /*
2 * probe.c - PCI detection and setup code
3 */
5 #include <linux/kernel.h>
6 #include <linux/delay.h>
7 #include <linux/init.h>
8 #include <linux/pci.h>
9 #include <linux/slab.h>
10 #include <linux/module.h>
11 #include <linux/cpumask.h>
12 #include <linux/pci-aspm.h>
13 #include "pci.h"
15 #define CARDBUS_LATENCY_TIMER 176 /* secondary latency timer */
16 #define CARDBUS_RESERVE_BUSNR 3
18 /* Ugh. Need to stop exporting this to modules. */
19 LIST_HEAD(pci_root_buses);
20 EXPORT_SYMBOL(pci_root_buses);
23 static int find_anything(struct device *dev, void *data)
25 return 1;
29 * Some device drivers need know if pci is initiated.
30 * Basically, we think pci is not initiated when there
31 * is no device to be found on the pci_bus_type.
33 int no_pci_devices(void)
35 struct device *dev;
36 int no_devices;
38 dev = bus_find_device(&pci_bus_type, NULL, NULL, find_anything);
39 no_devices = (dev == NULL);
40 put_device(dev);
41 return no_devices;
43 EXPORT_SYMBOL(no_pci_devices);
46 * PCI Bus Class Devices
48 static ssize_t pci_bus_show_cpuaffinity(struct device *dev,
49 int type,
50 struct device_attribute *attr,
51 char *buf)
53 int ret;
54 const struct cpumask *cpumask;
56 cpumask = cpumask_of_pcibus(to_pci_bus(dev));
57 ret = type?
58 cpulist_scnprintf(buf, PAGE_SIZE-2, cpumask) :
59 cpumask_scnprintf(buf, PAGE_SIZE-2, cpumask);
60 buf[ret++] = '\n';
61 buf[ret] = '\0';
62 return ret;
65 static ssize_t inline pci_bus_show_cpumaskaffinity(struct device *dev,
66 struct device_attribute *attr,
67 char *buf)
69 return pci_bus_show_cpuaffinity(dev, 0, attr, buf);
72 static ssize_t inline pci_bus_show_cpulistaffinity(struct device *dev,
73 struct device_attribute *attr,
74 char *buf)
76 return pci_bus_show_cpuaffinity(dev, 1, attr, buf);
79 DEVICE_ATTR(cpuaffinity, S_IRUGO, pci_bus_show_cpumaskaffinity, NULL);
80 DEVICE_ATTR(cpulistaffinity, S_IRUGO, pci_bus_show_cpulistaffinity, NULL);
83 * PCI Bus Class
85 static void release_pcibus_dev(struct device *dev)
87 struct pci_bus *pci_bus = to_pci_bus(dev);
89 if (pci_bus->bridge)
90 put_device(pci_bus->bridge);
91 pci_bus_remove_resources(pci_bus);
92 kfree(pci_bus);
95 static struct class pcibus_class = {
96 .name = "pci_bus",
97 .dev_release = &release_pcibus_dev,
100 static int __init pcibus_class_init(void)
102 return class_register(&pcibus_class);
104 postcore_initcall(pcibus_class_init);
107 * Translate the low bits of the PCI base
108 * to the resource type
110 static inline unsigned int pci_calc_resource_flags(unsigned int flags)
112 if (flags & PCI_BASE_ADDRESS_SPACE_IO)
113 return IORESOURCE_IO;
115 if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
116 return IORESOURCE_MEM | IORESOURCE_PREFETCH;
118 return IORESOURCE_MEM;
121 static u64 pci_size(u64 base, u64 maxbase, u64 mask)
123 u64 size = mask & maxbase; /* Find the significant bits */
124 if (!size)
125 return 0;
127 /* Get the lowest of them to find the decode size, and
128 from that the extent. */
129 size = (size & ~(size-1)) - 1;
131 /* base == maxbase can be valid only if the BAR has
132 already been programmed with all 1s. */
133 if (base == maxbase && ((base | size) & mask) != mask)
134 return 0;
136 return size;
139 static inline enum pci_bar_type decode_bar(struct resource *res, u32 bar)
141 if ((bar & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO) {
142 res->flags = bar & ~PCI_BASE_ADDRESS_IO_MASK;
143 return pci_bar_io;
146 res->flags = bar & ~PCI_BASE_ADDRESS_MEM_MASK;
148 if (res->flags & PCI_BASE_ADDRESS_MEM_TYPE_64)
149 return pci_bar_mem64;
150 return pci_bar_mem32;
154 * pci_read_base - read a PCI BAR
155 * @dev: the PCI device
156 * @type: type of the BAR
157 * @res: resource buffer to be filled in
158 * @pos: BAR position in the config space
160 * Returns 1 if the BAR is 64-bit, or 0 if 32-bit.
162 int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
163 struct resource *res, unsigned int pos)
165 u32 l, sz, mask;
166 u16 orig_cmd;
168 mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
170 if (!dev->mmio_always_on) {
171 pci_read_config_word(dev, PCI_COMMAND, &orig_cmd);
172 pci_write_config_word(dev, PCI_COMMAND,
173 orig_cmd & ~(PCI_COMMAND_MEMORY | PCI_COMMAND_IO));
176 res->name = pci_name(dev);
178 pci_read_config_dword(dev, pos, &l);
179 pci_write_config_dword(dev, pos, l | mask);
180 pci_read_config_dword(dev, pos, &sz);
181 pci_write_config_dword(dev, pos, l);
183 if (!dev->mmio_always_on)
184 pci_write_config_word(dev, PCI_COMMAND, orig_cmd);
187 * All bits set in sz means the device isn't working properly.
188 * If the BAR isn't implemented, all bits must be 0. If it's a
189 * memory BAR or a ROM, bit 0 must be clear; if it's an io BAR, bit
190 * 1 must be clear.
192 if (!sz || sz == 0xffffffff)
193 goto fail;
196 * I don't know how l can have all bits set. Copied from old code.
197 * Maybe it fixes a bug on some ancient platform.
199 if (l == 0xffffffff)
200 l = 0;
202 if (type == pci_bar_unknown) {
203 type = decode_bar(res, l);
204 res->flags |= pci_calc_resource_flags(l) | IORESOURCE_SIZEALIGN;
205 if (type == pci_bar_io) {
206 l &= PCI_BASE_ADDRESS_IO_MASK;
207 mask = PCI_BASE_ADDRESS_IO_MASK & IO_SPACE_LIMIT;
208 } else {
209 l &= PCI_BASE_ADDRESS_MEM_MASK;
210 mask = (u32)PCI_BASE_ADDRESS_MEM_MASK;
212 } else {
213 res->flags |= (l & IORESOURCE_ROM_ENABLE);
214 l &= PCI_ROM_ADDRESS_MASK;
215 mask = (u32)PCI_ROM_ADDRESS_MASK;
218 if (type == pci_bar_mem64) {
219 u64 l64 = l;
220 u64 sz64 = sz;
221 u64 mask64 = mask | (u64)~0 << 32;
223 pci_read_config_dword(dev, pos + 4, &l);
224 pci_write_config_dword(dev, pos + 4, ~0);
225 pci_read_config_dword(dev, pos + 4, &sz);
226 pci_write_config_dword(dev, pos + 4, l);
228 l64 |= ((u64)l << 32);
229 sz64 |= ((u64)sz << 32);
231 sz64 = pci_size(l64, sz64, mask64);
233 if (!sz64)
234 goto fail;
236 if ((sizeof(resource_size_t) < 8) && (sz64 > 0x100000000ULL)) {
237 dev_err(&dev->dev, "reg %x: can't handle 64-bit BAR\n",
238 pos);
239 goto fail;
242 res->flags |= IORESOURCE_MEM_64;
243 if ((sizeof(resource_size_t) < 8) && l) {
244 /* Address above 32-bit boundary; disable the BAR */
245 pci_write_config_dword(dev, pos, 0);
246 pci_write_config_dword(dev, pos + 4, 0);
247 res->start = 0;
248 res->end = sz64;
249 } else {
250 res->start = l64;
251 res->end = l64 + sz64;
252 dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n",
253 pos, res);
255 } else {
256 sz = pci_size(l, sz, mask);
258 if (!sz)
259 goto fail;
261 res->start = l;
262 res->end = l + sz;
264 dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n", pos, res);
267 out:
268 return (type == pci_bar_mem64) ? 1 : 0;
269 fail:
270 res->flags = 0;
271 goto out;
274 static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
276 unsigned int pos, reg;
278 for (pos = 0; pos < howmany; pos++) {
279 struct resource *res = &dev->resource[pos];
280 reg = PCI_BASE_ADDRESS_0 + (pos << 2);
281 pos += __pci_read_base(dev, pci_bar_unknown, res, reg);
284 if (rom) {
285 struct resource *res = &dev->resource[PCI_ROM_RESOURCE];
286 dev->rom_base_reg = rom;
287 res->flags = IORESOURCE_MEM | IORESOURCE_PREFETCH |
288 IORESOURCE_READONLY | IORESOURCE_CACHEABLE |
289 IORESOURCE_SIZEALIGN;
290 __pci_read_base(dev, pci_bar_mem32, res, rom);
294 static void __devinit pci_read_bridge_io(struct pci_bus *child)
296 struct pci_dev *dev = child->self;
297 u8 io_base_lo, io_limit_lo;
298 unsigned long base, limit;
299 struct resource *res;
301 res = child->resource[0];
302 pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
303 pci_read_config_byte(dev, PCI_IO_LIMIT, &io_limit_lo);
304 base = (io_base_lo & PCI_IO_RANGE_MASK) << 8;
305 limit = (io_limit_lo & PCI_IO_RANGE_MASK) << 8;
307 if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
308 u16 io_base_hi, io_limit_hi;
309 pci_read_config_word(dev, PCI_IO_BASE_UPPER16, &io_base_hi);
310 pci_read_config_word(dev, PCI_IO_LIMIT_UPPER16, &io_limit_hi);
311 base |= (io_base_hi << 16);
312 limit |= (io_limit_hi << 16);
315 if (base && base <= limit) {
316 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
317 if (!res->start)
318 res->start = base;
319 if (!res->end)
320 res->end = limit + 0xfff;
321 dev_printk(KERN_DEBUG, &dev->dev, " bridge window %pR\n", res);
322 } else {
323 dev_printk(KERN_DEBUG, &dev->dev,
324 " bridge window [io %#06lx-%#06lx] (disabled)\n",
325 base, limit);
329 static void __devinit pci_read_bridge_mmio(struct pci_bus *child)
331 struct pci_dev *dev = child->self;
332 u16 mem_base_lo, mem_limit_lo;
333 unsigned long base, limit;
334 struct resource *res;
336 res = child->resource[1];
337 pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
338 pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
339 base = (mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
340 limit = (mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
341 if (base && base <= limit) {
342 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
343 res->start = base;
344 res->end = limit + 0xfffff;
345 dev_printk(KERN_DEBUG, &dev->dev, " bridge window %pR\n", res);
346 } else {
347 dev_printk(KERN_DEBUG, &dev->dev,
348 " bridge window [mem %#010lx-%#010lx] (disabled)\n",
349 base, limit + 0xfffff);
353 static void __devinit pci_read_bridge_mmio_pref(struct pci_bus *child)
355 struct pci_dev *dev = child->self;
356 u16 mem_base_lo, mem_limit_lo;
357 unsigned long base, limit;
358 struct resource *res;
360 res = child->resource[2];
361 pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
362 pci_read_config_word(dev, PCI_PREF_MEMORY_LIMIT, &mem_limit_lo);
363 base = (mem_base_lo & PCI_PREF_RANGE_MASK) << 16;
364 limit = (mem_limit_lo & PCI_PREF_RANGE_MASK) << 16;
366 if ((mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
367 u32 mem_base_hi, mem_limit_hi;
368 pci_read_config_dword(dev, PCI_PREF_BASE_UPPER32, &mem_base_hi);
369 pci_read_config_dword(dev, PCI_PREF_LIMIT_UPPER32, &mem_limit_hi);
372 * Some bridges set the base > limit by default, and some
373 * (broken) BIOSes do not initialize them. If we find
374 * this, just assume they are not being used.
376 if (mem_base_hi <= mem_limit_hi) {
377 #if BITS_PER_LONG == 64
378 base |= ((long) mem_base_hi) << 32;
379 limit |= ((long) mem_limit_hi) << 32;
380 #else
381 if (mem_base_hi || mem_limit_hi) {
382 dev_err(&dev->dev, "can't handle 64-bit "
383 "address space for bridge\n");
384 return;
386 #endif
389 if (base && base <= limit) {
390 res->flags = (mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) |
391 IORESOURCE_MEM | IORESOURCE_PREFETCH;
392 if (res->flags & PCI_PREF_RANGE_TYPE_64)
393 res->flags |= IORESOURCE_MEM_64;
394 res->start = base;
395 res->end = limit + 0xfffff;
396 dev_printk(KERN_DEBUG, &dev->dev, " bridge window %pR\n", res);
397 } else {
398 dev_printk(KERN_DEBUG, &dev->dev,
399 " bridge window [mem %#010lx-%#010lx pref] (disabled)\n",
400 base, limit + 0xfffff);
404 void __devinit pci_read_bridge_bases(struct pci_bus *child)
406 struct pci_dev *dev = child->self;
407 struct resource *res;
408 int i;
410 if (pci_is_root_bus(child)) /* It's a host bus, nothing to read */
411 return;
413 dev_info(&dev->dev, "PCI bridge to [bus %02x-%02x]%s\n",
414 child->secondary, child->subordinate,
415 dev->transparent ? " (subtractive decode)" : "");
417 pci_bus_remove_resources(child);
418 for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++)
419 child->resource[i] = &dev->resource[PCI_BRIDGE_RESOURCES+i];
421 pci_read_bridge_io(child);
422 pci_read_bridge_mmio(child);
423 pci_read_bridge_mmio_pref(child);
425 if (dev->transparent) {
426 pci_bus_for_each_resource(child->parent, res, i) {
427 if (res) {
428 pci_bus_add_resource(child, res,
429 PCI_SUBTRACTIVE_DECODE);
430 dev_printk(KERN_DEBUG, &dev->dev,
431 " bridge window %pR (subtractive decode)\n",
432 res);
438 static struct pci_bus * pci_alloc_bus(void)
440 struct pci_bus *b;
442 b = kzalloc(sizeof(*b), GFP_KERNEL);
443 if (b) {
444 INIT_LIST_HEAD(&b->node);
445 INIT_LIST_HEAD(&b->children);
446 INIT_LIST_HEAD(&b->devices);
447 INIT_LIST_HEAD(&b->slots);
448 INIT_LIST_HEAD(&b->resources);
449 b->max_bus_speed = PCI_SPEED_UNKNOWN;
450 b->cur_bus_speed = PCI_SPEED_UNKNOWN;
452 return b;
455 static unsigned char pcix_bus_speed[] = {
456 PCI_SPEED_UNKNOWN, /* 0 */
457 PCI_SPEED_66MHz_PCIX, /* 1 */
458 PCI_SPEED_100MHz_PCIX, /* 2 */
459 PCI_SPEED_133MHz_PCIX, /* 3 */
460 PCI_SPEED_UNKNOWN, /* 4 */
461 PCI_SPEED_66MHz_PCIX_ECC, /* 5 */
462 PCI_SPEED_100MHz_PCIX_ECC, /* 6 */
463 PCI_SPEED_133MHz_PCIX_ECC, /* 7 */
464 PCI_SPEED_UNKNOWN, /* 8 */
465 PCI_SPEED_66MHz_PCIX_266, /* 9 */
466 PCI_SPEED_100MHz_PCIX_266, /* A */
467 PCI_SPEED_133MHz_PCIX_266, /* B */
468 PCI_SPEED_UNKNOWN, /* C */
469 PCI_SPEED_66MHz_PCIX_533, /* D */
470 PCI_SPEED_100MHz_PCIX_533, /* E */
471 PCI_SPEED_133MHz_PCIX_533 /* F */
474 static unsigned char pcie_link_speed[] = {
475 PCI_SPEED_UNKNOWN, /* 0 */
476 PCIE_SPEED_2_5GT, /* 1 */
477 PCIE_SPEED_5_0GT, /* 2 */
478 PCIE_SPEED_8_0GT, /* 3 */
479 PCI_SPEED_UNKNOWN, /* 4 */
480 PCI_SPEED_UNKNOWN, /* 5 */
481 PCI_SPEED_UNKNOWN, /* 6 */
482 PCI_SPEED_UNKNOWN, /* 7 */
483 PCI_SPEED_UNKNOWN, /* 8 */
484 PCI_SPEED_UNKNOWN, /* 9 */
485 PCI_SPEED_UNKNOWN, /* A */
486 PCI_SPEED_UNKNOWN, /* B */
487 PCI_SPEED_UNKNOWN, /* C */
488 PCI_SPEED_UNKNOWN, /* D */
489 PCI_SPEED_UNKNOWN, /* E */
490 PCI_SPEED_UNKNOWN /* F */
493 void pcie_update_link_speed(struct pci_bus *bus, u16 linksta)
495 bus->cur_bus_speed = pcie_link_speed[linksta & 0xf];
497 EXPORT_SYMBOL_GPL(pcie_update_link_speed);
499 static unsigned char agp_speeds[] = {
500 AGP_UNKNOWN,
501 AGP_1X,
502 AGP_2X,
503 AGP_4X,
504 AGP_8X
507 static enum pci_bus_speed agp_speed(int agp3, int agpstat)
509 int index = 0;
511 if (agpstat & 4)
512 index = 3;
513 else if (agpstat & 2)
514 index = 2;
515 else if (agpstat & 1)
516 index = 1;
517 else
518 goto out;
520 if (agp3) {
521 index += 2;
522 if (index == 5)
523 index = 0;
526 out:
527 return agp_speeds[index];
531 static void pci_set_bus_speed(struct pci_bus *bus)
533 struct pci_dev *bridge = bus->self;
534 int pos;
536 pos = pci_find_capability(bridge, PCI_CAP_ID_AGP);
537 if (!pos)
538 pos = pci_find_capability(bridge, PCI_CAP_ID_AGP3);
539 if (pos) {
540 u32 agpstat, agpcmd;
542 pci_read_config_dword(bridge, pos + PCI_AGP_STATUS, &agpstat);
543 bus->max_bus_speed = agp_speed(agpstat & 8, agpstat & 7);
545 pci_read_config_dword(bridge, pos + PCI_AGP_COMMAND, &agpcmd);
546 bus->cur_bus_speed = agp_speed(agpstat & 8, agpcmd & 7);
549 pos = pci_find_capability(bridge, PCI_CAP_ID_PCIX);
550 if (pos) {
551 u16 status;
552 enum pci_bus_speed max;
553 pci_read_config_word(bridge, pos + 2, &status);
555 if (status & 0x8000) {
556 max = PCI_SPEED_133MHz_PCIX_533;
557 } else if (status & 0x4000) {
558 max = PCI_SPEED_133MHz_PCIX_266;
559 } else if (status & 0x0002) {
560 if (((status >> 12) & 0x3) == 2) {
561 max = PCI_SPEED_133MHz_PCIX_ECC;
562 } else {
563 max = PCI_SPEED_133MHz_PCIX;
565 } else {
566 max = PCI_SPEED_66MHz_PCIX;
569 bus->max_bus_speed = max;
570 bus->cur_bus_speed = pcix_bus_speed[(status >> 6) & 0xf];
572 return;
575 pos = pci_find_capability(bridge, PCI_CAP_ID_EXP);
576 if (pos) {
577 u32 linkcap;
578 u16 linksta;
580 pci_read_config_dword(bridge, pos + PCI_EXP_LNKCAP, &linkcap);
581 bus->max_bus_speed = pcie_link_speed[linkcap & 0xf];
583 pci_read_config_word(bridge, pos + PCI_EXP_LNKSTA, &linksta);
584 pcie_update_link_speed(bus, linksta);
589 static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
590 struct pci_dev *bridge, int busnr)
592 struct pci_bus *child;
593 int i;
596 * Allocate a new bus, and inherit stuff from the parent..
598 child = pci_alloc_bus();
599 if (!child)
600 return NULL;
602 child->parent = parent;
603 child->ops = parent->ops;
604 child->sysdata = parent->sysdata;
605 child->bus_flags = parent->bus_flags;
607 /* initialize some portions of the bus device, but don't register it
608 * now as the parent is not properly set up yet. This device will get
609 * registered later in pci_bus_add_devices()
611 child->dev.class = &pcibus_class;
612 dev_set_name(&child->dev, "%04x:%02x", pci_domain_nr(child), busnr);
615 * Set up the primary, secondary and subordinate
616 * bus numbers.
618 child->number = child->secondary = busnr;
619 child->primary = parent->secondary;
620 child->subordinate = 0xff;
622 if (!bridge)
623 return child;
625 child->self = bridge;
626 child->bridge = get_device(&bridge->dev);
628 pci_set_bus_speed(child);
630 /* Set up default resource pointers and names.. */
631 for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) {
632 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
633 child->resource[i]->name = child->name;
635 bridge->subordinate = child;
637 return child;
640 struct pci_bus *__ref pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr)
642 struct pci_bus *child;
644 child = pci_alloc_child_bus(parent, dev, busnr);
645 if (child) {
646 down_write(&pci_bus_sem);
647 list_add_tail(&child->node, &parent->children);
648 up_write(&pci_bus_sem);
650 return child;
653 static void pci_fixup_parent_subordinate_busnr(struct pci_bus *child, int max)
655 struct pci_bus *parent = child->parent;
657 /* Attempts to fix that up are really dangerous unless
658 we're going to re-assign all bus numbers. */
659 if (!pcibios_assign_all_busses())
660 return;
662 while (parent->parent && parent->subordinate < max) {
663 parent->subordinate = max;
664 pci_write_config_byte(parent->self, PCI_SUBORDINATE_BUS, max);
665 parent = parent->parent;
670 * If it's a bridge, configure it and scan the bus behind it.
671 * For CardBus bridges, we don't scan behind as the devices will
672 * be handled by the bridge driver itself.
674 * We need to process bridges in two passes -- first we scan those
675 * already configured by the BIOS and after we are done with all of
676 * them, we proceed to assigning numbers to the remaining buses in
677 * order to avoid overlaps between old and new bus numbers.
679 int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
681 struct pci_bus *child;
682 int is_cardbus = (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS);
683 u32 buses, i, j = 0;
684 u16 bctl;
685 u8 primary, secondary, subordinate;
686 int broken = 0;
688 pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
689 primary = buses & 0xFF;
690 secondary = (buses >> 8) & 0xFF;
691 subordinate = (buses >> 16) & 0xFF;
693 dev_dbg(&dev->dev, "scanning [bus %02x-%02x] behind bridge, pass %d\n",
694 secondary, subordinate, pass);
696 /* Check if setup is sensible at all */
697 if (!pass &&
698 (primary != bus->number || secondary <= bus->number)) {
699 dev_dbg(&dev->dev, "bus configuration invalid, reconfiguring\n");
700 broken = 1;
703 /* Disable MasterAbortMode during probing to avoid reporting
704 of bus errors (in some architectures) */
705 pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl);
706 pci_write_config_word(dev, PCI_BRIDGE_CONTROL,
707 bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT);
709 if ((secondary || subordinate) && !pcibios_assign_all_busses() &&
710 !is_cardbus && !broken) {
711 unsigned int cmax;
713 * Bus already configured by firmware, process it in the first
714 * pass and just note the configuration.
716 if (pass)
717 goto out;
720 * If we already got to this bus through a different bridge,
721 * don't re-add it. This can happen with the i450NX chipset.
723 * However, we continue to descend down the hierarchy and
724 * scan remaining child buses.
726 child = pci_find_bus(pci_domain_nr(bus), secondary);
727 if (!child) {
728 child = pci_add_new_bus(bus, dev, secondary);
729 if (!child)
730 goto out;
731 child->primary = primary;
732 child->subordinate = subordinate;
733 child->bridge_ctl = bctl;
736 cmax = pci_scan_child_bus(child);
737 if (cmax > max)
738 max = cmax;
739 if (child->subordinate > max)
740 max = child->subordinate;
741 } else {
743 * We need to assign a number to this bus which we always
744 * do in the second pass.
746 if (!pass) {
747 if (pcibios_assign_all_busses() || broken)
748 /* Temporarily disable forwarding of the
749 configuration cycles on all bridges in
750 this bus segment to avoid possible
751 conflicts in the second pass between two
752 bridges programmed with overlapping
753 bus ranges. */
754 pci_write_config_dword(dev, PCI_PRIMARY_BUS,
755 buses & ~0xffffff);
756 goto out;
759 /* Clear errors */
760 pci_write_config_word(dev, PCI_STATUS, 0xffff);
762 /* Prevent assigning a bus number that already exists.
763 * This can happen when a bridge is hot-plugged */
764 if (pci_find_bus(pci_domain_nr(bus), max+1))
765 goto out;
766 child = pci_add_new_bus(bus, dev, ++max);
767 buses = (buses & 0xff000000)
768 | ((unsigned int)(child->primary) << 0)
769 | ((unsigned int)(child->secondary) << 8)
770 | ((unsigned int)(child->subordinate) << 16);
773 * yenta.c forces a secondary latency timer of 176.
774 * Copy that behaviour here.
776 if (is_cardbus) {
777 buses &= ~0xff000000;
778 buses |= CARDBUS_LATENCY_TIMER << 24;
782 * We need to blast all three values with a single write.
784 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
786 if (!is_cardbus) {
787 child->bridge_ctl = bctl;
789 * Adjust subordinate busnr in parent buses.
790 * We do this before scanning for children because
791 * some devices may not be detected if the bios
792 * was lazy.
794 pci_fixup_parent_subordinate_busnr(child, max);
795 /* Now we can scan all subordinate buses... */
796 max = pci_scan_child_bus(child);
798 * now fix it up again since we have found
799 * the real value of max.
801 pci_fixup_parent_subordinate_busnr(child, max);
802 } else {
804 * For CardBus bridges, we leave 4 bus numbers
805 * as cards with a PCI-to-PCI bridge can be
806 * inserted later.
808 for (i=0; i<CARDBUS_RESERVE_BUSNR; i++) {
809 struct pci_bus *parent = bus;
810 if (pci_find_bus(pci_domain_nr(bus),
811 max+i+1))
812 break;
813 while (parent->parent) {
814 if ((!pcibios_assign_all_busses()) &&
815 (parent->subordinate > max) &&
816 (parent->subordinate <= max+i)) {
817 j = 1;
819 parent = parent->parent;
821 if (j) {
823 * Often, there are two cardbus bridges
824 * -- try to leave one valid bus number
825 * for each one.
827 i /= 2;
828 break;
831 max += i;
832 pci_fixup_parent_subordinate_busnr(child, max);
835 * Set the subordinate bus number to its real value.
837 child->subordinate = max;
838 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
841 sprintf(child->name,
842 (is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"),
843 pci_domain_nr(bus), child->number);
845 /* Has only triggered on CardBus, fixup is in yenta_socket */
846 while (bus->parent) {
847 if ((child->subordinate > bus->subordinate) ||
848 (child->number > bus->subordinate) ||
849 (child->number < bus->number) ||
850 (child->subordinate < bus->number)) {
851 dev_info(&child->dev, "[bus %02x-%02x] %s "
852 "hidden behind%s bridge %s [bus %02x-%02x]\n",
853 child->number, child->subordinate,
854 (bus->number > child->subordinate &&
855 bus->subordinate < child->number) ?
856 "wholly" : "partially",
857 bus->self->transparent ? " transparent" : "",
858 dev_name(&bus->dev),
859 bus->number, bus->subordinate);
861 bus = bus->parent;
864 out:
865 pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
867 return max;
871 * Read interrupt line and base address registers.
872 * The architecture-dependent code can tweak these, of course.
874 static void pci_read_irq(struct pci_dev *dev)
876 unsigned char irq;
878 pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq);
879 dev->pin = irq;
880 if (irq)
881 pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
882 dev->irq = irq;
885 void set_pcie_port_type(struct pci_dev *pdev)
887 int pos;
888 u16 reg16;
890 pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
891 if (!pos)
892 return;
893 pdev->is_pcie = 1;
894 pdev->pcie_cap = pos;
895 pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
896 pdev->pcie_type = (reg16 & PCI_EXP_FLAGS_TYPE) >> 4;
899 void set_pcie_hotplug_bridge(struct pci_dev *pdev)
901 int pos;
902 u16 reg16;
903 u32 reg32;
905 pos = pci_pcie_cap(pdev);
906 if (!pos)
907 return;
908 pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
909 if (!(reg16 & PCI_EXP_FLAGS_SLOT))
910 return;
911 pci_read_config_dword(pdev, pos + PCI_EXP_SLTCAP, &reg32);
912 if (reg32 & PCI_EXP_SLTCAP_HPC)
913 pdev->is_hotplug_bridge = 1;
916 #define LEGACY_IO_RESOURCE (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
919 * pci_setup_device - fill in class and map information of a device
920 * @dev: the device structure to fill
922 * Initialize the device structure with information about the device's
923 * vendor,class,memory and IO-space addresses,IRQ lines etc.
924 * Called at initialisation of the PCI subsystem and by CardBus services.
925 * Returns 0 on success and negative if unknown type of device (not normal,
926 * bridge or CardBus).
928 int pci_setup_device(struct pci_dev *dev)
930 u32 class;
931 u8 hdr_type;
932 struct pci_slot *slot;
933 int pos = 0;
935 if (pci_read_config_byte(dev, PCI_HEADER_TYPE, &hdr_type))
936 return -EIO;
938 dev->sysdata = dev->bus->sysdata;
939 dev->dev.parent = dev->bus->bridge;
940 dev->dev.bus = &pci_bus_type;
941 dev->hdr_type = hdr_type & 0x7f;
942 dev->multifunction = !!(hdr_type & 0x80);
943 dev->error_state = pci_channel_io_normal;
944 set_pcie_port_type(dev);
946 list_for_each_entry(slot, &dev->bus->slots, list)
947 if (PCI_SLOT(dev->devfn) == slot->number)
948 dev->slot = slot;
950 /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
951 set this higher, assuming the system even supports it. */
952 dev->dma_mask = 0xffffffff;
954 dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
955 dev->bus->number, PCI_SLOT(dev->devfn),
956 PCI_FUNC(dev->devfn));
958 pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
959 dev->revision = class & 0xff;
960 class >>= 8; /* upper 3 bytes */
961 dev->class = class;
962 class >>= 8;
964 dev_dbg(&dev->dev, "found [%04x:%04x] class %06x header type %02x\n",
965 dev->vendor, dev->device, class, dev->hdr_type);
967 /* need to have dev->class ready */
968 dev->cfg_size = pci_cfg_space_size(dev);
970 /* "Unknown power state" */
971 dev->current_state = PCI_UNKNOWN;
973 /* Early fixups, before probing the BARs */
974 pci_fixup_device(pci_fixup_early, dev);
975 /* device class may be changed after fixup */
976 class = dev->class >> 8;
978 switch (dev->hdr_type) { /* header type */
979 case PCI_HEADER_TYPE_NORMAL: /* standard header */
980 if (class == PCI_CLASS_BRIDGE_PCI)
981 goto bad;
982 pci_read_irq(dev);
983 pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
984 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
985 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
988 * Do the ugly legacy mode stuff here rather than broken chip
989 * quirk code. Legacy mode ATA controllers have fixed
990 * addresses. These are not always echoed in BAR0-3, and
991 * BAR0-3 in a few cases contain junk!
993 if (class == PCI_CLASS_STORAGE_IDE) {
994 u8 progif;
995 pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
996 if ((progif & 1) == 0) {
997 dev->resource[0].start = 0x1F0;
998 dev->resource[0].end = 0x1F7;
999 dev->resource[0].flags = LEGACY_IO_RESOURCE;
1000 dev->resource[1].start = 0x3F6;
1001 dev->resource[1].end = 0x3F6;
1002 dev->resource[1].flags = LEGACY_IO_RESOURCE;
1004 if ((progif & 4) == 0) {
1005 dev->resource[2].start = 0x170;
1006 dev->resource[2].end = 0x177;
1007 dev->resource[2].flags = LEGACY_IO_RESOURCE;
1008 dev->resource[3].start = 0x376;
1009 dev->resource[3].end = 0x376;
1010 dev->resource[3].flags = LEGACY_IO_RESOURCE;
1013 break;
1015 case PCI_HEADER_TYPE_BRIDGE: /* bridge header */
1016 if (class != PCI_CLASS_BRIDGE_PCI)
1017 goto bad;
1018 /* The PCI-to-PCI bridge spec requires that subtractive
1019 decoding (i.e. transparent) bridge must have programming
1020 interface code of 0x01. */
1021 pci_read_irq(dev);
1022 dev->transparent = ((dev->class & 0xff) == 1);
1023 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
1024 set_pcie_hotplug_bridge(dev);
1025 pos = pci_find_capability(dev, PCI_CAP_ID_SSVID);
1026 if (pos) {
1027 pci_read_config_word(dev, pos + PCI_SSVID_VENDOR_ID, &dev->subsystem_vendor);
1028 pci_read_config_word(dev, pos + PCI_SSVID_DEVICE_ID, &dev->subsystem_device);
1030 break;
1032 case PCI_HEADER_TYPE_CARDBUS: /* CardBus bridge header */
1033 if (class != PCI_CLASS_BRIDGE_CARDBUS)
1034 goto bad;
1035 pci_read_irq(dev);
1036 pci_read_bases(dev, 1, 0);
1037 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
1038 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device);
1039 break;
1041 default: /* unknown header */
1042 dev_err(&dev->dev, "unknown header type %02x, "
1043 "ignoring device\n", dev->hdr_type);
1044 return -EIO;
1046 bad:
1047 dev_err(&dev->dev, "ignoring class %02x (doesn't match header "
1048 "type %02x)\n", class, dev->hdr_type);
1049 dev->class = PCI_CLASS_NOT_DEFINED;
1052 /* We found a fine healthy device, go go go... */
1053 return 0;
1056 static void pci_release_capabilities(struct pci_dev *dev)
1058 pci_vpd_release(dev);
1059 pci_iov_release(dev);
1063 * pci_release_dev - free a pci device structure when all users of it are finished.
1064 * @dev: device that's been disconnected
1066 * Will be called only by the device core when all users of this pci device are
1067 * done.
1069 static void pci_release_dev(struct device *dev)
1071 struct pci_dev *pci_dev;
1073 pci_dev = to_pci_dev(dev);
1074 pci_release_capabilities(pci_dev);
1075 kfree(pci_dev);
1079 * pci_cfg_space_size - get the configuration space size of the PCI device.
1080 * @dev: PCI device
1082 * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices
1083 * have 4096 bytes. Even if the device is capable, that doesn't mean we can
1084 * access it. Maybe we don't have a way to generate extended config space
1085 * accesses, or the device is behind a reverse Express bridge. So we try
1086 * reading the dword at 0x100 which must either be 0 or a valid extended
1087 * capability header.
1089 int pci_cfg_space_size_ext(struct pci_dev *dev)
1091 u32 status;
1092 int pos = PCI_CFG_SPACE_SIZE;
1094 if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL)
1095 goto fail;
1096 if (status == 0xffffffff)
1097 goto fail;
1099 return PCI_CFG_SPACE_EXP_SIZE;
1101 fail:
1102 return PCI_CFG_SPACE_SIZE;
1105 int pci_cfg_space_size(struct pci_dev *dev)
1107 int pos;
1108 u32 status;
1109 u16 class;
1111 class = dev->class >> 8;
1112 if (class == PCI_CLASS_BRIDGE_HOST)
1113 return pci_cfg_space_size_ext(dev);
1115 pos = pci_pcie_cap(dev);
1116 if (!pos) {
1117 pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1118 if (!pos)
1119 goto fail;
1121 pci_read_config_dword(dev, pos + PCI_X_STATUS, &status);
1122 if (!(status & (PCI_X_STATUS_266MHZ | PCI_X_STATUS_533MHZ)))
1123 goto fail;
1126 return pci_cfg_space_size_ext(dev);
1128 fail:
1129 return PCI_CFG_SPACE_SIZE;
1132 static void pci_release_bus_bridge_dev(struct device *dev)
1134 kfree(dev);
1137 struct pci_dev *alloc_pci_dev(void)
1139 struct pci_dev *dev;
1141 dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
1142 if (!dev)
1143 return NULL;
1145 INIT_LIST_HEAD(&dev->bus_list);
1147 return dev;
1149 EXPORT_SYMBOL(alloc_pci_dev);
1152 * Read the config data for a PCI device, sanity-check it
1153 * and fill in the dev structure...
1155 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
1157 struct pci_dev *dev;
1158 u32 l;
1159 int delay = 1;
1161 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
1162 return NULL;
1164 /* some broken boards return 0 or ~0 if a slot is empty: */
1165 if (l == 0xffffffff || l == 0x00000000 ||
1166 l == 0x0000ffff || l == 0xffff0000)
1167 return NULL;
1169 /* Configuration request Retry Status */
1170 while (l == 0xffff0001) {
1171 msleep(delay);
1172 delay *= 2;
1173 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
1174 return NULL;
1175 /* Card hasn't responded in 60 seconds? Must be stuck. */
1176 if (delay > 60 * 1000) {
1177 printk(KERN_WARNING "pci %04x:%02x:%02x.%d: not "
1178 "responding\n", pci_domain_nr(bus),
1179 bus->number, PCI_SLOT(devfn),
1180 PCI_FUNC(devfn));
1181 return NULL;
1185 dev = alloc_pci_dev();
1186 if (!dev)
1187 return NULL;
1189 dev->bus = bus;
1190 dev->devfn = devfn;
1191 dev->vendor = l & 0xffff;
1192 dev->device = (l >> 16) & 0xffff;
1194 if (pci_setup_device(dev)) {
1195 kfree(dev);
1196 return NULL;
1199 return dev;
1202 static void pci_init_capabilities(struct pci_dev *dev)
1204 /* MSI/MSI-X list */
1205 pci_msi_init_pci_dev(dev);
1207 /* Buffers for saving PCIe and PCI-X capabilities */
1208 pci_allocate_cap_save_buffers(dev);
1210 /* Power Management */
1211 pci_pm_init(dev);
1212 platform_pci_wakeup_init(dev);
1214 /* Vital Product Data */
1215 pci_vpd_pci22_init(dev);
1217 /* Alternative Routing-ID Forwarding */
1218 pci_enable_ari(dev);
1220 /* Single Root I/O Virtualization */
1221 pci_iov_init(dev);
1223 /* Enable ACS P2P upstream forwarding */
1224 pci_enable_acs(dev);
1227 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
1229 device_initialize(&dev->dev);
1230 dev->dev.release = pci_release_dev;
1231 pci_dev_get(dev);
1233 dev->dev.dma_mask = &dev->dma_mask;
1234 dev->dev.dma_parms = &dev->dma_parms;
1235 dev->dev.coherent_dma_mask = 0xffffffffull;
1237 pci_set_dma_max_seg_size(dev, 65536);
1238 pci_set_dma_seg_boundary(dev, 0xffffffff);
1240 /* Fix up broken headers */
1241 pci_fixup_device(pci_fixup_header, dev);
1243 /* Clear the state_saved flag. */
1244 dev->state_saved = false;
1246 /* Initialize various capabilities */
1247 pci_init_capabilities(dev);
1250 * Add the device to our list of discovered devices
1251 * and the bus list for fixup functions, etc.
1253 down_write(&pci_bus_sem);
1254 list_add_tail(&dev->bus_list, &bus->devices);
1255 up_write(&pci_bus_sem);
1258 struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
1260 struct pci_dev *dev;
1262 dev = pci_get_slot(bus, devfn);
1263 if (dev) {
1264 pci_dev_put(dev);
1265 return dev;
1268 dev = pci_scan_device(bus, devfn);
1269 if (!dev)
1270 return NULL;
1272 pci_device_add(dev, bus);
1274 return dev;
1276 EXPORT_SYMBOL(pci_scan_single_device);
1278 static unsigned next_ari_fn(struct pci_dev *dev, unsigned fn)
1280 u16 cap;
1281 unsigned pos, next_fn;
1283 if (!dev)
1284 return 0;
1286 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI);
1287 if (!pos)
1288 return 0;
1289 pci_read_config_word(dev, pos + 4, &cap);
1290 next_fn = cap >> 8;
1291 if (next_fn <= fn)
1292 return 0;
1293 return next_fn;
1296 static unsigned next_trad_fn(struct pci_dev *dev, unsigned fn)
1298 return (fn + 1) % 8;
1301 static unsigned no_next_fn(struct pci_dev *dev, unsigned fn)
1303 return 0;
1306 static int only_one_child(struct pci_bus *bus)
1308 struct pci_dev *parent = bus->self;
1309 if (!parent || !pci_is_pcie(parent))
1310 return 0;
1311 if (parent->pcie_type == PCI_EXP_TYPE_ROOT_PORT ||
1312 parent->pcie_type == PCI_EXP_TYPE_DOWNSTREAM)
1313 return 1;
1314 return 0;
1318 * pci_scan_slot - scan a PCI slot on a bus for devices.
1319 * @bus: PCI bus to scan
1320 * @devfn: slot number to scan (must have zero function.)
1322 * Scan a PCI slot on the specified PCI bus for devices, adding
1323 * discovered devices to the @bus->devices list. New devices
1324 * will not have is_added set.
1326 * Returns the number of new devices found.
1328 int pci_scan_slot(struct pci_bus *bus, int devfn)
1330 unsigned fn, nr = 0;
1331 struct pci_dev *dev;
1332 unsigned (*next_fn)(struct pci_dev *, unsigned) = no_next_fn;
1334 if (only_one_child(bus) && (devfn > 0))
1335 return 0; /* Already scanned the entire slot */
1337 dev = pci_scan_single_device(bus, devfn);
1338 if (!dev)
1339 return 0;
1340 if (!dev->is_added)
1341 nr++;
1343 if (pci_ari_enabled(bus))
1344 next_fn = next_ari_fn;
1345 else if (dev->multifunction)
1346 next_fn = next_trad_fn;
1348 for (fn = next_fn(dev, 0); fn > 0; fn = next_fn(dev, fn)) {
1349 dev = pci_scan_single_device(bus, devfn + fn);
1350 if (dev) {
1351 if (!dev->is_added)
1352 nr++;
1353 dev->multifunction = 1;
1357 /* only one slot has pcie device */
1358 if (bus->self && nr)
1359 pcie_aspm_init_link_state(bus->self);
1361 return nr;
1364 unsigned int __devinit pci_scan_child_bus(struct pci_bus *bus)
1366 unsigned int devfn, pass, max = bus->secondary;
1367 struct pci_dev *dev;
1369 dev_dbg(&bus->dev, "scanning bus\n");
1371 /* Go find them, Rover! */
1372 for (devfn = 0; devfn < 0x100; devfn += 8)
1373 pci_scan_slot(bus, devfn);
1375 /* Reserve buses for SR-IOV capability. */
1376 max += pci_iov_bus_range(bus);
1379 * After performing arch-dependent fixup of the bus, look behind
1380 * all PCI-to-PCI bridges on this bus.
1382 if (!bus->is_added) {
1383 dev_dbg(&bus->dev, "fixups for bus\n");
1384 pcibios_fixup_bus(bus);
1385 if (pci_is_root_bus(bus))
1386 bus->is_added = 1;
1389 for (pass=0; pass < 2; pass++)
1390 list_for_each_entry(dev, &bus->devices, bus_list) {
1391 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1392 dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1393 max = pci_scan_bridge(bus, dev, max, pass);
1397 * We've scanned the bus and so we know all about what's on
1398 * the other side of any bridges that may be on this bus plus
1399 * any devices.
1401 * Return how far we've got finding sub-buses.
1403 dev_dbg(&bus->dev, "bus scan returning with max=%02x\n", max);
1404 return max;
1407 struct pci_bus * pci_create_bus(struct device *parent,
1408 int bus, struct pci_ops *ops, void *sysdata)
1410 int error;
1411 struct pci_bus *b, *b2;
1412 struct device *dev;
1414 b = pci_alloc_bus();
1415 if (!b)
1416 return NULL;
1418 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1419 if (!dev){
1420 kfree(b);
1421 return NULL;
1424 b->sysdata = sysdata;
1425 b->ops = ops;
1427 b2 = pci_find_bus(pci_domain_nr(b), bus);
1428 if (b2) {
1429 /* If we already got to this bus through a different bridge, ignore it */
1430 dev_dbg(&b2->dev, "bus already known\n");
1431 goto err_out;
1434 down_write(&pci_bus_sem);
1435 list_add_tail(&b->node, &pci_root_buses);
1436 up_write(&pci_bus_sem);
1438 dev->parent = parent;
1439 dev->release = pci_release_bus_bridge_dev;
1440 dev_set_name(dev, "pci%04x:%02x", pci_domain_nr(b), bus);
1441 error = device_register(dev);
1442 if (error)
1443 goto dev_reg_err;
1444 b->bridge = get_device(dev);
1445 device_enable_async_suspend(b->bridge);
1447 if (!parent)
1448 set_dev_node(b->bridge, pcibus_to_node(b));
1450 b->dev.class = &pcibus_class;
1451 b->dev.parent = b->bridge;
1452 dev_set_name(&b->dev, "%04x:%02x", pci_domain_nr(b), bus);
1453 error = device_register(&b->dev);
1454 if (error)
1455 goto class_dev_reg_err;
1456 error = device_create_file(&b->dev, &dev_attr_cpuaffinity);
1457 if (error)
1458 goto dev_create_file_err;
1460 /* Create legacy_io and legacy_mem files for this bus */
1461 pci_create_legacy_files(b);
1463 b->number = b->secondary = bus;
1464 b->resource[0] = &ioport_resource;
1465 b->resource[1] = &iomem_resource;
1467 return b;
1469 dev_create_file_err:
1470 device_unregister(&b->dev);
1471 class_dev_reg_err:
1472 device_unregister(dev);
1473 dev_reg_err:
1474 down_write(&pci_bus_sem);
1475 list_del(&b->node);
1476 up_write(&pci_bus_sem);
1477 err_out:
1478 kfree(dev);
1479 kfree(b);
1480 return NULL;
1483 struct pci_bus * __devinit pci_scan_bus_parented(struct device *parent,
1484 int bus, struct pci_ops *ops, void *sysdata)
1486 struct pci_bus *b;
1488 b = pci_create_bus(parent, bus, ops, sysdata);
1489 if (b)
1490 b->subordinate = pci_scan_child_bus(b);
1491 return b;
1493 EXPORT_SYMBOL(pci_scan_bus_parented);
1495 #ifdef CONFIG_HOTPLUG
1497 * pci_rescan_bus - scan a PCI bus for devices.
1498 * @bus: PCI bus to scan
1500 * Scan a PCI bus and child buses for new devices, adds them,
1501 * and enables them.
1503 * Returns the max number of subordinate bus discovered.
1505 unsigned int __ref pci_rescan_bus(struct pci_bus *bus)
1507 unsigned int max;
1508 struct pci_dev *dev;
1510 max = pci_scan_child_bus(bus);
1512 down_read(&pci_bus_sem);
1513 list_for_each_entry(dev, &bus->devices, bus_list)
1514 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1515 dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1516 if (dev->subordinate)
1517 pci_bus_size_bridges(dev->subordinate);
1518 up_read(&pci_bus_sem);
1520 pci_bus_assign_resources(bus);
1521 pci_enable_bridges(bus);
1522 pci_bus_add_devices(bus);
1524 return max;
1526 EXPORT_SYMBOL_GPL(pci_rescan_bus);
1528 EXPORT_SYMBOL(pci_add_new_bus);
1529 EXPORT_SYMBOL(pci_scan_slot);
1530 EXPORT_SYMBOL(pci_scan_bridge);
1531 EXPORT_SYMBOL_GPL(pci_scan_child_bus);
1532 #endif
1534 static int __init pci_sort_bf_cmp(const struct device *d_a, const struct device *d_b)
1536 const struct pci_dev *a = to_pci_dev(d_a);
1537 const struct pci_dev *b = to_pci_dev(d_b);
1539 if (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
1540 else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return 1;
1542 if (a->bus->number < b->bus->number) return -1;
1543 else if (a->bus->number > b->bus->number) return 1;
1545 if (a->devfn < b->devfn) return -1;
1546 else if (a->devfn > b->devfn) return 1;
1548 return 0;
1551 void __init pci_sort_breadthfirst(void)
1553 bus_sort_breadthfirst(&pci_bus_type, &pci_sort_bf_cmp);