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