projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
[deliverable/linux.git] / drivers / pci / probe.c
1 /*
2 * probe.c - PCI detection and setup code
3 */
4
5 #include <linux/kernel.h>
6 #include <linux/delay.h>
7 #include <linux/init.h>
8 #include <linux/pci.h>
9 #include <linux/slab.h>
10 #include <linux/module.h>
11 #include <linux/cpumask.h>
12 #include <linux/pci-aspm.h>
13 #include "pci.h"
14
15 #define CARDBUS_LATENCY_TIMER 176 /* secondary latency timer */
16 #define CARDBUS_RESERVE_BUSNR 3
17
18 /* Ugh. Need to stop exporting this to modules. */
19 LIST_HEAD(pci_root_buses);
20 EXPORT_SYMBOL(pci_root_buses);
21
22
23 static int find_anything(struct device *dev, void *data)
24 {
25 return 1;
26 }
27
28 /*
29 * Some device drivers need know if pci is initiated.
30 * Basically, we think pci is not initiated when there
31 * is no device to be found on the pci_bus_type.
32 */
33 int no_pci_devices(void)
34 {
35 struct device *dev;
36 int no_devices;
37
38 dev = bus_find_device(&pci_bus_type, NULL, NULL, find_anything);
39 no_devices = (dev == NULL);
40 put_device(dev);
41 return no_devices;
42 }
43 EXPORT_SYMBOL(no_pci_devices);
44
45 /*
46 * PCI Bus Class Devices
47 */
48 static ssize_t pci_bus_show_cpuaffinity(struct device *dev,
49 int type,
50 struct device_attribute *attr,
51 char *buf)
52 {
53 int ret;
54 const struct cpumask *cpumask;
55
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;
63 }
64
65 static ssize_t inline pci_bus_show_cpumaskaffinity(struct device *dev,
66 struct device_attribute *attr,
67 char *buf)
68 {
69 return pci_bus_show_cpuaffinity(dev, 0, attr, buf);
70 }
71
72 static ssize_t inline pci_bus_show_cpulistaffinity(struct device *dev,
73 struct device_attribute *attr,
74 char *buf)
75 {
76 return pci_bus_show_cpuaffinity(dev, 1, attr, buf);
77 }
78
79 DEVICE_ATTR(cpuaffinity, S_IRUGO, pci_bus_show_cpumaskaffinity, NULL);
80 DEVICE_ATTR(cpulistaffinity, S_IRUGO, pci_bus_show_cpulistaffinity, NULL);
81
82 /*
83 * PCI Bus Class
84 */
85 static void release_pcibus_dev(struct device *dev)
86 {
87 struct pci_bus *pci_bus = to_pci_bus(dev);
88
89 if (pci_bus->bridge)
90 put_device(pci_bus->bridge);
91 pci_bus_remove_resources(pci_bus);
92 kfree(pci_bus);
93 }
94
95 static struct class pcibus_class = {
96 .name = "pci_bus",
97 .dev_release = &release_pcibus_dev,
98 };
99
100 static int __init pcibus_class_init(void)
101 {
102 return class_register(&pcibus_class);
103 }
104 postcore_initcall(pcibus_class_init);
105
106 /*
107 * Translate the low bits of the PCI base
108 * to the resource type
109 */
110 static inline unsigned int pci_calc_resource_flags(unsigned int flags)
111 {
112 if (flags & PCI_BASE_ADDRESS_SPACE_IO)
113 return IORESOURCE_IO;
114
115 if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
116 return IORESOURCE_MEM | IORESOURCE_PREFETCH;
117
118 return IORESOURCE_MEM;
119 }
120
121 static u64 pci_size(u64 base, u64 maxbase, u64 mask)
122 {
123 u64 size = mask & maxbase; /* Find the significant bits */
124 if (!size)
125 return 0;
126
127 /* Get the lowest of them to find the decode size, and
128 from that the extent. */
129 size = (size & ~(size-1)) - 1;
130
131 /* base == maxbase can be valid only if the BAR has
132 already been programmed with all 1s. */
133 if (base == maxbase && ((base | size) & mask) != mask)
134 return 0;
135
136 return size;
137 }
138
139 static inline enum pci_bar_type decode_bar(struct resource *res, u32 bar)
140 {
141 if ((bar & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO) {
142 res->flags = bar & ~PCI_BASE_ADDRESS_IO_MASK;
143 return pci_bar_io;
144 }
145
146 res->flags = bar & ~PCI_BASE_ADDRESS_MEM_MASK;
147
148 if (res->flags & PCI_BASE_ADDRESS_MEM_TYPE_64)
149 return pci_bar_mem64;
150 return pci_bar_mem32;
151 }
152
153 /**
154 * pci_read_base - read a PCI BAR
155 * @dev: the PCI device
156 * @type: type of the BAR
157 * @res: resource buffer to be filled in
158 * @pos: BAR position in the config space
159 *
160 * Returns 1 if the BAR is 64-bit, or 0 if 32-bit.
161 */
162 int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
163 struct resource *res, unsigned int pos)
164 {
165 u32 l, sz, mask;
166 u16 orig_cmd;
167
168 mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
169
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));
174 }
175
176 res->name = pci_name(dev);
177
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);
182
183 if (!dev->mmio_always_on)
184 pci_write_config_word(dev, PCI_COMMAND, orig_cmd);
185
186 /*
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.
191 */
192 if (!sz || sz == 0xffffffff)
193 goto fail;
194
195 /*
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.
198 */
199 if (l == 0xffffffff)
200 l = 0;
201
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;
211 }
212 } else {
213 res->flags |= (l & IORESOURCE_ROM_ENABLE);
214 l &= PCI_ROM_ADDRESS_MASK;
215 mask = (u32)PCI_ROM_ADDRESS_MASK;
216 }
217
218 if (type == pci_bar_mem64) {
219 u64 l64 = l;
220 u64 sz64 = sz;
221 u64 mask64 = mask | (u64)~0 << 32;
222
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);
227
228 l64 |= ((u64)l << 32);
229 sz64 |= ((u64)sz << 32);
230
231 sz64 = pci_size(l64, sz64, mask64);
232
233 if (!sz64)
234 goto fail;
235
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;
240 }
241
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);
254 }
255 } else {
256 sz = pci_size(l, sz, mask);
257
258 if (!sz)
259 goto fail;
260
261 res->start = l;
262 res->end = l + sz;
263
264 dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n", pos, res);
265 }
266
267 out:
268 return (type == pci_bar_mem64) ? 1 : 0;
269 fail:
270 res->flags = 0;
271 goto out;
272 }
273
274 static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
275 {
276 unsigned int pos, reg;
277
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);
282 }
283
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);
291 }
292 }
293
294 static void __devinit pci_read_bridge_io(struct pci_bus *child)
295 {
296 struct pci_dev *dev = child->self;
297 u8 io_base_lo, io_limit_lo;
298 unsigned long base, limit;
299 struct resource *res;
300
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;
306
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);
313 }
314
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);
326 }
327 }
328
329 static void __devinit pci_read_bridge_mmio(struct pci_bus *child)
330 {
331 struct pci_dev *dev = child->self;
332 u16 mem_base_lo, mem_limit_lo;
333 unsigned long base, limit;
334 struct resource *res;
335
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);
350 }
351 }
352
353 static void __devinit pci_read_bridge_mmio_pref(struct pci_bus *child)
354 {
355 struct pci_dev *dev = child->self;
356 u16 mem_base_lo, mem_limit_lo;
357 unsigned long base, limit;
358 struct resource *res;
359
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;
365
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);
370
371 /*
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.
375 */
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;
385 }
386 #endif
387 }
388 }
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);
401 }
402 }
403
404 void __devinit pci_read_bridge_bases(struct pci_bus *child)
405 {
406 struct pci_dev *dev = child->self;
407 struct resource *res;
408 int i;
409
410 if (pci_is_root_bus(child)) /* It's a host bus, nothing to read */
411 return;
412
413 dev_info(&dev->dev, "PCI bridge to [bus %02x-%02x]%s\n",
414 child->secondary, child->subordinate,
415 dev->transparent ? " (subtractive decode)" : "");
416
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];
420
421 pci_read_bridge_io(child);
422 pci_read_bridge_mmio(child);
423 pci_read_bridge_mmio_pref(child);
424
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);
433 }
434 }
435 }
436 }
437
438 static struct pci_bus * pci_alloc_bus(void)
439 {
440 struct pci_bus *b;
441
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;
451 }
452 return b;
453 }
454
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 */
472 };
473
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 */
491 };
492
493 void pcie_update_link_speed(struct pci_bus *bus, u16 linksta)
494 {
495 bus->cur_bus_speed = pcie_link_speed[linksta & 0xf];
496 }
497 EXPORT_SYMBOL_GPL(pcie_update_link_speed);
498
499 static unsigned char agp_speeds[] = {
500 AGP_UNKNOWN,
501 AGP_1X,
502 AGP_2X,
503 AGP_4X,
504 AGP_8X
505 };
506
507 static enum pci_bus_speed agp_speed(int agp3, int agpstat)
508 {
509 int index = 0;
510
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;
519
520 if (agp3) {
521 index += 2;
522 if (index == 5)
523 index = 0;
524 }
525
526 out:
527 return agp_speeds[index];
528 }
529
530
531 static void pci_set_bus_speed(struct pci_bus *bus)
532 {
533 struct pci_dev *bridge = bus->self;
534 int pos;
535
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;
541
542 pci_read_config_dword(bridge, pos + PCI_AGP_STATUS, &agpstat);
543 bus->max_bus_speed = agp_speed(agpstat & 8, agpstat & 7);
544
545 pci_read_config_dword(bridge, pos + PCI_AGP_COMMAND, &agpcmd);
546 bus->cur_bus_speed = agp_speed(agpstat & 8, agpcmd & 7);
547 }
548
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);
554
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;
564 }
565 } else {
566 max = PCI_SPEED_66MHz_PCIX;
567 }
568
569 bus->max_bus_speed = max;
570 bus->cur_bus_speed = pcix_bus_speed[(status >> 6) & 0xf];
571
572 return;
573 }
574
575 pos = pci_find_capability(bridge, PCI_CAP_ID_EXP);
576 if (pos) {
577 u32 linkcap;
578 u16 linksta;
579
580 pci_read_config_dword(bridge, pos + PCI_EXP_LNKCAP, &linkcap);
581 bus->max_bus_speed = pcie_link_speed[linkcap & 0xf];
582
583 pci_read_config_word(bridge, pos + PCI_EXP_LNKSTA, &linksta);
584 pcie_update_link_speed(bus, linksta);
585 }
586 }
587
588
589 static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
590 struct pci_dev *bridge, int busnr)
591 {
592 struct pci_bus *child;
593 int i;
594
595 /*
596 * Allocate a new bus, and inherit stuff from the parent..
597 */
598 child = pci_alloc_bus();
599 if (!child)
600 return NULL;
601
602 child->parent = parent;
603 child->ops = parent->ops;
604 child->sysdata = parent->sysdata;
605 child->bus_flags = parent->bus_flags;
606
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()
610 */
611 child->dev.class = &pcibus_class;
612 dev_set_name(&child->dev, "%04x:%02x", pci_domain_nr(child), busnr);
613
614 /*
615 * Set up the primary, secondary and subordinate
616 * bus numbers.
617 */
618 child->number = child->secondary = busnr;
619 child->primary = parent->secondary;
620 child->subordinate = 0xff;
621
622 if (!bridge)
623 return child;
624
625 child->self = bridge;
626 child->bridge = get_device(&bridge->dev);
627
628 pci_set_bus_speed(child);
629
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;
634 }
635 bridge->subordinate = child;
636
637 return child;
638 }
639
640 struct pci_bus *__ref pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr)
641 {
642 struct pci_bus *child;
643
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);
649 }
650 return child;
651 }
652
653 static void pci_fixup_parent_subordinate_busnr(struct pci_bus *child, int max)
654 {
655 struct pci_bus *parent = child->parent;
656
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;
661
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;
666 }
667 }
668
669 /*
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.
673 *
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.
678 */
679 int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
680 {
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;
687
688 pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
689 primary = buses & 0xFF;
690 secondary = (buses >> 8) & 0xFF;
691 subordinate = (buses >> 16) & 0xFF;
692
693 dev_dbg(&dev->dev, "scanning [bus %02x-%02x] behind bridge, pass %d\n",
694 secondary, subordinate, pass);
695
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;
701 }
702
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);
708
709 if ((secondary || subordinate) && !pcibios_assign_all_busses() &&
710 !is_cardbus && !broken) {
711 unsigned int cmax;
712 /*
713 * Bus already configured by firmware, process it in the first
714 * pass and just note the configuration.
715 */
716 if (pass)
717 goto out;
718
719 /*
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.
722 *
723 * However, we continue to descend down the hierarchy and
724 * scan remaining child buses.
725 */
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;
734 }
735
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 {
742 /*
743 * We need to assign a number to this bus which we always
744 * do in the second pass.
745 */
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;
757 }
758
759 /* Clear errors */
760 pci_write_config_word(dev, PCI_STATUS, 0xffff);
761
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);
771
772 /*
773 * yenta.c forces a secondary latency timer of 176.
774 * Copy that behaviour here.
775 */
776 if (is_cardbus) {
777 buses &= ~0xff000000;
778 buses |= CARDBUS_LATENCY_TIMER << 24;
779 }
780
781 /*
782 * We need to blast all three values with a single write.
783 */
784 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
785
786 if (!is_cardbus) {
787 child->bridge_ctl = bctl;
788 /*
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.
793 */
794 pci_fixup_parent_subordinate_busnr(child, max);
795 /* Now we can scan all subordinate buses... */
796 max = pci_scan_child_bus(child);
797 /*
798 * now fix it up again since we have found
799 * the real value of max.
800 */
801 pci_fixup_parent_subordinate_busnr(child, max);
802 } else {
803 /*
804 * For CardBus bridges, we leave 4 bus numbers
805 * as cards with a PCI-to-PCI bridge can be
806 * inserted later.
807 */
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;
818 }
819 parent = parent->parent;
820 }
821 if (j) {
822 /*
823 * Often, there are two cardbus bridges
824 * -- try to leave one valid bus number
825 * for each one.
826 */
827 i /= 2;
828 break;
829 }
830 }
831 max += i;
832 pci_fixup_parent_subordinate_busnr(child, max);
833 }
834 /*
835 * Set the subordinate bus number to its real value.
836 */
837 child->subordinate = max;
838 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
839 }
840
841 sprintf(child->name,
842 (is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"),
843 pci_domain_nr(bus), child->number);
844
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);
860 }
861 bus = bus->parent;
862 }
863
864 out:
865 pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
866
867 return max;
868 }
869
870 /*
871 * Read interrupt line and base address registers.
872 * The architecture-dependent code can tweak these, of course.
873 */
874 static void pci_read_irq(struct pci_dev *dev)
875 {
876 unsigned char irq;
877
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;
883 }
884
885 void set_pcie_port_type(struct pci_dev *pdev)
886 {
887 int pos;
888 u16 reg16;
889
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;
897 }
898
899 void set_pcie_hotplug_bridge(struct pci_dev *pdev)
900 {
901 int pos;
902 u16 reg16;
903 u32 reg32;
904
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;
914 }
915
916 #define LEGACY_IO_RESOURCE (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
917
918 /**
919 * pci_setup_device - fill in class and map information of a device
920 * @dev: the device structure to fill
921 *
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).
927 */
928 int pci_setup_device(struct pci_dev *dev)
929 {
930 u32 class;
931 u8 hdr_type;
932 struct pci_slot *slot;
933 int pos = 0;
934
935 if (pci_read_config_byte(dev, PCI_HEADER_TYPE, &hdr_type))
936 return -EIO;
937
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);
945
946 list_for_each_entry(slot, &dev->bus->slots, list)
947 if (PCI_SLOT(dev->devfn) == slot->number)
948 dev->slot = slot;
949
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;
953
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));
957
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;
963
964 dev_dbg(&dev->dev, "found [%04x:%04x] class %06x header type %02x\n",
965 dev->vendor, dev->device, class, dev->hdr_type);
966
967 /* need to have dev->class ready */
968 dev->cfg_size = pci_cfg_space_size(dev);
969
970 /* "Unknown power state" */
971 dev->current_state = PCI_UNKNOWN;
972
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;
977
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);
986
987 /*
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!
992 */
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;
1003 }
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;
1011 }
1012 }
1013 break;
1014
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);
1029 }
1030 break;
1031
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;
1040
1041 default: /* unknown header */
1042 dev_err(&dev->dev, "unknown header type %02x, "
1043 "ignoring device\n", dev->hdr_type);
1044 return -EIO;
1045
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;
1050 }
1051
1052 /* We found a fine healthy device, go go go... */
1053 return 0;
1054 }
1055
1056 static void pci_release_capabilities(struct pci_dev *dev)
1057 {
1058 pci_vpd_release(dev);
1059 pci_iov_release(dev);
1060 }
1061
1062 /**
1063 * pci_release_dev - free a pci device structure when all users of it are finished.
1064 * @dev: device that's been disconnected
1065 *
1066 * Will be called only by the device core when all users of this pci device are
1067 * done.
1068 */
1069 static void pci_release_dev(struct device *dev)
1070 {
1071 struct pci_dev *pci_dev;
1072
1073 pci_dev = to_pci_dev(dev);
1074 pci_release_capabilities(pci_dev);
1075 kfree(pci_dev);
1076 }
1077
1078 /**
1079 * pci_cfg_space_size - get the configuration space size of the PCI device.
1080 * @dev: PCI device
1081 *
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.
1088 */
1089 int pci_cfg_space_size_ext(struct pci_dev *dev)
1090 {
1091 u32 status;
1092 int pos = PCI_CFG_SPACE_SIZE;
1093
1094 if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL)
1095 goto fail;
1096 if (status == 0xffffffff)
1097 goto fail;
1098
1099 return PCI_CFG_SPACE_EXP_SIZE;
1100
1101 fail:
1102 return PCI_CFG_SPACE_SIZE;
1103 }
1104
1105 int pci_cfg_space_size(struct pci_dev *dev)
1106 {
1107 int pos;
1108 u32 status;
1109 u16 class;
1110
1111 class = dev->class >> 8;
1112 if (class == PCI_CLASS_BRIDGE_HOST)
1113 return pci_cfg_space_size_ext(dev);
1114
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;
1120
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;
1124 }
1125
1126 return pci_cfg_space_size_ext(dev);
1127
1128 fail:
1129 return PCI_CFG_SPACE_SIZE;
1130 }
1131
1132 static void pci_release_bus_bridge_dev(struct device *dev)
1133 {
1134 kfree(dev);
1135 }
1136
1137 struct pci_dev *alloc_pci_dev(void)
1138 {
1139 struct pci_dev *dev;
1140
1141 dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
1142 if (!dev)
1143 return NULL;
1144
1145 INIT_LIST_HEAD(&dev->bus_list);
1146
1147 return dev;
1148 }
1149 EXPORT_SYMBOL(alloc_pci_dev);
1150
1151 /*
1152 * Read the config data for a PCI device, sanity-check it
1153 * and fill in the dev structure...
1154 */
1155 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
1156 {
1157 struct pci_dev *dev;
1158 u32 l;
1159 int delay = 1;
1160
1161 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
1162 return NULL;
1163
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;
1168
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;
1182 }
1183 }
1184
1185 dev = alloc_pci_dev();
1186 if (!dev)
1187 return NULL;
1188
1189 dev->bus = bus;
1190 dev->devfn = devfn;
1191 dev->vendor = l & 0xffff;
1192 dev->device = (l >> 16) & 0xffff;
1193
1194 if (pci_setup_device(dev)) {
1195 kfree(dev);
1196 return NULL;
1197 }
1198
1199 return dev;
1200 }
1201
1202 static void pci_init_capabilities(struct pci_dev *dev)
1203 {
1204 /* MSI/MSI-X list */
1205 pci_msi_init_pci_dev(dev);
1206
1207 /* Buffers for saving PCIe and PCI-X capabilities */
1208 pci_allocate_cap_save_buffers(dev);
1209
1210 /* Power Management */
1211 pci_pm_init(dev);
1212 platform_pci_wakeup_init(dev);
1213
1214 /* Vital Product Data */
1215 pci_vpd_pci22_init(dev);
1216
1217 /* Alternative Routing-ID Forwarding */
1218 pci_enable_ari(dev);
1219
1220 /* Single Root I/O Virtualization */
1221 pci_iov_init(dev);
1222
1223 /* Enable ACS P2P upstream forwarding */
1224 pci_enable_acs(dev);
1225 }
1226
1227 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
1228 {
1229 device_initialize(&dev->dev);
1230 dev->dev.release = pci_release_dev;
1231 pci_dev_get(dev);
1232
1233 dev->dev.dma_mask = &dev->dma_mask;
1234 dev->dev.dma_parms = &dev->dma_parms;
1235 dev->dev.coherent_dma_mask = 0xffffffffull;
1236
1237 pci_set_dma_max_seg_size(dev, 65536);
1238 pci_set_dma_seg_boundary(dev, 0xffffffff);
1239
1240 /* Fix up broken headers */
1241 pci_fixup_device(pci_fixup_header, dev);
1242
1243 /* Clear the state_saved flag. */
1244 dev->state_saved = false;
1245
1246 /* Initialize various capabilities */
1247 pci_init_capabilities(dev);
1248
1249 /*
1250 * Add the device to our list of discovered devices
1251 * and the bus list for fixup functions, etc.
1252 */
1253 down_write(&pci_bus_sem);
1254 list_add_tail(&dev->bus_list, &bus->devices);
1255 up_write(&pci_bus_sem);
1256 }
1257
1258 struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
1259 {
1260 struct pci_dev *dev;
1261
1262 dev = pci_get_slot(bus, devfn);
1263 if (dev) {
1264 pci_dev_put(dev);
1265 return dev;
1266 }
1267
1268 dev = pci_scan_device(bus, devfn);
1269 if (!dev)
1270 return NULL;
1271
1272 pci_device_add(dev, bus);
1273
1274 return dev;
1275 }
1276 EXPORT_SYMBOL(pci_scan_single_device);
1277
1278 static unsigned next_ari_fn(struct pci_dev *dev, unsigned fn)
1279 {
1280 u16 cap;
1281 unsigned pos, next_fn;
1282
1283 if (!dev)
1284 return 0;
1285
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;
1294 }
1295
1296 static unsigned next_trad_fn(struct pci_dev *dev, unsigned fn)
1297 {
1298 return (fn + 1) % 8;
1299 }
1300
1301 static unsigned no_next_fn(struct pci_dev *dev, unsigned fn)
1302 {
1303 return 0;
1304 }
1305
1306 static int only_one_child(struct pci_bus *bus)
1307 {
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;
1315 }
1316
1317 /**
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.)
1321 *
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.
1325 *
1326 * Returns the number of new devices found.
1327 */
1328 int pci_scan_slot(struct pci_bus *bus, int devfn)
1329 {
1330 unsigned fn, nr = 0;
1331 struct pci_dev *dev;
1332 unsigned (*next_fn)(struct pci_dev *, unsigned) = no_next_fn;
1333
1334 if (only_one_child(bus) && (devfn > 0))
1335 return 0; /* Already scanned the entire slot */
1336
1337 dev = pci_scan_single_device(bus, devfn);
1338 if (!dev)
1339 return 0;
1340 if (!dev->is_added)
1341 nr++;
1342
1343 if (pci_ari_enabled(bus))
1344 next_fn = next_ari_fn;
1345 else if (dev->multifunction)
1346 next_fn = next_trad_fn;
1347
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;
1354 }
1355 }
1356
1357 /* only one slot has pcie device */
1358 if (bus->self && nr)
1359 pcie_aspm_init_link_state(bus->self);
1360
1361 return nr;
1362 }
1363
1364 unsigned int __devinit pci_scan_child_bus(struct pci_bus *bus)
1365 {
1366 unsigned int devfn, pass, max = bus->secondary;
1367 struct pci_dev *dev;
1368
1369 dev_dbg(&bus->dev, "scanning bus\n");
1370
1371 /* Go find them, Rover! */
1372 for (devfn = 0; devfn < 0x100; devfn += 8)
1373 pci_scan_slot(bus, devfn);
1374
1375 /* Reserve buses for SR-IOV capability. */
1376 max += pci_iov_bus_range(bus);
1377
1378 /*
1379 * After performing arch-dependent fixup of the bus, look behind
1380 * all PCI-to-PCI bridges on this bus.
1381 */
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;
1387 }
1388
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);
1394 }
1395
1396 /*
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.
1400 *
1401 * Return how far we've got finding sub-buses.
1402 */
1403 dev_dbg(&bus->dev, "bus scan returning with max=%02x\n", max);
1404 return max;
1405 }
1406
1407 struct pci_bus * pci_create_bus(struct device *parent,
1408 int bus, struct pci_ops *ops, void *sysdata)
1409 {
1410 int error;
1411 struct pci_bus *b, *b2;
1412 struct device *dev;
1413
1414 b = pci_alloc_bus();
1415 if (!b)
1416 return NULL;
1417
1418 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1419 if (!dev){
1420 kfree(b);
1421 return NULL;
1422 }
1423
1424 b->sysdata = sysdata;
1425 b->ops = ops;
1426
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;
1432 }
1433
1434 down_write(&pci_bus_sem);
1435 list_add_tail(&b->node, &pci_root_buses);
1436 up_write(&pci_bus_sem);
1437
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);
1446
1447 if (!parent)
1448 set_dev_node(b->bridge, pcibus_to_node(b));
1449
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;
1459
1460 /* Create legacy_io and legacy_mem files for this bus */
1461 pci_create_legacy_files(b);
1462
1463 b->number = b->secondary = bus;
1464 b->resource[0] = &ioport_resource;
1465 b->resource[1] = &iomem_resource;
1466
1467 return b;
1468
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;
1481 }
1482
1483 struct pci_bus * __devinit pci_scan_bus_parented(struct device *parent,
1484 int bus, struct pci_ops *ops, void *sysdata)
1485 {
1486 struct pci_bus *b;
1487
1488 b = pci_create_bus(parent, bus, ops, sysdata);
1489 if (b)
1490 b->subordinate = pci_scan_child_bus(b);
1491 return b;
1492 }
1493 EXPORT_SYMBOL(pci_scan_bus_parented);
1494
1495 #ifdef CONFIG_HOTPLUG
1496 /**
1497 * pci_rescan_bus - scan a PCI bus for devices.
1498 * @bus: PCI bus to scan
1499 *
1500 * Scan a PCI bus and child buses for new devices, adds them,
1501 * and enables them.
1502 *
1503 * Returns the max number of subordinate bus discovered.
1504 */
1505 unsigned int __ref pci_rescan_bus(struct pci_bus *bus)
1506 {
1507 unsigned int max;
1508 struct pci_dev *dev;
1509
1510 max = pci_scan_child_bus(bus);
1511
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);
1519
1520 pci_bus_assign_resources(bus);
1521 pci_enable_bridges(bus);
1522 pci_bus_add_devices(bus);
1523
1524 return max;
1525 }
1526 EXPORT_SYMBOL_GPL(pci_rescan_bus);
1527
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
1533
1534 static int __init pci_sort_bf_cmp(const struct device *d_a, const struct device *d_b)
1535 {
1536 const struct pci_dev *a = to_pci_dev(d_a);
1537 const struct pci_dev *b = to_pci_dev(d_b);
1538
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;
1541
1542 if (a->bus->number < b->bus->number) return -1;
1543 else if (a->bus->number > b->bus->number) return 1;
1544
1545 if (a->devfn < b->devfn) return -1;
1546 else if (a->devfn > b->devfn) return 1;
1547
1548 return 0;
1549 }
1550
1551 void __init pci_sort_breadthfirst(void)
1552 {
1553 bus_sort_breadthfirst(&pci_bus_type, &pci_sort_bf_cmp);
1554 }
Linux kernel - Deliverables
This page took 0.064108 seconds and 5 git commands to generate.