Merge branch 'linus' into pci-for-jesse
[sfrench/cifs-2.6.git] / drivers / pci / probe.c
1 /*
2  * probe.c - PCI detection and setup code
3  */
4
5 #include <linux/kernel.h>
6 #include <linux/delay.h>
7 #include <linux/init.h>
8 #include <linux/pci.h>
9 #include <linux/slab.h>
10 #include <linux/module.h>
11 #include <linux/cpumask.h>
12 #include <linux/pci-aspm.h>
13 #include "pci.h"
14
15 #define CARDBUS_LATENCY_TIMER   176     /* secondary latency timer */
16 #define CARDBUS_RESERVE_BUSNR   3
17 #define PCI_CFG_SPACE_SIZE      256
18 #define PCI_CFG_SPACE_EXP_SIZE  4096
19
20 /* Ugh.  Need to stop exporting this to modules. */
21 LIST_HEAD(pci_root_buses);
22 EXPORT_SYMBOL(pci_root_buses);
23
24
25 static int find_anything(struct device *dev, void *data)
26 {
27         return 1;
28 }
29
30 /*
31  * Some device drivers need know if pci is initiated.
32  * Basically, we think pci is not initiated when there
33  * is no device to be found on the pci_bus_type.
34  */
35 int no_pci_devices(void)
36 {
37         struct device *dev;
38         int no_devices;
39
40         dev = bus_find_device(&pci_bus_type, NULL, NULL, find_anything);
41         no_devices = (dev == NULL);
42         put_device(dev);
43         return no_devices;
44 }
45 EXPORT_SYMBOL(no_pci_devices);
46
47 #ifdef HAVE_PCI_LEGACY
48 /**
49  * pci_create_legacy_files - create legacy I/O port and memory files
50  * @b: bus to create files under
51  *
52  * Some platforms allow access to legacy I/O port and ISA memory space on
53  * a per-bus basis.  This routine creates the files and ties them into
54  * their associated read, write and mmap files from pci-sysfs.c
55  */
56 static void pci_create_legacy_files(struct pci_bus *b)
57 {
58         b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2,
59                                GFP_ATOMIC);
60         if (b->legacy_io) {
61                 b->legacy_io->attr.name = "legacy_io";
62                 b->legacy_io->size = 0xffff;
63                 b->legacy_io->attr.mode = S_IRUSR | S_IWUSR;
64                 b->legacy_io->read = pci_read_legacy_io;
65                 b->legacy_io->write = pci_write_legacy_io;
66                 device_create_bin_file(&b->dev, b->legacy_io);
67
68                 /* Allocated above after the legacy_io struct */
69                 b->legacy_mem = b->legacy_io + 1;
70                 b->legacy_mem->attr.name = "legacy_mem";
71                 b->legacy_mem->size = 1024*1024;
72                 b->legacy_mem->attr.mode = S_IRUSR | S_IWUSR;
73                 b->legacy_mem->mmap = pci_mmap_legacy_mem;
74                 device_create_bin_file(&b->dev, b->legacy_mem);
75         }
76 }
77
78 void pci_remove_legacy_files(struct pci_bus *b)
79 {
80         if (b->legacy_io) {
81                 device_remove_bin_file(&b->dev, b->legacy_io);
82                 device_remove_bin_file(&b->dev, b->legacy_mem);
83                 kfree(b->legacy_io); /* both are allocated here */
84         }
85 }
86 #else /* !HAVE_PCI_LEGACY */
87 static inline void pci_create_legacy_files(struct pci_bus *bus) { return; }
88 void pci_remove_legacy_files(struct pci_bus *bus) { return; }
89 #endif /* HAVE_PCI_LEGACY */
90
91 /*
92  * PCI Bus Class Devices
93  */
94 static ssize_t pci_bus_show_cpuaffinity(struct device *dev,
95                                         int type,
96                                         struct device_attribute *attr,
97                                         char *buf)
98 {
99         int ret;
100         cpumask_t cpumask;
101
102         cpumask = pcibus_to_cpumask(to_pci_bus(dev));
103         ret = type?
104                 cpulist_scnprintf(buf, PAGE_SIZE-2, cpumask):
105                 cpumask_scnprintf(buf, PAGE_SIZE-2, cpumask);
106         buf[ret++] = '\n';
107         buf[ret] = '\0';
108         return ret;
109 }
110
111 static ssize_t inline pci_bus_show_cpumaskaffinity(struct device *dev,
112                                         struct device_attribute *attr,
113                                         char *buf)
114 {
115         return pci_bus_show_cpuaffinity(dev, 0, attr, buf);
116 }
117
118 static ssize_t inline pci_bus_show_cpulistaffinity(struct device *dev,
119                                         struct device_attribute *attr,
120                                         char *buf)
121 {
122         return pci_bus_show_cpuaffinity(dev, 1, attr, buf);
123 }
124
125 DEVICE_ATTR(cpuaffinity,     S_IRUGO, pci_bus_show_cpumaskaffinity, NULL);
126 DEVICE_ATTR(cpulistaffinity, S_IRUGO, pci_bus_show_cpulistaffinity, NULL);
127
128 /*
129  * PCI Bus Class
130  */
131 static void release_pcibus_dev(struct device *dev)
132 {
133         struct pci_bus *pci_bus = to_pci_bus(dev);
134
135         if (pci_bus->bridge)
136                 put_device(pci_bus->bridge);
137         kfree(pci_bus);
138 }
139
140 static struct class pcibus_class = {
141         .name           = "pci_bus",
142         .dev_release    = &release_pcibus_dev,
143 };
144
145 static int __init pcibus_class_init(void)
146 {
147         return class_register(&pcibus_class);
148 }
149 postcore_initcall(pcibus_class_init);
150
151 /*
152  * Translate the low bits of the PCI base
153  * to the resource type
154  */
155 static inline unsigned int pci_calc_resource_flags(unsigned int flags)
156 {
157         if (flags & PCI_BASE_ADDRESS_SPACE_IO)
158                 return IORESOURCE_IO;
159
160         if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
161                 return IORESOURCE_MEM | IORESOURCE_PREFETCH;
162
163         return IORESOURCE_MEM;
164 }
165
166 /*
167  * Find the extent of a PCI decode..
168  */
169 static u32 pci_size(u32 base, u32 maxbase, u32 mask)
170 {
171         u32 size = mask & maxbase;      /* Find the significant bits */
172         if (!size)
173                 return 0;
174
175         /* Get the lowest of them to find the decode size, and
176            from that the extent.  */
177         size = (size & ~(size-1)) - 1;
178
179         /* base == maxbase can be valid only if the BAR has
180            already been programmed with all 1s.  */
181         if (base == maxbase && ((base | size) & mask) != mask)
182                 return 0;
183
184         return size;
185 }
186
187 static u64 pci_size64(u64 base, u64 maxbase, u64 mask)
188 {
189         u64 size = mask & maxbase;      /* Find the significant bits */
190         if (!size)
191                 return 0;
192
193         /* Get the lowest of them to find the decode size, and
194            from that the extent.  */
195         size = (size & ~(size-1)) - 1;
196
197         /* base == maxbase can be valid only if the BAR has
198            already been programmed with all 1s.  */
199         if (base == maxbase && ((base | size) & mask) != mask)
200                 return 0;
201
202         return size;
203 }
204
205 static inline int is_64bit_memory(u32 mask)
206 {
207         if ((mask & (PCI_BASE_ADDRESS_SPACE|PCI_BASE_ADDRESS_MEM_TYPE_MASK)) ==
208             (PCI_BASE_ADDRESS_SPACE_MEMORY|PCI_BASE_ADDRESS_MEM_TYPE_64))
209                 return 1;
210         return 0;
211 }
212
213 static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
214 {
215         unsigned int pos, reg, next;
216         u32 l, sz;
217         struct resource *res;
218
219         for(pos=0; pos<howmany; pos = next) {
220                 u64 l64;
221                 u64 sz64;
222                 u32 raw_sz;
223
224                 next = pos+1;
225                 res = &dev->resource[pos];
226                 res->name = pci_name(dev);
227                 reg = PCI_BASE_ADDRESS_0 + (pos << 2);
228                 pci_read_config_dword(dev, reg, &l);
229                 pci_write_config_dword(dev, reg, ~0);
230                 pci_read_config_dword(dev, reg, &sz);
231                 pci_write_config_dword(dev, reg, l);
232                 if (!sz || sz == 0xffffffff)
233                         continue;
234                 if (l == 0xffffffff)
235                         l = 0;
236                 raw_sz = sz;
237                 if ((l & PCI_BASE_ADDRESS_SPACE) ==
238                                 PCI_BASE_ADDRESS_SPACE_MEMORY) {
239                         sz = pci_size(l, sz, (u32)PCI_BASE_ADDRESS_MEM_MASK);
240                         /*
241                          * For 64bit prefetchable memory sz could be 0, if the
242                          * real size is bigger than 4G, so we need to check
243                          * szhi for that.
244                          */
245                         if (!is_64bit_memory(l) && !sz)
246                                 continue;
247                         res->start = l & PCI_BASE_ADDRESS_MEM_MASK;
248                         res->flags |= l & ~PCI_BASE_ADDRESS_MEM_MASK;
249                 } else {
250                         sz = pci_size(l, sz, PCI_BASE_ADDRESS_IO_MASK & 0xffff);
251                         if (!sz)
252                                 continue;
253                         res->start = l & PCI_BASE_ADDRESS_IO_MASK;
254                         res->flags |= l & ~PCI_BASE_ADDRESS_IO_MASK;
255                 }
256                 res->end = res->start + (unsigned long) sz;
257                 res->flags |= pci_calc_resource_flags(l) | IORESOURCE_SIZEALIGN;
258                 if (is_64bit_memory(l)) {
259                         u32 szhi, lhi;
260
261                         pci_read_config_dword(dev, reg+4, &lhi);
262                         pci_write_config_dword(dev, reg+4, ~0);
263                         pci_read_config_dword(dev, reg+4, &szhi);
264                         pci_write_config_dword(dev, reg+4, lhi);
265                         sz64 = ((u64)szhi << 32) | raw_sz;
266                         l64 = ((u64)lhi << 32) | l;
267                         sz64 = pci_size64(l64, sz64, PCI_BASE_ADDRESS_MEM_MASK);
268                         next++;
269 #if BITS_PER_LONG == 64
270                         if (!sz64) {
271                                 res->start = 0;
272                                 res->end = 0;
273                                 res->flags = 0;
274                                 continue;
275                         }
276                         res->start = l64 & PCI_BASE_ADDRESS_MEM_MASK;
277                         res->end = res->start + sz64;
278                         printk(KERN_INFO "PCI: %s reg %x 64bit mmio: [%llx, %llx]\n", pci_name(dev), reg, res->start, res->end);
279 #else
280                         if (sz64 > 0x100000000ULL) {
281                                 dev_err(&dev->dev, "BAR %d: can't handle 64-bit"
282                                         " BAR\n", pos);
283                                 res->start = 0;
284                                 res->flags = 0;
285                         } else if (lhi) {
286                                 /* 64-bit wide address, treat as disabled */
287                                 pci_write_config_dword(dev, reg,
288                                         l & ~(u32)PCI_BASE_ADDRESS_MEM_MASK);
289                                 pci_write_config_dword(dev, reg+4, 0);
290                                 res->start = 0;
291                                 res->end = sz;
292                         }
293 #endif
294                 } else {
295                         printk(KERN_INFO "PCI: %s reg %x %s: [%llx, %llx]\n", pci_name(dev), reg, (res->flags & IORESOURCE_IO)? "io port":"32bit mmio", res->start, res->end);
296                 }
297         }
298         if (rom) {
299                 dev->rom_base_reg = rom;
300                 res = &dev->resource[PCI_ROM_RESOURCE];
301                 res->name = pci_name(dev);
302                 pci_read_config_dword(dev, rom, &l);
303                 pci_write_config_dword(dev, rom, ~PCI_ROM_ADDRESS_ENABLE);
304                 pci_read_config_dword(dev, rom, &sz);
305                 pci_write_config_dword(dev, rom, l);
306                 if (l == 0xffffffff)
307                         l = 0;
308                 if (sz && sz != 0xffffffff) {
309                         sz = pci_size(l, sz, (u32)PCI_ROM_ADDRESS_MASK);
310                         if (sz) {
311                                 res->flags = (l & IORESOURCE_ROM_ENABLE) |
312                                   IORESOURCE_MEM | IORESOURCE_PREFETCH |
313                                   IORESOURCE_READONLY | IORESOURCE_CACHEABLE |
314                                   IORESOURCE_SIZEALIGN;
315                                 res->start = l & PCI_ROM_ADDRESS_MASK;
316                                 res->end = res->start + (unsigned long) sz;
317                         }
318                 }
319         }
320 }
321
322 void __devinit pci_read_bridge_bases(struct pci_bus *child)
323 {
324         struct pci_dev *dev = child->self;
325         u8 io_base_lo, io_limit_lo;
326         u16 mem_base_lo, mem_limit_lo;
327         unsigned long base, limit;
328         struct resource *res;
329         int i;
330
331         if (!dev)               /* It's a host bus, nothing to read */
332                 return;
333
334         if (dev->transparent) {
335                 dev_info(&dev->dev, "transparent bridge\n");
336                 for(i = 3; i < PCI_BUS_NUM_RESOURCES; i++)
337                         child->resource[i] = child->parent->resource[i - 3];
338         }
339
340         for(i=0; i<3; i++)
341                 child->resource[i] = &dev->resource[PCI_BRIDGE_RESOURCES+i];
342
343         res = child->resource[0];
344         pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
345         pci_read_config_byte(dev, PCI_IO_LIMIT, &io_limit_lo);
346         base = (io_base_lo & PCI_IO_RANGE_MASK) << 8;
347         limit = (io_limit_lo & PCI_IO_RANGE_MASK) << 8;
348
349         if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
350                 u16 io_base_hi, io_limit_hi;
351                 pci_read_config_word(dev, PCI_IO_BASE_UPPER16, &io_base_hi);
352                 pci_read_config_word(dev, PCI_IO_LIMIT_UPPER16, &io_limit_hi);
353                 base |= (io_base_hi << 16);
354                 limit |= (io_limit_hi << 16);
355         }
356
357         if (base <= limit) {
358                 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
359                 if (!res->start)
360                         res->start = base;
361                 if (!res->end)
362                         res->end = limit + 0xfff;
363                 printk(KERN_INFO "PCI: bridge %s io port: [%llx, %llx]\n", pci_name(dev), res->start, res->end);
364         }
365
366         res = child->resource[1];
367         pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
368         pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
369         base = (mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
370         limit = (mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
371         if (base <= limit) {
372                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
373                 res->start = base;
374                 res->end = limit + 0xfffff;
375                 printk(KERN_INFO "PCI: bridge %s 32bit mmio: [%llx, %llx]\n", pci_name(dev), res->start, res->end);
376         }
377
378         res = child->resource[2];
379         pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
380         pci_read_config_word(dev, PCI_PREF_MEMORY_LIMIT, &mem_limit_lo);
381         base = (mem_base_lo & PCI_PREF_RANGE_MASK) << 16;
382         limit = (mem_limit_lo & PCI_PREF_RANGE_MASK) << 16;
383
384         if ((mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
385                 u32 mem_base_hi, mem_limit_hi;
386                 pci_read_config_dword(dev, PCI_PREF_BASE_UPPER32, &mem_base_hi);
387                 pci_read_config_dword(dev, PCI_PREF_LIMIT_UPPER32, &mem_limit_hi);
388
389                 /*
390                  * Some bridges set the base > limit by default, and some
391                  * (broken) BIOSes do not initialize them.  If we find
392                  * this, just assume they are not being used.
393                  */
394                 if (mem_base_hi <= mem_limit_hi) {
395 #if BITS_PER_LONG == 64
396                         base |= ((long) mem_base_hi) << 32;
397                         limit |= ((long) mem_limit_hi) << 32;
398 #else
399                         if (mem_base_hi || mem_limit_hi) {
400                                 dev_err(&dev->dev, "can't handle 64-bit "
401                                         "address space for bridge\n");
402                                 return;
403                         }
404 #endif
405                 }
406         }
407         if (base <= limit) {
408                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM | IORESOURCE_PREFETCH;
409                 res->start = base;
410                 res->end = limit + 0xfffff;
411                 printk(KERN_INFO "PCI: bridge %s %sbit mmio pref: [%llx, %llx]\n", pci_name(dev), (res->flags & PCI_PREF_RANGE_TYPE_64)?"64":"32",res->start, res->end);
412         }
413 }
414
415 static struct pci_bus * pci_alloc_bus(void)
416 {
417         struct pci_bus *b;
418
419         b = kzalloc(sizeof(*b), GFP_KERNEL);
420         if (b) {
421                 INIT_LIST_HEAD(&b->node);
422                 INIT_LIST_HEAD(&b->children);
423                 INIT_LIST_HEAD(&b->devices);
424                 INIT_LIST_HEAD(&b->slots);
425         }
426         return b;
427 }
428
429 static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
430                                            struct pci_dev *bridge, int busnr)
431 {
432         struct pci_bus *child;
433         int i;
434
435         /*
436          * Allocate a new bus, and inherit stuff from the parent..
437          */
438         child = pci_alloc_bus();
439         if (!child)
440                 return NULL;
441
442         child->self = bridge;
443         child->parent = parent;
444         child->ops = parent->ops;
445         child->sysdata = parent->sysdata;
446         child->bus_flags = parent->bus_flags;
447         child->bridge = get_device(&bridge->dev);
448
449         /* initialize some portions of the bus device, but don't register it
450          * now as the parent is not properly set up yet.  This device will get
451          * registered later in pci_bus_add_devices()
452          */
453         child->dev.class = &pcibus_class;
454         sprintf(child->dev.bus_id, "%04x:%02x", pci_domain_nr(child), busnr);
455
456         /*
457          * Set up the primary, secondary and subordinate
458          * bus numbers.
459          */
460         child->number = child->secondary = busnr;
461         child->primary = parent->secondary;
462         child->subordinate = 0xff;
463
464         /* Set up default resource pointers and names.. */
465         for (i = 0; i < 4; i++) {
466                 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
467                 child->resource[i]->name = child->name;
468         }
469         bridge->subordinate = child;
470
471         return child;
472 }
473
474 struct pci_bus *__ref pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr)
475 {
476         struct pci_bus *child;
477
478         child = pci_alloc_child_bus(parent, dev, busnr);
479         if (child) {
480                 down_write(&pci_bus_sem);
481                 list_add_tail(&child->node, &parent->children);
482                 up_write(&pci_bus_sem);
483         }
484         return child;
485 }
486
487 static void pci_fixup_parent_subordinate_busnr(struct pci_bus *child, int max)
488 {
489         struct pci_bus *parent = child->parent;
490
491         /* Attempts to fix that up are really dangerous unless
492            we're going to re-assign all bus numbers. */
493         if (!pcibios_assign_all_busses())
494                 return;
495
496         while (parent->parent && parent->subordinate < max) {
497                 parent->subordinate = max;
498                 pci_write_config_byte(parent->self, PCI_SUBORDINATE_BUS, max);
499                 parent = parent->parent;
500         }
501 }
502
503 /*
504  * If it's a bridge, configure it and scan the bus behind it.
505  * For CardBus bridges, we don't scan behind as the devices will
506  * be handled by the bridge driver itself.
507  *
508  * We need to process bridges in two passes -- first we scan those
509  * already configured by the BIOS and after we are done with all of
510  * them, we proceed to assigning numbers to the remaining buses in
511  * order to avoid overlaps between old and new bus numbers.
512  */
513 int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
514 {
515         struct pci_bus *child;
516         int is_cardbus = (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS);
517         u32 buses, i, j = 0;
518         u16 bctl;
519
520         pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
521
522         dev_dbg(&dev->dev, "scanning behind bridge, config %06x, pass %d\n",
523                 buses & 0xffffff, pass);
524
525         /* Disable MasterAbortMode during probing to avoid reporting
526            of bus errors (in some architectures) */ 
527         pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl);
528         pci_write_config_word(dev, PCI_BRIDGE_CONTROL,
529                               bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT);
530
531         if ((buses & 0xffff00) && !pcibios_assign_all_busses() && !is_cardbus) {
532                 unsigned int cmax, busnr;
533                 /*
534                  * Bus already configured by firmware, process it in the first
535                  * pass and just note the configuration.
536                  */
537                 if (pass)
538                         goto out;
539                 busnr = (buses >> 8) & 0xFF;
540
541                 /*
542                  * If we already got to this bus through a different bridge,
543                  * ignore it.  This can happen with the i450NX chipset.
544                  */
545                 if (pci_find_bus(pci_domain_nr(bus), busnr)) {
546                         dev_info(&dev->dev, "bus %04x:%02x already known\n",
547                                  pci_domain_nr(bus), busnr);
548                         goto out;
549                 }
550
551                 child = pci_add_new_bus(bus, dev, busnr);
552                 if (!child)
553                         goto out;
554                 child->primary = buses & 0xFF;
555                 child->subordinate = (buses >> 16) & 0xFF;
556                 child->bridge_ctl = bctl;
557
558                 cmax = pci_scan_child_bus(child);
559                 if (cmax > max)
560                         max = cmax;
561                 if (child->subordinate > max)
562                         max = child->subordinate;
563         } else {
564                 /*
565                  * We need to assign a number to this bus which we always
566                  * do in the second pass.
567                  */
568                 if (!pass) {
569                         if (pcibios_assign_all_busses())
570                                 /* Temporarily disable forwarding of the
571                                    configuration cycles on all bridges in
572                                    this bus segment to avoid possible
573                                    conflicts in the second pass between two
574                                    bridges programmed with overlapping
575                                    bus ranges. */
576                                 pci_write_config_dword(dev, PCI_PRIMARY_BUS,
577                                                        buses & ~0xffffff);
578                         goto out;
579                 }
580
581                 /* Clear errors */
582                 pci_write_config_word(dev, PCI_STATUS, 0xffff);
583
584                 /* Prevent assigning a bus number that already exists.
585                  * This can happen when a bridge is hot-plugged */
586                 if (pci_find_bus(pci_domain_nr(bus), max+1))
587                         goto out;
588                 child = pci_add_new_bus(bus, dev, ++max);
589                 buses = (buses & 0xff000000)
590                       | ((unsigned int)(child->primary)     <<  0)
591                       | ((unsigned int)(child->secondary)   <<  8)
592                       | ((unsigned int)(child->subordinate) << 16);
593
594                 /*
595                  * yenta.c forces a secondary latency timer of 176.
596                  * Copy that behaviour here.
597                  */
598                 if (is_cardbus) {
599                         buses &= ~0xff000000;
600                         buses |= CARDBUS_LATENCY_TIMER << 24;
601                 }
602                         
603                 /*
604                  * We need to blast all three values with a single write.
605                  */
606                 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
607
608                 if (!is_cardbus) {
609                         child->bridge_ctl = bctl;
610                         /*
611                          * Adjust subordinate busnr in parent buses.
612                          * We do this before scanning for children because
613                          * some devices may not be detected if the bios
614                          * was lazy.
615                          */
616                         pci_fixup_parent_subordinate_busnr(child, max);
617                         /* Now we can scan all subordinate buses... */
618                         max = pci_scan_child_bus(child);
619                         /*
620                          * now fix it up again since we have found
621                          * the real value of max.
622                          */
623                         pci_fixup_parent_subordinate_busnr(child, max);
624                 } else {
625                         /*
626                          * For CardBus bridges, we leave 4 bus numbers
627                          * as cards with a PCI-to-PCI bridge can be
628                          * inserted later.
629                          */
630                         for (i=0; i<CARDBUS_RESERVE_BUSNR; i++) {
631                                 struct pci_bus *parent = bus;
632                                 if (pci_find_bus(pci_domain_nr(bus),
633                                                         max+i+1))
634                                         break;
635                                 while (parent->parent) {
636                                         if ((!pcibios_assign_all_busses()) &&
637                                             (parent->subordinate > max) &&
638                                             (parent->subordinate <= max+i)) {
639                                                 j = 1;
640                                         }
641                                         parent = parent->parent;
642                                 }
643                                 if (j) {
644                                         /*
645                                          * Often, there are two cardbus bridges
646                                          * -- try to leave one valid bus number
647                                          * for each one.
648                                          */
649                                         i /= 2;
650                                         break;
651                                 }
652                         }
653                         max += i;
654                         pci_fixup_parent_subordinate_busnr(child, max);
655                 }
656                 /*
657                  * Set the subordinate bus number to its real value.
658                  */
659                 child->subordinate = max;
660                 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
661         }
662
663         sprintf(child->name,
664                 (is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"),
665                 pci_domain_nr(bus), child->number);
666
667         /* Has only triggered on CardBus, fixup is in yenta_socket */
668         while (bus->parent) {
669                 if ((child->subordinate > bus->subordinate) ||
670                     (child->number > bus->subordinate) ||
671                     (child->number < bus->number) ||
672                     (child->subordinate < bus->number)) {
673                         pr_debug("PCI: Bus #%02x (-#%02x) is %s "
674                                 "hidden behind%s bridge #%02x (-#%02x)\n",
675                                 child->number, child->subordinate,
676                                 (bus->number > child->subordinate &&
677                                  bus->subordinate < child->number) ?
678                                         "wholly" : "partially",
679                                 bus->self->transparent ? " transparent" : "",
680                                 bus->number, bus->subordinate);
681                 }
682                 bus = bus->parent;
683         }
684
685 out:
686         pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
687
688         return max;
689 }
690
691 /*
692  * Read interrupt line and base address registers.
693  * The architecture-dependent code can tweak these, of course.
694  */
695 static void pci_read_irq(struct pci_dev *dev)
696 {
697         unsigned char irq;
698
699         pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq);
700         dev->pin = irq;
701         if (irq)
702                 pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
703         dev->irq = irq;
704 }
705
706 #define LEGACY_IO_RESOURCE      (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
707
708 /**
709  * pci_setup_device - fill in class and map information of a device
710  * @dev: the device structure to fill
711  *
712  * Initialize the device structure with information about the device's 
713  * vendor,class,memory and IO-space addresses,IRQ lines etc.
714  * Called at initialisation of the PCI subsystem and by CardBus services.
715  * Returns 0 on success and -1 if unknown type of device (not normal, bridge
716  * or CardBus).
717  */
718 static int pci_setup_device(struct pci_dev * dev)
719 {
720         u32 class;
721
722         dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
723                      dev->bus->number, PCI_SLOT(dev->devfn),
724                      PCI_FUNC(dev->devfn));
725
726         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
727         dev->revision = class & 0xff;
728         class >>= 8;                                /* upper 3 bytes */
729         dev->class = class;
730         class >>= 8;
731
732         dev_dbg(&dev->dev, "found [%04x/%04x] class %06x header type %02x\n",
733                  dev->vendor, dev->device, class, dev->hdr_type);
734
735         /* "Unknown power state" */
736         dev->current_state = PCI_UNKNOWN;
737
738         /* Early fixups, before probing the BARs */
739         pci_fixup_device(pci_fixup_early, dev);
740         class = dev->class >> 8;
741
742         switch (dev->hdr_type) {                    /* header type */
743         case PCI_HEADER_TYPE_NORMAL:                /* standard header */
744                 if (class == PCI_CLASS_BRIDGE_PCI)
745                         goto bad;
746                 pci_read_irq(dev);
747                 pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
748                 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
749                 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
750
751                 /*
752                  *      Do the ugly legacy mode stuff here rather than broken chip
753                  *      quirk code. Legacy mode ATA controllers have fixed
754                  *      addresses. These are not always echoed in BAR0-3, and
755                  *      BAR0-3 in a few cases contain junk!
756                  */
757                 if (class == PCI_CLASS_STORAGE_IDE) {
758                         u8 progif;
759                         pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
760                         if ((progif & 1) == 0) {
761                                 dev->resource[0].start = 0x1F0;
762                                 dev->resource[0].end = 0x1F7;
763                                 dev->resource[0].flags = LEGACY_IO_RESOURCE;
764                                 dev->resource[1].start = 0x3F6;
765                                 dev->resource[1].end = 0x3F6;
766                                 dev->resource[1].flags = LEGACY_IO_RESOURCE;
767                         }
768                         if ((progif & 4) == 0) {
769                                 dev->resource[2].start = 0x170;
770                                 dev->resource[2].end = 0x177;
771                                 dev->resource[2].flags = LEGACY_IO_RESOURCE;
772                                 dev->resource[3].start = 0x376;
773                                 dev->resource[3].end = 0x376;
774                                 dev->resource[3].flags = LEGACY_IO_RESOURCE;
775                         }
776                 }
777                 break;
778
779         case PCI_HEADER_TYPE_BRIDGE:                /* bridge header */
780                 if (class != PCI_CLASS_BRIDGE_PCI)
781                         goto bad;
782                 /* The PCI-to-PCI bridge spec requires that subtractive
783                    decoding (i.e. transparent) bridge must have programming
784                    interface code of 0x01. */ 
785                 pci_read_irq(dev);
786                 dev->transparent = ((dev->class & 0xff) == 1);
787                 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
788                 break;
789
790         case PCI_HEADER_TYPE_CARDBUS:               /* CardBus bridge header */
791                 if (class != PCI_CLASS_BRIDGE_CARDBUS)
792                         goto bad;
793                 pci_read_irq(dev);
794                 pci_read_bases(dev, 1, 0);
795                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
796                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device);
797                 break;
798
799         default:                                    /* unknown header */
800                 dev_err(&dev->dev, "unknown header type %02x, "
801                         "ignoring device\n", dev->hdr_type);
802                 return -1;
803
804         bad:
805                 dev_err(&dev->dev, "ignoring class %02x (doesn't match header "
806                         "type %02x)\n", class, dev->hdr_type);
807                 dev->class = PCI_CLASS_NOT_DEFINED;
808         }
809
810         /* We found a fine healthy device, go go go... */
811         return 0;
812 }
813
814 /**
815  * pci_release_dev - free a pci device structure when all users of it are finished.
816  * @dev: device that's been disconnected
817  *
818  * Will be called only by the device core when all users of this pci device are
819  * done.
820  */
821 static void pci_release_dev(struct device *dev)
822 {
823         struct pci_dev *pci_dev;
824
825         pci_dev = to_pci_dev(dev);
826         pci_vpd_release(pci_dev);
827         kfree(pci_dev);
828 }
829
830 static void set_pcie_port_type(struct pci_dev *pdev)
831 {
832         int pos;
833         u16 reg16;
834
835         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
836         if (!pos)
837                 return;
838         pdev->is_pcie = 1;
839         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
840         pdev->pcie_type = (reg16 & PCI_EXP_FLAGS_TYPE) >> 4;
841 }
842
843 /**
844  * pci_cfg_space_size - get the configuration space size of the PCI device.
845  * @dev: PCI device
846  *
847  * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices
848  * have 4096 bytes.  Even if the device is capable, that doesn't mean we can
849  * access it.  Maybe we don't have a way to generate extended config space
850  * accesses, or the device is behind a reverse Express bridge.  So we try
851  * reading the dword at 0x100 which must either be 0 or a valid extended
852  * capability header.
853  */
854 int pci_cfg_space_size_ext(struct pci_dev *dev)
855 {
856         u32 status;
857
858         if (pci_read_config_dword(dev, 256, &status) != PCIBIOS_SUCCESSFUL)
859                 goto fail;
860         if (status == 0xffffffff)
861                 goto fail;
862
863         return PCI_CFG_SPACE_EXP_SIZE;
864
865  fail:
866         return PCI_CFG_SPACE_SIZE;
867 }
868
869 int pci_cfg_space_size(struct pci_dev *dev)
870 {
871         int pos;
872         u32 status;
873
874         pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
875         if (!pos) {
876                 pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
877                 if (!pos)
878                         goto fail;
879
880                 pci_read_config_dword(dev, pos + PCI_X_STATUS, &status);
881                 if (!(status & (PCI_X_STATUS_266MHZ | PCI_X_STATUS_533MHZ)))
882                         goto fail;
883         }
884
885         return pci_cfg_space_size_ext(dev);
886
887  fail:
888         return PCI_CFG_SPACE_SIZE;
889 }
890
891 static void pci_release_bus_bridge_dev(struct device *dev)
892 {
893         kfree(dev);
894 }
895
896 struct pci_dev *alloc_pci_dev(void)
897 {
898         struct pci_dev *dev;
899
900         dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
901         if (!dev)
902                 return NULL;
903
904         INIT_LIST_HEAD(&dev->bus_list);
905
906         pci_msi_init_pci_dev(dev);
907
908         return dev;
909 }
910 EXPORT_SYMBOL(alloc_pci_dev);
911
912 /*
913  * Read the config data for a PCI device, sanity-check it
914  * and fill in the dev structure...
915  */
916 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
917 {
918         struct pci_dev *dev;
919         u32 l;
920         u8 hdr_type;
921         int delay = 1;
922
923         if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
924                 return NULL;
925
926         /* some broken boards return 0 or ~0 if a slot is empty: */
927         if (l == 0xffffffff || l == 0x00000000 ||
928             l == 0x0000ffff || l == 0xffff0000)
929                 return NULL;
930
931         /* Configuration request Retry Status */
932         while (l == 0xffff0001) {
933                 msleep(delay);
934                 delay *= 2;
935                 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
936                         return NULL;
937                 /* Card hasn't responded in 60 seconds?  Must be stuck. */
938                 if (delay > 60 * 1000) {
939                         printk(KERN_WARNING "pci %04x:%02x:%02x.%d: not "
940                                         "responding\n", pci_domain_nr(bus),
941                                         bus->number, PCI_SLOT(devfn),
942                                         PCI_FUNC(devfn));
943                         return NULL;
944                 }
945         }
946
947         if (pci_bus_read_config_byte(bus, devfn, PCI_HEADER_TYPE, &hdr_type))
948                 return NULL;
949
950         dev = alloc_pci_dev();
951         if (!dev)
952                 return NULL;
953
954         dev->bus = bus;
955         dev->sysdata = bus->sysdata;
956         dev->dev.parent = bus->bridge;
957         dev->dev.bus = &pci_bus_type;
958         dev->devfn = devfn;
959         dev->hdr_type = hdr_type & 0x7f;
960         dev->multifunction = !!(hdr_type & 0x80);
961         dev->vendor = l & 0xffff;
962         dev->device = (l >> 16) & 0xffff;
963         dev->cfg_size = pci_cfg_space_size(dev);
964         dev->error_state = pci_channel_io_normal;
965         set_pcie_port_type(dev);
966
967         /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
968            set this higher, assuming the system even supports it.  */
969         dev->dma_mask = 0xffffffff;
970         if (pci_setup_device(dev) < 0) {
971                 kfree(dev);
972                 return NULL;
973         }
974
975         pci_vpd_pci22_init(dev);
976
977         return dev;
978 }
979
980 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
981 {
982         device_initialize(&dev->dev);
983         dev->dev.release = pci_release_dev;
984         pci_dev_get(dev);
985
986         dev->dev.dma_mask = &dev->dma_mask;
987         dev->dev.dma_parms = &dev->dma_parms;
988         dev->dev.coherent_dma_mask = 0xffffffffull;
989
990         pci_set_dma_max_seg_size(dev, 65536);
991         pci_set_dma_seg_boundary(dev, 0xffffffff);
992
993         /* Fix up broken headers */
994         pci_fixup_device(pci_fixup_header, dev);
995
996         /* Initialize power management of the device */
997         pci_pm_init(dev);
998
999         /*
1000          * Add the device to our list of discovered devices
1001          * and the bus list for fixup functions, etc.
1002          */
1003         down_write(&pci_bus_sem);
1004         list_add_tail(&dev->bus_list, &bus->devices);
1005         up_write(&pci_bus_sem);
1006 }
1007
1008 struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
1009 {
1010         struct pci_dev *dev;
1011
1012         dev = pci_scan_device(bus, devfn);
1013         if (!dev)
1014                 return NULL;
1015
1016         pci_device_add(dev, bus);
1017
1018         return dev;
1019 }
1020 EXPORT_SYMBOL(pci_scan_single_device);
1021
1022 /**
1023  * pci_scan_slot - scan a PCI slot on a bus for devices.
1024  * @bus: PCI bus to scan
1025  * @devfn: slot number to scan (must have zero function.)
1026  *
1027  * Scan a PCI slot on the specified PCI bus for devices, adding
1028  * discovered devices to the @bus->devices list.  New devices
1029  * will not have is_added set.
1030  */
1031 int pci_scan_slot(struct pci_bus *bus, int devfn)
1032 {
1033         int func, nr = 0;
1034         int scan_all_fns;
1035
1036         scan_all_fns = pcibios_scan_all_fns(bus, devfn);
1037
1038         for (func = 0; func < 8; func++, devfn++) {
1039                 struct pci_dev *dev;
1040
1041                 dev = pci_scan_single_device(bus, devfn);
1042                 if (dev) {
1043                         nr++;
1044
1045                         /*
1046                          * If this is a single function device,
1047                          * don't scan past the first function.
1048                          */
1049                         if (!dev->multifunction) {
1050                                 if (func > 0) {
1051                                         dev->multifunction = 1;
1052                                 } else {
1053                                         break;
1054                                 }
1055                         }
1056                 } else {
1057                         if (func == 0 && !scan_all_fns)
1058                                 break;
1059                 }
1060         }
1061
1062         if (bus->self)
1063                 pcie_aspm_init_link_state(bus->self);
1064
1065         return nr;
1066 }
1067
1068 unsigned int __devinit pci_scan_child_bus(struct pci_bus *bus)
1069 {
1070         unsigned int devfn, pass, max = bus->secondary;
1071         struct pci_dev *dev;
1072
1073         pr_debug("PCI: Scanning bus %04x:%02x\n", pci_domain_nr(bus), bus->number);
1074
1075         /* Go find them, Rover! */
1076         for (devfn = 0; devfn < 0x100; devfn += 8)
1077                 pci_scan_slot(bus, devfn);
1078
1079         /*
1080          * After performing arch-dependent fixup of the bus, look behind
1081          * all PCI-to-PCI bridges on this bus.
1082          */
1083         pr_debug("PCI: Fixups for bus %04x:%02x\n", pci_domain_nr(bus), bus->number);
1084         pcibios_fixup_bus(bus);
1085         for (pass=0; pass < 2; pass++)
1086                 list_for_each_entry(dev, &bus->devices, bus_list) {
1087                         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1088                             dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1089                                 max = pci_scan_bridge(bus, dev, max, pass);
1090                 }
1091
1092         /*
1093          * We've scanned the bus and so we know all about what's on
1094          * the other side of any bridges that may be on this bus plus
1095          * any devices.
1096          *
1097          * Return how far we've got finding sub-buses.
1098          */
1099         pr_debug("PCI: Bus scan for %04x:%02x returning with max=%02x\n",
1100                 pci_domain_nr(bus), bus->number, max);
1101         return max;
1102 }
1103
1104 void __attribute__((weak)) set_pci_bus_resources_arch_default(struct pci_bus *b)
1105 {
1106 }
1107
1108 struct pci_bus * pci_create_bus(struct device *parent,
1109                 int bus, struct pci_ops *ops, void *sysdata)
1110 {
1111         int error;
1112         struct pci_bus *b;
1113         struct device *dev;
1114
1115         b = pci_alloc_bus();
1116         if (!b)
1117                 return NULL;
1118
1119         dev = kmalloc(sizeof(*dev), GFP_KERNEL);
1120         if (!dev){
1121                 kfree(b);
1122                 return NULL;
1123         }
1124
1125         b->sysdata = sysdata;
1126         b->ops = ops;
1127
1128         if (pci_find_bus(pci_domain_nr(b), bus)) {
1129                 /* If we already got to this bus through a different bridge, ignore it */
1130                 pr_debug("PCI: Bus %04x:%02x already known\n", pci_domain_nr(b), bus);
1131                 goto err_out;
1132         }
1133
1134         down_write(&pci_bus_sem);
1135         list_add_tail(&b->node, &pci_root_buses);
1136         up_write(&pci_bus_sem);
1137
1138         memset(dev, 0, sizeof(*dev));
1139         dev->parent = parent;
1140         dev->release = pci_release_bus_bridge_dev;
1141         sprintf(dev->bus_id, "pci%04x:%02x", pci_domain_nr(b), bus);
1142         error = device_register(dev);
1143         if (error)
1144                 goto dev_reg_err;
1145         b->bridge = get_device(dev);
1146
1147         if (!parent)
1148                 set_dev_node(b->bridge, pcibus_to_node(b));
1149
1150         b->dev.class = &pcibus_class;
1151         b->dev.parent = b->bridge;
1152         sprintf(b->dev.bus_id, "%04x:%02x", pci_domain_nr(b), bus);
1153         error = device_register(&b->dev);
1154         if (error)
1155                 goto class_dev_reg_err;
1156         error = device_create_file(&b->dev, &dev_attr_cpuaffinity);
1157         if (error)
1158                 goto dev_create_file_err;
1159
1160         /* Create legacy_io and legacy_mem files for this bus */
1161         pci_create_legacy_files(b);
1162
1163         b->number = b->secondary = bus;
1164         b->resource[0] = &ioport_resource;
1165         b->resource[1] = &iomem_resource;
1166
1167         set_pci_bus_resources_arch_default(b);
1168
1169         return b;
1170
1171 dev_create_file_err:
1172         device_unregister(&b->dev);
1173 class_dev_reg_err:
1174         device_unregister(dev);
1175 dev_reg_err:
1176         down_write(&pci_bus_sem);
1177         list_del(&b->node);
1178         up_write(&pci_bus_sem);
1179 err_out:
1180         kfree(dev);
1181         kfree(b);
1182         return NULL;
1183 }
1184
1185 struct pci_bus * __devinit pci_scan_bus_parented(struct device *parent,
1186                 int bus, struct pci_ops *ops, void *sysdata)
1187 {
1188         struct pci_bus *b;
1189
1190         b = pci_create_bus(parent, bus, ops, sysdata);
1191         if (b)
1192                 b->subordinate = pci_scan_child_bus(b);
1193         return b;
1194 }
1195 EXPORT_SYMBOL(pci_scan_bus_parented);
1196
1197 #ifdef CONFIG_HOTPLUG
1198 EXPORT_SYMBOL(pci_add_new_bus);
1199 EXPORT_SYMBOL(pci_scan_slot);
1200 EXPORT_SYMBOL(pci_scan_bridge);
1201 EXPORT_SYMBOL_GPL(pci_scan_child_bus);
1202 #endif
1203
1204 static int __init pci_sort_bf_cmp(const struct pci_dev *a, const struct pci_dev *b)
1205 {
1206         if      (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
1207         else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return  1;
1208
1209         if      (a->bus->number < b->bus->number) return -1;
1210         else if (a->bus->number > b->bus->number) return  1;
1211
1212         if      (a->devfn < b->devfn) return -1;
1213         else if (a->devfn > b->devfn) return  1;
1214
1215         return 0;
1216 }
1217
1218 /*
1219  * Yes, this forcably breaks the klist abstraction temporarily.  It
1220  * just wants to sort the klist, not change reference counts and
1221  * take/drop locks rapidly in the process.  It does all this while
1222  * holding the lock for the list, so objects can't otherwise be
1223  * added/removed while we're swizzling.
1224  */
1225 static void __init pci_insertion_sort_klist(struct pci_dev *a, struct list_head *list)
1226 {
1227         struct list_head *pos;
1228         struct klist_node *n;
1229         struct device *dev;
1230         struct pci_dev *b;
1231
1232         list_for_each(pos, list) {
1233                 n = container_of(pos, struct klist_node, n_node);
1234                 dev = container_of(n, struct device, knode_bus);
1235                 b = to_pci_dev(dev);
1236                 if (pci_sort_bf_cmp(a, b) <= 0) {
1237                         list_move_tail(&a->dev.knode_bus.n_node, &b->dev.knode_bus.n_node);
1238                         return;
1239                 }
1240         }
1241         list_move_tail(&a->dev.knode_bus.n_node, list);
1242 }
1243
1244 void __init pci_sort_breadthfirst(void)
1245 {
1246         LIST_HEAD(sorted_devices);
1247         struct list_head *pos, *tmp;
1248         struct klist_node *n;
1249         struct device *dev;
1250         struct pci_dev *pdev;
1251         struct klist *device_klist;
1252
1253         device_klist = bus_get_device_klist(&pci_bus_type);
1254
1255         spin_lock(&device_klist->k_lock);
1256         list_for_each_safe(pos, tmp, &device_klist->k_list) {
1257                 n = container_of(pos, struct klist_node, n_node);
1258                 dev = container_of(n, struct device, knode_bus);
1259                 pdev = to_pci_dev(dev);
1260                 pci_insertion_sort_klist(pdev, &sorted_devices);
1261         }
1262         list_splice(&sorted_devices, &device_klist->k_list);
1263         spin_unlock(&device_klist->k_lock);
1264 }