Merge branch 'pci/sparc'
[muen/linux.git] / drivers / pci / probe.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * PCI detection and setup code
4  */
5
6 #include <linux/kernel.h>
7 #include <linux/delay.h>
8 #include <linux/init.h>
9 #include <linux/pci.h>
10 #include <linux/of_device.h>
11 #include <linux/of_pci.h>
12 #include <linux/pci_hotplug.h>
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <linux/cpumask.h>
16 #include <linux/pci-aspm.h>
17 #include <linux/aer.h>
18 #include <linux/acpi.h>
19 #include <linux/irqdomain.h>
20 #include <linux/pm_runtime.h>
21 #include "pci.h"
22
23 #define CARDBUS_LATENCY_TIMER   176     /* secondary latency timer */
24 #define CARDBUS_RESERVE_BUSNR   3
25
26 static struct resource busn_resource = {
27         .name   = "PCI busn",
28         .start  = 0,
29         .end    = 255,
30         .flags  = IORESOURCE_BUS,
31 };
32
33 /* Ugh.  Need to stop exporting this to modules. */
34 LIST_HEAD(pci_root_buses);
35 EXPORT_SYMBOL(pci_root_buses);
36
37 static LIST_HEAD(pci_domain_busn_res_list);
38
39 struct pci_domain_busn_res {
40         struct list_head list;
41         struct resource res;
42         int domain_nr;
43 };
44
45 static struct resource *get_pci_domain_busn_res(int domain_nr)
46 {
47         struct pci_domain_busn_res *r;
48
49         list_for_each_entry(r, &pci_domain_busn_res_list, list)
50                 if (r->domain_nr == domain_nr)
51                         return &r->res;
52
53         r = kzalloc(sizeof(*r), GFP_KERNEL);
54         if (!r)
55                 return NULL;
56
57         r->domain_nr = domain_nr;
58         r->res.start = 0;
59         r->res.end = 0xff;
60         r->res.flags = IORESOURCE_BUS | IORESOURCE_PCI_FIXED;
61
62         list_add_tail(&r->list, &pci_domain_busn_res_list);
63
64         return &r->res;
65 }
66
67 static int find_anything(struct device *dev, void *data)
68 {
69         return 1;
70 }
71
72 /*
73  * Some device drivers need know if PCI is initiated.
74  * Basically, we think PCI is not initiated when there
75  * is no device to be found on the pci_bus_type.
76  */
77 int no_pci_devices(void)
78 {
79         struct device *dev;
80         int no_devices;
81
82         dev = bus_find_device(&pci_bus_type, NULL, NULL, find_anything);
83         no_devices = (dev == NULL);
84         put_device(dev);
85         return no_devices;
86 }
87 EXPORT_SYMBOL(no_pci_devices);
88
89 /*
90  * PCI Bus Class
91  */
92 static void release_pcibus_dev(struct device *dev)
93 {
94         struct pci_bus *pci_bus = to_pci_bus(dev);
95
96         put_device(pci_bus->bridge);
97         pci_bus_remove_resources(pci_bus);
98         pci_release_bus_of_node(pci_bus);
99         kfree(pci_bus);
100 }
101
102 static struct class pcibus_class = {
103         .name           = "pci_bus",
104         .dev_release    = &release_pcibus_dev,
105         .dev_groups     = pcibus_groups,
106 };
107
108 static int __init pcibus_class_init(void)
109 {
110         return class_register(&pcibus_class);
111 }
112 postcore_initcall(pcibus_class_init);
113
114 static u64 pci_size(u64 base, u64 maxbase, u64 mask)
115 {
116         u64 size = mask & maxbase;      /* Find the significant bits */
117         if (!size)
118                 return 0;
119
120         /*
121          * Get the lowest of them to find the decode size, and from that
122          * the extent.
123          */
124         size = (size & ~(size-1)) - 1;
125
126         /*
127          * base == maxbase can be valid only if the BAR has already been
128          * programmed with all 1s.
129          */
130         if (base == maxbase && ((base | size) & mask) != mask)
131                 return 0;
132
133         return size;
134 }
135
136 static inline unsigned long decode_bar(struct pci_dev *dev, u32 bar)
137 {
138         u32 mem_type;
139         unsigned long flags;
140
141         if ((bar & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO) {
142                 flags = bar & ~PCI_BASE_ADDRESS_IO_MASK;
143                 flags |= IORESOURCE_IO;
144                 return flags;
145         }
146
147         flags = bar & ~PCI_BASE_ADDRESS_MEM_MASK;
148         flags |= IORESOURCE_MEM;
149         if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
150                 flags |= IORESOURCE_PREFETCH;
151
152         mem_type = bar & PCI_BASE_ADDRESS_MEM_TYPE_MASK;
153         switch (mem_type) {
154         case PCI_BASE_ADDRESS_MEM_TYPE_32:
155                 break;
156         case PCI_BASE_ADDRESS_MEM_TYPE_1M:
157                 /* 1M mem BAR treated as 32-bit BAR */
158                 break;
159         case PCI_BASE_ADDRESS_MEM_TYPE_64:
160                 flags |= IORESOURCE_MEM_64;
161                 break;
162         default:
163                 /* mem unknown type treated as 32-bit BAR */
164                 break;
165         }
166         return flags;
167 }
168
169 #define PCI_COMMAND_DECODE_ENABLE       (PCI_COMMAND_MEMORY | PCI_COMMAND_IO)
170
171 /**
172  * pci_read_base - Read a PCI BAR
173  * @dev: the PCI device
174  * @type: type of the BAR
175  * @res: resource buffer to be filled in
176  * @pos: BAR position in the config space
177  *
178  * Returns 1 if the BAR is 64-bit, or 0 if 32-bit.
179  */
180 int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
181                     struct resource *res, unsigned int pos)
182 {
183         u32 l = 0, sz = 0, mask;
184         u64 l64, sz64, mask64;
185         u16 orig_cmd;
186         struct pci_bus_region region, inverted_region;
187
188         mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
189
190         /* No printks while decoding is disabled! */
191         if (!dev->mmio_always_on) {
192                 pci_read_config_word(dev, PCI_COMMAND, &orig_cmd);
193                 if (orig_cmd & PCI_COMMAND_DECODE_ENABLE) {
194                         pci_write_config_word(dev, PCI_COMMAND,
195                                 orig_cmd & ~PCI_COMMAND_DECODE_ENABLE);
196                 }
197         }
198
199         res->name = pci_name(dev);
200
201         pci_read_config_dword(dev, pos, &l);
202         pci_write_config_dword(dev, pos, l | mask);
203         pci_read_config_dword(dev, pos, &sz);
204         pci_write_config_dword(dev, pos, l);
205
206         /*
207          * All bits set in sz means the device isn't working properly.
208          * If the BAR isn't implemented, all bits must be 0.  If it's a
209          * memory BAR or a ROM, bit 0 must be clear; if it's an io BAR, bit
210          * 1 must be clear.
211          */
212         if (sz == 0xffffffff)
213                 sz = 0;
214
215         /*
216          * I don't know how l can have all bits set.  Copied from old code.
217          * Maybe it fixes a bug on some ancient platform.
218          */
219         if (l == 0xffffffff)
220                 l = 0;
221
222         if (type == pci_bar_unknown) {
223                 res->flags = decode_bar(dev, l);
224                 res->flags |= IORESOURCE_SIZEALIGN;
225                 if (res->flags & IORESOURCE_IO) {
226                         l64 = l & PCI_BASE_ADDRESS_IO_MASK;
227                         sz64 = sz & PCI_BASE_ADDRESS_IO_MASK;
228                         mask64 = PCI_BASE_ADDRESS_IO_MASK & (u32)IO_SPACE_LIMIT;
229                 } else {
230                         l64 = l & PCI_BASE_ADDRESS_MEM_MASK;
231                         sz64 = sz & PCI_BASE_ADDRESS_MEM_MASK;
232                         mask64 = (u32)PCI_BASE_ADDRESS_MEM_MASK;
233                 }
234         } else {
235                 if (l & PCI_ROM_ADDRESS_ENABLE)
236                         res->flags |= IORESOURCE_ROM_ENABLE;
237                 l64 = l & PCI_ROM_ADDRESS_MASK;
238                 sz64 = sz & PCI_ROM_ADDRESS_MASK;
239                 mask64 = PCI_ROM_ADDRESS_MASK;
240         }
241
242         if (res->flags & IORESOURCE_MEM_64) {
243                 pci_read_config_dword(dev, pos + 4, &l);
244                 pci_write_config_dword(dev, pos + 4, ~0);
245                 pci_read_config_dword(dev, pos + 4, &sz);
246                 pci_write_config_dword(dev, pos + 4, l);
247
248                 l64 |= ((u64)l << 32);
249                 sz64 |= ((u64)sz << 32);
250                 mask64 |= ((u64)~0 << 32);
251         }
252
253         if (!dev->mmio_always_on && (orig_cmd & PCI_COMMAND_DECODE_ENABLE))
254                 pci_write_config_word(dev, PCI_COMMAND, orig_cmd);
255
256         if (!sz64)
257                 goto fail;
258
259         sz64 = pci_size(l64, sz64, mask64);
260         if (!sz64) {
261                 pci_info(dev, FW_BUG "reg 0x%x: invalid BAR (can't size)\n",
262                          pos);
263                 goto fail;
264         }
265
266         if (res->flags & IORESOURCE_MEM_64) {
267                 if ((sizeof(pci_bus_addr_t) < 8 || sizeof(resource_size_t) < 8)
268                     && sz64 > 0x100000000ULL) {
269                         res->flags |= IORESOURCE_UNSET | IORESOURCE_DISABLED;
270                         res->start = 0;
271                         res->end = 0;
272                         pci_err(dev, "reg 0x%x: can't handle BAR larger than 4GB (size %#010llx)\n",
273                                 pos, (unsigned long long)sz64);
274                         goto out;
275                 }
276
277                 if ((sizeof(pci_bus_addr_t) < 8) && l) {
278                         /* Above 32-bit boundary; try to reallocate */
279                         res->flags |= IORESOURCE_UNSET;
280                         res->start = 0;
281                         res->end = sz64;
282                         pci_info(dev, "reg 0x%x: can't handle BAR above 4GB (bus address %#010llx)\n",
283                                  pos, (unsigned long long)l64);
284                         goto out;
285                 }
286         }
287
288         region.start = l64;
289         region.end = l64 + sz64;
290
291         pcibios_bus_to_resource(dev->bus, res, &region);
292         pcibios_resource_to_bus(dev->bus, &inverted_region, res);
293
294         /*
295          * If "A" is a BAR value (a bus address), "bus_to_resource(A)" is
296          * the corresponding resource address (the physical address used by
297          * the CPU.  Converting that resource address back to a bus address
298          * should yield the original BAR value:
299          *
300          *     resource_to_bus(bus_to_resource(A)) == A
301          *
302          * If it doesn't, CPU accesses to "bus_to_resource(A)" will not
303          * be claimed by the device.
304          */
305         if (inverted_region.start != region.start) {
306                 res->flags |= IORESOURCE_UNSET;
307                 res->start = 0;
308                 res->end = region.end - region.start;
309                 pci_info(dev, "reg 0x%x: initial BAR value %#010llx invalid\n",
310                          pos, (unsigned long long)region.start);
311         }
312
313         goto out;
314
315
316 fail:
317         res->flags = 0;
318 out:
319         if (res->flags)
320                 pci_printk(KERN_DEBUG, dev, "reg 0x%x: %pR\n", pos, res);
321
322         return (res->flags & IORESOURCE_MEM_64) ? 1 : 0;
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         if (dev->non_compliant_bars)
330                 return;
331
332         for (pos = 0; pos < howmany; pos++) {
333                 struct resource *res = &dev->resource[pos];
334                 reg = PCI_BASE_ADDRESS_0 + (pos << 2);
335                 pos += __pci_read_base(dev, pci_bar_unknown, res, reg);
336         }
337
338         if (rom) {
339                 struct resource *res = &dev->resource[PCI_ROM_RESOURCE];
340                 dev->rom_base_reg = rom;
341                 res->flags = IORESOURCE_MEM | IORESOURCE_PREFETCH |
342                                 IORESOURCE_READONLY | IORESOURCE_SIZEALIGN;
343                 __pci_read_base(dev, pci_bar_mem32, res, rom);
344         }
345 }
346
347 static void pci_read_bridge_io(struct pci_bus *child)
348 {
349         struct pci_dev *dev = child->self;
350         u8 io_base_lo, io_limit_lo;
351         unsigned long io_mask, io_granularity, base, limit;
352         struct pci_bus_region region;
353         struct resource *res;
354
355         io_mask = PCI_IO_RANGE_MASK;
356         io_granularity = 0x1000;
357         if (dev->io_window_1k) {
358                 /* Support 1K I/O space granularity */
359                 io_mask = PCI_IO_1K_RANGE_MASK;
360                 io_granularity = 0x400;
361         }
362
363         res = child->resource[0];
364         pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
365         pci_read_config_byte(dev, PCI_IO_LIMIT, &io_limit_lo);
366         base = (io_base_lo & io_mask) << 8;
367         limit = (io_limit_lo & io_mask) << 8;
368
369         if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
370                 u16 io_base_hi, io_limit_hi;
371
372                 pci_read_config_word(dev, PCI_IO_BASE_UPPER16, &io_base_hi);
373                 pci_read_config_word(dev, PCI_IO_LIMIT_UPPER16, &io_limit_hi);
374                 base |= ((unsigned long) io_base_hi << 16);
375                 limit |= ((unsigned long) io_limit_hi << 16);
376         }
377
378         if (base <= limit) {
379                 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
380                 region.start = base;
381                 region.end = limit + io_granularity - 1;
382                 pcibios_bus_to_resource(dev->bus, res, &region);
383                 pci_printk(KERN_DEBUG, dev, "  bridge window %pR\n", res);
384         }
385 }
386
387 static void pci_read_bridge_mmio(struct pci_bus *child)
388 {
389         struct pci_dev *dev = child->self;
390         u16 mem_base_lo, mem_limit_lo;
391         unsigned long base, limit;
392         struct pci_bus_region region;
393         struct resource *res;
394
395         res = child->resource[1];
396         pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
397         pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
398         base = ((unsigned long) mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
399         limit = ((unsigned long) mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
400         if (base <= limit) {
401                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
402                 region.start = base;
403                 region.end = limit + 0xfffff;
404                 pcibios_bus_to_resource(dev->bus, res, &region);
405                 pci_printk(KERN_DEBUG, dev, "  bridge window %pR\n", res);
406         }
407 }
408
409 static void pci_read_bridge_mmio_pref(struct pci_bus *child)
410 {
411         struct pci_dev *dev = child->self;
412         u16 mem_base_lo, mem_limit_lo;
413         u64 base64, limit64;
414         pci_bus_addr_t base, limit;
415         struct pci_bus_region region;
416         struct resource *res;
417
418         res = child->resource[2];
419         pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
420         pci_read_config_word(dev, PCI_PREF_MEMORY_LIMIT, &mem_limit_lo);
421         base64 = (mem_base_lo & PCI_PREF_RANGE_MASK) << 16;
422         limit64 = (mem_limit_lo & PCI_PREF_RANGE_MASK) << 16;
423
424         if ((mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
425                 u32 mem_base_hi, mem_limit_hi;
426
427                 pci_read_config_dword(dev, PCI_PREF_BASE_UPPER32, &mem_base_hi);
428                 pci_read_config_dword(dev, PCI_PREF_LIMIT_UPPER32, &mem_limit_hi);
429
430                 /*
431                  * Some bridges set the base > limit by default, and some
432                  * (broken) BIOSes do not initialize them.  If we find
433                  * this, just assume they are not being used.
434                  */
435                 if (mem_base_hi <= mem_limit_hi) {
436                         base64 |= (u64) mem_base_hi << 32;
437                         limit64 |= (u64) mem_limit_hi << 32;
438                 }
439         }
440
441         base = (pci_bus_addr_t) base64;
442         limit = (pci_bus_addr_t) limit64;
443
444         if (base != base64) {
445                 pci_err(dev, "can't handle bridge window above 4GB (bus address %#010llx)\n",
446                         (unsigned long long) base64);
447                 return;
448         }
449
450         if (base <= limit) {
451                 res->flags = (mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) |
452                                          IORESOURCE_MEM | IORESOURCE_PREFETCH;
453                 if (res->flags & PCI_PREF_RANGE_TYPE_64)
454                         res->flags |= IORESOURCE_MEM_64;
455                 region.start = base;
456                 region.end = limit + 0xfffff;
457                 pcibios_bus_to_resource(dev->bus, res, &region);
458                 pci_printk(KERN_DEBUG, dev, "  bridge window %pR\n", res);
459         }
460 }
461
462 void pci_read_bridge_bases(struct pci_bus *child)
463 {
464         struct pci_dev *dev = child->self;
465         struct resource *res;
466         int i;
467
468         if (pci_is_root_bus(child))     /* It's a host bus, nothing to read */
469                 return;
470
471         pci_info(dev, "PCI bridge to %pR%s\n",
472                  &child->busn_res,
473                  dev->transparent ? " (subtractive decode)" : "");
474
475         pci_bus_remove_resources(child);
476         for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++)
477                 child->resource[i] = &dev->resource[PCI_BRIDGE_RESOURCES+i];
478
479         pci_read_bridge_io(child);
480         pci_read_bridge_mmio(child);
481         pci_read_bridge_mmio_pref(child);
482
483         if (dev->transparent) {
484                 pci_bus_for_each_resource(child->parent, res, i) {
485                         if (res && res->flags) {
486                                 pci_bus_add_resource(child, res,
487                                                      PCI_SUBTRACTIVE_DECODE);
488                                 pci_printk(KERN_DEBUG, dev,
489                                            "  bridge window %pR (subtractive decode)\n",
490                                            res);
491                         }
492                 }
493         }
494 }
495
496 static struct pci_bus *pci_alloc_bus(struct pci_bus *parent)
497 {
498         struct pci_bus *b;
499
500         b = kzalloc(sizeof(*b), GFP_KERNEL);
501         if (!b)
502                 return NULL;
503
504         INIT_LIST_HEAD(&b->node);
505         INIT_LIST_HEAD(&b->children);
506         INIT_LIST_HEAD(&b->devices);
507         INIT_LIST_HEAD(&b->slots);
508         INIT_LIST_HEAD(&b->resources);
509         b->max_bus_speed = PCI_SPEED_UNKNOWN;
510         b->cur_bus_speed = PCI_SPEED_UNKNOWN;
511 #ifdef CONFIG_PCI_DOMAINS_GENERIC
512         if (parent)
513                 b->domain_nr = parent->domain_nr;
514 #endif
515         return b;
516 }
517
518 static void devm_pci_release_host_bridge_dev(struct device *dev)
519 {
520         struct pci_host_bridge *bridge = to_pci_host_bridge(dev);
521
522         if (bridge->release_fn)
523                 bridge->release_fn(bridge);
524 }
525
526 static void pci_release_host_bridge_dev(struct device *dev)
527 {
528         devm_pci_release_host_bridge_dev(dev);
529         pci_free_host_bridge(to_pci_host_bridge(dev));
530 }
531
532 struct pci_host_bridge *pci_alloc_host_bridge(size_t priv)
533 {
534         struct pci_host_bridge *bridge;
535
536         bridge = kzalloc(sizeof(*bridge) + priv, GFP_KERNEL);
537         if (!bridge)
538                 return NULL;
539
540         INIT_LIST_HEAD(&bridge->windows);
541         bridge->dev.release = pci_release_host_bridge_dev;
542
543         /*
544          * We assume we can manage these PCIe features.  Some systems may
545          * reserve these for use by the platform itself, e.g., an ACPI BIOS
546          * may implement its own AER handling and use _OSC to prevent the
547          * OS from interfering.
548          */
549         bridge->native_aer = 1;
550         bridge->native_hotplug = 1;
551         bridge->native_pme = 1;
552
553         return bridge;
554 }
555 EXPORT_SYMBOL(pci_alloc_host_bridge);
556
557 struct pci_host_bridge *devm_pci_alloc_host_bridge(struct device *dev,
558                                                    size_t priv)
559 {
560         struct pci_host_bridge *bridge;
561
562         bridge = devm_kzalloc(dev, sizeof(*bridge) + priv, GFP_KERNEL);
563         if (!bridge)
564                 return NULL;
565
566         INIT_LIST_HEAD(&bridge->windows);
567         bridge->dev.release = devm_pci_release_host_bridge_dev;
568
569         return bridge;
570 }
571 EXPORT_SYMBOL(devm_pci_alloc_host_bridge);
572
573 void pci_free_host_bridge(struct pci_host_bridge *bridge)
574 {
575         pci_free_resource_list(&bridge->windows);
576
577         kfree(bridge);
578 }
579 EXPORT_SYMBOL(pci_free_host_bridge);
580
581 static const unsigned char pcix_bus_speed[] = {
582         PCI_SPEED_UNKNOWN,              /* 0 */
583         PCI_SPEED_66MHz_PCIX,           /* 1 */
584         PCI_SPEED_100MHz_PCIX,          /* 2 */
585         PCI_SPEED_133MHz_PCIX,          /* 3 */
586         PCI_SPEED_UNKNOWN,              /* 4 */
587         PCI_SPEED_66MHz_PCIX_ECC,       /* 5 */
588         PCI_SPEED_100MHz_PCIX_ECC,      /* 6 */
589         PCI_SPEED_133MHz_PCIX_ECC,      /* 7 */
590         PCI_SPEED_UNKNOWN,              /* 8 */
591         PCI_SPEED_66MHz_PCIX_266,       /* 9 */
592         PCI_SPEED_100MHz_PCIX_266,      /* A */
593         PCI_SPEED_133MHz_PCIX_266,      /* B */
594         PCI_SPEED_UNKNOWN,              /* C */
595         PCI_SPEED_66MHz_PCIX_533,       /* D */
596         PCI_SPEED_100MHz_PCIX_533,      /* E */
597         PCI_SPEED_133MHz_PCIX_533       /* F */
598 };
599
600 const unsigned char pcie_link_speed[] = {
601         PCI_SPEED_UNKNOWN,              /* 0 */
602         PCIE_SPEED_2_5GT,               /* 1 */
603         PCIE_SPEED_5_0GT,               /* 2 */
604         PCIE_SPEED_8_0GT,               /* 3 */
605         PCIE_SPEED_16_0GT,              /* 4 */
606         PCI_SPEED_UNKNOWN,              /* 5 */
607         PCI_SPEED_UNKNOWN,              /* 6 */
608         PCI_SPEED_UNKNOWN,              /* 7 */
609         PCI_SPEED_UNKNOWN,              /* 8 */
610         PCI_SPEED_UNKNOWN,              /* 9 */
611         PCI_SPEED_UNKNOWN,              /* A */
612         PCI_SPEED_UNKNOWN,              /* B */
613         PCI_SPEED_UNKNOWN,              /* C */
614         PCI_SPEED_UNKNOWN,              /* D */
615         PCI_SPEED_UNKNOWN,              /* E */
616         PCI_SPEED_UNKNOWN               /* F */
617 };
618
619 void pcie_update_link_speed(struct pci_bus *bus, u16 linksta)
620 {
621         bus->cur_bus_speed = pcie_link_speed[linksta & PCI_EXP_LNKSTA_CLS];
622 }
623 EXPORT_SYMBOL_GPL(pcie_update_link_speed);
624
625 static unsigned char agp_speeds[] = {
626         AGP_UNKNOWN,
627         AGP_1X,
628         AGP_2X,
629         AGP_4X,
630         AGP_8X
631 };
632
633 static enum pci_bus_speed agp_speed(int agp3, int agpstat)
634 {
635         int index = 0;
636
637         if (agpstat & 4)
638                 index = 3;
639         else if (agpstat & 2)
640                 index = 2;
641         else if (agpstat & 1)
642                 index = 1;
643         else
644                 goto out;
645
646         if (agp3) {
647                 index += 2;
648                 if (index == 5)
649                         index = 0;
650         }
651
652  out:
653         return agp_speeds[index];
654 }
655
656 static void pci_set_bus_speed(struct pci_bus *bus)
657 {
658         struct pci_dev *bridge = bus->self;
659         int pos;
660
661         pos = pci_find_capability(bridge, PCI_CAP_ID_AGP);
662         if (!pos)
663                 pos = pci_find_capability(bridge, PCI_CAP_ID_AGP3);
664         if (pos) {
665                 u32 agpstat, agpcmd;
666
667                 pci_read_config_dword(bridge, pos + PCI_AGP_STATUS, &agpstat);
668                 bus->max_bus_speed = agp_speed(agpstat & 8, agpstat & 7);
669
670                 pci_read_config_dword(bridge, pos + PCI_AGP_COMMAND, &agpcmd);
671                 bus->cur_bus_speed = agp_speed(agpstat & 8, agpcmd & 7);
672         }
673
674         pos = pci_find_capability(bridge, PCI_CAP_ID_PCIX);
675         if (pos) {
676                 u16 status;
677                 enum pci_bus_speed max;
678
679                 pci_read_config_word(bridge, pos + PCI_X_BRIDGE_SSTATUS,
680                                      &status);
681
682                 if (status & PCI_X_SSTATUS_533MHZ) {
683                         max = PCI_SPEED_133MHz_PCIX_533;
684                 } else if (status & PCI_X_SSTATUS_266MHZ) {
685                         max = PCI_SPEED_133MHz_PCIX_266;
686                 } else if (status & PCI_X_SSTATUS_133MHZ) {
687                         if ((status & PCI_X_SSTATUS_VERS) == PCI_X_SSTATUS_V2)
688                                 max = PCI_SPEED_133MHz_PCIX_ECC;
689                         else
690                                 max = PCI_SPEED_133MHz_PCIX;
691                 } else {
692                         max = PCI_SPEED_66MHz_PCIX;
693                 }
694
695                 bus->max_bus_speed = max;
696                 bus->cur_bus_speed = pcix_bus_speed[
697                         (status & PCI_X_SSTATUS_FREQ) >> 6];
698
699                 return;
700         }
701
702         if (pci_is_pcie(bridge)) {
703                 u32 linkcap;
704                 u16 linksta;
705
706                 pcie_capability_read_dword(bridge, PCI_EXP_LNKCAP, &linkcap);
707                 bus->max_bus_speed = pcie_link_speed[linkcap & PCI_EXP_LNKCAP_SLS];
708
709                 pcie_capability_read_word(bridge, PCI_EXP_LNKSTA, &linksta);
710                 pcie_update_link_speed(bus, linksta);
711         }
712 }
713
714 static struct irq_domain *pci_host_bridge_msi_domain(struct pci_bus *bus)
715 {
716         struct irq_domain *d;
717
718         /*
719          * Any firmware interface that can resolve the msi_domain
720          * should be called from here.
721          */
722         d = pci_host_bridge_of_msi_domain(bus);
723         if (!d)
724                 d = pci_host_bridge_acpi_msi_domain(bus);
725
726 #ifdef CONFIG_PCI_MSI_IRQ_DOMAIN
727         /*
728          * If no IRQ domain was found via the OF tree, try looking it up
729          * directly through the fwnode_handle.
730          */
731         if (!d) {
732                 struct fwnode_handle *fwnode = pci_root_bus_fwnode(bus);
733
734                 if (fwnode)
735                         d = irq_find_matching_fwnode(fwnode,
736                                                      DOMAIN_BUS_PCI_MSI);
737         }
738 #endif
739
740         return d;
741 }
742
743 static void pci_set_bus_msi_domain(struct pci_bus *bus)
744 {
745         struct irq_domain *d;
746         struct pci_bus *b;
747
748         /*
749          * The bus can be a root bus, a subordinate bus, or a virtual bus
750          * created by an SR-IOV device.  Walk up to the first bridge device
751          * found or derive the domain from the host bridge.
752          */
753         for (b = bus, d = NULL; !d && !pci_is_root_bus(b); b = b->parent) {
754                 if (b->self)
755                         d = dev_get_msi_domain(&b->self->dev);
756         }
757
758         if (!d)
759                 d = pci_host_bridge_msi_domain(b);
760
761         dev_set_msi_domain(&bus->dev, d);
762 }
763
764 static int pci_register_host_bridge(struct pci_host_bridge *bridge)
765 {
766         struct device *parent = bridge->dev.parent;
767         struct resource_entry *window, *n;
768         struct pci_bus *bus, *b;
769         resource_size_t offset;
770         LIST_HEAD(resources);
771         struct resource *res;
772         char addr[64], *fmt;
773         const char *name;
774         int err;
775
776         bus = pci_alloc_bus(NULL);
777         if (!bus)
778                 return -ENOMEM;
779
780         bridge->bus = bus;
781
782         /* Temporarily move resources off the list */
783         list_splice_init(&bridge->windows, &resources);
784         bus->sysdata = bridge->sysdata;
785         bus->msi = bridge->msi;
786         bus->ops = bridge->ops;
787         bus->number = bus->busn_res.start = bridge->busnr;
788 #ifdef CONFIG_PCI_DOMAINS_GENERIC
789         bus->domain_nr = pci_bus_find_domain_nr(bus, parent);
790 #endif
791
792         b = pci_find_bus(pci_domain_nr(bus), bridge->busnr);
793         if (b) {
794                 /* Ignore it if we already got here via a different bridge */
795                 dev_dbg(&b->dev, "bus already known\n");
796                 err = -EEXIST;
797                 goto free;
798         }
799
800         dev_set_name(&bridge->dev, "pci%04x:%02x", pci_domain_nr(bus),
801                      bridge->busnr);
802
803         err = pcibios_root_bridge_prepare(bridge);
804         if (err)
805                 goto free;
806
807         err = device_register(&bridge->dev);
808         if (err)
809                 put_device(&bridge->dev);
810
811         bus->bridge = get_device(&bridge->dev);
812         device_enable_async_suspend(bus->bridge);
813         pci_set_bus_of_node(bus);
814         pci_set_bus_msi_domain(bus);
815
816         if (!parent)
817                 set_dev_node(bus->bridge, pcibus_to_node(bus));
818
819         bus->dev.class = &pcibus_class;
820         bus->dev.parent = bus->bridge;
821
822         dev_set_name(&bus->dev, "%04x:%02x", pci_domain_nr(bus), bus->number);
823         name = dev_name(&bus->dev);
824
825         err = device_register(&bus->dev);
826         if (err)
827                 goto unregister;
828
829         pcibios_add_bus(bus);
830
831         /* Create legacy_io and legacy_mem files for this bus */
832         pci_create_legacy_files(bus);
833
834         if (parent)
835                 dev_info(parent, "PCI host bridge to bus %s\n", name);
836         else
837                 pr_info("PCI host bridge to bus %s\n", name);
838
839         /* Add initial resources to the bus */
840         resource_list_for_each_entry_safe(window, n, &resources) {
841                 list_move_tail(&window->node, &bridge->windows);
842                 offset = window->offset;
843                 res = window->res;
844
845                 if (res->flags & IORESOURCE_BUS)
846                         pci_bus_insert_busn_res(bus, bus->number, res->end);
847                 else
848                         pci_bus_add_resource(bus, res, 0);
849
850                 if (offset) {
851                         if (resource_type(res) == IORESOURCE_IO)
852                                 fmt = " (bus address [%#06llx-%#06llx])";
853                         else
854                                 fmt = " (bus address [%#010llx-%#010llx])";
855
856                         snprintf(addr, sizeof(addr), fmt,
857                                  (unsigned long long)(res->start - offset),
858                                  (unsigned long long)(res->end - offset));
859                 } else
860                         addr[0] = '\0';
861
862                 dev_info(&bus->dev, "root bus resource %pR%s\n", res, addr);
863         }
864
865         down_write(&pci_bus_sem);
866         list_add_tail(&bus->node, &pci_root_buses);
867         up_write(&pci_bus_sem);
868
869         return 0;
870
871 unregister:
872         put_device(&bridge->dev);
873         device_unregister(&bridge->dev);
874
875 free:
876         kfree(bus);
877         return err;
878 }
879
880 static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
881                                            struct pci_dev *bridge, int busnr)
882 {
883         struct pci_bus *child;
884         int i;
885         int ret;
886
887         /* Allocate a new bus and inherit stuff from the parent */
888         child = pci_alloc_bus(parent);
889         if (!child)
890                 return NULL;
891
892         child->parent = parent;
893         child->ops = parent->ops;
894         child->msi = parent->msi;
895         child->sysdata = parent->sysdata;
896         child->bus_flags = parent->bus_flags;
897
898         /*
899          * Initialize some portions of the bus device, but don't register
900          * it now as the parent is not properly set up yet.
901          */
902         child->dev.class = &pcibus_class;
903         dev_set_name(&child->dev, "%04x:%02x", pci_domain_nr(child), busnr);
904
905         /* Set up the primary, secondary and subordinate bus numbers */
906         child->number = child->busn_res.start = busnr;
907         child->primary = parent->busn_res.start;
908         child->busn_res.end = 0xff;
909
910         if (!bridge) {
911                 child->dev.parent = parent->bridge;
912                 goto add_dev;
913         }
914
915         child->self = bridge;
916         child->bridge = get_device(&bridge->dev);
917         child->dev.parent = child->bridge;
918         pci_set_bus_of_node(child);
919         pci_set_bus_speed(child);
920
921         /* Set up default resource pointers and names */
922         for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) {
923                 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
924                 child->resource[i]->name = child->name;
925         }
926         bridge->subordinate = child;
927
928 add_dev:
929         pci_set_bus_msi_domain(child);
930         ret = device_register(&child->dev);
931         WARN_ON(ret < 0);
932
933         pcibios_add_bus(child);
934
935         if (child->ops->add_bus) {
936                 ret = child->ops->add_bus(child);
937                 if (WARN_ON(ret < 0))
938                         dev_err(&child->dev, "failed to add bus: %d\n", ret);
939         }
940
941         /* Create legacy_io and legacy_mem files for this bus */
942         pci_create_legacy_files(child);
943
944         return child;
945 }
946
947 struct pci_bus *pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev,
948                                 int busnr)
949 {
950         struct pci_bus *child;
951
952         child = pci_alloc_child_bus(parent, dev, busnr);
953         if (child) {
954                 down_write(&pci_bus_sem);
955                 list_add_tail(&child->node, &parent->children);
956                 up_write(&pci_bus_sem);
957         }
958         return child;
959 }
960 EXPORT_SYMBOL(pci_add_new_bus);
961
962 static void pci_enable_crs(struct pci_dev *pdev)
963 {
964         u16 root_cap = 0;
965
966         /* Enable CRS Software Visibility if supported */
967         pcie_capability_read_word(pdev, PCI_EXP_RTCAP, &root_cap);
968         if (root_cap & PCI_EXP_RTCAP_CRSVIS)
969                 pcie_capability_set_word(pdev, PCI_EXP_RTCTL,
970                                          PCI_EXP_RTCTL_CRSSVE);
971 }
972
973 static unsigned int pci_scan_child_bus_extend(struct pci_bus *bus,
974                                               unsigned int available_buses);
975
976 /*
977  * pci_scan_bridge_extend() - Scan buses behind a bridge
978  * @bus: Parent bus the bridge is on
979  * @dev: Bridge itself
980  * @max: Starting subordinate number of buses behind this bridge
981  * @available_buses: Total number of buses available for this bridge and
982  *                   the devices below. After the minimal bus space has
983  *                   been allocated the remaining buses will be
984  *                   distributed equally between hotplug-capable bridges.
985  * @pass: Either %0 (scan already configured bridges) or %1 (scan bridges
986  *        that need to be reconfigured.
987  *
988  * If it's a bridge, configure it and scan the bus behind it.
989  * For CardBus bridges, we don't scan behind as the devices will
990  * be handled by the bridge driver itself.
991  *
992  * We need to process bridges in two passes -- first we scan those
993  * already configured by the BIOS and after we are done with all of
994  * them, we proceed to assigning numbers to the remaining buses in
995  * order to avoid overlaps between old and new bus numbers.
996  */
997 static int pci_scan_bridge_extend(struct pci_bus *bus, struct pci_dev *dev,
998                                   int max, unsigned int available_buses,
999                                   int pass)
1000 {
1001         struct pci_bus *child;
1002         int is_cardbus = (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS);
1003         u32 buses, i, j = 0;
1004         u16 bctl;
1005         u8 primary, secondary, subordinate;
1006         int broken = 0;
1007
1008         /*
1009          * Make sure the bridge is powered on to be able to access config
1010          * space of devices below it.
1011          */
1012         pm_runtime_get_sync(&dev->dev);
1013
1014         pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
1015         primary = buses & 0xFF;
1016         secondary = (buses >> 8) & 0xFF;
1017         subordinate = (buses >> 16) & 0xFF;
1018
1019         pci_dbg(dev, "scanning [bus %02x-%02x] behind bridge, pass %d\n",
1020                 secondary, subordinate, pass);
1021
1022         if (!primary && (primary != bus->number) && secondary && subordinate) {
1023                 pci_warn(dev, "Primary bus is hard wired to 0\n");
1024                 primary = bus->number;
1025         }
1026
1027         /* Check if setup is sensible at all */
1028         if (!pass &&
1029             (primary != bus->number || secondary <= bus->number ||
1030              secondary > subordinate)) {
1031                 pci_info(dev, "bridge configuration invalid ([bus %02x-%02x]), reconfiguring\n",
1032                          secondary, subordinate);
1033                 broken = 1;
1034         }
1035
1036         /*
1037          * Disable Master-Abort Mode during probing to avoid reporting of
1038          * bus errors in some architectures.
1039          */
1040         pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl);
1041         pci_write_config_word(dev, PCI_BRIDGE_CONTROL,
1042                               bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT);
1043
1044         pci_enable_crs(dev);
1045
1046         if ((secondary || subordinate) && !pcibios_assign_all_busses() &&
1047             !is_cardbus && !broken) {
1048                 unsigned int cmax;
1049
1050                 /*
1051                  * Bus already configured by firmware, process it in the
1052                  * first pass and just note the configuration.
1053                  */
1054                 if (pass)
1055                         goto out;
1056
1057                 /*
1058                  * The bus might already exist for two reasons: Either we
1059                  * are rescanning the bus or the bus is reachable through
1060                  * more than one bridge. The second case can happen with
1061                  * the i450NX chipset.
1062                  */
1063                 child = pci_find_bus(pci_domain_nr(bus), secondary);
1064                 if (!child) {
1065                         child = pci_add_new_bus(bus, dev, secondary);
1066                         if (!child)
1067                                 goto out;
1068                         child->primary = primary;
1069                         pci_bus_insert_busn_res(child, secondary, subordinate);
1070                         child->bridge_ctl = bctl;
1071                 }
1072
1073                 cmax = pci_scan_child_bus(child);
1074                 if (cmax > subordinate)
1075                         pci_warn(dev, "bridge has subordinate %02x but max busn %02x\n",
1076                                  subordinate, cmax);
1077
1078                 /* Subordinate should equal child->busn_res.end */
1079                 if (subordinate > max)
1080                         max = subordinate;
1081         } else {
1082
1083                 /*
1084                  * We need to assign a number to this bus which we always
1085                  * do in the second pass.
1086                  */
1087                 if (!pass) {
1088                         if (pcibios_assign_all_busses() || broken || is_cardbus)
1089
1090                                 /*
1091                                  * Temporarily disable forwarding of the
1092                                  * configuration cycles on all bridges in
1093                                  * this bus segment to avoid possible
1094                                  * conflicts in the second pass between two
1095                                  * bridges programmed with overlapping bus
1096                                  * ranges.
1097                                  */
1098                                 pci_write_config_dword(dev, PCI_PRIMARY_BUS,
1099                                                        buses & ~0xffffff);
1100                         goto out;
1101                 }
1102
1103                 /* Clear errors */
1104                 pci_write_config_word(dev, PCI_STATUS, 0xffff);
1105
1106                 /*
1107                  * Prevent assigning a bus number that already exists.
1108                  * This can happen when a bridge is hot-plugged, so in this
1109                  * case we only re-scan this bus.
1110                  */
1111                 child = pci_find_bus(pci_domain_nr(bus), max+1);
1112                 if (!child) {
1113                         child = pci_add_new_bus(bus, dev, max+1);
1114                         if (!child)
1115                                 goto out;
1116                         pci_bus_insert_busn_res(child, max+1,
1117                                                 bus->busn_res.end);
1118                 }
1119                 max++;
1120                 if (available_buses)
1121                         available_buses--;
1122
1123                 buses = (buses & 0xff000000)
1124                       | ((unsigned int)(child->primary)     <<  0)
1125                       | ((unsigned int)(child->busn_res.start)   <<  8)
1126                       | ((unsigned int)(child->busn_res.end) << 16);
1127
1128                 /*
1129                  * yenta.c forces a secondary latency timer of 176.
1130                  * Copy that behaviour here.
1131                  */
1132                 if (is_cardbus) {
1133                         buses &= ~0xff000000;
1134                         buses |= CARDBUS_LATENCY_TIMER << 24;
1135                 }
1136
1137                 /* We need to blast all three values with a single write */
1138                 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
1139
1140                 if (!is_cardbus) {
1141                         child->bridge_ctl = bctl;
1142                         max = pci_scan_child_bus_extend(child, available_buses);
1143                 } else {
1144
1145                         /*
1146                          * For CardBus bridges, we leave 4 bus numbers as
1147                          * cards with a PCI-to-PCI bridge can be inserted
1148                          * later.
1149                          */
1150                         for (i = 0; i < CARDBUS_RESERVE_BUSNR; i++) {
1151                                 struct pci_bus *parent = bus;
1152                                 if (pci_find_bus(pci_domain_nr(bus),
1153                                                         max+i+1))
1154                                         break;
1155                                 while (parent->parent) {
1156                                         if ((!pcibios_assign_all_busses()) &&
1157                                             (parent->busn_res.end > max) &&
1158                                             (parent->busn_res.end <= max+i)) {
1159                                                 j = 1;
1160                                         }
1161                                         parent = parent->parent;
1162                                 }
1163                                 if (j) {
1164
1165                                         /*
1166                                          * Often, there are two CardBus
1167                                          * bridges -- try to leave one
1168                                          * valid bus number for each one.
1169                                          */
1170                                         i /= 2;
1171                                         break;
1172                                 }
1173                         }
1174                         max += i;
1175                 }
1176
1177                 /* Set subordinate bus number to its real value */
1178                 pci_bus_update_busn_res_end(child, max);
1179                 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
1180         }
1181
1182         sprintf(child->name,
1183                 (is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"),
1184                 pci_domain_nr(bus), child->number);
1185
1186         /* Has only triggered on CardBus, fixup is in yenta_socket */
1187         while (bus->parent) {
1188                 if ((child->busn_res.end > bus->busn_res.end) ||
1189                     (child->number > bus->busn_res.end) ||
1190                     (child->number < bus->number) ||
1191                     (child->busn_res.end < bus->number)) {
1192                         dev_info(&child->dev, "%pR %s hidden behind%s bridge %s %pR\n",
1193                                 &child->busn_res,
1194                                 (bus->number > child->busn_res.end &&
1195                                  bus->busn_res.end < child->number) ?
1196                                         "wholly" : "partially",
1197                                 bus->self->transparent ? " transparent" : "",
1198                                 dev_name(&bus->dev),
1199                                 &bus->busn_res);
1200                 }
1201                 bus = bus->parent;
1202         }
1203
1204 out:
1205         pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
1206
1207         pm_runtime_put(&dev->dev);
1208
1209         return max;
1210 }
1211
1212 /*
1213  * pci_scan_bridge() - Scan buses behind a bridge
1214  * @bus: Parent bus the bridge is on
1215  * @dev: Bridge itself
1216  * @max: Starting subordinate number of buses behind this bridge
1217  * @pass: Either %0 (scan already configured bridges) or %1 (scan bridges
1218  *        that need to be reconfigured.
1219  *
1220  * If it's a bridge, configure it and scan the bus behind it.
1221  * For CardBus bridges, we don't scan behind as the devices will
1222  * be handled by the bridge driver itself.
1223  *
1224  * We need to process bridges in two passes -- first we scan those
1225  * already configured by the BIOS and after we are done with all of
1226  * them, we proceed to assigning numbers to the remaining buses in
1227  * order to avoid overlaps between old and new bus numbers.
1228  */
1229 int pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
1230 {
1231         return pci_scan_bridge_extend(bus, dev, max, 0, pass);
1232 }
1233 EXPORT_SYMBOL(pci_scan_bridge);
1234
1235 /*
1236  * Read interrupt line and base address registers.
1237  * The architecture-dependent code can tweak these, of course.
1238  */
1239 static void pci_read_irq(struct pci_dev *dev)
1240 {
1241         unsigned char irq;
1242
1243         pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq);
1244         dev->pin = irq;
1245         if (irq)
1246                 pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
1247         dev->irq = irq;
1248 }
1249
1250 void set_pcie_port_type(struct pci_dev *pdev)
1251 {
1252         int pos;
1253         u16 reg16;
1254         int type;
1255         struct pci_dev *parent;
1256
1257         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
1258         if (!pos)
1259                 return;
1260
1261         pdev->pcie_cap = pos;
1262         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
1263         pdev->pcie_flags_reg = reg16;
1264         pci_read_config_word(pdev, pos + PCI_EXP_DEVCAP, &reg16);
1265         pdev->pcie_mpss = reg16 & PCI_EXP_DEVCAP_PAYLOAD;
1266
1267         /*
1268          * A Root Port or a PCI-to-PCIe bridge is always the upstream end
1269          * of a Link.  No PCIe component has two Links.  Two Links are
1270          * connected by a Switch that has a Port on each Link and internal
1271          * logic to connect the two Ports.
1272          */
1273         type = pci_pcie_type(pdev);
1274         if (type == PCI_EXP_TYPE_ROOT_PORT ||
1275             type == PCI_EXP_TYPE_PCIE_BRIDGE)
1276                 pdev->has_secondary_link = 1;
1277         else if (type == PCI_EXP_TYPE_UPSTREAM ||
1278                  type == PCI_EXP_TYPE_DOWNSTREAM) {
1279                 parent = pci_upstream_bridge(pdev);
1280
1281                 /*
1282                  * Usually there's an upstream device (Root Port or Switch
1283                  * Downstream Port), but we can't assume one exists.
1284                  */
1285                 if (parent && !parent->has_secondary_link)
1286                         pdev->has_secondary_link = 1;
1287         }
1288 }
1289
1290 void set_pcie_hotplug_bridge(struct pci_dev *pdev)
1291 {
1292         u32 reg32;
1293
1294         pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, &reg32);
1295         if (reg32 & PCI_EXP_SLTCAP_HPC)
1296                 pdev->is_hotplug_bridge = 1;
1297 }
1298
1299 static void set_pcie_thunderbolt(struct pci_dev *dev)
1300 {
1301         int vsec = 0;
1302         u32 header;
1303
1304         while ((vsec = pci_find_next_ext_capability(dev, vsec,
1305                                                     PCI_EXT_CAP_ID_VNDR))) {
1306                 pci_read_config_dword(dev, vsec + PCI_VNDR_HEADER, &header);
1307
1308                 /* Is the device part of a Thunderbolt controller? */
1309                 if (dev->vendor == PCI_VENDOR_ID_INTEL &&
1310                     PCI_VNDR_HEADER_ID(header) == PCI_VSEC_ID_INTEL_TBT) {
1311                         dev->is_thunderbolt = 1;
1312                         return;
1313                 }
1314         }
1315 }
1316
1317 /**
1318  * pci_ext_cfg_is_aliased - Is ext config space just an alias of std config?
1319  * @dev: PCI device
1320  *
1321  * PCI Express to PCI/PCI-X Bridge Specification, rev 1.0, 4.1.4 says that
1322  * when forwarding a type1 configuration request the bridge must check that
1323  * the extended register address field is zero.  The bridge is not permitted
1324  * to forward the transactions and must handle it as an Unsupported Request.
1325  * Some bridges do not follow this rule and simply drop the extended register
1326  * bits, resulting in the standard config space being aliased, every 256
1327  * bytes across the entire configuration space.  Test for this condition by
1328  * comparing the first dword of each potential alias to the vendor/device ID.
1329  * Known offenders:
1330  *   ASM1083/1085 PCIe-to-PCI Reversible Bridge (1b21:1080, rev 01 & 03)
1331  *   AMD/ATI SBx00 PCI to PCI Bridge (1002:4384, rev 40)
1332  */
1333 static bool pci_ext_cfg_is_aliased(struct pci_dev *dev)
1334 {
1335 #ifdef CONFIG_PCI_QUIRKS
1336         int pos;
1337         u32 header, tmp;
1338
1339         pci_read_config_dword(dev, PCI_VENDOR_ID, &header);
1340
1341         for (pos = PCI_CFG_SPACE_SIZE;
1342              pos < PCI_CFG_SPACE_EXP_SIZE; pos += PCI_CFG_SPACE_SIZE) {
1343                 if (pci_read_config_dword(dev, pos, &tmp) != PCIBIOS_SUCCESSFUL
1344                     || header != tmp)
1345                         return false;
1346         }
1347
1348         return true;
1349 #else
1350         return false;
1351 #endif
1352 }
1353
1354 /**
1355  * pci_cfg_space_size - Get the configuration space size of the PCI device
1356  * @dev: PCI device
1357  *
1358  * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices
1359  * have 4096 bytes.  Even if the device is capable, that doesn't mean we can
1360  * access it.  Maybe we don't have a way to generate extended config space
1361  * accesses, or the device is behind a reverse Express bridge.  So we try
1362  * reading the dword at 0x100 which must either be 0 or a valid extended
1363  * capability header.
1364  */
1365 static int pci_cfg_space_size_ext(struct pci_dev *dev)
1366 {
1367         u32 status;
1368         int pos = PCI_CFG_SPACE_SIZE;
1369
1370         if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL)
1371                 return PCI_CFG_SPACE_SIZE;
1372         if (status == 0xffffffff || pci_ext_cfg_is_aliased(dev))
1373                 return PCI_CFG_SPACE_SIZE;
1374
1375         return PCI_CFG_SPACE_EXP_SIZE;
1376 }
1377
1378 int pci_cfg_space_size(struct pci_dev *dev)
1379 {
1380         int pos;
1381         u32 status;
1382         u16 class;
1383
1384         class = dev->class >> 8;
1385         if (class == PCI_CLASS_BRIDGE_HOST)
1386                 return pci_cfg_space_size_ext(dev);
1387
1388         if (pci_is_pcie(dev))
1389                 return pci_cfg_space_size_ext(dev);
1390
1391         pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1392         if (!pos)
1393                 return PCI_CFG_SPACE_SIZE;
1394
1395         pci_read_config_dword(dev, pos + PCI_X_STATUS, &status);
1396         if (status & (PCI_X_STATUS_266MHZ | PCI_X_STATUS_533MHZ))
1397                 return pci_cfg_space_size_ext(dev);
1398
1399         return PCI_CFG_SPACE_SIZE;
1400 }
1401
1402 #define LEGACY_IO_RESOURCE      (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
1403
1404 static void pci_msi_setup_pci_dev(struct pci_dev *dev)
1405 {
1406         /*
1407          * Disable the MSI hardware to avoid screaming interrupts
1408          * during boot.  This is the power on reset default so
1409          * usually this should be a noop.
1410          */
1411         dev->msi_cap = pci_find_capability(dev, PCI_CAP_ID_MSI);
1412         if (dev->msi_cap)
1413                 pci_msi_set_enable(dev, 0);
1414
1415         dev->msix_cap = pci_find_capability(dev, PCI_CAP_ID_MSIX);
1416         if (dev->msix_cap)
1417                 pci_msix_clear_and_set_ctrl(dev, PCI_MSIX_FLAGS_ENABLE, 0);
1418 }
1419
1420 /**
1421  * pci_intx_mask_broken - Test PCI_COMMAND_INTX_DISABLE writability
1422  * @dev: PCI device
1423  *
1424  * Test whether PCI_COMMAND_INTX_DISABLE is writable for @dev.  Check this
1425  * at enumeration-time to avoid modifying PCI_COMMAND at run-time.
1426  */
1427 static int pci_intx_mask_broken(struct pci_dev *dev)
1428 {
1429         u16 orig, toggle, new;
1430
1431         pci_read_config_word(dev, PCI_COMMAND, &orig);
1432         toggle = orig ^ PCI_COMMAND_INTX_DISABLE;
1433         pci_write_config_word(dev, PCI_COMMAND, toggle);
1434         pci_read_config_word(dev, PCI_COMMAND, &new);
1435
1436         pci_write_config_word(dev, PCI_COMMAND, orig);
1437
1438         /*
1439          * PCI_COMMAND_INTX_DISABLE was reserved and read-only prior to PCI
1440          * r2.3, so strictly speaking, a device is not *broken* if it's not
1441          * writable.  But we'll live with the misnomer for now.
1442          */
1443         if (new != toggle)
1444                 return 1;
1445         return 0;
1446 }
1447
1448 /**
1449  * pci_setup_device - Fill in class and map information of a device
1450  * @dev: the device structure to fill
1451  *
1452  * Initialize the device structure with information about the device's
1453  * vendor,class,memory and IO-space addresses, IRQ lines etc.
1454  * Called at initialisation of the PCI subsystem and by CardBus services.
1455  * Returns 0 on success and negative if unknown type of device (not normal,
1456  * bridge or CardBus).
1457  */
1458 int pci_setup_device(struct pci_dev *dev)
1459 {
1460         u32 class;
1461         u16 cmd;
1462         u8 hdr_type;
1463         int pos = 0;
1464         struct pci_bus_region region;
1465         struct resource *res;
1466
1467         if (pci_read_config_byte(dev, PCI_HEADER_TYPE, &hdr_type))
1468                 return -EIO;
1469
1470         dev->sysdata = dev->bus->sysdata;
1471         dev->dev.parent = dev->bus->bridge;
1472         dev->dev.bus = &pci_bus_type;
1473         dev->hdr_type = hdr_type & 0x7f;
1474         dev->multifunction = !!(hdr_type & 0x80);
1475         dev->error_state = pci_channel_io_normal;
1476         set_pcie_port_type(dev);
1477
1478         pci_dev_assign_slot(dev);
1479
1480         /*
1481          * Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
1482          * set this higher, assuming the system even supports it.
1483          */
1484         dev->dma_mask = 0xffffffff;
1485
1486         dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
1487                      dev->bus->number, PCI_SLOT(dev->devfn),
1488                      PCI_FUNC(dev->devfn));
1489
1490         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
1491         dev->revision = class & 0xff;
1492         dev->class = class >> 8;                    /* upper 3 bytes */
1493
1494         pci_printk(KERN_DEBUG, dev, "[%04x:%04x] type %02x class %#08x\n",
1495                    dev->vendor, dev->device, dev->hdr_type, dev->class);
1496
1497         /* Need to have dev->class ready */
1498         dev->cfg_size = pci_cfg_space_size(dev);
1499
1500         /* Need to have dev->cfg_size ready */
1501         set_pcie_thunderbolt(dev);
1502
1503         /* "Unknown power state" */
1504         dev->current_state = PCI_UNKNOWN;
1505
1506         /* Early fixups, before probing the BARs */
1507         pci_fixup_device(pci_fixup_early, dev);
1508
1509         /* Device class may be changed after fixup */
1510         class = dev->class >> 8;
1511
1512         if (dev->non_compliant_bars) {
1513                 pci_read_config_word(dev, PCI_COMMAND, &cmd);
1514                 if (cmd & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) {
1515                         pci_info(dev, "device has non-compliant BARs; disabling IO/MEM decoding\n");
1516                         cmd &= ~PCI_COMMAND_IO;
1517                         cmd &= ~PCI_COMMAND_MEMORY;
1518                         pci_write_config_word(dev, PCI_COMMAND, cmd);
1519                 }
1520         }
1521
1522         dev->broken_intx_masking = pci_intx_mask_broken(dev);
1523
1524         switch (dev->hdr_type) {                    /* header type */
1525         case PCI_HEADER_TYPE_NORMAL:                /* standard header */
1526                 if (class == PCI_CLASS_BRIDGE_PCI)
1527                         goto bad;
1528                 pci_read_irq(dev);
1529                 pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
1530                 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
1531                 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
1532
1533                 /*
1534                  * Do the ugly legacy mode stuff here rather than broken chip
1535                  * quirk code. Legacy mode ATA controllers have fixed
1536                  * addresses. These are not always echoed in BAR0-3, and
1537                  * BAR0-3 in a few cases contain junk!
1538                  */
1539                 if (class == PCI_CLASS_STORAGE_IDE) {
1540                         u8 progif;
1541                         pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
1542                         if ((progif & 1) == 0) {
1543                                 region.start = 0x1F0;
1544                                 region.end = 0x1F7;
1545                                 res = &dev->resource[0];
1546                                 res->flags = LEGACY_IO_RESOURCE;
1547                                 pcibios_bus_to_resource(dev->bus, res, &region);
1548                                 pci_info(dev, "legacy IDE quirk: reg 0x10: %pR\n",
1549                                          res);
1550                                 region.start = 0x3F6;
1551                                 region.end = 0x3F6;
1552                                 res = &dev->resource[1];
1553                                 res->flags = LEGACY_IO_RESOURCE;
1554                                 pcibios_bus_to_resource(dev->bus, res, &region);
1555                                 pci_info(dev, "legacy IDE quirk: reg 0x14: %pR\n",
1556                                          res);
1557                         }
1558                         if ((progif & 4) == 0) {
1559                                 region.start = 0x170;
1560                                 region.end = 0x177;
1561                                 res = &dev->resource[2];
1562                                 res->flags = LEGACY_IO_RESOURCE;
1563                                 pcibios_bus_to_resource(dev->bus, res, &region);
1564                                 pci_info(dev, "legacy IDE quirk: reg 0x18: %pR\n",
1565                                          res);
1566                                 region.start = 0x376;
1567                                 region.end = 0x376;
1568                                 res = &dev->resource[3];
1569                                 res->flags = LEGACY_IO_RESOURCE;
1570                                 pcibios_bus_to_resource(dev->bus, res, &region);
1571                                 pci_info(dev, "legacy IDE quirk: reg 0x1c: %pR\n",
1572                                          res);
1573                         }
1574                 }
1575                 break;
1576
1577         case PCI_HEADER_TYPE_BRIDGE:                /* bridge header */
1578                 if (class != PCI_CLASS_BRIDGE_PCI)
1579                         goto bad;
1580
1581                 /*
1582                  * The PCI-to-PCI bridge spec requires that subtractive
1583                  * decoding (i.e. transparent) bridge must have programming
1584                  * interface code of 0x01.
1585                  */
1586                 pci_read_irq(dev);
1587                 dev->transparent = ((dev->class & 0xff) == 1);
1588                 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
1589                 set_pcie_hotplug_bridge(dev);
1590                 pos = pci_find_capability(dev, PCI_CAP_ID_SSVID);
1591                 if (pos) {
1592                         pci_read_config_word(dev, pos + PCI_SSVID_VENDOR_ID, &dev->subsystem_vendor);
1593                         pci_read_config_word(dev, pos + PCI_SSVID_DEVICE_ID, &dev->subsystem_device);
1594                 }
1595                 break;
1596
1597         case PCI_HEADER_TYPE_CARDBUS:               /* CardBus bridge header */
1598                 if (class != PCI_CLASS_BRIDGE_CARDBUS)
1599                         goto bad;
1600                 pci_read_irq(dev);
1601                 pci_read_bases(dev, 1, 0);
1602                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
1603                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device);
1604                 break;
1605
1606         default:                                    /* unknown header */
1607                 pci_err(dev, "unknown header type %02x, ignoring device\n",
1608                         dev->hdr_type);
1609                 return -EIO;
1610
1611         bad:
1612                 pci_err(dev, "ignoring class %#08x (doesn't match header type %02x)\n",
1613                         dev->class, dev->hdr_type);
1614                 dev->class = PCI_CLASS_NOT_DEFINED << 8;
1615         }
1616
1617         /* We found a fine healthy device, go go go... */
1618         return 0;
1619 }
1620
1621 static void pci_configure_mps(struct pci_dev *dev)
1622 {
1623         struct pci_dev *bridge = pci_upstream_bridge(dev);
1624         int mps, p_mps, rc;
1625
1626         if (!pci_is_pcie(dev) || !bridge || !pci_is_pcie(bridge))
1627                 return;
1628
1629         mps = pcie_get_mps(dev);
1630         p_mps = pcie_get_mps(bridge);
1631
1632         if (mps == p_mps)
1633                 return;
1634
1635         if (pcie_bus_config == PCIE_BUS_TUNE_OFF) {
1636                 pci_warn(dev, "Max Payload Size %d, but upstream %s set to %d; if necessary, use \"pci=pcie_bus_safe\" and report a bug\n",
1637                          mps, pci_name(bridge), p_mps);
1638                 return;
1639         }
1640
1641         /*
1642          * Fancier MPS configuration is done later by
1643          * pcie_bus_configure_settings()
1644          */
1645         if (pcie_bus_config != PCIE_BUS_DEFAULT)
1646                 return;
1647
1648         rc = pcie_set_mps(dev, p_mps);
1649         if (rc) {
1650                 pci_warn(dev, "can't set Max Payload Size to %d; if necessary, use \"pci=pcie_bus_safe\" and report a bug\n",
1651                          p_mps);
1652                 return;
1653         }
1654
1655         pci_info(dev, "Max Payload Size set to %d (was %d, max %d)\n",
1656                  p_mps, mps, 128 << dev->pcie_mpss);
1657 }
1658
1659 static struct hpp_type0 pci_default_type0 = {
1660         .revision = 1,
1661         .cache_line_size = 8,
1662         .latency_timer = 0x40,
1663         .enable_serr = 0,
1664         .enable_perr = 0,
1665 };
1666
1667 static void program_hpp_type0(struct pci_dev *dev, struct hpp_type0 *hpp)
1668 {
1669         u16 pci_cmd, pci_bctl;
1670
1671         if (!hpp)
1672                 hpp = &pci_default_type0;
1673
1674         if (hpp->revision > 1) {
1675                 pci_warn(dev, "PCI settings rev %d not supported; using defaults\n",
1676                          hpp->revision);
1677                 hpp = &pci_default_type0;
1678         }
1679
1680         pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, hpp->cache_line_size);
1681         pci_write_config_byte(dev, PCI_LATENCY_TIMER, hpp->latency_timer);
1682         pci_read_config_word(dev, PCI_COMMAND, &pci_cmd);
1683         if (hpp->enable_serr)
1684                 pci_cmd |= PCI_COMMAND_SERR;
1685         if (hpp->enable_perr)
1686                 pci_cmd |= PCI_COMMAND_PARITY;
1687         pci_write_config_word(dev, PCI_COMMAND, pci_cmd);
1688
1689         /* Program bridge control value */
1690         if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI) {
1691                 pci_write_config_byte(dev, PCI_SEC_LATENCY_TIMER,
1692                                       hpp->latency_timer);
1693                 pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &pci_bctl);
1694                 if (hpp->enable_serr)
1695                         pci_bctl |= PCI_BRIDGE_CTL_SERR;
1696                 if (hpp->enable_perr)
1697                         pci_bctl |= PCI_BRIDGE_CTL_PARITY;
1698                 pci_write_config_word(dev, PCI_BRIDGE_CONTROL, pci_bctl);
1699         }
1700 }
1701
1702 static void program_hpp_type1(struct pci_dev *dev, struct hpp_type1 *hpp)
1703 {
1704         int pos;
1705
1706         if (!hpp)
1707                 return;
1708
1709         pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1710         if (!pos)
1711                 return;
1712
1713         pci_warn(dev, "PCI-X settings not supported\n");
1714 }
1715
1716 static bool pcie_root_rcb_set(struct pci_dev *dev)
1717 {
1718         struct pci_dev *rp = pcie_find_root_port(dev);
1719         u16 lnkctl;
1720
1721         if (!rp)
1722                 return false;
1723
1724         pcie_capability_read_word(rp, PCI_EXP_LNKCTL, &lnkctl);
1725         if (lnkctl & PCI_EXP_LNKCTL_RCB)
1726                 return true;
1727
1728         return false;
1729 }
1730
1731 static void program_hpp_type2(struct pci_dev *dev, struct hpp_type2 *hpp)
1732 {
1733         int pos;
1734         u32 reg32;
1735
1736         if (!hpp)
1737                 return;
1738
1739         if (!pci_is_pcie(dev))
1740                 return;
1741
1742         if (hpp->revision > 1) {
1743                 pci_warn(dev, "PCIe settings rev %d not supported\n",
1744                          hpp->revision);
1745                 return;
1746         }
1747
1748         /*
1749          * Don't allow _HPX to change MPS or MRRS settings.  We manage
1750          * those to make sure they're consistent with the rest of the
1751          * platform.
1752          */
1753         hpp->pci_exp_devctl_and |= PCI_EXP_DEVCTL_PAYLOAD |
1754                                     PCI_EXP_DEVCTL_READRQ;
1755         hpp->pci_exp_devctl_or &= ~(PCI_EXP_DEVCTL_PAYLOAD |
1756                                     PCI_EXP_DEVCTL_READRQ);
1757
1758         /* Initialize Device Control Register */
1759         pcie_capability_clear_and_set_word(dev, PCI_EXP_DEVCTL,
1760                         ~hpp->pci_exp_devctl_and, hpp->pci_exp_devctl_or);
1761
1762         /* Initialize Link Control Register */
1763         if (pcie_cap_has_lnkctl(dev)) {
1764
1765                 /*
1766                  * If the Root Port supports Read Completion Boundary of
1767                  * 128, set RCB to 128.  Otherwise, clear it.
1768                  */
1769                 hpp->pci_exp_lnkctl_and |= PCI_EXP_LNKCTL_RCB;
1770                 hpp->pci_exp_lnkctl_or &= ~PCI_EXP_LNKCTL_RCB;
1771                 if (pcie_root_rcb_set(dev))
1772                         hpp->pci_exp_lnkctl_or |= PCI_EXP_LNKCTL_RCB;
1773
1774                 pcie_capability_clear_and_set_word(dev, PCI_EXP_LNKCTL,
1775                         ~hpp->pci_exp_lnkctl_and, hpp->pci_exp_lnkctl_or);
1776         }
1777
1778         /* Find Advanced Error Reporting Enhanced Capability */
1779         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
1780         if (!pos)
1781                 return;
1782
1783         /* Initialize Uncorrectable Error Mask Register */
1784         pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_MASK, &reg32);
1785         reg32 = (reg32 & hpp->unc_err_mask_and) | hpp->unc_err_mask_or;
1786         pci_write_config_dword(dev, pos + PCI_ERR_UNCOR_MASK, reg32);
1787
1788         /* Initialize Uncorrectable Error Severity Register */
1789         pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_SEVER, &reg32);
1790         reg32 = (reg32 & hpp->unc_err_sever_and) | hpp->unc_err_sever_or;
1791         pci_write_config_dword(dev, pos + PCI_ERR_UNCOR_SEVER, reg32);
1792
1793         /* Initialize Correctable Error Mask Register */
1794         pci_read_config_dword(dev, pos + PCI_ERR_COR_MASK, &reg32);
1795         reg32 = (reg32 & hpp->cor_err_mask_and) | hpp->cor_err_mask_or;
1796         pci_write_config_dword(dev, pos + PCI_ERR_COR_MASK, reg32);
1797
1798         /* Initialize Advanced Error Capabilities and Control Register */
1799         pci_read_config_dword(dev, pos + PCI_ERR_CAP, &reg32);
1800         reg32 = (reg32 & hpp->adv_err_cap_and) | hpp->adv_err_cap_or;
1801
1802         /* Don't enable ECRC generation or checking if unsupported */
1803         if (!(reg32 & PCI_ERR_CAP_ECRC_GENC))
1804                 reg32 &= ~PCI_ERR_CAP_ECRC_GENE;
1805         if (!(reg32 & PCI_ERR_CAP_ECRC_CHKC))
1806                 reg32 &= ~PCI_ERR_CAP_ECRC_CHKE;
1807         pci_write_config_dword(dev, pos + PCI_ERR_CAP, reg32);
1808
1809         /*
1810          * FIXME: The following two registers are not supported yet.
1811          *
1812          *   o Secondary Uncorrectable Error Severity Register
1813          *   o Secondary Uncorrectable Error Mask Register
1814          */
1815 }
1816
1817 int pci_configure_extended_tags(struct pci_dev *dev, void *ign)
1818 {
1819         struct pci_host_bridge *host;
1820         u32 cap;
1821         u16 ctl;
1822         int ret;
1823
1824         if (!pci_is_pcie(dev))
1825                 return 0;
1826
1827         ret = pcie_capability_read_dword(dev, PCI_EXP_DEVCAP, &cap);
1828         if (ret)
1829                 return 0;
1830
1831         if (!(cap & PCI_EXP_DEVCAP_EXT_TAG))
1832                 return 0;
1833
1834         ret = pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &ctl);
1835         if (ret)
1836                 return 0;
1837
1838         host = pci_find_host_bridge(dev->bus);
1839         if (!host)
1840                 return 0;
1841
1842         /*
1843          * If some device in the hierarchy doesn't handle Extended Tags
1844          * correctly, make sure they're disabled.
1845          */
1846         if (host->no_ext_tags) {
1847                 if (ctl & PCI_EXP_DEVCTL_EXT_TAG) {
1848                         pci_info(dev, "disabling Extended Tags\n");
1849                         pcie_capability_clear_word(dev, PCI_EXP_DEVCTL,
1850                                                    PCI_EXP_DEVCTL_EXT_TAG);
1851                 }
1852                 return 0;
1853         }
1854
1855         if (!(ctl & PCI_EXP_DEVCTL_EXT_TAG)) {
1856                 pci_info(dev, "enabling Extended Tags\n");
1857                 pcie_capability_set_word(dev, PCI_EXP_DEVCTL,
1858                                          PCI_EXP_DEVCTL_EXT_TAG);
1859         }
1860         return 0;
1861 }
1862
1863 /**
1864  * pcie_relaxed_ordering_enabled - Probe for PCIe relaxed ordering enable
1865  * @dev: PCI device to query
1866  *
1867  * Returns true if the device has enabled relaxed ordering attribute.
1868  */
1869 bool pcie_relaxed_ordering_enabled(struct pci_dev *dev)
1870 {
1871         u16 v;
1872
1873         pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &v);
1874
1875         return !!(v & PCI_EXP_DEVCTL_RELAX_EN);
1876 }
1877 EXPORT_SYMBOL(pcie_relaxed_ordering_enabled);
1878
1879 static void pci_configure_relaxed_ordering(struct pci_dev *dev)
1880 {
1881         struct pci_dev *root;
1882
1883         /* PCI_EXP_DEVICE_RELAX_EN is RsvdP in VFs */
1884         if (dev->is_virtfn)
1885                 return;
1886
1887         if (!pcie_relaxed_ordering_enabled(dev))
1888                 return;
1889
1890         /*
1891          * For now, we only deal with Relaxed Ordering issues with Root
1892          * Ports. Peer-to-Peer DMA is another can of worms.
1893          */
1894         root = pci_find_pcie_root_port(dev);
1895         if (!root)
1896                 return;
1897
1898         if (root->dev_flags & PCI_DEV_FLAGS_NO_RELAXED_ORDERING) {
1899                 pcie_capability_clear_word(dev, PCI_EXP_DEVCTL,
1900                                            PCI_EXP_DEVCTL_RELAX_EN);
1901                 pci_info(dev, "Relaxed Ordering disabled because the Root Port didn't support it\n");
1902         }
1903 }
1904
1905 static void pci_configure_ltr(struct pci_dev *dev)
1906 {
1907 #ifdef CONFIG_PCIEASPM
1908         u32 cap;
1909         struct pci_dev *bridge;
1910
1911         if (!pci_is_pcie(dev))
1912                 return;
1913
1914         pcie_capability_read_dword(dev, PCI_EXP_DEVCAP2, &cap);
1915         if (!(cap & PCI_EXP_DEVCAP2_LTR))
1916                 return;
1917
1918         /*
1919          * Software must not enable LTR in an Endpoint unless the Root
1920          * Complex and all intermediate Switches indicate support for LTR.
1921          * PCIe r3.1, sec 6.18.
1922          */
1923         if (pci_pcie_type(dev) == PCI_EXP_TYPE_ROOT_PORT)
1924                 dev->ltr_path = 1;
1925         else {
1926                 bridge = pci_upstream_bridge(dev);
1927                 if (bridge && bridge->ltr_path)
1928                         dev->ltr_path = 1;
1929         }
1930
1931         if (dev->ltr_path)
1932                 pcie_capability_set_word(dev, PCI_EXP_DEVCTL2,
1933                                          PCI_EXP_DEVCTL2_LTR_EN);
1934 #endif
1935 }
1936
1937 static void pci_configure_device(struct pci_dev *dev)
1938 {
1939         struct hotplug_params hpp;
1940         int ret;
1941
1942         pci_configure_mps(dev);
1943         pci_configure_extended_tags(dev, NULL);
1944         pci_configure_relaxed_ordering(dev);
1945         pci_configure_ltr(dev);
1946
1947         memset(&hpp, 0, sizeof(hpp));
1948         ret = pci_get_hp_params(dev, &hpp);
1949         if (ret)
1950                 return;
1951
1952         program_hpp_type2(dev, hpp.t2);
1953         program_hpp_type1(dev, hpp.t1);
1954         program_hpp_type0(dev, hpp.t0);
1955 }
1956
1957 static void pci_release_capabilities(struct pci_dev *dev)
1958 {
1959         pci_vpd_release(dev);
1960         pci_iov_release(dev);
1961         pci_free_cap_save_buffers(dev);
1962 }
1963
1964 /**
1965  * pci_release_dev - Free a PCI device structure when all users of it are
1966  *                   finished
1967  * @dev: device that's been disconnected
1968  *
1969  * Will be called only by the device core when all users of this PCI device are
1970  * done.
1971  */
1972 static void pci_release_dev(struct device *dev)
1973 {
1974         struct pci_dev *pci_dev;
1975
1976         pci_dev = to_pci_dev(dev);
1977         pci_release_capabilities(pci_dev);
1978         pci_release_of_node(pci_dev);
1979         pcibios_release_device(pci_dev);
1980         pci_bus_put(pci_dev->bus);
1981         kfree(pci_dev->driver_override);
1982         kfree(pci_dev->dma_alias_mask);
1983         kfree(pci_dev);
1984 }
1985
1986 struct pci_dev *pci_alloc_dev(struct pci_bus *bus)
1987 {
1988         struct pci_dev *dev;
1989
1990         dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
1991         if (!dev)
1992                 return NULL;
1993
1994         INIT_LIST_HEAD(&dev->bus_list);
1995         dev->dev.type = &pci_dev_type;
1996         dev->bus = pci_bus_get(bus);
1997
1998         return dev;
1999 }
2000 EXPORT_SYMBOL(pci_alloc_dev);
2001
2002 static bool pci_bus_crs_vendor_id(u32 l)
2003 {
2004         return (l & 0xffff) == 0x0001;
2005 }
2006
2007 static bool pci_bus_wait_crs(struct pci_bus *bus, int devfn, u32 *l,
2008                              int timeout)
2009 {
2010         int delay = 1;
2011
2012         if (!pci_bus_crs_vendor_id(*l))
2013                 return true;    /* not a CRS completion */
2014
2015         if (!timeout)
2016                 return false;   /* CRS, but caller doesn't want to wait */
2017
2018         /*
2019          * We got the reserved Vendor ID that indicates a completion with
2020          * Configuration Request Retry Status (CRS).  Retry until we get a
2021          * valid Vendor ID or we time out.
2022          */
2023         while (pci_bus_crs_vendor_id(*l)) {
2024                 if (delay > timeout) {
2025                         pr_warn("pci %04x:%02x:%02x.%d: not ready after %dms; giving up\n",
2026                                 pci_domain_nr(bus), bus->number,
2027                                 PCI_SLOT(devfn), PCI_FUNC(devfn), delay - 1);
2028
2029                         return false;
2030                 }
2031                 if (delay >= 1000)
2032                         pr_info("pci %04x:%02x:%02x.%d: not ready after %dms; waiting\n",
2033                                 pci_domain_nr(bus), bus->number,
2034                                 PCI_SLOT(devfn), PCI_FUNC(devfn), delay - 1);
2035
2036                 msleep(delay);
2037                 delay *= 2;
2038
2039                 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
2040                         return false;
2041         }
2042
2043         if (delay >= 1000)
2044                 pr_info("pci %04x:%02x:%02x.%d: ready after %dms\n",
2045                         pci_domain_nr(bus), bus->number,
2046                         PCI_SLOT(devfn), PCI_FUNC(devfn), delay - 1);
2047
2048         return true;
2049 }
2050
2051 bool pci_bus_read_dev_vendor_id(struct pci_bus *bus, int devfn, u32 *l,
2052                                 int timeout)
2053 {
2054         if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
2055                 return false;
2056
2057         /* Some broken boards return 0 or ~0 if a slot is empty: */
2058         if (*l == 0xffffffff || *l == 0x00000000 ||
2059             *l == 0x0000ffff || *l == 0xffff0000)
2060                 return false;
2061
2062         if (pci_bus_crs_vendor_id(*l))
2063                 return pci_bus_wait_crs(bus, devfn, l, timeout);
2064
2065         return true;
2066 }
2067 EXPORT_SYMBOL(pci_bus_read_dev_vendor_id);
2068
2069 /*
2070  * Read the config data for a PCI device, sanity-check it,
2071  * and fill in the dev structure.
2072  */
2073 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
2074 {
2075         struct pci_dev *dev;
2076         u32 l;
2077
2078         if (!pci_bus_read_dev_vendor_id(bus, devfn, &l, 60*1000))
2079                 return NULL;
2080
2081         dev = pci_alloc_dev(bus);
2082         if (!dev)
2083                 return NULL;
2084
2085         dev->devfn = devfn;
2086         dev->vendor = l & 0xffff;
2087         dev->device = (l >> 16) & 0xffff;
2088
2089         pci_set_of_node(dev);
2090
2091         if (pci_setup_device(dev)) {
2092                 pci_bus_put(dev->bus);
2093                 kfree(dev);
2094                 return NULL;
2095         }
2096
2097         return dev;
2098 }
2099
2100 static void pci_init_capabilities(struct pci_dev *dev)
2101 {
2102         /* Enhanced Allocation */
2103         pci_ea_init(dev);
2104
2105         /* Setup MSI caps & disable MSI/MSI-X interrupts */
2106         pci_msi_setup_pci_dev(dev);
2107
2108         /* Buffers for saving PCIe and PCI-X capabilities */
2109         pci_allocate_cap_save_buffers(dev);
2110
2111         /* Power Management */
2112         pci_pm_init(dev);
2113
2114         /* Vital Product Data */
2115         pci_vpd_init(dev);
2116
2117         /* Alternative Routing-ID Forwarding */
2118         pci_configure_ari(dev);
2119
2120         /* Single Root I/O Virtualization */
2121         pci_iov_init(dev);
2122
2123         /* Address Translation Services */
2124         pci_ats_init(dev);
2125
2126         /* Enable ACS P2P upstream forwarding */
2127         pci_enable_acs(dev);
2128
2129         /* Precision Time Measurement */
2130         pci_ptm_init(dev);
2131
2132         /* Advanced Error Reporting */
2133         pci_aer_init(dev);
2134 }
2135
2136 /*
2137  * This is the equivalent of pci_host_bridge_msi_domain() that acts on
2138  * devices. Firmware interfaces that can select the MSI domain on a
2139  * per-device basis should be called from here.
2140  */
2141 static struct irq_domain *pci_dev_msi_domain(struct pci_dev *dev)
2142 {
2143         struct irq_domain *d;
2144
2145         /*
2146          * If a domain has been set through the pcibios_add_device()
2147          * callback, then this is the one (platform code knows best).
2148          */
2149         d = dev_get_msi_domain(&dev->dev);
2150         if (d)
2151                 return d;
2152
2153         /*
2154          * Let's see if we have a firmware interface able to provide
2155          * the domain.
2156          */
2157         d = pci_msi_get_device_domain(dev);
2158         if (d)
2159                 return d;
2160
2161         return NULL;
2162 }
2163
2164 static void pci_set_msi_domain(struct pci_dev *dev)
2165 {
2166         struct irq_domain *d;
2167
2168         /*
2169          * If the platform or firmware interfaces cannot supply a
2170          * device-specific MSI domain, then inherit the default domain
2171          * from the host bridge itself.
2172          */
2173         d = pci_dev_msi_domain(dev);
2174         if (!d)
2175                 d = dev_get_msi_domain(&dev->bus->dev);
2176
2177         dev_set_msi_domain(&dev->dev, d);
2178 }
2179
2180 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
2181 {
2182         int ret;
2183
2184         pci_configure_device(dev);
2185
2186         device_initialize(&dev->dev);
2187         dev->dev.release = pci_release_dev;
2188
2189         set_dev_node(&dev->dev, pcibus_to_node(bus));
2190         dev->dev.dma_mask = &dev->dma_mask;
2191         dev->dev.dma_parms = &dev->dma_parms;
2192         dev->dev.coherent_dma_mask = 0xffffffffull;
2193
2194         pci_set_dma_max_seg_size(dev, 65536);
2195         pci_set_dma_seg_boundary(dev, 0xffffffff);
2196
2197         /* Fix up broken headers */
2198         pci_fixup_device(pci_fixup_header, dev);
2199
2200         /* Moved out from quirk header fixup code */
2201         pci_reassigndev_resource_alignment(dev);
2202
2203         /* Clear the state_saved flag */
2204         dev->state_saved = false;
2205
2206         /* Initialize various capabilities */
2207         pci_init_capabilities(dev);
2208
2209         /*
2210          * Add the device to our list of discovered devices
2211          * and the bus list for fixup functions, etc.
2212          */
2213         down_write(&pci_bus_sem);
2214         list_add_tail(&dev->bus_list, &bus->devices);
2215         up_write(&pci_bus_sem);
2216
2217         ret = pcibios_add_device(dev);
2218         WARN_ON(ret < 0);
2219
2220         /* Set up MSI IRQ domain */
2221         pci_set_msi_domain(dev);
2222
2223         /* Notifier could use PCI capabilities */
2224         dev->match_driver = false;
2225         ret = device_add(&dev->dev);
2226         WARN_ON(ret < 0);
2227 }
2228
2229 struct pci_dev *pci_scan_single_device(struct pci_bus *bus, int devfn)
2230 {
2231         struct pci_dev *dev;
2232
2233         dev = pci_get_slot(bus, devfn);
2234         if (dev) {
2235                 pci_dev_put(dev);
2236                 return dev;
2237         }
2238
2239         dev = pci_scan_device(bus, devfn);
2240         if (!dev)
2241                 return NULL;
2242
2243         pci_device_add(dev, bus);
2244
2245         return dev;
2246 }
2247 EXPORT_SYMBOL(pci_scan_single_device);
2248
2249 static unsigned next_fn(struct pci_bus *bus, struct pci_dev *dev, unsigned fn)
2250 {
2251         int pos;
2252         u16 cap = 0;
2253         unsigned next_fn;
2254
2255         if (pci_ari_enabled(bus)) {
2256                 if (!dev)
2257                         return 0;
2258                 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI);
2259                 if (!pos)
2260                         return 0;
2261
2262                 pci_read_config_word(dev, pos + PCI_ARI_CAP, &cap);
2263                 next_fn = PCI_ARI_CAP_NFN(cap);
2264                 if (next_fn <= fn)
2265                         return 0;       /* protect against malformed list */
2266
2267                 return next_fn;
2268         }
2269
2270         /* dev may be NULL for non-contiguous multifunction devices */
2271         if (!dev || dev->multifunction)
2272                 return (fn + 1) % 8;
2273
2274         return 0;
2275 }
2276
2277 static int only_one_child(struct pci_bus *bus)
2278 {
2279         struct pci_dev *bridge = bus->self;
2280
2281         /*
2282          * Systems with unusual topologies set PCI_SCAN_ALL_PCIE_DEVS so
2283          * we scan for all possible devices, not just Device 0.
2284          */
2285         if (pci_has_flag(PCI_SCAN_ALL_PCIE_DEVS))
2286                 return 0;
2287
2288         /*
2289          * A PCIe Downstream Port normally leads to a Link with only Device
2290          * 0 on it (PCIe spec r3.1, sec 7.3.1).  As an optimization, scan
2291          * only for Device 0 in that situation.
2292          *
2293          * Checking has_secondary_link is a hack to identify Downstream
2294          * Ports because sometimes Switches are configured such that the
2295          * PCIe Port Type labels are backwards.
2296          */
2297         if (bridge && pci_is_pcie(bridge) && bridge->has_secondary_link)
2298                 return 1;
2299
2300         return 0;
2301 }
2302
2303 /**
2304  * pci_scan_slot - Scan a PCI slot on a bus for devices
2305  * @bus: PCI bus to scan
2306  * @devfn: slot number to scan (must have zero function)
2307  *
2308  * Scan a PCI slot on the specified PCI bus for devices, adding
2309  * discovered devices to the @bus->devices list.  New devices
2310  * will not have is_added set.
2311  *
2312  * Returns the number of new devices found.
2313  */
2314 int pci_scan_slot(struct pci_bus *bus, int devfn)
2315 {
2316         unsigned fn, nr = 0;
2317         struct pci_dev *dev;
2318
2319         if (only_one_child(bus) && (devfn > 0))
2320                 return 0; /* Already scanned the entire slot */
2321
2322         dev = pci_scan_single_device(bus, devfn);
2323         if (!dev)
2324                 return 0;
2325         if (!dev->is_added)
2326                 nr++;
2327
2328         for (fn = next_fn(bus, dev, 0); fn > 0; fn = next_fn(bus, dev, fn)) {
2329                 dev = pci_scan_single_device(bus, devfn + fn);
2330                 if (dev) {
2331                         if (!dev->is_added)
2332                                 nr++;
2333                         dev->multifunction = 1;
2334                 }
2335         }
2336
2337         /* Only one slot has PCIe device */
2338         if (bus->self && nr)
2339                 pcie_aspm_init_link_state(bus->self);
2340
2341         return nr;
2342 }
2343 EXPORT_SYMBOL(pci_scan_slot);
2344
2345 static int pcie_find_smpss(struct pci_dev *dev, void *data)
2346 {
2347         u8 *smpss = data;
2348
2349         if (!pci_is_pcie(dev))
2350                 return 0;
2351
2352         /*
2353          * We don't have a way to change MPS settings on devices that have
2354          * drivers attached.  A hot-added device might support only the minimum
2355          * MPS setting (MPS=128).  Therefore, if the fabric contains a bridge
2356          * where devices may be hot-added, we limit the fabric MPS to 128 so
2357          * hot-added devices will work correctly.
2358          *
2359          * However, if we hot-add a device to a slot directly below a Root
2360          * Port, it's impossible for there to be other existing devices below
2361          * the port.  We don't limit the MPS in this case because we can
2362          * reconfigure MPS on both the Root Port and the hot-added device,
2363          * and there are no other devices involved.
2364          *
2365          * Note that this PCIE_BUS_SAFE path assumes no peer-to-peer DMA.
2366          */
2367         if (dev->is_hotplug_bridge &&
2368             pci_pcie_type(dev) != PCI_EXP_TYPE_ROOT_PORT)
2369                 *smpss = 0;
2370
2371         if (*smpss > dev->pcie_mpss)
2372                 *smpss = dev->pcie_mpss;
2373
2374         return 0;
2375 }
2376
2377 static void pcie_write_mps(struct pci_dev *dev, int mps)
2378 {
2379         int rc;
2380
2381         if (pcie_bus_config == PCIE_BUS_PERFORMANCE) {
2382                 mps = 128 << dev->pcie_mpss;
2383
2384                 if (pci_pcie_type(dev) != PCI_EXP_TYPE_ROOT_PORT &&
2385                     dev->bus->self)
2386
2387                         /*
2388                          * For "Performance", the assumption is made that
2389                          * downstream communication will never be larger than
2390                          * the MRRS.  So, the MPS only needs to be configured
2391                          * for the upstream communication.  This being the case,
2392                          * walk from the top down and set the MPS of the child
2393                          * to that of the parent bus.
2394                          *
2395                          * Configure the device MPS with the smaller of the
2396                          * device MPSS or the bridge MPS (which is assumed to be
2397                          * properly configured at this point to the largest
2398                          * allowable MPS based on its parent bus).
2399                          */
2400                         mps = min(mps, pcie_get_mps(dev->bus->self));
2401         }
2402
2403         rc = pcie_set_mps(dev, mps);
2404         if (rc)
2405                 pci_err(dev, "Failed attempting to set the MPS\n");
2406 }
2407
2408 static void pcie_write_mrrs(struct pci_dev *dev)
2409 {
2410         int rc, mrrs;
2411
2412         /*
2413          * In the "safe" case, do not configure the MRRS.  There appear to be
2414          * issues with setting MRRS to 0 on a number of devices.
2415          */
2416         if (pcie_bus_config != PCIE_BUS_PERFORMANCE)
2417                 return;
2418
2419         /*
2420          * For max performance, the MRRS must be set to the largest supported
2421          * value.  However, it cannot be configured larger than the MPS the
2422          * device or the bus can support.  This should already be properly
2423          * configured by a prior call to pcie_write_mps().
2424          */
2425         mrrs = pcie_get_mps(dev);
2426
2427         /*
2428          * MRRS is a R/W register.  Invalid values can be written, but a
2429          * subsequent read will verify if the value is acceptable or not.
2430          * If the MRRS value provided is not acceptable (e.g., too large),
2431          * shrink the value until it is acceptable to the HW.
2432          */
2433         while (mrrs != pcie_get_readrq(dev) && mrrs >= 128) {
2434                 rc = pcie_set_readrq(dev, mrrs);
2435                 if (!rc)
2436                         break;
2437
2438                 pci_warn(dev, "Failed attempting to set the MRRS\n");
2439                 mrrs /= 2;
2440         }
2441
2442         if (mrrs < 128)
2443                 pci_err(dev, "MRRS was unable to be configured with a safe value.  If problems are experienced, try running with pci=pcie_bus_safe\n");
2444 }
2445
2446 static int pcie_bus_configure_set(struct pci_dev *dev, void *data)
2447 {
2448         int mps, orig_mps;
2449
2450         if (!pci_is_pcie(dev))
2451                 return 0;
2452
2453         if (pcie_bus_config == PCIE_BUS_TUNE_OFF ||
2454             pcie_bus_config == PCIE_BUS_DEFAULT)
2455                 return 0;
2456
2457         mps = 128 << *(u8 *)data;
2458         orig_mps = pcie_get_mps(dev);
2459
2460         pcie_write_mps(dev, mps);
2461         pcie_write_mrrs(dev);
2462
2463         pci_info(dev, "Max Payload Size set to %4d/%4d (was %4d), Max Read Rq %4d\n",
2464                  pcie_get_mps(dev), 128 << dev->pcie_mpss,
2465                  orig_mps, pcie_get_readrq(dev));
2466
2467         return 0;
2468 }
2469
2470 /*
2471  * pcie_bus_configure_settings() requires that pci_walk_bus work in a top-down,
2472  * parents then children fashion.  If this changes, then this code will not
2473  * work as designed.
2474  */
2475 void pcie_bus_configure_settings(struct pci_bus *bus)
2476 {
2477         u8 smpss = 0;
2478
2479         if (!bus->self)
2480                 return;
2481
2482         if (!pci_is_pcie(bus->self))
2483                 return;
2484
2485         /*
2486          * FIXME - Peer to peer DMA is possible, though the endpoint would need
2487          * to be aware of the MPS of the destination.  To work around this,
2488          * simply force the MPS of the entire system to the smallest possible.
2489          */
2490         if (pcie_bus_config == PCIE_BUS_PEER2PEER)
2491                 smpss = 0;
2492
2493         if (pcie_bus_config == PCIE_BUS_SAFE) {
2494                 smpss = bus->self->pcie_mpss;
2495
2496                 pcie_find_smpss(bus->self, &smpss);
2497                 pci_walk_bus(bus, pcie_find_smpss, &smpss);
2498         }
2499
2500         pcie_bus_configure_set(bus->self, &smpss);
2501         pci_walk_bus(bus, pcie_bus_configure_set, &smpss);
2502 }
2503 EXPORT_SYMBOL_GPL(pcie_bus_configure_settings);
2504
2505 /*
2506  * Called after each bus is probed, but before its children are examined.  This
2507  * is marked as __weak because multiple architectures define it.
2508  */
2509 void __weak pcibios_fixup_bus(struct pci_bus *bus)
2510 {
2511        /* nothing to do, expected to be removed in the future */
2512 }
2513
2514 /**
2515  * pci_scan_child_bus_extend() - Scan devices below a bus
2516  * @bus: Bus to scan for devices
2517  * @available_buses: Total number of buses available (%0 does not try to
2518  *                   extend beyond the minimal)
2519  *
2520  * Scans devices below @bus including subordinate buses. Returns new
2521  * subordinate number including all the found devices. Passing
2522  * @available_buses causes the remaining bus space to be distributed
2523  * equally between hotplug-capable bridges to allow future extension of the
2524  * hierarchy.
2525  */
2526 static unsigned int pci_scan_child_bus_extend(struct pci_bus *bus,
2527                                               unsigned int available_buses)
2528 {
2529         unsigned int used_buses, normal_bridges = 0, hotplug_bridges = 0;
2530         unsigned int start = bus->busn_res.start;
2531         unsigned int devfn, cmax, max = start;
2532         struct pci_dev *dev;
2533
2534         dev_dbg(&bus->dev, "scanning bus\n");
2535
2536         /* Go find them, Rover! */
2537         for (devfn = 0; devfn < 0x100; devfn += 8)
2538                 pci_scan_slot(bus, devfn);
2539
2540         /* Reserve buses for SR-IOV capability */
2541         used_buses = pci_iov_bus_range(bus);
2542         max += used_buses;
2543
2544         /*
2545          * After performing arch-dependent fixup of the bus, look behind
2546          * all PCI-to-PCI bridges on this bus.
2547          */
2548         if (!bus->is_added) {
2549                 dev_dbg(&bus->dev, "fixups for bus\n");
2550                 pcibios_fixup_bus(bus);
2551                 bus->is_added = 1;
2552         }
2553
2554         /*
2555          * Calculate how many hotplug bridges and normal bridges there
2556          * are on this bus. We will distribute the additional available
2557          * buses between hotplug bridges.
2558          */
2559         for_each_pci_bridge(dev, bus) {
2560                 if (dev->is_hotplug_bridge)
2561                         hotplug_bridges++;
2562                 else
2563                         normal_bridges++;
2564         }
2565
2566         /*
2567          * Scan bridges that are already configured. We don't touch them
2568          * unless they are misconfigured (which will be done in the second
2569          * scan below).
2570          */
2571         for_each_pci_bridge(dev, bus) {
2572                 cmax = max;
2573                 max = pci_scan_bridge_extend(bus, dev, max, 0, 0);
2574                 used_buses += cmax - max;
2575         }
2576
2577         /* Scan bridges that need to be reconfigured */
2578         for_each_pci_bridge(dev, bus) {
2579                 unsigned int buses = 0;
2580
2581                 if (!hotplug_bridges && normal_bridges == 1) {
2582
2583                         /*
2584                          * There is only one bridge on the bus (upstream
2585                          * port) so it gets all available buses which it
2586                          * can then distribute to the possible hotplug
2587                          * bridges below.
2588                          */
2589                         buses = available_buses;
2590                 } else if (dev->is_hotplug_bridge) {
2591
2592                         /*
2593                          * Distribute the extra buses between hotplug
2594                          * bridges if any.
2595                          */
2596                         buses = available_buses / hotplug_bridges;
2597                         buses = min(buses, available_buses - used_buses);
2598                 }
2599
2600                 cmax = max;
2601                 max = pci_scan_bridge_extend(bus, dev, cmax, buses, 1);
2602                 used_buses += max - cmax;
2603         }
2604
2605         /*
2606          * Make sure a hotplug bridge has at least the minimum requested
2607          * number of buses but allow it to grow up to the maximum available
2608          * bus number of there is room.
2609          */
2610         if (bus->self && bus->self->is_hotplug_bridge) {
2611                 used_buses = max_t(unsigned int, available_buses,
2612                                    pci_hotplug_bus_size - 1);
2613                 if (max - start < used_buses) {
2614                         max = start + used_buses;
2615
2616                         /* Do not allocate more buses than we have room left */
2617                         if (max > bus->busn_res.end)
2618                                 max = bus->busn_res.end;
2619
2620                         dev_dbg(&bus->dev, "%pR extended by %#02x\n",
2621                                 &bus->busn_res, max - start);
2622                 }
2623         }
2624
2625         /*
2626          * We've scanned the bus and so we know all about what's on
2627          * the other side of any bridges that may be on this bus plus
2628          * any devices.
2629          *
2630          * Return how far we've got finding sub-buses.
2631          */
2632         dev_dbg(&bus->dev, "bus scan returning with max=%02x\n", max);
2633         return max;
2634 }
2635
2636 /**
2637  * pci_scan_child_bus() - Scan devices below a bus
2638  * @bus: Bus to scan for devices
2639  *
2640  * Scans devices below @bus including subordinate buses. Returns new
2641  * subordinate number including all the found devices.
2642  */
2643 unsigned int pci_scan_child_bus(struct pci_bus *bus)
2644 {
2645         return pci_scan_child_bus_extend(bus, 0);
2646 }
2647 EXPORT_SYMBOL_GPL(pci_scan_child_bus);
2648
2649 /**
2650  * pcibios_root_bridge_prepare - Platform-specific host bridge setup
2651  * @bridge: Host bridge to set up
2652  *
2653  * Default empty implementation.  Replace with an architecture-specific setup
2654  * routine, if necessary.
2655  */
2656 int __weak pcibios_root_bridge_prepare(struct pci_host_bridge *bridge)
2657 {
2658         return 0;
2659 }
2660
2661 void __weak pcibios_add_bus(struct pci_bus *bus)
2662 {
2663 }
2664
2665 void __weak pcibios_remove_bus(struct pci_bus *bus)
2666 {
2667 }
2668
2669 struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
2670                 struct pci_ops *ops, void *sysdata, struct list_head *resources)
2671 {
2672         int error;
2673         struct pci_host_bridge *bridge;
2674
2675         bridge = pci_alloc_host_bridge(0);
2676         if (!bridge)
2677                 return NULL;
2678
2679         bridge->dev.parent = parent;
2680
2681         list_splice_init(resources, &bridge->windows);
2682         bridge->sysdata = sysdata;
2683         bridge->busnr = bus;
2684         bridge->ops = ops;
2685
2686         error = pci_register_host_bridge(bridge);
2687         if (error < 0)
2688                 goto err_out;
2689
2690         return bridge->bus;
2691
2692 err_out:
2693         kfree(bridge);
2694         return NULL;
2695 }
2696 EXPORT_SYMBOL_GPL(pci_create_root_bus);
2697
2698 int pci_host_probe(struct pci_host_bridge *bridge)
2699 {
2700         struct pci_bus *bus, *child;
2701         int ret;
2702
2703         ret = pci_scan_root_bus_bridge(bridge);
2704         if (ret < 0) {
2705                 dev_err(bridge->dev.parent, "Scanning root bridge failed");
2706                 return ret;
2707         }
2708
2709         bus = bridge->bus;
2710
2711         /*
2712          * We insert PCI resources into the iomem_resource and
2713          * ioport_resource trees in either pci_bus_claim_resources()
2714          * or pci_bus_assign_resources().
2715          */
2716         if (pci_has_flag(PCI_PROBE_ONLY)) {
2717                 pci_bus_claim_resources(bus);
2718         } else {
2719                 pci_bus_size_bridges(bus);
2720                 pci_bus_assign_resources(bus);
2721
2722                 list_for_each_entry(child, &bus->children, node)
2723                         pcie_bus_configure_settings(child);
2724         }
2725
2726         pci_bus_add_devices(bus);
2727         return 0;
2728 }
2729 EXPORT_SYMBOL_GPL(pci_host_probe);
2730
2731 int pci_bus_insert_busn_res(struct pci_bus *b, int bus, int bus_max)
2732 {
2733         struct resource *res = &b->busn_res;
2734         struct resource *parent_res, *conflict;
2735
2736         res->start = bus;
2737         res->end = bus_max;
2738         res->flags = IORESOURCE_BUS;
2739
2740         if (!pci_is_root_bus(b))
2741                 parent_res = &b->parent->busn_res;
2742         else {
2743                 parent_res = get_pci_domain_busn_res(pci_domain_nr(b));
2744                 res->flags |= IORESOURCE_PCI_FIXED;
2745         }
2746
2747         conflict = request_resource_conflict(parent_res, res);
2748
2749         if (conflict)
2750                 dev_printk(KERN_DEBUG, &b->dev,
2751                            "busn_res: can not insert %pR under %s%pR (conflicts with %s %pR)\n",
2752                             res, pci_is_root_bus(b) ? "domain " : "",
2753                             parent_res, conflict->name, conflict);
2754
2755         return conflict == NULL;
2756 }
2757
2758 int pci_bus_update_busn_res_end(struct pci_bus *b, int bus_max)
2759 {
2760         struct resource *res = &b->busn_res;
2761         struct resource old_res = *res;
2762         resource_size_t size;
2763         int ret;
2764
2765         if (res->start > bus_max)
2766                 return -EINVAL;
2767
2768         size = bus_max - res->start + 1;
2769         ret = adjust_resource(res, res->start, size);
2770         dev_printk(KERN_DEBUG, &b->dev,
2771                         "busn_res: %pR end %s updated to %02x\n",
2772                         &old_res, ret ? "can not be" : "is", bus_max);
2773
2774         if (!ret && !res->parent)
2775                 pci_bus_insert_busn_res(b, res->start, res->end);
2776
2777         return ret;
2778 }
2779
2780 void pci_bus_release_busn_res(struct pci_bus *b)
2781 {
2782         struct resource *res = &b->busn_res;
2783         int ret;
2784
2785         if (!res->flags || !res->parent)
2786                 return;
2787
2788         ret = release_resource(res);
2789         dev_printk(KERN_DEBUG, &b->dev,
2790                         "busn_res: %pR %s released\n",
2791                         res, ret ? "can not be" : "is");
2792 }
2793
2794 int pci_scan_root_bus_bridge(struct pci_host_bridge *bridge)
2795 {
2796         struct resource_entry *window;
2797         bool found = false;
2798         struct pci_bus *b;
2799         int max, bus, ret;
2800
2801         if (!bridge)
2802                 return -EINVAL;
2803
2804         resource_list_for_each_entry(window, &bridge->windows)
2805                 if (window->res->flags & IORESOURCE_BUS) {
2806                         found = true;
2807                         break;
2808                 }
2809
2810         ret = pci_register_host_bridge(bridge);
2811         if (ret < 0)
2812                 return ret;
2813
2814         b = bridge->bus;
2815         bus = bridge->busnr;
2816
2817         if (!found) {
2818                 dev_info(&b->dev,
2819                  "No busn resource found for root bus, will use [bus %02x-ff]\n",
2820                         bus);
2821                 pci_bus_insert_busn_res(b, bus, 255);
2822         }
2823
2824         max = pci_scan_child_bus(b);
2825
2826         if (!found)
2827                 pci_bus_update_busn_res_end(b, max);
2828
2829         return 0;
2830 }
2831 EXPORT_SYMBOL(pci_scan_root_bus_bridge);
2832
2833 struct pci_bus *pci_scan_root_bus(struct device *parent, int bus,
2834                 struct pci_ops *ops, void *sysdata, struct list_head *resources)
2835 {
2836         struct resource_entry *window;
2837         bool found = false;
2838         struct pci_bus *b;
2839         int max;
2840
2841         resource_list_for_each_entry(window, resources)
2842                 if (window->res->flags & IORESOURCE_BUS) {
2843                         found = true;
2844                         break;
2845                 }
2846
2847         b = pci_create_root_bus(parent, bus, ops, sysdata, resources);
2848         if (!b)
2849                 return NULL;
2850
2851         if (!found) {
2852                 dev_info(&b->dev,
2853                  "No busn resource found for root bus, will use [bus %02x-ff]\n",
2854                         bus);
2855                 pci_bus_insert_busn_res(b, bus, 255);
2856         }
2857
2858         max = pci_scan_child_bus(b);
2859
2860         if (!found)
2861                 pci_bus_update_busn_res_end(b, max);
2862
2863         return b;
2864 }
2865 EXPORT_SYMBOL(pci_scan_root_bus);
2866
2867 struct pci_bus *pci_scan_bus(int bus, struct pci_ops *ops,
2868                                         void *sysdata)
2869 {
2870         LIST_HEAD(resources);
2871         struct pci_bus *b;
2872
2873         pci_add_resource(&resources, &ioport_resource);
2874         pci_add_resource(&resources, &iomem_resource);
2875         pci_add_resource(&resources, &busn_resource);
2876         b = pci_create_root_bus(NULL, bus, ops, sysdata, &resources);
2877         if (b) {
2878                 pci_scan_child_bus(b);
2879         } else {
2880                 pci_free_resource_list(&resources);
2881         }
2882         return b;
2883 }
2884 EXPORT_SYMBOL(pci_scan_bus);
2885
2886 /**
2887  * pci_rescan_bus_bridge_resize - Scan a PCI bus for devices
2888  * @bridge: PCI bridge for the bus to scan
2889  *
2890  * Scan a PCI bus and child buses for new devices, add them,
2891  * and enable them, resizing bridge mmio/io resource if necessary
2892  * and possible.  The caller must ensure the child devices are already
2893  * removed for resizing to occur.
2894  *
2895  * Returns the max number of subordinate bus discovered.
2896  */
2897 unsigned int pci_rescan_bus_bridge_resize(struct pci_dev *bridge)
2898 {
2899         unsigned int max;
2900         struct pci_bus *bus = bridge->subordinate;
2901
2902         max = pci_scan_child_bus(bus);
2903
2904         pci_assign_unassigned_bridge_resources(bridge);
2905
2906         pci_bus_add_devices(bus);
2907
2908         return max;
2909 }
2910
2911 /**
2912  * pci_rescan_bus - Scan a PCI bus for devices
2913  * @bus: PCI bus to scan
2914  *
2915  * Scan a PCI bus and child buses for new devices, add them,
2916  * and enable them.
2917  *
2918  * Returns the max number of subordinate bus discovered.
2919  */
2920 unsigned int pci_rescan_bus(struct pci_bus *bus)
2921 {
2922         unsigned int max;
2923
2924         max = pci_scan_child_bus(bus);
2925         pci_assign_unassigned_bus_resources(bus);
2926         pci_bus_add_devices(bus);
2927
2928         return max;
2929 }
2930 EXPORT_SYMBOL_GPL(pci_rescan_bus);
2931
2932 /*
2933  * pci_rescan_bus(), pci_rescan_bus_bridge_resize() and PCI device removal
2934  * routines should always be executed under this mutex.
2935  */
2936 static DEFINE_MUTEX(pci_rescan_remove_lock);
2937
2938 void pci_lock_rescan_remove(void)
2939 {
2940         mutex_lock(&pci_rescan_remove_lock);
2941 }
2942 EXPORT_SYMBOL_GPL(pci_lock_rescan_remove);
2943
2944 void pci_unlock_rescan_remove(void)
2945 {
2946         mutex_unlock(&pci_rescan_remove_lock);
2947 }
2948 EXPORT_SYMBOL_GPL(pci_unlock_rescan_remove);
2949
2950 static int __init pci_sort_bf_cmp(const struct device *d_a,
2951                                   const struct device *d_b)
2952 {
2953         const struct pci_dev *a = to_pci_dev(d_a);
2954         const struct pci_dev *b = to_pci_dev(d_b);
2955
2956         if      (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
2957         else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return  1;
2958
2959         if      (a->bus->number < b->bus->number) return -1;
2960         else if (a->bus->number > b->bus->number) return  1;
2961
2962         if      (a->devfn < b->devfn) return -1;
2963         else if (a->devfn > b->devfn) return  1;
2964
2965         return 0;
2966 }
2967
2968 void __init pci_sort_breadthfirst(void)
2969 {
2970         bus_sort_breadthfirst(&pci_bus_type, &pci_sort_bf_cmp);
2971 }
2972
2973 int pci_hp_add_bridge(struct pci_dev *dev)
2974 {
2975         struct pci_bus *parent = dev->bus;
2976         int busnr, start = parent->busn_res.start;
2977         unsigned int available_buses = 0;
2978         int end = parent->busn_res.end;
2979
2980         for (busnr = start; busnr <= end; busnr++) {
2981                 if (!pci_find_bus(pci_domain_nr(parent), busnr))
2982                         break;
2983         }
2984         if (busnr-- > end) {
2985                 pci_err(dev, "No bus number available for hot-added bridge\n");
2986                 return -1;
2987         }
2988
2989         /* Scan bridges that are already configured */
2990         busnr = pci_scan_bridge(parent, dev, busnr, 0);
2991
2992         /*
2993          * Distribute the available bus numbers between hotplug-capable
2994          * bridges to make extending the chain later possible.
2995          */
2996         available_buses = end - busnr;
2997
2998         /* Scan bridges that need to be reconfigured */
2999         pci_scan_bridge_extend(parent, dev, busnr, available_buses, 1);
3000
3001         if (!dev->subordinate)
3002                 return -1;
3003
3004         return 0;
3005 }
3006 EXPORT_SYMBOL_GPL(pci_hp_add_bridge);