Merge tag 'pci-v5.1-changes' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci
[sfrench/cifs-2.6.git] / drivers / pci / pci.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * PCI Bus Services, see include/linux/pci.h for further explanation.
4  *
5  * Copyright 1993 -- 1997 Drew Eckhardt, Frederic Potter,
6  * David Mosberger-Tang
7  *
8  * Copyright 1997 -- 2000 Martin Mares <mj@ucw.cz>
9  */
10
11 #include <linux/acpi.h>
12 #include <linux/kernel.h>
13 #include <linux/delay.h>
14 #include <linux/dmi.h>
15 #include <linux/init.h>
16 #include <linux/of.h>
17 #include <linux/of_pci.h>
18 #include <linux/pci.h>
19 #include <linux/pm.h>
20 #include <linux/slab.h>
21 #include <linux/module.h>
22 #include <linux/spinlock.h>
23 #include <linux/string.h>
24 #include <linux/log2.h>
25 #include <linux/logic_pio.h>
26 #include <linux/pm_wakeup.h>
27 #include <linux/interrupt.h>
28 #include <linux/device.h>
29 #include <linux/pm_runtime.h>
30 #include <linux/pci_hotplug.h>
31 #include <linux/vmalloc.h>
32 #include <linux/pci-ats.h>
33 #include <asm/setup.h>
34 #include <asm/dma.h>
35 #include <linux/aer.h>
36 #include "pci.h"
37
38 DEFINE_MUTEX(pci_slot_mutex);
39
40 const char *pci_power_names[] = {
41         "error", "D0", "D1", "D2", "D3hot", "D3cold", "unknown",
42 };
43 EXPORT_SYMBOL_GPL(pci_power_names);
44
45 int isa_dma_bridge_buggy;
46 EXPORT_SYMBOL(isa_dma_bridge_buggy);
47
48 int pci_pci_problems;
49 EXPORT_SYMBOL(pci_pci_problems);
50
51 unsigned int pci_pm_d3_delay;
52
53 static void pci_pme_list_scan(struct work_struct *work);
54
55 static LIST_HEAD(pci_pme_list);
56 static DEFINE_MUTEX(pci_pme_list_mutex);
57 static DECLARE_DELAYED_WORK(pci_pme_work, pci_pme_list_scan);
58
59 struct pci_pme_device {
60         struct list_head list;
61         struct pci_dev *dev;
62 };
63
64 #define PME_TIMEOUT 1000 /* How long between PME checks */
65
66 static void pci_dev_d3_sleep(struct pci_dev *dev)
67 {
68         unsigned int delay = dev->d3_delay;
69
70         if (delay < pci_pm_d3_delay)
71                 delay = pci_pm_d3_delay;
72
73         if (delay)
74                 msleep(delay);
75 }
76
77 #ifdef CONFIG_PCI_DOMAINS
78 int pci_domains_supported = 1;
79 #endif
80
81 #define DEFAULT_CARDBUS_IO_SIZE         (256)
82 #define DEFAULT_CARDBUS_MEM_SIZE        (64*1024*1024)
83 /* pci=cbmemsize=nnM,cbiosize=nn can override this */
84 unsigned long pci_cardbus_io_size = DEFAULT_CARDBUS_IO_SIZE;
85 unsigned long pci_cardbus_mem_size = DEFAULT_CARDBUS_MEM_SIZE;
86
87 #define DEFAULT_HOTPLUG_IO_SIZE         (256)
88 #define DEFAULT_HOTPLUG_MEM_SIZE        (2*1024*1024)
89 /* pci=hpmemsize=nnM,hpiosize=nn can override this */
90 unsigned long pci_hotplug_io_size  = DEFAULT_HOTPLUG_IO_SIZE;
91 unsigned long pci_hotplug_mem_size = DEFAULT_HOTPLUG_MEM_SIZE;
92
93 #define DEFAULT_HOTPLUG_BUS_SIZE        1
94 unsigned long pci_hotplug_bus_size = DEFAULT_HOTPLUG_BUS_SIZE;
95
96 enum pcie_bus_config_types pcie_bus_config = PCIE_BUS_DEFAULT;
97
98 /*
99  * The default CLS is used if arch didn't set CLS explicitly and not
100  * all pci devices agree on the same value.  Arch can override either
101  * the dfl or actual value as it sees fit.  Don't forget this is
102  * measured in 32-bit words, not bytes.
103  */
104 u8 pci_dfl_cache_line_size = L1_CACHE_BYTES >> 2;
105 u8 pci_cache_line_size;
106
107 /*
108  * If we set up a device for bus mastering, we need to check the latency
109  * timer as certain BIOSes forget to set it properly.
110  */
111 unsigned int pcibios_max_latency = 255;
112
113 /* If set, the PCIe ARI capability will not be used. */
114 static bool pcie_ari_disabled;
115
116 /* If set, the PCIe ATS capability will not be used. */
117 static bool pcie_ats_disabled;
118
119 /* If set, the PCI config space of each device is printed during boot. */
120 bool pci_early_dump;
121
122 bool pci_ats_disabled(void)
123 {
124         return pcie_ats_disabled;
125 }
126
127 /* Disable bridge_d3 for all PCIe ports */
128 static bool pci_bridge_d3_disable;
129 /* Force bridge_d3 for all PCIe ports */
130 static bool pci_bridge_d3_force;
131
132 static int __init pcie_port_pm_setup(char *str)
133 {
134         if (!strcmp(str, "off"))
135                 pci_bridge_d3_disable = true;
136         else if (!strcmp(str, "force"))
137                 pci_bridge_d3_force = true;
138         return 1;
139 }
140 __setup("pcie_port_pm=", pcie_port_pm_setup);
141
142 /* Time to wait after a reset for device to become responsive */
143 #define PCIE_RESET_READY_POLL_MS 60000
144
145 /**
146  * pci_bus_max_busnr - returns maximum PCI bus number of given bus' children
147  * @bus: pointer to PCI bus structure to search
148  *
149  * Given a PCI bus, returns the highest PCI bus number present in the set
150  * including the given PCI bus and its list of child PCI buses.
151  */
152 unsigned char pci_bus_max_busnr(struct pci_bus *bus)
153 {
154         struct pci_bus *tmp;
155         unsigned char max, n;
156
157         max = bus->busn_res.end;
158         list_for_each_entry(tmp, &bus->children, node) {
159                 n = pci_bus_max_busnr(tmp);
160                 if (n > max)
161                         max = n;
162         }
163         return max;
164 }
165 EXPORT_SYMBOL_GPL(pci_bus_max_busnr);
166
167 #ifdef CONFIG_HAS_IOMEM
168 void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar)
169 {
170         struct resource *res = &pdev->resource[bar];
171
172         /*
173          * Make sure the BAR is actually a memory resource, not an IO resource
174          */
175         if (res->flags & IORESOURCE_UNSET || !(res->flags & IORESOURCE_MEM)) {
176                 pci_warn(pdev, "can't ioremap BAR %d: %pR\n", bar, res);
177                 return NULL;
178         }
179         return ioremap_nocache(res->start, resource_size(res));
180 }
181 EXPORT_SYMBOL_GPL(pci_ioremap_bar);
182
183 void __iomem *pci_ioremap_wc_bar(struct pci_dev *pdev, int bar)
184 {
185         /*
186          * Make sure the BAR is actually a memory resource, not an IO resource
187          */
188         if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM)) {
189                 WARN_ON(1);
190                 return NULL;
191         }
192         return ioremap_wc(pci_resource_start(pdev, bar),
193                           pci_resource_len(pdev, bar));
194 }
195 EXPORT_SYMBOL_GPL(pci_ioremap_wc_bar);
196 #endif
197
198 /**
199  * pci_dev_str_match_path - test if a path string matches a device
200  * @dev:    the PCI device to test
201  * @path:   string to match the device against
202  * @endptr: pointer to the string after the match
203  *
204  * Test if a string (typically from a kernel parameter) formatted as a
205  * path of device/function addresses matches a PCI device. The string must
206  * be of the form:
207  *
208  *   [<domain>:]<bus>:<device>.<func>[/<device>.<func>]*
209  *
210  * A path for a device can be obtained using 'lspci -t'.  Using a path
211  * is more robust against bus renumbering than using only a single bus,
212  * device and function address.
213  *
214  * Returns 1 if the string matches the device, 0 if it does not and
215  * a negative error code if it fails to parse the string.
216  */
217 static int pci_dev_str_match_path(struct pci_dev *dev, const char *path,
218                                   const char **endptr)
219 {
220         int ret;
221         int seg, bus, slot, func;
222         char *wpath, *p;
223         char end;
224
225         *endptr = strchrnul(path, ';');
226
227         wpath = kmemdup_nul(path, *endptr - path, GFP_KERNEL);
228         if (!wpath)
229                 return -ENOMEM;
230
231         while (1) {
232                 p = strrchr(wpath, '/');
233                 if (!p)
234                         break;
235                 ret = sscanf(p, "/%x.%x%c", &slot, &func, &end);
236                 if (ret != 2) {
237                         ret = -EINVAL;
238                         goto free_and_exit;
239                 }
240
241                 if (dev->devfn != PCI_DEVFN(slot, func)) {
242                         ret = 0;
243                         goto free_and_exit;
244                 }
245
246                 /*
247                  * Note: we don't need to get a reference to the upstream
248                  * bridge because we hold a reference to the top level
249                  * device which should hold a reference to the bridge,
250                  * and so on.
251                  */
252                 dev = pci_upstream_bridge(dev);
253                 if (!dev) {
254                         ret = 0;
255                         goto free_and_exit;
256                 }
257
258                 *p = 0;
259         }
260
261         ret = sscanf(wpath, "%x:%x:%x.%x%c", &seg, &bus, &slot,
262                      &func, &end);
263         if (ret != 4) {
264                 seg = 0;
265                 ret = sscanf(wpath, "%x:%x.%x%c", &bus, &slot, &func, &end);
266                 if (ret != 3) {
267                         ret = -EINVAL;
268                         goto free_and_exit;
269                 }
270         }
271
272         ret = (seg == pci_domain_nr(dev->bus) &&
273                bus == dev->bus->number &&
274                dev->devfn == PCI_DEVFN(slot, func));
275
276 free_and_exit:
277         kfree(wpath);
278         return ret;
279 }
280
281 /**
282  * pci_dev_str_match - test if a string matches a device
283  * @dev:    the PCI device to test
284  * @p:      string to match the device against
285  * @endptr: pointer to the string after the match
286  *
287  * Test if a string (typically from a kernel parameter) matches a specified
288  * PCI device. The string may be of one of the following formats:
289  *
290  *   [<domain>:]<bus>:<device>.<func>[/<device>.<func>]*
291  *   pci:<vendor>:<device>[:<subvendor>:<subdevice>]
292  *
293  * The first format specifies a PCI bus/device/function address which
294  * may change if new hardware is inserted, if motherboard firmware changes,
295  * or due to changes caused in kernel parameters. If the domain is
296  * left unspecified, it is taken to be 0.  In order to be robust against
297  * bus renumbering issues, a path of PCI device/function numbers may be used
298  * to address the specific device.  The path for a device can be determined
299  * through the use of 'lspci -t'.
300  *
301  * The second format matches devices using IDs in the configuration
302  * space which may match multiple devices in the system. A value of 0
303  * for any field will match all devices. (Note: this differs from
304  * in-kernel code that uses PCI_ANY_ID which is ~0; this is for
305  * legacy reasons and convenience so users don't have to specify
306  * FFFFFFFFs on the command line.)
307  *
308  * Returns 1 if the string matches the device, 0 if it does not and
309  * a negative error code if the string cannot be parsed.
310  */
311 static int pci_dev_str_match(struct pci_dev *dev, const char *p,
312                              const char **endptr)
313 {
314         int ret;
315         int count;
316         unsigned short vendor, device, subsystem_vendor, subsystem_device;
317
318         if (strncmp(p, "pci:", 4) == 0) {
319                 /* PCI vendor/device (subvendor/subdevice) IDs are specified */
320                 p += 4;
321                 ret = sscanf(p, "%hx:%hx:%hx:%hx%n", &vendor, &device,
322                              &subsystem_vendor, &subsystem_device, &count);
323                 if (ret != 4) {
324                         ret = sscanf(p, "%hx:%hx%n", &vendor, &device, &count);
325                         if (ret != 2)
326                                 return -EINVAL;
327
328                         subsystem_vendor = 0;
329                         subsystem_device = 0;
330                 }
331
332                 p += count;
333
334                 if ((!vendor || vendor == dev->vendor) &&
335                     (!device || device == dev->device) &&
336                     (!subsystem_vendor ||
337                             subsystem_vendor == dev->subsystem_vendor) &&
338                     (!subsystem_device ||
339                             subsystem_device == dev->subsystem_device))
340                         goto found;
341         } else {
342                 /*
343                  * PCI Bus, Device, Function IDs are specified
344                  *  (optionally, may include a path of devfns following it)
345                  */
346                 ret = pci_dev_str_match_path(dev, p, &p);
347                 if (ret < 0)
348                         return ret;
349                 else if (ret)
350                         goto found;
351         }
352
353         *endptr = p;
354         return 0;
355
356 found:
357         *endptr = p;
358         return 1;
359 }
360
361 static int __pci_find_next_cap_ttl(struct pci_bus *bus, unsigned int devfn,
362                                    u8 pos, int cap, int *ttl)
363 {
364         u8 id;
365         u16 ent;
366
367         pci_bus_read_config_byte(bus, devfn, pos, &pos);
368
369         while ((*ttl)--) {
370                 if (pos < 0x40)
371                         break;
372                 pos &= ~3;
373                 pci_bus_read_config_word(bus, devfn, pos, &ent);
374
375                 id = ent & 0xff;
376                 if (id == 0xff)
377                         break;
378                 if (id == cap)
379                         return pos;
380                 pos = (ent >> 8);
381         }
382         return 0;
383 }
384
385 static int __pci_find_next_cap(struct pci_bus *bus, unsigned int devfn,
386                                u8 pos, int cap)
387 {
388         int ttl = PCI_FIND_CAP_TTL;
389
390         return __pci_find_next_cap_ttl(bus, devfn, pos, cap, &ttl);
391 }
392
393 int pci_find_next_capability(struct pci_dev *dev, u8 pos, int cap)
394 {
395         return __pci_find_next_cap(dev->bus, dev->devfn,
396                                    pos + PCI_CAP_LIST_NEXT, cap);
397 }
398 EXPORT_SYMBOL_GPL(pci_find_next_capability);
399
400 static int __pci_bus_find_cap_start(struct pci_bus *bus,
401                                     unsigned int devfn, u8 hdr_type)
402 {
403         u16 status;
404
405         pci_bus_read_config_word(bus, devfn, PCI_STATUS, &status);
406         if (!(status & PCI_STATUS_CAP_LIST))
407                 return 0;
408
409         switch (hdr_type) {
410         case PCI_HEADER_TYPE_NORMAL:
411         case PCI_HEADER_TYPE_BRIDGE:
412                 return PCI_CAPABILITY_LIST;
413         case PCI_HEADER_TYPE_CARDBUS:
414                 return PCI_CB_CAPABILITY_LIST;
415         }
416
417         return 0;
418 }
419
420 /**
421  * pci_find_capability - query for devices' capabilities
422  * @dev: PCI device to query
423  * @cap: capability code
424  *
425  * Tell if a device supports a given PCI capability.
426  * Returns the address of the requested capability structure within the
427  * device's PCI configuration space or 0 in case the device does not
428  * support it.  Possible values for @cap:
429  *
430  *  %PCI_CAP_ID_PM           Power Management
431  *  %PCI_CAP_ID_AGP          Accelerated Graphics Port
432  *  %PCI_CAP_ID_VPD          Vital Product Data
433  *  %PCI_CAP_ID_SLOTID       Slot Identification
434  *  %PCI_CAP_ID_MSI          Message Signalled Interrupts
435  *  %PCI_CAP_ID_CHSWP        CompactPCI HotSwap
436  *  %PCI_CAP_ID_PCIX         PCI-X
437  *  %PCI_CAP_ID_EXP          PCI Express
438  */
439 int pci_find_capability(struct pci_dev *dev, int cap)
440 {
441         int pos;
442
443         pos = __pci_bus_find_cap_start(dev->bus, dev->devfn, dev->hdr_type);
444         if (pos)
445                 pos = __pci_find_next_cap(dev->bus, dev->devfn, pos, cap);
446
447         return pos;
448 }
449 EXPORT_SYMBOL(pci_find_capability);
450
451 /**
452  * pci_bus_find_capability - query for devices' capabilities
453  * @bus:   the PCI bus to query
454  * @devfn: PCI device to query
455  * @cap:   capability code
456  *
457  * Like pci_find_capability() but works for pci devices that do not have a
458  * pci_dev structure set up yet.
459  *
460  * Returns the address of the requested capability structure within the
461  * device's PCI configuration space or 0 in case the device does not
462  * support it.
463  */
464 int pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap)
465 {
466         int pos;
467         u8 hdr_type;
468
469         pci_bus_read_config_byte(bus, devfn, PCI_HEADER_TYPE, &hdr_type);
470
471         pos = __pci_bus_find_cap_start(bus, devfn, hdr_type & 0x7f);
472         if (pos)
473                 pos = __pci_find_next_cap(bus, devfn, pos, cap);
474
475         return pos;
476 }
477 EXPORT_SYMBOL(pci_bus_find_capability);
478
479 /**
480  * pci_find_next_ext_capability - Find an extended capability
481  * @dev: PCI device to query
482  * @start: address at which to start looking (0 to start at beginning of list)
483  * @cap: capability code
484  *
485  * Returns the address of the next matching extended capability structure
486  * within the device's PCI configuration space or 0 if the device does
487  * not support it.  Some capabilities can occur several times, e.g., the
488  * vendor-specific capability, and this provides a way to find them all.
489  */
490 int pci_find_next_ext_capability(struct pci_dev *dev, int start, int cap)
491 {
492         u32 header;
493         int ttl;
494         int pos = PCI_CFG_SPACE_SIZE;
495
496         /* minimum 8 bytes per capability */
497         ttl = (PCI_CFG_SPACE_EXP_SIZE - PCI_CFG_SPACE_SIZE) / 8;
498
499         if (dev->cfg_size <= PCI_CFG_SPACE_SIZE)
500                 return 0;
501
502         if (start)
503                 pos = start;
504
505         if (pci_read_config_dword(dev, pos, &header) != PCIBIOS_SUCCESSFUL)
506                 return 0;
507
508         /*
509          * If we have no capabilities, this is indicated by cap ID,
510          * cap version and next pointer all being 0.
511          */
512         if (header == 0)
513                 return 0;
514
515         while (ttl-- > 0) {
516                 if (PCI_EXT_CAP_ID(header) == cap && pos != start)
517                         return pos;
518
519                 pos = PCI_EXT_CAP_NEXT(header);
520                 if (pos < PCI_CFG_SPACE_SIZE)
521                         break;
522
523                 if (pci_read_config_dword(dev, pos, &header) != PCIBIOS_SUCCESSFUL)
524                         break;
525         }
526
527         return 0;
528 }
529 EXPORT_SYMBOL_GPL(pci_find_next_ext_capability);
530
531 /**
532  * pci_find_ext_capability - Find an extended capability
533  * @dev: PCI device to query
534  * @cap: capability code
535  *
536  * Returns the address of the requested extended capability structure
537  * within the device's PCI configuration space or 0 if the device does
538  * not support it.  Possible values for @cap:
539  *
540  *  %PCI_EXT_CAP_ID_ERR         Advanced Error Reporting
541  *  %PCI_EXT_CAP_ID_VC          Virtual Channel
542  *  %PCI_EXT_CAP_ID_DSN         Device Serial Number
543  *  %PCI_EXT_CAP_ID_PWR         Power Budgeting
544  */
545 int pci_find_ext_capability(struct pci_dev *dev, int cap)
546 {
547         return pci_find_next_ext_capability(dev, 0, cap);
548 }
549 EXPORT_SYMBOL_GPL(pci_find_ext_capability);
550
551 static int __pci_find_next_ht_cap(struct pci_dev *dev, int pos, int ht_cap)
552 {
553         int rc, ttl = PCI_FIND_CAP_TTL;
554         u8 cap, mask;
555
556         if (ht_cap == HT_CAPTYPE_SLAVE || ht_cap == HT_CAPTYPE_HOST)
557                 mask = HT_3BIT_CAP_MASK;
558         else
559                 mask = HT_5BIT_CAP_MASK;
560
561         pos = __pci_find_next_cap_ttl(dev->bus, dev->devfn, pos,
562                                       PCI_CAP_ID_HT, &ttl);
563         while (pos) {
564                 rc = pci_read_config_byte(dev, pos + 3, &cap);
565                 if (rc != PCIBIOS_SUCCESSFUL)
566                         return 0;
567
568                 if ((cap & mask) == ht_cap)
569                         return pos;
570
571                 pos = __pci_find_next_cap_ttl(dev->bus, dev->devfn,
572                                               pos + PCI_CAP_LIST_NEXT,
573                                               PCI_CAP_ID_HT, &ttl);
574         }
575
576         return 0;
577 }
578 /**
579  * pci_find_next_ht_capability - query a device's Hypertransport capabilities
580  * @dev: PCI device to query
581  * @pos: Position from which to continue searching
582  * @ht_cap: Hypertransport capability code
583  *
584  * To be used in conjunction with pci_find_ht_capability() to search for
585  * all capabilities matching @ht_cap. @pos should always be a value returned
586  * from pci_find_ht_capability().
587  *
588  * NB. To be 100% safe against broken PCI devices, the caller should take
589  * steps to avoid an infinite loop.
590  */
591 int pci_find_next_ht_capability(struct pci_dev *dev, int pos, int ht_cap)
592 {
593         return __pci_find_next_ht_cap(dev, pos + PCI_CAP_LIST_NEXT, ht_cap);
594 }
595 EXPORT_SYMBOL_GPL(pci_find_next_ht_capability);
596
597 /**
598  * pci_find_ht_capability - query a device's Hypertransport capabilities
599  * @dev: PCI device to query
600  * @ht_cap: Hypertransport capability code
601  *
602  * Tell if a device supports a given Hypertransport capability.
603  * Returns an address within the device's PCI configuration space
604  * or 0 in case the device does not support the request capability.
605  * The address points to the PCI capability, of type PCI_CAP_ID_HT,
606  * which has a Hypertransport capability matching @ht_cap.
607  */
608 int pci_find_ht_capability(struct pci_dev *dev, int ht_cap)
609 {
610         int pos;
611
612         pos = __pci_bus_find_cap_start(dev->bus, dev->devfn, dev->hdr_type);
613         if (pos)
614                 pos = __pci_find_next_ht_cap(dev, pos, ht_cap);
615
616         return pos;
617 }
618 EXPORT_SYMBOL_GPL(pci_find_ht_capability);
619
620 /**
621  * pci_find_parent_resource - return resource region of parent bus of given region
622  * @dev: PCI device structure contains resources to be searched
623  * @res: child resource record for which parent is sought
624  *
625  *  For given resource region of given device, return the resource
626  *  region of parent bus the given region is contained in.
627  */
628 struct resource *pci_find_parent_resource(const struct pci_dev *dev,
629                                           struct resource *res)
630 {
631         const struct pci_bus *bus = dev->bus;
632         struct resource *r;
633         int i;
634
635         pci_bus_for_each_resource(bus, r, i) {
636                 if (!r)
637                         continue;
638                 if (resource_contains(r, res)) {
639
640                         /*
641                          * If the window is prefetchable but the BAR is
642                          * not, the allocator made a mistake.
643                          */
644                         if (r->flags & IORESOURCE_PREFETCH &&
645                             !(res->flags & IORESOURCE_PREFETCH))
646                                 return NULL;
647
648                         /*
649                          * If we're below a transparent bridge, there may
650                          * be both a positively-decoded aperture and a
651                          * subtractively-decoded region that contain the BAR.
652                          * We want the positively-decoded one, so this depends
653                          * on pci_bus_for_each_resource() giving us those
654                          * first.
655                          */
656                         return r;
657                 }
658         }
659         return NULL;
660 }
661 EXPORT_SYMBOL(pci_find_parent_resource);
662
663 /**
664  * pci_find_resource - Return matching PCI device resource
665  * @dev: PCI device to query
666  * @res: Resource to look for
667  *
668  * Goes over standard PCI resources (BARs) and checks if the given resource
669  * is partially or fully contained in any of them. In that case the
670  * matching resource is returned, %NULL otherwise.
671  */
672 struct resource *pci_find_resource(struct pci_dev *dev, struct resource *res)
673 {
674         int i;
675
676         for (i = 0; i < PCI_ROM_RESOURCE; i++) {
677                 struct resource *r = &dev->resource[i];
678
679                 if (r->start && resource_contains(r, res))
680                         return r;
681         }
682
683         return NULL;
684 }
685 EXPORT_SYMBOL(pci_find_resource);
686
687 /**
688  * pci_find_pcie_root_port - return PCIe Root Port
689  * @dev: PCI device to query
690  *
691  * Traverse up the parent chain and return the PCIe Root Port PCI Device
692  * for a given PCI Device.
693  */
694 struct pci_dev *pci_find_pcie_root_port(struct pci_dev *dev)
695 {
696         struct pci_dev *bridge, *highest_pcie_bridge = dev;
697
698         bridge = pci_upstream_bridge(dev);
699         while (bridge && pci_is_pcie(bridge)) {
700                 highest_pcie_bridge = bridge;
701                 bridge = pci_upstream_bridge(bridge);
702         }
703
704         if (pci_pcie_type(highest_pcie_bridge) != PCI_EXP_TYPE_ROOT_PORT)
705                 return NULL;
706
707         return highest_pcie_bridge;
708 }
709 EXPORT_SYMBOL(pci_find_pcie_root_port);
710
711 /**
712  * pci_wait_for_pending - wait for @mask bit(s) to clear in status word @pos
713  * @dev: the PCI device to operate on
714  * @pos: config space offset of status word
715  * @mask: mask of bit(s) to care about in status word
716  *
717  * Return 1 when mask bit(s) in status word clear, 0 otherwise.
718  */
719 int pci_wait_for_pending(struct pci_dev *dev, int pos, u16 mask)
720 {
721         int i;
722
723         /* Wait for Transaction Pending bit clean */
724         for (i = 0; i < 4; i++) {
725                 u16 status;
726                 if (i)
727                         msleep((1 << (i - 1)) * 100);
728
729                 pci_read_config_word(dev, pos, &status);
730                 if (!(status & mask))
731                         return 1;
732         }
733
734         return 0;
735 }
736
737 /**
738  * pci_restore_bars - restore a device's BAR values (e.g. after wake-up)
739  * @dev: PCI device to have its BARs restored
740  *
741  * Restore the BAR values for a given device, so as to make it
742  * accessible by its driver.
743  */
744 static void pci_restore_bars(struct pci_dev *dev)
745 {
746         int i;
747
748         for (i = 0; i < PCI_BRIDGE_RESOURCES; i++)
749                 pci_update_resource(dev, i);
750 }
751
752 static const struct pci_platform_pm_ops *pci_platform_pm;
753
754 int pci_set_platform_pm(const struct pci_platform_pm_ops *ops)
755 {
756         if (!ops->is_manageable || !ops->set_state  || !ops->get_state ||
757             !ops->choose_state  || !ops->set_wakeup || !ops->need_resume)
758                 return -EINVAL;
759         pci_platform_pm = ops;
760         return 0;
761 }
762
763 static inline bool platform_pci_power_manageable(struct pci_dev *dev)
764 {
765         return pci_platform_pm ? pci_platform_pm->is_manageable(dev) : false;
766 }
767
768 static inline int platform_pci_set_power_state(struct pci_dev *dev,
769                                                pci_power_t t)
770 {
771         return pci_platform_pm ? pci_platform_pm->set_state(dev, t) : -ENOSYS;
772 }
773
774 static inline pci_power_t platform_pci_get_power_state(struct pci_dev *dev)
775 {
776         return pci_platform_pm ? pci_platform_pm->get_state(dev) : PCI_UNKNOWN;
777 }
778
779 static inline pci_power_t platform_pci_choose_state(struct pci_dev *dev)
780 {
781         return pci_platform_pm ?
782                         pci_platform_pm->choose_state(dev) : PCI_POWER_ERROR;
783 }
784
785 static inline int platform_pci_set_wakeup(struct pci_dev *dev, bool enable)
786 {
787         return pci_platform_pm ?
788                         pci_platform_pm->set_wakeup(dev, enable) : -ENODEV;
789 }
790
791 static inline bool platform_pci_need_resume(struct pci_dev *dev)
792 {
793         return pci_platform_pm ? pci_platform_pm->need_resume(dev) : false;
794 }
795
796 static inline bool platform_pci_bridge_d3(struct pci_dev *dev)
797 {
798         return pci_platform_pm ? pci_platform_pm->bridge_d3(dev) : false;
799 }
800
801 /**
802  * pci_raw_set_power_state - Use PCI PM registers to set the power state of
803  *                           given PCI device
804  * @dev: PCI device to handle.
805  * @state: PCI power state (D0, D1, D2, D3hot) to put the device into.
806  *
807  * RETURN VALUE:
808  * -EINVAL if the requested state is invalid.
809  * -EIO if device does not support PCI PM or its PM capabilities register has a
810  * wrong version, or device doesn't support the requested state.
811  * 0 if device already is in the requested state.
812  * 0 if device's power state has been successfully changed.
813  */
814 static int pci_raw_set_power_state(struct pci_dev *dev, pci_power_t state)
815 {
816         u16 pmcsr;
817         bool need_restore = false;
818
819         /* Check if we're already there */
820         if (dev->current_state == state)
821                 return 0;
822
823         if (!dev->pm_cap)
824                 return -EIO;
825
826         if (state < PCI_D0 || state > PCI_D3hot)
827                 return -EINVAL;
828
829         /* Validate current state:
830          * Can enter D0 from any state, but if we can only go deeper
831          * to sleep if we're already in a low power state
832          */
833         if (state != PCI_D0 && dev->current_state <= PCI_D3cold
834             && dev->current_state > state) {
835                 pci_err(dev, "invalid power transition (from state %d to %d)\n",
836                         dev->current_state, state);
837                 return -EINVAL;
838         }
839
840         /* check if this device supports the desired state */
841         if ((state == PCI_D1 && !dev->d1_support)
842            || (state == PCI_D2 && !dev->d2_support))
843                 return -EIO;
844
845         pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
846
847         /* If we're (effectively) in D3, force entire word to 0.
848          * This doesn't affect PME_Status, disables PME_En, and
849          * sets PowerState to 0.
850          */
851         switch (dev->current_state) {
852         case PCI_D0:
853         case PCI_D1:
854         case PCI_D2:
855                 pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
856                 pmcsr |= state;
857                 break;
858         case PCI_D3hot:
859         case PCI_D3cold:
860         case PCI_UNKNOWN: /* Boot-up */
861                 if ((pmcsr & PCI_PM_CTRL_STATE_MASK) == PCI_D3hot
862                  && !(pmcsr & PCI_PM_CTRL_NO_SOFT_RESET))
863                         need_restore = true;
864                 /* Fall-through - force to D0 */
865         default:
866                 pmcsr = 0;
867                 break;
868         }
869
870         /* enter specified state */
871         pci_write_config_word(dev, dev->pm_cap + PCI_PM_CTRL, pmcsr);
872
873         /* Mandatory power management transition delays */
874         /* see PCI PM 1.1 5.6.1 table 18 */
875         if (state == PCI_D3hot || dev->current_state == PCI_D3hot)
876                 pci_dev_d3_sleep(dev);
877         else if (state == PCI_D2 || dev->current_state == PCI_D2)
878                 udelay(PCI_PM_D2_DELAY);
879
880         pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
881         dev->current_state = (pmcsr & PCI_PM_CTRL_STATE_MASK);
882         if (dev->current_state != state && printk_ratelimit())
883                 pci_info(dev, "Refused to change power state, currently in D%d\n",
884                          dev->current_state);
885
886         /*
887          * According to section 5.4.1 of the "PCI BUS POWER MANAGEMENT
888          * INTERFACE SPECIFICATION, REV. 1.2", a device transitioning
889          * from D3hot to D0 _may_ perform an internal reset, thereby
890          * going to "D0 Uninitialized" rather than "D0 Initialized".
891          * For example, at least some versions of the 3c905B and the
892          * 3c556B exhibit this behaviour.
893          *
894          * At least some laptop BIOSen (e.g. the Thinkpad T21) leave
895          * devices in a D3hot state at boot.  Consequently, we need to
896          * restore at least the BARs so that the device will be
897          * accessible to its driver.
898          */
899         if (need_restore)
900                 pci_restore_bars(dev);
901
902         if (dev->bus->self)
903                 pcie_aspm_pm_state_change(dev->bus->self);
904
905         return 0;
906 }
907
908 /**
909  * pci_update_current_state - Read power state of given device and cache it
910  * @dev: PCI device to handle.
911  * @state: State to cache in case the device doesn't have the PM capability
912  *
913  * The power state is read from the PMCSR register, which however is
914  * inaccessible in D3cold.  The platform firmware is therefore queried first
915  * to detect accessibility of the register.  In case the platform firmware
916  * reports an incorrect state or the device isn't power manageable by the
917  * platform at all, we try to detect D3cold by testing accessibility of the
918  * vendor ID in config space.
919  */
920 void pci_update_current_state(struct pci_dev *dev, pci_power_t state)
921 {
922         if (platform_pci_get_power_state(dev) == PCI_D3cold ||
923             !pci_device_is_present(dev)) {
924                 dev->current_state = PCI_D3cold;
925         } else if (dev->pm_cap) {
926                 u16 pmcsr;
927
928                 pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
929                 dev->current_state = (pmcsr & PCI_PM_CTRL_STATE_MASK);
930         } else {
931                 dev->current_state = state;
932         }
933 }
934
935 /**
936  * pci_power_up - Put the given device into D0 forcibly
937  * @dev: PCI device to power up
938  */
939 void pci_power_up(struct pci_dev *dev)
940 {
941         if (platform_pci_power_manageable(dev))
942                 platform_pci_set_power_state(dev, PCI_D0);
943
944         pci_raw_set_power_state(dev, PCI_D0);
945         pci_update_current_state(dev, PCI_D0);
946 }
947
948 /**
949  * pci_platform_power_transition - Use platform to change device power state
950  * @dev: PCI device to handle.
951  * @state: State to put the device into.
952  */
953 static int pci_platform_power_transition(struct pci_dev *dev, pci_power_t state)
954 {
955         int error;
956
957         if (platform_pci_power_manageable(dev)) {
958                 error = platform_pci_set_power_state(dev, state);
959                 if (!error)
960                         pci_update_current_state(dev, state);
961         } else
962                 error = -ENODEV;
963
964         if (error && !dev->pm_cap) /* Fall back to PCI_D0 */
965                 dev->current_state = PCI_D0;
966
967         return error;
968 }
969
970 /**
971  * pci_wakeup - Wake up a PCI device
972  * @pci_dev: Device to handle.
973  * @ign: ignored parameter
974  */
975 static int pci_wakeup(struct pci_dev *pci_dev, void *ign)
976 {
977         pci_wakeup_event(pci_dev);
978         pm_request_resume(&pci_dev->dev);
979         return 0;
980 }
981
982 /**
983  * pci_wakeup_bus - Walk given bus and wake up devices on it
984  * @bus: Top bus of the subtree to walk.
985  */
986 void pci_wakeup_bus(struct pci_bus *bus)
987 {
988         if (bus)
989                 pci_walk_bus(bus, pci_wakeup, NULL);
990 }
991
992 /**
993  * __pci_start_power_transition - Start power transition of a PCI device
994  * @dev: PCI device to handle.
995  * @state: State to put the device into.
996  */
997 static void __pci_start_power_transition(struct pci_dev *dev, pci_power_t state)
998 {
999         if (state == PCI_D0) {
1000                 pci_platform_power_transition(dev, PCI_D0);
1001                 /*
1002                  * Mandatory power management transition delays, see
1003                  * PCI Express Base Specification Revision 2.0 Section
1004                  * 6.6.1: Conventional Reset.  Do not delay for
1005                  * devices powered on/off by corresponding bridge,
1006                  * because have already delayed for the bridge.
1007                  */
1008                 if (dev->runtime_d3cold) {
1009                         if (dev->d3cold_delay && !dev->imm_ready)
1010                                 msleep(dev->d3cold_delay);
1011                         /*
1012                          * When powering on a bridge from D3cold, the
1013                          * whole hierarchy may be powered on into
1014                          * D0uninitialized state, resume them to give
1015                          * them a chance to suspend again
1016                          */
1017                         pci_wakeup_bus(dev->subordinate);
1018                 }
1019         }
1020 }
1021
1022 /**
1023  * __pci_dev_set_current_state - Set current state of a PCI device
1024  * @dev: Device to handle
1025  * @data: pointer to state to be set
1026  */
1027 static int __pci_dev_set_current_state(struct pci_dev *dev, void *data)
1028 {
1029         pci_power_t state = *(pci_power_t *)data;
1030
1031         dev->current_state = state;
1032         return 0;
1033 }
1034
1035 /**
1036  * pci_bus_set_current_state - Walk given bus and set current state of devices
1037  * @bus: Top bus of the subtree to walk.
1038  * @state: state to be set
1039  */
1040 void pci_bus_set_current_state(struct pci_bus *bus, pci_power_t state)
1041 {
1042         if (bus)
1043                 pci_walk_bus(bus, __pci_dev_set_current_state, &state);
1044 }
1045
1046 /**
1047  * __pci_complete_power_transition - Complete power transition of a PCI device
1048  * @dev: PCI device to handle.
1049  * @state: State to put the device into.
1050  *
1051  * This function should not be called directly by device drivers.
1052  */
1053 int __pci_complete_power_transition(struct pci_dev *dev, pci_power_t state)
1054 {
1055         int ret;
1056
1057         if (state <= PCI_D0)
1058                 return -EINVAL;
1059         ret = pci_platform_power_transition(dev, state);
1060         /* Power off the bridge may power off the whole hierarchy */
1061         if (!ret && state == PCI_D3cold)
1062                 pci_bus_set_current_state(dev->subordinate, PCI_D3cold);
1063         return ret;
1064 }
1065 EXPORT_SYMBOL_GPL(__pci_complete_power_transition);
1066
1067 /**
1068  * pci_set_power_state - Set the power state of a PCI device
1069  * @dev: PCI device to handle.
1070  * @state: PCI power state (D0, D1, D2, D3hot) to put the device into.
1071  *
1072  * Transition a device to a new power state, using the platform firmware and/or
1073  * the device's PCI PM registers.
1074  *
1075  * RETURN VALUE:
1076  * -EINVAL if the requested state is invalid.
1077  * -EIO if device does not support PCI PM or its PM capabilities register has a
1078  * wrong version, or device doesn't support the requested state.
1079  * 0 if the transition is to D1 or D2 but D1 and D2 are not supported.
1080  * 0 if device already is in the requested state.
1081  * 0 if the transition is to D3 but D3 is not supported.
1082  * 0 if device's power state has been successfully changed.
1083  */
1084 int pci_set_power_state(struct pci_dev *dev, pci_power_t state)
1085 {
1086         int error;
1087
1088         /* bound the state we're entering */
1089         if (state > PCI_D3cold)
1090                 state = PCI_D3cold;
1091         else if (state < PCI_D0)
1092                 state = PCI_D0;
1093         else if ((state == PCI_D1 || state == PCI_D2) && pci_no_d1d2(dev))
1094                 /*
1095                  * If the device or the parent bridge do not support PCI PM,
1096                  * ignore the request if we're doing anything other than putting
1097                  * it into D0 (which would only happen on boot).
1098                  */
1099                 return 0;
1100
1101         /* Check if we're already there */
1102         if (dev->current_state == state)
1103                 return 0;
1104
1105         __pci_start_power_transition(dev, state);
1106
1107         /* This device is quirked not to be put into D3, so
1108            don't put it in D3 */
1109         if (state >= PCI_D3hot && (dev->dev_flags & PCI_DEV_FLAGS_NO_D3))
1110                 return 0;
1111
1112         /*
1113          * To put device in D3cold, we put device into D3hot in native
1114          * way, then put device into D3cold with platform ops
1115          */
1116         error = pci_raw_set_power_state(dev, state > PCI_D3hot ?
1117                                         PCI_D3hot : state);
1118
1119         if (!__pci_complete_power_transition(dev, state))
1120                 error = 0;
1121
1122         return error;
1123 }
1124 EXPORT_SYMBOL(pci_set_power_state);
1125
1126 /**
1127  * pci_choose_state - Choose the power state of a PCI device
1128  * @dev: PCI device to be suspended
1129  * @state: target sleep state for the whole system. This is the value
1130  *      that is passed to suspend() function.
1131  *
1132  * Returns PCI power state suitable for given device and given system
1133  * message.
1134  */
1135
1136 pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state)
1137 {
1138         pci_power_t ret;
1139
1140         if (!dev->pm_cap)
1141                 return PCI_D0;
1142
1143         ret = platform_pci_choose_state(dev);
1144         if (ret != PCI_POWER_ERROR)
1145                 return ret;
1146
1147         switch (state.event) {
1148         case PM_EVENT_ON:
1149                 return PCI_D0;
1150         case PM_EVENT_FREEZE:
1151         case PM_EVENT_PRETHAW:
1152                 /* REVISIT both freeze and pre-thaw "should" use D0 */
1153         case PM_EVENT_SUSPEND:
1154         case PM_EVENT_HIBERNATE:
1155                 return PCI_D3hot;
1156         default:
1157                 pci_info(dev, "unrecognized suspend event %d\n",
1158                          state.event);
1159                 BUG();
1160         }
1161         return PCI_D0;
1162 }
1163 EXPORT_SYMBOL(pci_choose_state);
1164
1165 #define PCI_EXP_SAVE_REGS       7
1166
1167 static struct pci_cap_saved_state *_pci_find_saved_cap(struct pci_dev *pci_dev,
1168                                                        u16 cap, bool extended)
1169 {
1170         struct pci_cap_saved_state *tmp;
1171
1172         hlist_for_each_entry(tmp, &pci_dev->saved_cap_space, next) {
1173                 if (tmp->cap.cap_extended == extended && tmp->cap.cap_nr == cap)
1174                         return tmp;
1175         }
1176         return NULL;
1177 }
1178
1179 struct pci_cap_saved_state *pci_find_saved_cap(struct pci_dev *dev, char cap)
1180 {
1181         return _pci_find_saved_cap(dev, cap, false);
1182 }
1183
1184 struct pci_cap_saved_state *pci_find_saved_ext_cap(struct pci_dev *dev, u16 cap)
1185 {
1186         return _pci_find_saved_cap(dev, cap, true);
1187 }
1188
1189 static int pci_save_pcie_state(struct pci_dev *dev)
1190 {
1191         int i = 0;
1192         struct pci_cap_saved_state *save_state;
1193         u16 *cap;
1194
1195         if (!pci_is_pcie(dev))
1196                 return 0;
1197
1198         save_state = pci_find_saved_cap(dev, PCI_CAP_ID_EXP);
1199         if (!save_state) {
1200                 pci_err(dev, "buffer not found in %s\n", __func__);
1201                 return -ENOMEM;
1202         }
1203
1204         cap = (u16 *)&save_state->cap.data[0];
1205         pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &cap[i++]);
1206         pcie_capability_read_word(dev, PCI_EXP_LNKCTL, &cap[i++]);
1207         pcie_capability_read_word(dev, PCI_EXP_SLTCTL, &cap[i++]);
1208         pcie_capability_read_word(dev, PCI_EXP_RTCTL,  &cap[i++]);
1209         pcie_capability_read_word(dev, PCI_EXP_DEVCTL2, &cap[i++]);
1210         pcie_capability_read_word(dev, PCI_EXP_LNKCTL2, &cap[i++]);
1211         pcie_capability_read_word(dev, PCI_EXP_SLTCTL2, &cap[i++]);
1212
1213         return 0;
1214 }
1215
1216 static void pci_restore_pcie_state(struct pci_dev *dev)
1217 {
1218         int i = 0;
1219         struct pci_cap_saved_state *save_state;
1220         u16 *cap;
1221
1222         save_state = pci_find_saved_cap(dev, PCI_CAP_ID_EXP);
1223         if (!save_state)
1224                 return;
1225
1226         cap = (u16 *)&save_state->cap.data[0];
1227         pcie_capability_write_word(dev, PCI_EXP_DEVCTL, cap[i++]);
1228         pcie_capability_write_word(dev, PCI_EXP_LNKCTL, cap[i++]);
1229         pcie_capability_write_word(dev, PCI_EXP_SLTCTL, cap[i++]);
1230         pcie_capability_write_word(dev, PCI_EXP_RTCTL, cap[i++]);
1231         pcie_capability_write_word(dev, PCI_EXP_DEVCTL2, cap[i++]);
1232         pcie_capability_write_word(dev, PCI_EXP_LNKCTL2, cap[i++]);
1233         pcie_capability_write_word(dev, PCI_EXP_SLTCTL2, cap[i++]);
1234 }
1235
1236 static int pci_save_pcix_state(struct pci_dev *dev)
1237 {
1238         int pos;
1239         struct pci_cap_saved_state *save_state;
1240
1241         pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1242         if (!pos)
1243                 return 0;
1244
1245         save_state = pci_find_saved_cap(dev, PCI_CAP_ID_PCIX);
1246         if (!save_state) {
1247                 pci_err(dev, "buffer not found in %s\n", __func__);
1248                 return -ENOMEM;
1249         }
1250
1251         pci_read_config_word(dev, pos + PCI_X_CMD,
1252                              (u16 *)save_state->cap.data);
1253
1254         return 0;
1255 }
1256
1257 static void pci_restore_pcix_state(struct pci_dev *dev)
1258 {
1259         int i = 0, pos;
1260         struct pci_cap_saved_state *save_state;
1261         u16 *cap;
1262
1263         save_state = pci_find_saved_cap(dev, PCI_CAP_ID_PCIX);
1264         pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1265         if (!save_state || !pos)
1266                 return;
1267         cap = (u16 *)&save_state->cap.data[0];
1268
1269         pci_write_config_word(dev, pos + PCI_X_CMD, cap[i++]);
1270 }
1271
1272 static void pci_save_ltr_state(struct pci_dev *dev)
1273 {
1274         int ltr;
1275         struct pci_cap_saved_state *save_state;
1276         u16 *cap;
1277
1278         if (!pci_is_pcie(dev))
1279                 return;
1280
1281         ltr = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_LTR);
1282         if (!ltr)
1283                 return;
1284
1285         save_state = pci_find_saved_ext_cap(dev, PCI_EXT_CAP_ID_LTR);
1286         if (!save_state) {
1287                 pci_err(dev, "no suspend buffer for LTR; ASPM issues possible after resume\n");
1288                 return;
1289         }
1290
1291         cap = (u16 *)&save_state->cap.data[0];
1292         pci_read_config_word(dev, ltr + PCI_LTR_MAX_SNOOP_LAT, cap++);
1293         pci_read_config_word(dev, ltr + PCI_LTR_MAX_NOSNOOP_LAT, cap++);
1294 }
1295
1296 static void pci_restore_ltr_state(struct pci_dev *dev)
1297 {
1298         struct pci_cap_saved_state *save_state;
1299         int ltr;
1300         u16 *cap;
1301
1302         save_state = pci_find_saved_ext_cap(dev, PCI_EXT_CAP_ID_LTR);
1303         ltr = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_LTR);
1304         if (!save_state || !ltr)
1305                 return;
1306
1307         cap = (u16 *)&save_state->cap.data[0];
1308         pci_write_config_word(dev, ltr + PCI_LTR_MAX_SNOOP_LAT, *cap++);
1309         pci_write_config_word(dev, ltr + PCI_LTR_MAX_NOSNOOP_LAT, *cap++);
1310 }
1311
1312 /**
1313  * pci_save_state - save the PCI configuration space of a device before suspending
1314  * @dev: - PCI device that we're dealing with
1315  */
1316 int pci_save_state(struct pci_dev *dev)
1317 {
1318         int i;
1319         /* XXX: 100% dword access ok here? */
1320         for (i = 0; i < 16; i++)
1321                 pci_read_config_dword(dev, i * 4, &dev->saved_config_space[i]);
1322         dev->state_saved = true;
1323
1324         i = pci_save_pcie_state(dev);
1325         if (i != 0)
1326                 return i;
1327
1328         i = pci_save_pcix_state(dev);
1329         if (i != 0)
1330                 return i;
1331
1332         pci_save_ltr_state(dev);
1333         pci_save_dpc_state(dev);
1334         return pci_save_vc_state(dev);
1335 }
1336 EXPORT_SYMBOL(pci_save_state);
1337
1338 static void pci_restore_config_dword(struct pci_dev *pdev, int offset,
1339                                      u32 saved_val, int retry, bool force)
1340 {
1341         u32 val;
1342
1343         pci_read_config_dword(pdev, offset, &val);
1344         if (!force && val == saved_val)
1345                 return;
1346
1347         for (;;) {
1348                 pci_dbg(pdev, "restoring config space at offset %#x (was %#x, writing %#x)\n",
1349                         offset, val, saved_val);
1350                 pci_write_config_dword(pdev, offset, saved_val);
1351                 if (retry-- <= 0)
1352                         return;
1353
1354                 pci_read_config_dword(pdev, offset, &val);
1355                 if (val == saved_val)
1356                         return;
1357
1358                 mdelay(1);
1359         }
1360 }
1361
1362 static void pci_restore_config_space_range(struct pci_dev *pdev,
1363                                            int start, int end, int retry,
1364                                            bool force)
1365 {
1366         int index;
1367
1368         for (index = end; index >= start; index--)
1369                 pci_restore_config_dword(pdev, 4 * index,
1370                                          pdev->saved_config_space[index],
1371                                          retry, force);
1372 }
1373
1374 static void pci_restore_config_space(struct pci_dev *pdev)
1375 {
1376         if (pdev->hdr_type == PCI_HEADER_TYPE_NORMAL) {
1377                 pci_restore_config_space_range(pdev, 10, 15, 0, false);
1378                 /* Restore BARs before the command register. */
1379                 pci_restore_config_space_range(pdev, 4, 9, 10, false);
1380                 pci_restore_config_space_range(pdev, 0, 3, 0, false);
1381         } else if (pdev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
1382                 pci_restore_config_space_range(pdev, 12, 15, 0, false);
1383
1384                 /*
1385                  * Force rewriting of prefetch registers to avoid S3 resume
1386                  * issues on Intel PCI bridges that occur when these
1387                  * registers are not explicitly written.
1388                  */
1389                 pci_restore_config_space_range(pdev, 9, 11, 0, true);
1390                 pci_restore_config_space_range(pdev, 0, 8, 0, false);
1391         } else {
1392                 pci_restore_config_space_range(pdev, 0, 15, 0, false);
1393         }
1394 }
1395
1396 static void pci_restore_rebar_state(struct pci_dev *pdev)
1397 {
1398         unsigned int pos, nbars, i;
1399         u32 ctrl;
1400
1401         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_REBAR);
1402         if (!pos)
1403                 return;
1404
1405         pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl);
1406         nbars = (ctrl & PCI_REBAR_CTRL_NBAR_MASK) >>
1407                     PCI_REBAR_CTRL_NBAR_SHIFT;
1408
1409         for (i = 0; i < nbars; i++, pos += 8) {
1410                 struct resource *res;
1411                 int bar_idx, size;
1412
1413                 pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl);
1414                 bar_idx = ctrl & PCI_REBAR_CTRL_BAR_IDX;
1415                 res = pdev->resource + bar_idx;
1416                 size = order_base_2((resource_size(res) >> 20) | 1) - 1;
1417                 ctrl &= ~PCI_REBAR_CTRL_BAR_SIZE;
1418                 ctrl |= size << PCI_REBAR_CTRL_BAR_SHIFT;
1419                 pci_write_config_dword(pdev, pos + PCI_REBAR_CTRL, ctrl);
1420         }
1421 }
1422
1423 /**
1424  * pci_restore_state - Restore the saved state of a PCI device
1425  * @dev: - PCI device that we're dealing with
1426  */
1427 void pci_restore_state(struct pci_dev *dev)
1428 {
1429         if (!dev->state_saved)
1430                 return;
1431
1432         /*
1433          * Restore max latencies (in the LTR capability) before enabling
1434          * LTR itself (in the PCIe capability).
1435          */
1436         pci_restore_ltr_state(dev);
1437
1438         pci_restore_pcie_state(dev);
1439         pci_restore_pasid_state(dev);
1440         pci_restore_pri_state(dev);
1441         pci_restore_ats_state(dev);
1442         pci_restore_vc_state(dev);
1443         pci_restore_rebar_state(dev);
1444         pci_restore_dpc_state(dev);
1445
1446         pci_cleanup_aer_error_status_regs(dev);
1447
1448         pci_restore_config_space(dev);
1449
1450         pci_restore_pcix_state(dev);
1451         pci_restore_msi_state(dev);
1452
1453         /* Restore ACS and IOV configuration state */
1454         pci_enable_acs(dev);
1455         pci_restore_iov_state(dev);
1456
1457         dev->state_saved = false;
1458 }
1459 EXPORT_SYMBOL(pci_restore_state);
1460
1461 struct pci_saved_state {
1462         u32 config_space[16];
1463         struct pci_cap_saved_data cap[0];
1464 };
1465
1466 /**
1467  * pci_store_saved_state - Allocate and return an opaque struct containing
1468  *                         the device saved state.
1469  * @dev: PCI device that we're dealing with
1470  *
1471  * Return NULL if no state or error.
1472  */
1473 struct pci_saved_state *pci_store_saved_state(struct pci_dev *dev)
1474 {
1475         struct pci_saved_state *state;
1476         struct pci_cap_saved_state *tmp;
1477         struct pci_cap_saved_data *cap;
1478         size_t size;
1479
1480         if (!dev->state_saved)
1481                 return NULL;
1482
1483         size = sizeof(*state) + sizeof(struct pci_cap_saved_data);
1484
1485         hlist_for_each_entry(tmp, &dev->saved_cap_space, next)
1486                 size += sizeof(struct pci_cap_saved_data) + tmp->cap.size;
1487
1488         state = kzalloc(size, GFP_KERNEL);
1489         if (!state)
1490                 return NULL;
1491
1492         memcpy(state->config_space, dev->saved_config_space,
1493                sizeof(state->config_space));
1494
1495         cap = state->cap;
1496         hlist_for_each_entry(tmp, &dev->saved_cap_space, next) {
1497                 size_t len = sizeof(struct pci_cap_saved_data) + tmp->cap.size;
1498                 memcpy(cap, &tmp->cap, len);
1499                 cap = (struct pci_cap_saved_data *)((u8 *)cap + len);
1500         }
1501         /* Empty cap_save terminates list */
1502
1503         return state;
1504 }
1505 EXPORT_SYMBOL_GPL(pci_store_saved_state);
1506
1507 /**
1508  * pci_load_saved_state - Reload the provided save state into struct pci_dev.
1509  * @dev: PCI device that we're dealing with
1510  * @state: Saved state returned from pci_store_saved_state()
1511  */
1512 int pci_load_saved_state(struct pci_dev *dev,
1513                          struct pci_saved_state *state)
1514 {
1515         struct pci_cap_saved_data *cap;
1516
1517         dev->state_saved = false;
1518
1519         if (!state)
1520                 return 0;
1521
1522         memcpy(dev->saved_config_space, state->config_space,
1523                sizeof(state->config_space));
1524
1525         cap = state->cap;
1526         while (cap->size) {
1527                 struct pci_cap_saved_state *tmp;
1528
1529                 tmp = _pci_find_saved_cap(dev, cap->cap_nr, cap->cap_extended);
1530                 if (!tmp || tmp->cap.size != cap->size)
1531                         return -EINVAL;
1532
1533                 memcpy(tmp->cap.data, cap->data, tmp->cap.size);
1534                 cap = (struct pci_cap_saved_data *)((u8 *)cap +
1535                        sizeof(struct pci_cap_saved_data) + cap->size);
1536         }
1537
1538         dev->state_saved = true;
1539         return 0;
1540 }
1541 EXPORT_SYMBOL_GPL(pci_load_saved_state);
1542
1543 /**
1544  * pci_load_and_free_saved_state - Reload the save state pointed to by state,
1545  *                                 and free the memory allocated for it.
1546  * @dev: PCI device that we're dealing with
1547  * @state: Pointer to saved state returned from pci_store_saved_state()
1548  */
1549 int pci_load_and_free_saved_state(struct pci_dev *dev,
1550                                   struct pci_saved_state **state)
1551 {
1552         int ret = pci_load_saved_state(dev, *state);
1553         kfree(*state);
1554         *state = NULL;
1555         return ret;
1556 }
1557 EXPORT_SYMBOL_GPL(pci_load_and_free_saved_state);
1558
1559 int __weak pcibios_enable_device(struct pci_dev *dev, int bars)
1560 {
1561         return pci_enable_resources(dev, bars);
1562 }
1563
1564 static int do_pci_enable_device(struct pci_dev *dev, int bars)
1565 {
1566         int err;
1567         struct pci_dev *bridge;
1568         u16 cmd;
1569         u8 pin;
1570
1571         err = pci_set_power_state(dev, PCI_D0);
1572         if (err < 0 && err != -EIO)
1573                 return err;
1574
1575         bridge = pci_upstream_bridge(dev);
1576         if (bridge)
1577                 pcie_aspm_powersave_config_link(bridge);
1578
1579         err = pcibios_enable_device(dev, bars);
1580         if (err < 0)
1581                 return err;
1582         pci_fixup_device(pci_fixup_enable, dev);
1583
1584         if (dev->msi_enabled || dev->msix_enabled)
1585                 return 0;
1586
1587         pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
1588         if (pin) {
1589                 pci_read_config_word(dev, PCI_COMMAND, &cmd);
1590                 if (cmd & PCI_COMMAND_INTX_DISABLE)
1591                         pci_write_config_word(dev, PCI_COMMAND,
1592                                               cmd & ~PCI_COMMAND_INTX_DISABLE);
1593         }
1594
1595         return 0;
1596 }
1597
1598 /**
1599  * pci_reenable_device - Resume abandoned device
1600  * @dev: PCI device to be resumed
1601  *
1602  *  Note this function is a backend of pci_default_resume and is not supposed
1603  *  to be called by normal code, write proper resume handler and use it instead.
1604  */
1605 int pci_reenable_device(struct pci_dev *dev)
1606 {
1607         if (pci_is_enabled(dev))
1608                 return do_pci_enable_device(dev, (1 << PCI_NUM_RESOURCES) - 1);
1609         return 0;
1610 }
1611 EXPORT_SYMBOL(pci_reenable_device);
1612
1613 static void pci_enable_bridge(struct pci_dev *dev)
1614 {
1615         struct pci_dev *bridge;
1616         int retval;
1617
1618         bridge = pci_upstream_bridge(dev);
1619         if (bridge)
1620                 pci_enable_bridge(bridge);
1621
1622         if (pci_is_enabled(dev)) {
1623                 if (!dev->is_busmaster)
1624                         pci_set_master(dev);
1625                 return;
1626         }
1627
1628         retval = pci_enable_device(dev);
1629         if (retval)
1630                 pci_err(dev, "Error enabling bridge (%d), continuing\n",
1631                         retval);
1632         pci_set_master(dev);
1633 }
1634
1635 static int pci_enable_device_flags(struct pci_dev *dev, unsigned long flags)
1636 {
1637         struct pci_dev *bridge;
1638         int err;
1639         int i, bars = 0;
1640
1641         /*
1642          * Power state could be unknown at this point, either due to a fresh
1643          * boot or a device removal call.  So get the current power state
1644          * so that things like MSI message writing will behave as expected
1645          * (e.g. if the device really is in D0 at enable time).
1646          */
1647         if (dev->pm_cap) {
1648                 u16 pmcsr;
1649                 pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
1650                 dev->current_state = (pmcsr & PCI_PM_CTRL_STATE_MASK);
1651         }
1652
1653         if (atomic_inc_return(&dev->enable_cnt) > 1)
1654                 return 0;               /* already enabled */
1655
1656         bridge = pci_upstream_bridge(dev);
1657         if (bridge)
1658                 pci_enable_bridge(bridge);
1659
1660         /* only skip sriov related */
1661         for (i = 0; i <= PCI_ROM_RESOURCE; i++)
1662                 if (dev->resource[i].flags & flags)
1663                         bars |= (1 << i);
1664         for (i = PCI_BRIDGE_RESOURCES; i < DEVICE_COUNT_RESOURCE; i++)
1665                 if (dev->resource[i].flags & flags)
1666                         bars |= (1 << i);
1667
1668         err = do_pci_enable_device(dev, bars);
1669         if (err < 0)
1670                 atomic_dec(&dev->enable_cnt);
1671         return err;
1672 }
1673
1674 /**
1675  * pci_enable_device_io - Initialize a device for use with IO space
1676  * @dev: PCI device to be initialized
1677  *
1678  *  Initialize device before it's used by a driver. Ask low-level code
1679  *  to enable I/O resources. Wake up the device if it was suspended.
1680  *  Beware, this function can fail.
1681  */
1682 int pci_enable_device_io(struct pci_dev *dev)
1683 {
1684         return pci_enable_device_flags(dev, IORESOURCE_IO);
1685 }
1686 EXPORT_SYMBOL(pci_enable_device_io);
1687
1688 /**
1689  * pci_enable_device_mem - Initialize a device for use with Memory space
1690  * @dev: PCI device to be initialized
1691  *
1692  *  Initialize device before it's used by a driver. Ask low-level code
1693  *  to enable Memory resources. Wake up the device if it was suspended.
1694  *  Beware, this function can fail.
1695  */
1696 int pci_enable_device_mem(struct pci_dev *dev)
1697 {
1698         return pci_enable_device_flags(dev, IORESOURCE_MEM);
1699 }
1700 EXPORT_SYMBOL(pci_enable_device_mem);
1701
1702 /**
1703  * pci_enable_device - Initialize device before it's used by a driver.
1704  * @dev: PCI device to be initialized
1705  *
1706  *  Initialize device before it's used by a driver. Ask low-level code
1707  *  to enable I/O and memory. Wake up the device if it was suspended.
1708  *  Beware, this function can fail.
1709  *
1710  *  Note we don't actually enable the device many times if we call
1711  *  this function repeatedly (we just increment the count).
1712  */
1713 int pci_enable_device(struct pci_dev *dev)
1714 {
1715         return pci_enable_device_flags(dev, IORESOURCE_MEM | IORESOURCE_IO);
1716 }
1717 EXPORT_SYMBOL(pci_enable_device);
1718
1719 /*
1720  * Managed PCI resources.  This manages device on/off, intx/msi/msix
1721  * on/off and BAR regions.  pci_dev itself records msi/msix status, so
1722  * there's no need to track it separately.  pci_devres is initialized
1723  * when a device is enabled using managed PCI device enable interface.
1724  */
1725 struct pci_devres {
1726         unsigned int enabled:1;
1727         unsigned int pinned:1;
1728         unsigned int orig_intx:1;
1729         unsigned int restore_intx:1;
1730         unsigned int mwi:1;
1731         u32 region_mask;
1732 };
1733
1734 static void pcim_release(struct device *gendev, void *res)
1735 {
1736         struct pci_dev *dev = to_pci_dev(gendev);
1737         struct pci_devres *this = res;
1738         int i;
1739
1740         if (dev->msi_enabled)
1741                 pci_disable_msi(dev);
1742         if (dev->msix_enabled)
1743                 pci_disable_msix(dev);
1744
1745         for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
1746                 if (this->region_mask & (1 << i))
1747                         pci_release_region(dev, i);
1748
1749         if (this->mwi)
1750                 pci_clear_mwi(dev);
1751
1752         if (this->restore_intx)
1753                 pci_intx(dev, this->orig_intx);
1754
1755         if (this->enabled && !this->pinned)
1756                 pci_disable_device(dev);
1757 }
1758
1759 static struct pci_devres *get_pci_dr(struct pci_dev *pdev)
1760 {
1761         struct pci_devres *dr, *new_dr;
1762
1763         dr = devres_find(&pdev->dev, pcim_release, NULL, NULL);
1764         if (dr)
1765                 return dr;
1766
1767         new_dr = devres_alloc(pcim_release, sizeof(*new_dr), GFP_KERNEL);
1768         if (!new_dr)
1769                 return NULL;
1770         return devres_get(&pdev->dev, new_dr, NULL, NULL);
1771 }
1772
1773 static struct pci_devres *find_pci_dr(struct pci_dev *pdev)
1774 {
1775         if (pci_is_managed(pdev))
1776                 return devres_find(&pdev->dev, pcim_release, NULL, NULL);
1777         return NULL;
1778 }
1779
1780 /**
1781  * pcim_enable_device - Managed pci_enable_device()
1782  * @pdev: PCI device to be initialized
1783  *
1784  * Managed pci_enable_device().
1785  */
1786 int pcim_enable_device(struct pci_dev *pdev)
1787 {
1788         struct pci_devres *dr;
1789         int rc;
1790
1791         dr = get_pci_dr(pdev);
1792         if (unlikely(!dr))
1793                 return -ENOMEM;
1794         if (dr->enabled)
1795                 return 0;
1796
1797         rc = pci_enable_device(pdev);
1798         if (!rc) {
1799                 pdev->is_managed = 1;
1800                 dr->enabled = 1;
1801         }
1802         return rc;
1803 }
1804 EXPORT_SYMBOL(pcim_enable_device);
1805
1806 /**
1807  * pcim_pin_device - Pin managed PCI device
1808  * @pdev: PCI device to pin
1809  *
1810  * Pin managed PCI device @pdev.  Pinned device won't be disabled on
1811  * driver detach.  @pdev must have been enabled with
1812  * pcim_enable_device().
1813  */
1814 void pcim_pin_device(struct pci_dev *pdev)
1815 {
1816         struct pci_devres *dr;
1817
1818         dr = find_pci_dr(pdev);
1819         WARN_ON(!dr || !dr->enabled);
1820         if (dr)
1821                 dr->pinned = 1;
1822 }
1823 EXPORT_SYMBOL(pcim_pin_device);
1824
1825 /*
1826  * pcibios_add_device - provide arch specific hooks when adding device dev
1827  * @dev: the PCI device being added
1828  *
1829  * Permits the platform to provide architecture specific functionality when
1830  * devices are added. This is the default implementation. Architecture
1831  * implementations can override this.
1832  */
1833 int __weak pcibios_add_device(struct pci_dev *dev)
1834 {
1835         return 0;
1836 }
1837
1838 /**
1839  * pcibios_release_device - provide arch specific hooks when releasing device dev
1840  * @dev: the PCI device being released
1841  *
1842  * Permits the platform to provide architecture specific functionality when
1843  * devices are released. This is the default implementation. Architecture
1844  * implementations can override this.
1845  */
1846 void __weak pcibios_release_device(struct pci_dev *dev) {}
1847
1848 /**
1849  * pcibios_disable_device - disable arch specific PCI resources for device dev
1850  * @dev: the PCI device to disable
1851  *
1852  * Disables architecture specific PCI resources for the device. This
1853  * is the default implementation. Architecture implementations can
1854  * override this.
1855  */
1856 void __weak pcibios_disable_device(struct pci_dev *dev) {}
1857
1858 /**
1859  * pcibios_penalize_isa_irq - penalize an ISA IRQ
1860  * @irq: ISA IRQ to penalize
1861  * @active: IRQ active or not
1862  *
1863  * Permits the platform to provide architecture-specific functionality when
1864  * penalizing ISA IRQs. This is the default implementation. Architecture
1865  * implementations can override this.
1866  */
1867 void __weak pcibios_penalize_isa_irq(int irq, int active) {}
1868
1869 static void do_pci_disable_device(struct pci_dev *dev)
1870 {
1871         u16 pci_command;
1872
1873         pci_read_config_word(dev, PCI_COMMAND, &pci_command);
1874         if (pci_command & PCI_COMMAND_MASTER) {
1875                 pci_command &= ~PCI_COMMAND_MASTER;
1876                 pci_write_config_word(dev, PCI_COMMAND, pci_command);
1877         }
1878
1879         pcibios_disable_device(dev);
1880 }
1881
1882 /**
1883  * pci_disable_enabled_device - Disable device without updating enable_cnt
1884  * @dev: PCI device to disable
1885  *
1886  * NOTE: This function is a backend of PCI power management routines and is
1887  * not supposed to be called drivers.
1888  */
1889 void pci_disable_enabled_device(struct pci_dev *dev)
1890 {
1891         if (pci_is_enabled(dev))
1892                 do_pci_disable_device(dev);
1893 }
1894
1895 /**
1896  * pci_disable_device - Disable PCI device after use
1897  * @dev: PCI device to be disabled
1898  *
1899  * Signal to the system that the PCI device is not in use by the system
1900  * anymore.  This only involves disabling PCI bus-mastering, if active.
1901  *
1902  * Note we don't actually disable the device until all callers of
1903  * pci_enable_device() have called pci_disable_device().
1904  */
1905 void pci_disable_device(struct pci_dev *dev)
1906 {
1907         struct pci_devres *dr;
1908
1909         dr = find_pci_dr(dev);
1910         if (dr)
1911                 dr->enabled = 0;
1912
1913         dev_WARN_ONCE(&dev->dev, atomic_read(&dev->enable_cnt) <= 0,
1914                       "disabling already-disabled device");
1915
1916         if (atomic_dec_return(&dev->enable_cnt) != 0)
1917                 return;
1918
1919         do_pci_disable_device(dev);
1920
1921         dev->is_busmaster = 0;
1922 }
1923 EXPORT_SYMBOL(pci_disable_device);
1924
1925 /**
1926  * pcibios_set_pcie_reset_state - set reset state for device dev
1927  * @dev: the PCIe device reset
1928  * @state: Reset state to enter into
1929  *
1930  *
1931  * Sets the PCIe reset state for the device. This is the default
1932  * implementation. Architecture implementations can override this.
1933  */
1934 int __weak pcibios_set_pcie_reset_state(struct pci_dev *dev,
1935                                         enum pcie_reset_state state)
1936 {
1937         return -EINVAL;
1938 }
1939
1940 /**
1941  * pci_set_pcie_reset_state - set reset state for device dev
1942  * @dev: the PCIe device reset
1943  * @state: Reset state to enter into
1944  *
1945  *
1946  * Sets the PCI reset state for the device.
1947  */
1948 int pci_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state)
1949 {
1950         return pcibios_set_pcie_reset_state(dev, state);
1951 }
1952 EXPORT_SYMBOL_GPL(pci_set_pcie_reset_state);
1953
1954 /**
1955  * pcie_clear_root_pme_status - Clear root port PME interrupt status.
1956  * @dev: PCIe root port or event collector.
1957  */
1958 void pcie_clear_root_pme_status(struct pci_dev *dev)
1959 {
1960         pcie_capability_set_dword(dev, PCI_EXP_RTSTA, PCI_EXP_RTSTA_PME);
1961 }
1962
1963 /**
1964  * pci_check_pme_status - Check if given device has generated PME.
1965  * @dev: Device to check.
1966  *
1967  * Check the PME status of the device and if set, clear it and clear PME enable
1968  * (if set).  Return 'true' if PME status and PME enable were both set or
1969  * 'false' otherwise.
1970  */
1971 bool pci_check_pme_status(struct pci_dev *dev)
1972 {
1973         int pmcsr_pos;
1974         u16 pmcsr;
1975         bool ret = false;
1976
1977         if (!dev->pm_cap)
1978                 return false;
1979
1980         pmcsr_pos = dev->pm_cap + PCI_PM_CTRL;
1981         pci_read_config_word(dev, pmcsr_pos, &pmcsr);
1982         if (!(pmcsr & PCI_PM_CTRL_PME_STATUS))
1983                 return false;
1984
1985         /* Clear PME status. */
1986         pmcsr |= PCI_PM_CTRL_PME_STATUS;
1987         if (pmcsr & PCI_PM_CTRL_PME_ENABLE) {
1988                 /* Disable PME to avoid interrupt flood. */
1989                 pmcsr &= ~PCI_PM_CTRL_PME_ENABLE;
1990                 ret = true;
1991         }
1992
1993         pci_write_config_word(dev, pmcsr_pos, pmcsr);
1994
1995         return ret;
1996 }
1997
1998 /**
1999  * pci_pme_wakeup - Wake up a PCI device if its PME Status bit is set.
2000  * @dev: Device to handle.
2001  * @pme_poll_reset: Whether or not to reset the device's pme_poll flag.
2002  *
2003  * Check if @dev has generated PME and queue a resume request for it in that
2004  * case.
2005  */
2006 static int pci_pme_wakeup(struct pci_dev *dev, void *pme_poll_reset)
2007 {
2008         if (pme_poll_reset && dev->pme_poll)
2009                 dev->pme_poll = false;
2010
2011         if (pci_check_pme_status(dev)) {
2012                 pci_wakeup_event(dev);
2013                 pm_request_resume(&dev->dev);
2014         }
2015         return 0;
2016 }
2017
2018 /**
2019  * pci_pme_wakeup_bus - Walk given bus and wake up devices on it, if necessary.
2020  * @bus: Top bus of the subtree to walk.
2021  */
2022 void pci_pme_wakeup_bus(struct pci_bus *bus)
2023 {
2024         if (bus)
2025                 pci_walk_bus(bus, pci_pme_wakeup, (void *)true);
2026 }
2027
2028
2029 /**
2030  * pci_pme_capable - check the capability of PCI device to generate PME#
2031  * @dev: PCI device to handle.
2032  * @state: PCI state from which device will issue PME#.
2033  */
2034 bool pci_pme_capable(struct pci_dev *dev, pci_power_t state)
2035 {
2036         if (!dev->pm_cap)
2037                 return false;
2038
2039         return !!(dev->pme_support & (1 << state));
2040 }
2041 EXPORT_SYMBOL(pci_pme_capable);
2042
2043 static void pci_pme_list_scan(struct work_struct *work)
2044 {
2045         struct pci_pme_device *pme_dev, *n;
2046
2047         mutex_lock(&pci_pme_list_mutex);
2048         list_for_each_entry_safe(pme_dev, n, &pci_pme_list, list) {
2049                 if (pme_dev->dev->pme_poll) {
2050                         struct pci_dev *bridge;
2051
2052                         bridge = pme_dev->dev->bus->self;
2053                         /*
2054                          * If bridge is in low power state, the
2055                          * configuration space of subordinate devices
2056                          * may be not accessible
2057                          */
2058                         if (bridge && bridge->current_state != PCI_D0)
2059                                 continue;
2060                         pci_pme_wakeup(pme_dev->dev, NULL);
2061                 } else {
2062                         list_del(&pme_dev->list);
2063                         kfree(pme_dev);
2064                 }
2065         }
2066         if (!list_empty(&pci_pme_list))
2067                 queue_delayed_work(system_freezable_wq, &pci_pme_work,
2068                                    msecs_to_jiffies(PME_TIMEOUT));
2069         mutex_unlock(&pci_pme_list_mutex);
2070 }
2071
2072 static void __pci_pme_active(struct pci_dev *dev, bool enable)
2073 {
2074         u16 pmcsr;
2075
2076         if (!dev->pme_support)
2077                 return;
2078
2079         pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
2080         /* Clear PME_Status by writing 1 to it and enable PME# */
2081         pmcsr |= PCI_PM_CTRL_PME_STATUS | PCI_PM_CTRL_PME_ENABLE;
2082         if (!enable)
2083                 pmcsr &= ~PCI_PM_CTRL_PME_ENABLE;
2084
2085         pci_write_config_word(dev, dev->pm_cap + PCI_PM_CTRL, pmcsr);
2086 }
2087
2088 /**
2089  * pci_pme_restore - Restore PME configuration after config space restore.
2090  * @dev: PCI device to update.
2091  */
2092 void pci_pme_restore(struct pci_dev *dev)
2093 {
2094         u16 pmcsr;
2095
2096         if (!dev->pme_support)
2097                 return;
2098
2099         pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
2100         if (dev->wakeup_prepared) {
2101                 pmcsr |= PCI_PM_CTRL_PME_ENABLE;
2102                 pmcsr &= ~PCI_PM_CTRL_PME_STATUS;
2103         } else {
2104                 pmcsr &= ~PCI_PM_CTRL_PME_ENABLE;
2105                 pmcsr |= PCI_PM_CTRL_PME_STATUS;
2106         }
2107         pci_write_config_word(dev, dev->pm_cap + PCI_PM_CTRL, pmcsr);
2108 }
2109
2110 /**
2111  * pci_pme_active - enable or disable PCI device's PME# function
2112  * @dev: PCI device to handle.
2113  * @enable: 'true' to enable PME# generation; 'false' to disable it.
2114  *
2115  * The caller must verify that the device is capable of generating PME# before
2116  * calling this function with @enable equal to 'true'.
2117  */
2118 void pci_pme_active(struct pci_dev *dev, bool enable)
2119 {
2120         __pci_pme_active(dev, enable);
2121
2122         /*
2123          * PCI (as opposed to PCIe) PME requires that the device have
2124          * its PME# line hooked up correctly. Not all hardware vendors
2125          * do this, so the PME never gets delivered and the device
2126          * remains asleep. The easiest way around this is to
2127          * periodically walk the list of suspended devices and check
2128          * whether any have their PME flag set. The assumption is that
2129          * we'll wake up often enough anyway that this won't be a huge
2130          * hit, and the power savings from the devices will still be a
2131          * win.
2132          *
2133          * Although PCIe uses in-band PME message instead of PME# line
2134          * to report PME, PME does not work for some PCIe devices in
2135          * reality.  For example, there are devices that set their PME
2136          * status bits, but don't really bother to send a PME message;
2137          * there are PCI Express Root Ports that don't bother to
2138          * trigger interrupts when they receive PME messages from the
2139          * devices below.  So PME poll is used for PCIe devices too.
2140          */
2141
2142         if (dev->pme_poll) {
2143                 struct pci_pme_device *pme_dev;
2144                 if (enable) {
2145                         pme_dev = kmalloc(sizeof(struct pci_pme_device),
2146                                           GFP_KERNEL);
2147                         if (!pme_dev) {
2148                                 pci_warn(dev, "can't enable PME#\n");
2149                                 return;
2150                         }
2151                         pme_dev->dev = dev;
2152                         mutex_lock(&pci_pme_list_mutex);
2153                         list_add(&pme_dev->list, &pci_pme_list);
2154                         if (list_is_singular(&pci_pme_list))
2155                                 queue_delayed_work(system_freezable_wq,
2156                                                    &pci_pme_work,
2157                                                    msecs_to_jiffies(PME_TIMEOUT));
2158                         mutex_unlock(&pci_pme_list_mutex);
2159                 } else {
2160                         mutex_lock(&pci_pme_list_mutex);
2161                         list_for_each_entry(pme_dev, &pci_pme_list, list) {
2162                                 if (pme_dev->dev == dev) {
2163                                         list_del(&pme_dev->list);
2164                                         kfree(pme_dev);
2165                                         break;
2166                                 }
2167                         }
2168                         mutex_unlock(&pci_pme_list_mutex);
2169                 }
2170         }
2171
2172         pci_dbg(dev, "PME# %s\n", enable ? "enabled" : "disabled");
2173 }
2174 EXPORT_SYMBOL(pci_pme_active);
2175
2176 /**
2177  * __pci_enable_wake - enable PCI device as wakeup event source
2178  * @dev: PCI device affected
2179  * @state: PCI state from which device will issue wakeup events
2180  * @enable: True to enable event generation; false to disable
2181  *
2182  * This enables the device as a wakeup event source, or disables it.
2183  * When such events involves platform-specific hooks, those hooks are
2184  * called automatically by this routine.
2185  *
2186  * Devices with legacy power management (no standard PCI PM capabilities)
2187  * always require such platform hooks.
2188  *
2189  * RETURN VALUE:
2190  * 0 is returned on success
2191  * -EINVAL is returned if device is not supposed to wake up the system
2192  * Error code depending on the platform is returned if both the platform and
2193  * the native mechanism fail to enable the generation of wake-up events
2194  */
2195 static int __pci_enable_wake(struct pci_dev *dev, pci_power_t state, bool enable)
2196 {
2197         int ret = 0;
2198
2199         /*
2200          * Bridges that are not power-manageable directly only signal
2201          * wakeup on behalf of subordinate devices which is set up
2202          * elsewhere, so skip them. However, bridges that are
2203          * power-manageable may signal wakeup for themselves (for example,
2204          * on a hotplug event) and they need to be covered here.
2205          */
2206         if (!pci_power_manageable(dev))
2207                 return 0;
2208
2209         /* Don't do the same thing twice in a row for one device. */
2210         if (!!enable == !!dev->wakeup_prepared)
2211                 return 0;
2212
2213         /*
2214          * According to "PCI System Architecture" 4th ed. by Tom Shanley & Don
2215          * Anderson we should be doing PME# wake enable followed by ACPI wake
2216          * enable.  To disable wake-up we call the platform first, for symmetry.
2217          */
2218
2219         if (enable) {
2220                 int error;
2221
2222                 if (pci_pme_capable(dev, state))
2223                         pci_pme_active(dev, true);
2224                 else
2225                         ret = 1;
2226                 error = platform_pci_set_wakeup(dev, true);
2227                 if (ret)
2228                         ret = error;
2229                 if (!ret)
2230                         dev->wakeup_prepared = true;
2231         } else {
2232                 platform_pci_set_wakeup(dev, false);
2233                 pci_pme_active(dev, false);
2234                 dev->wakeup_prepared = false;
2235         }
2236
2237         return ret;
2238 }
2239
2240 /**
2241  * pci_enable_wake - change wakeup settings for a PCI device
2242  * @pci_dev: Target device
2243  * @state: PCI state from which device will issue wakeup events
2244  * @enable: Whether or not to enable event generation
2245  *
2246  * If @enable is set, check device_may_wakeup() for the device before calling
2247  * __pci_enable_wake() for it.
2248  */
2249 int pci_enable_wake(struct pci_dev *pci_dev, pci_power_t state, bool enable)
2250 {
2251         if (enable && !device_may_wakeup(&pci_dev->dev))
2252                 return -EINVAL;
2253
2254         return __pci_enable_wake(pci_dev, state, enable);
2255 }
2256 EXPORT_SYMBOL(pci_enable_wake);
2257
2258 /**
2259  * pci_wake_from_d3 - enable/disable device to wake up from D3_hot or D3_cold
2260  * @dev: PCI device to prepare
2261  * @enable: True to enable wake-up event generation; false to disable
2262  *
2263  * Many drivers want the device to wake up the system from D3_hot or D3_cold
2264  * and this function allows them to set that up cleanly - pci_enable_wake()
2265  * should not be called twice in a row to enable wake-up due to PCI PM vs ACPI
2266  * ordering constraints.
2267  *
2268  * This function only returns error code if the device is not allowed to wake
2269  * up the system from sleep or it is not capable of generating PME# from both
2270  * D3_hot and D3_cold and the platform is unable to enable wake-up power for it.
2271  */
2272 int pci_wake_from_d3(struct pci_dev *dev, bool enable)
2273 {
2274         return pci_pme_capable(dev, PCI_D3cold) ?
2275                         pci_enable_wake(dev, PCI_D3cold, enable) :
2276                         pci_enable_wake(dev, PCI_D3hot, enable);
2277 }
2278 EXPORT_SYMBOL(pci_wake_from_d3);
2279
2280 /**
2281  * pci_target_state - find an appropriate low power state for a given PCI dev
2282  * @dev: PCI device
2283  * @wakeup: Whether or not wakeup functionality will be enabled for the device.
2284  *
2285  * Use underlying platform code to find a supported low power state for @dev.
2286  * If the platform can't manage @dev, return the deepest state from which it
2287  * can generate wake events, based on any available PME info.
2288  */
2289 static pci_power_t pci_target_state(struct pci_dev *dev, bool wakeup)
2290 {
2291         pci_power_t target_state = PCI_D3hot;
2292
2293         if (platform_pci_power_manageable(dev)) {
2294                 /*
2295                  * Call the platform to find the target state for the device.
2296                  */
2297                 pci_power_t state = platform_pci_choose_state(dev);
2298
2299                 switch (state) {
2300                 case PCI_POWER_ERROR:
2301                 case PCI_UNKNOWN:
2302                         break;
2303                 case PCI_D1:
2304                 case PCI_D2:
2305                         if (pci_no_d1d2(dev))
2306                                 break;
2307                         /* else, fall through */
2308                 default:
2309                         target_state = state;
2310                 }
2311
2312                 return target_state;
2313         }
2314
2315         if (!dev->pm_cap)
2316                 target_state = PCI_D0;
2317
2318         /*
2319          * If the device is in D3cold even though it's not power-manageable by
2320          * the platform, it may have been powered down by non-standard means.
2321          * Best to let it slumber.
2322          */
2323         if (dev->current_state == PCI_D3cold)
2324                 target_state = PCI_D3cold;
2325
2326         if (wakeup) {
2327                 /*
2328                  * Find the deepest state from which the device can generate
2329                  * PME#.
2330                  */
2331                 if (dev->pme_support) {
2332                         while (target_state
2333                               && !(dev->pme_support & (1 << target_state)))
2334                                 target_state--;
2335                 }
2336         }
2337
2338         return target_state;
2339 }
2340
2341 /**
2342  * pci_prepare_to_sleep - prepare PCI device for system-wide transition into a sleep state
2343  * @dev: Device to handle.
2344  *
2345  * Choose the power state appropriate for the device depending on whether
2346  * it can wake up the system and/or is power manageable by the platform
2347  * (PCI_D3hot is the default) and put the device into that state.
2348  */
2349 int pci_prepare_to_sleep(struct pci_dev *dev)
2350 {
2351         bool wakeup = device_may_wakeup(&dev->dev);
2352         pci_power_t target_state = pci_target_state(dev, wakeup);
2353         int error;
2354
2355         if (target_state == PCI_POWER_ERROR)
2356                 return -EIO;
2357
2358         pci_enable_wake(dev, target_state, wakeup);
2359
2360         error = pci_set_power_state(dev, target_state);
2361
2362         if (error)
2363                 pci_enable_wake(dev, target_state, false);
2364
2365         return error;
2366 }
2367 EXPORT_SYMBOL(pci_prepare_to_sleep);
2368
2369 /**
2370  * pci_back_from_sleep - turn PCI device on during system-wide transition into working state
2371  * @dev: Device to handle.
2372  *
2373  * Disable device's system wake-up capability and put it into D0.
2374  */
2375 int pci_back_from_sleep(struct pci_dev *dev)
2376 {
2377         pci_enable_wake(dev, PCI_D0, false);
2378         return pci_set_power_state(dev, PCI_D0);
2379 }
2380 EXPORT_SYMBOL(pci_back_from_sleep);
2381
2382 /**
2383  * pci_finish_runtime_suspend - Carry out PCI-specific part of runtime suspend.
2384  * @dev: PCI device being suspended.
2385  *
2386  * Prepare @dev to generate wake-up events at run time and put it into a low
2387  * power state.
2388  */
2389 int pci_finish_runtime_suspend(struct pci_dev *dev)
2390 {
2391         pci_power_t target_state;
2392         int error;
2393
2394         target_state = pci_target_state(dev, device_can_wakeup(&dev->dev));
2395         if (target_state == PCI_POWER_ERROR)
2396                 return -EIO;
2397
2398         dev->runtime_d3cold = target_state == PCI_D3cold;
2399
2400         __pci_enable_wake(dev, target_state, pci_dev_run_wake(dev));
2401
2402         error = pci_set_power_state(dev, target_state);
2403
2404         if (error) {
2405                 pci_enable_wake(dev, target_state, false);
2406                 dev->runtime_d3cold = false;
2407         }
2408
2409         return error;
2410 }
2411
2412 /**
2413  * pci_dev_run_wake - Check if device can generate run-time wake-up events.
2414  * @dev: Device to check.
2415  *
2416  * Return true if the device itself is capable of generating wake-up events
2417  * (through the platform or using the native PCIe PME) or if the device supports
2418  * PME and one of its upstream bridges can generate wake-up events.
2419  */
2420 bool pci_dev_run_wake(struct pci_dev *dev)
2421 {
2422         struct pci_bus *bus = dev->bus;
2423
2424         if (!dev->pme_support)
2425                 return false;
2426
2427         /* PME-capable in principle, but not from the target power state */
2428         if (!pci_pme_capable(dev, pci_target_state(dev, true)))
2429                 return false;
2430
2431         if (device_can_wakeup(&dev->dev))
2432                 return true;
2433
2434         while (bus->parent) {
2435                 struct pci_dev *bridge = bus->self;
2436
2437                 if (device_can_wakeup(&bridge->dev))
2438                         return true;
2439
2440                 bus = bus->parent;
2441         }
2442
2443         /* We have reached the root bus. */
2444         if (bus->bridge)
2445                 return device_can_wakeup(bus->bridge);
2446
2447         return false;
2448 }
2449 EXPORT_SYMBOL_GPL(pci_dev_run_wake);
2450
2451 /**
2452  * pci_dev_keep_suspended - Check if the device can stay in the suspended state.
2453  * @pci_dev: Device to check.
2454  *
2455  * Return 'true' if the device is runtime-suspended, it doesn't have to be
2456  * reconfigured due to wakeup settings difference between system and runtime
2457  * suspend and the current power state of it is suitable for the upcoming
2458  * (system) transition.
2459  *
2460  * If the device is not configured for system wakeup, disable PME for it before
2461  * returning 'true' to prevent it from waking up the system unnecessarily.
2462  */
2463 bool pci_dev_keep_suspended(struct pci_dev *pci_dev)
2464 {
2465         struct device *dev = &pci_dev->dev;
2466         bool wakeup = device_may_wakeup(dev);
2467
2468         if (!pm_runtime_suspended(dev)
2469             || pci_target_state(pci_dev, wakeup) != pci_dev->current_state
2470             || platform_pci_need_resume(pci_dev))
2471                 return false;
2472
2473         /*
2474          * At this point the device is good to go unless it's been configured
2475          * to generate PME at the runtime suspend time, but it is not supposed
2476          * to wake up the system.  In that case, simply disable PME for it
2477          * (it will have to be re-enabled on exit from system resume).
2478          *
2479          * If the device's power state is D3cold and the platform check above
2480          * hasn't triggered, the device's configuration is suitable and we don't
2481          * need to manipulate it at all.
2482          */
2483         spin_lock_irq(&dev->power.lock);
2484
2485         if (pm_runtime_suspended(dev) && pci_dev->current_state < PCI_D3cold &&
2486             !wakeup)
2487                 __pci_pme_active(pci_dev, false);
2488
2489         spin_unlock_irq(&dev->power.lock);
2490         return true;
2491 }
2492
2493 /**
2494  * pci_dev_complete_resume - Finalize resume from system sleep for a device.
2495  * @pci_dev: Device to handle.
2496  *
2497  * If the device is runtime suspended and wakeup-capable, enable PME for it as
2498  * it might have been disabled during the prepare phase of system suspend if
2499  * the device was not configured for system wakeup.
2500  */
2501 void pci_dev_complete_resume(struct pci_dev *pci_dev)
2502 {
2503         struct device *dev = &pci_dev->dev;
2504
2505         if (!pci_dev_run_wake(pci_dev))
2506                 return;
2507
2508         spin_lock_irq(&dev->power.lock);
2509
2510         if (pm_runtime_suspended(dev) && pci_dev->current_state < PCI_D3cold)
2511                 __pci_pme_active(pci_dev, true);
2512
2513         spin_unlock_irq(&dev->power.lock);
2514 }
2515
2516 void pci_config_pm_runtime_get(struct pci_dev *pdev)
2517 {
2518         struct device *dev = &pdev->dev;
2519         struct device *parent = dev->parent;
2520
2521         if (parent)
2522                 pm_runtime_get_sync(parent);
2523         pm_runtime_get_noresume(dev);
2524         /*
2525          * pdev->current_state is set to PCI_D3cold during suspending,
2526          * so wait until suspending completes
2527          */
2528         pm_runtime_barrier(dev);
2529         /*
2530          * Only need to resume devices in D3cold, because config
2531          * registers are still accessible for devices suspended but
2532          * not in D3cold.
2533          */
2534         if (pdev->current_state == PCI_D3cold)
2535                 pm_runtime_resume(dev);
2536 }
2537
2538 void pci_config_pm_runtime_put(struct pci_dev *pdev)
2539 {
2540         struct device *dev = &pdev->dev;
2541         struct device *parent = dev->parent;
2542
2543         pm_runtime_put(dev);
2544         if (parent)
2545                 pm_runtime_put_sync(parent);
2546 }
2547
2548 static const struct dmi_system_id bridge_d3_blacklist[] = {
2549 #ifdef CONFIG_X86
2550         {
2551                 /*
2552                  * Gigabyte X299 root port is not marked as hotplug capable
2553                  * which allows Linux to power manage it.  However, this
2554                  * confuses the BIOS SMI handler so don't power manage root
2555                  * ports on that system.
2556                  */
2557                 .ident = "X299 DESIGNARE EX-CF",
2558                 .matches = {
2559                         DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
2560                         DMI_MATCH(DMI_BOARD_NAME, "X299 DESIGNARE EX-CF"),
2561                 },
2562         },
2563 #endif
2564         { }
2565 };
2566
2567 /**
2568  * pci_bridge_d3_possible - Is it possible to put the bridge into D3
2569  * @bridge: Bridge to check
2570  *
2571  * This function checks if it is possible to move the bridge to D3.
2572  * Currently we only allow D3 for recent enough PCIe ports and Thunderbolt.
2573  */
2574 bool pci_bridge_d3_possible(struct pci_dev *bridge)
2575 {
2576         if (!pci_is_pcie(bridge))
2577                 return false;
2578
2579         switch (pci_pcie_type(bridge)) {
2580         case PCI_EXP_TYPE_ROOT_PORT:
2581         case PCI_EXP_TYPE_UPSTREAM:
2582         case PCI_EXP_TYPE_DOWNSTREAM:
2583                 if (pci_bridge_d3_disable)
2584                         return false;
2585
2586                 /*
2587                  * Hotplug ports handled by firmware in System Management Mode
2588                  * may not be put into D3 by the OS (Thunderbolt on non-Macs).
2589                  */
2590                 if (bridge->is_hotplug_bridge && !pciehp_is_native(bridge))
2591                         return false;
2592
2593                 if (pci_bridge_d3_force)
2594                         return true;
2595
2596                 /* Even the oldest 2010 Thunderbolt controller supports D3. */
2597                 if (bridge->is_thunderbolt)
2598                         return true;
2599
2600                 /* Platform might know better if the bridge supports D3 */
2601                 if (platform_pci_bridge_d3(bridge))
2602                         return true;
2603
2604                 /*
2605                  * Hotplug ports handled natively by the OS were not validated
2606                  * by vendors for runtime D3 at least until 2018 because there
2607                  * was no OS support.
2608                  */
2609                 if (bridge->is_hotplug_bridge)
2610                         return false;
2611
2612                 if (dmi_check_system(bridge_d3_blacklist))
2613                         return false;
2614
2615                 /*
2616                  * It should be safe to put PCIe ports from 2015 or newer
2617                  * to D3.
2618                  */
2619                 if (dmi_get_bios_year() >= 2015)
2620                         return true;
2621                 break;
2622         }
2623
2624         return false;
2625 }
2626
2627 static int pci_dev_check_d3cold(struct pci_dev *dev, void *data)
2628 {
2629         bool *d3cold_ok = data;
2630
2631         if (/* The device needs to be allowed to go D3cold ... */
2632             dev->no_d3cold || !dev->d3cold_allowed ||
2633
2634             /* ... and if it is wakeup capable to do so from D3cold. */
2635             (device_may_wakeup(&dev->dev) &&
2636              !pci_pme_capable(dev, PCI_D3cold)) ||
2637
2638             /* If it is a bridge it must be allowed to go to D3. */
2639             !pci_power_manageable(dev))
2640
2641                 *d3cold_ok = false;
2642
2643         return !*d3cold_ok;
2644 }
2645
2646 /*
2647  * pci_bridge_d3_update - Update bridge D3 capabilities
2648  * @dev: PCI device which is changed
2649  *
2650  * Update upstream bridge PM capabilities accordingly depending on if the
2651  * device PM configuration was changed or the device is being removed.  The
2652  * change is also propagated upstream.
2653  */
2654 void pci_bridge_d3_update(struct pci_dev *dev)
2655 {
2656         bool remove = !device_is_registered(&dev->dev);
2657         struct pci_dev *bridge;
2658         bool d3cold_ok = true;
2659
2660         bridge = pci_upstream_bridge(dev);
2661         if (!bridge || !pci_bridge_d3_possible(bridge))
2662                 return;
2663
2664         /*
2665          * If D3 is currently allowed for the bridge, removing one of its
2666          * children won't change that.
2667          */
2668         if (remove && bridge->bridge_d3)
2669                 return;
2670
2671         /*
2672          * If D3 is currently allowed for the bridge and a child is added or
2673          * changed, disallowance of D3 can only be caused by that child, so
2674          * we only need to check that single device, not any of its siblings.
2675          *
2676          * If D3 is currently not allowed for the bridge, checking the device
2677          * first may allow us to skip checking its siblings.
2678          */
2679         if (!remove)
2680                 pci_dev_check_d3cold(dev, &d3cold_ok);
2681
2682         /*
2683          * If D3 is currently not allowed for the bridge, this may be caused
2684          * either by the device being changed/removed or any of its siblings,
2685          * so we need to go through all children to find out if one of them
2686          * continues to block D3.
2687          */
2688         if (d3cold_ok && !bridge->bridge_d3)
2689                 pci_walk_bus(bridge->subordinate, pci_dev_check_d3cold,
2690                              &d3cold_ok);
2691
2692         if (bridge->bridge_d3 != d3cold_ok) {
2693                 bridge->bridge_d3 = d3cold_ok;
2694                 /* Propagate change to upstream bridges */
2695                 pci_bridge_d3_update(bridge);
2696         }
2697 }
2698
2699 /**
2700  * pci_d3cold_enable - Enable D3cold for device
2701  * @dev: PCI device to handle
2702  *
2703  * This function can be used in drivers to enable D3cold from the device
2704  * they handle.  It also updates upstream PCI bridge PM capabilities
2705  * accordingly.
2706  */
2707 void pci_d3cold_enable(struct pci_dev *dev)
2708 {
2709         if (dev->no_d3cold) {
2710                 dev->no_d3cold = false;
2711                 pci_bridge_d3_update(dev);
2712         }
2713 }
2714 EXPORT_SYMBOL_GPL(pci_d3cold_enable);
2715
2716 /**
2717  * pci_d3cold_disable - Disable D3cold for device
2718  * @dev: PCI device to handle
2719  *
2720  * This function can be used in drivers to disable D3cold from the device
2721  * they handle.  It also updates upstream PCI bridge PM capabilities
2722  * accordingly.
2723  */
2724 void pci_d3cold_disable(struct pci_dev *dev)
2725 {
2726         if (!dev->no_d3cold) {
2727                 dev->no_d3cold = true;
2728                 pci_bridge_d3_update(dev);
2729         }
2730 }
2731 EXPORT_SYMBOL_GPL(pci_d3cold_disable);
2732
2733 /**
2734  * pci_pm_init - Initialize PM functions of given PCI device
2735  * @dev: PCI device to handle.
2736  */
2737 void pci_pm_init(struct pci_dev *dev)
2738 {
2739         int pm;
2740         u16 status;
2741         u16 pmc;
2742
2743         pm_runtime_forbid(&dev->dev);
2744         pm_runtime_set_active(&dev->dev);
2745         pm_runtime_enable(&dev->dev);
2746         device_enable_async_suspend(&dev->dev);
2747         dev->wakeup_prepared = false;
2748
2749         dev->pm_cap = 0;
2750         dev->pme_support = 0;
2751
2752         /* find PCI PM capability in list */
2753         pm = pci_find_capability(dev, PCI_CAP_ID_PM);
2754         if (!pm)
2755                 return;
2756         /* Check device's ability to generate PME# */
2757         pci_read_config_word(dev, pm + PCI_PM_PMC, &pmc);
2758
2759         if ((pmc & PCI_PM_CAP_VER_MASK) > 3) {
2760                 pci_err(dev, "unsupported PM cap regs version (%u)\n",
2761                         pmc & PCI_PM_CAP_VER_MASK);
2762                 return;
2763         }
2764
2765         dev->pm_cap = pm;
2766         dev->d3_delay = PCI_PM_D3_WAIT;
2767         dev->d3cold_delay = PCI_PM_D3COLD_WAIT;
2768         dev->bridge_d3 = pci_bridge_d3_possible(dev);
2769         dev->d3cold_allowed = true;
2770
2771         dev->d1_support = false;
2772         dev->d2_support = false;
2773         if (!pci_no_d1d2(dev)) {
2774                 if (pmc & PCI_PM_CAP_D1)
2775                         dev->d1_support = true;
2776                 if (pmc & PCI_PM_CAP_D2)
2777                         dev->d2_support = true;
2778
2779                 if (dev->d1_support || dev->d2_support)
2780                         pci_printk(KERN_DEBUG, dev, "supports%s%s\n",
2781                                    dev->d1_support ? " D1" : "",
2782                                    dev->d2_support ? " D2" : "");
2783         }
2784
2785         pmc &= PCI_PM_CAP_PME_MASK;
2786         if (pmc) {
2787                 pci_printk(KERN_DEBUG, dev, "PME# supported from%s%s%s%s%s\n",
2788                          (pmc & PCI_PM_CAP_PME_D0) ? " D0" : "",
2789                          (pmc & PCI_PM_CAP_PME_D1) ? " D1" : "",
2790                          (pmc & PCI_PM_CAP_PME_D2) ? " D2" : "",
2791                          (pmc & PCI_PM_CAP_PME_D3) ? " D3hot" : "",
2792                          (pmc & PCI_PM_CAP_PME_D3cold) ? " D3cold" : "");
2793                 dev->pme_support = pmc >> PCI_PM_CAP_PME_SHIFT;
2794                 dev->pme_poll = true;
2795                 /*
2796                  * Make device's PM flags reflect the wake-up capability, but
2797                  * let the user space enable it to wake up the system as needed.
2798                  */
2799                 device_set_wakeup_capable(&dev->dev, true);
2800                 /* Disable the PME# generation functionality */
2801                 pci_pme_active(dev, false);
2802         }
2803
2804         pci_read_config_word(dev, PCI_STATUS, &status);
2805         if (status & PCI_STATUS_IMM_READY)
2806                 dev->imm_ready = 1;
2807 }
2808
2809 static unsigned long pci_ea_flags(struct pci_dev *dev, u8 prop)
2810 {
2811         unsigned long flags = IORESOURCE_PCI_FIXED | IORESOURCE_PCI_EA_BEI;
2812
2813         switch (prop) {
2814         case PCI_EA_P_MEM:
2815         case PCI_EA_P_VF_MEM:
2816                 flags |= IORESOURCE_MEM;
2817                 break;
2818         case PCI_EA_P_MEM_PREFETCH:
2819         case PCI_EA_P_VF_MEM_PREFETCH:
2820                 flags |= IORESOURCE_MEM | IORESOURCE_PREFETCH;
2821                 break;
2822         case PCI_EA_P_IO:
2823                 flags |= IORESOURCE_IO;
2824                 break;
2825         default:
2826                 return 0;
2827         }
2828
2829         return flags;
2830 }
2831
2832 static struct resource *pci_ea_get_resource(struct pci_dev *dev, u8 bei,
2833                                             u8 prop)
2834 {
2835         if (bei <= PCI_EA_BEI_BAR5 && prop <= PCI_EA_P_IO)
2836                 return &dev->resource[bei];
2837 #ifdef CONFIG_PCI_IOV
2838         else if (bei >= PCI_EA_BEI_VF_BAR0 && bei <= PCI_EA_BEI_VF_BAR5 &&
2839                  (prop == PCI_EA_P_VF_MEM || prop == PCI_EA_P_VF_MEM_PREFETCH))
2840                 return &dev->resource[PCI_IOV_RESOURCES +
2841                                       bei - PCI_EA_BEI_VF_BAR0];
2842 #endif
2843         else if (bei == PCI_EA_BEI_ROM)
2844                 return &dev->resource[PCI_ROM_RESOURCE];
2845         else
2846                 return NULL;
2847 }
2848
2849 /* Read an Enhanced Allocation (EA) entry */
2850 static int pci_ea_read(struct pci_dev *dev, int offset)
2851 {
2852         struct resource *res;
2853         int ent_size, ent_offset = offset;
2854         resource_size_t start, end;
2855         unsigned long flags;
2856         u32 dw0, bei, base, max_offset;
2857         u8 prop;
2858         bool support_64 = (sizeof(resource_size_t) >= 8);
2859
2860         pci_read_config_dword(dev, ent_offset, &dw0);
2861         ent_offset += 4;
2862
2863         /* Entry size field indicates DWORDs after 1st */
2864         ent_size = ((dw0 & PCI_EA_ES) + 1) << 2;
2865
2866         if (!(dw0 & PCI_EA_ENABLE)) /* Entry not enabled */
2867                 goto out;
2868
2869         bei = (dw0 & PCI_EA_BEI) >> 4;
2870         prop = (dw0 & PCI_EA_PP) >> 8;
2871
2872         /*
2873          * If the Property is in the reserved range, try the Secondary
2874          * Property instead.
2875          */
2876         if (prop > PCI_EA_P_BRIDGE_IO && prop < PCI_EA_P_MEM_RESERVED)
2877                 prop = (dw0 & PCI_EA_SP) >> 16;
2878         if (prop > PCI_EA_P_BRIDGE_IO)
2879                 goto out;
2880
2881         res = pci_ea_get_resource(dev, bei, prop);
2882         if (!res) {
2883                 pci_err(dev, "Unsupported EA entry BEI: %u\n", bei);
2884                 goto out;
2885         }
2886
2887         flags = pci_ea_flags(dev, prop);
2888         if (!flags) {
2889                 pci_err(dev, "Unsupported EA properties: %#x\n", prop);
2890                 goto out;
2891         }
2892
2893         /* Read Base */
2894         pci_read_config_dword(dev, ent_offset, &base);
2895         start = (base & PCI_EA_FIELD_MASK);
2896         ent_offset += 4;
2897
2898         /* Read MaxOffset */
2899         pci_read_config_dword(dev, ent_offset, &max_offset);
2900         ent_offset += 4;
2901
2902         /* Read Base MSBs (if 64-bit entry) */
2903         if (base & PCI_EA_IS_64) {
2904                 u32 base_upper;
2905
2906                 pci_read_config_dword(dev, ent_offset, &base_upper);
2907                 ent_offset += 4;
2908
2909                 flags |= IORESOURCE_MEM_64;
2910
2911                 /* entry starts above 32-bit boundary, can't use */
2912                 if (!support_64 && base_upper)
2913                         goto out;
2914
2915                 if (support_64)
2916                         start |= ((u64)base_upper << 32);
2917         }
2918
2919         end = start + (max_offset | 0x03);
2920
2921         /* Read MaxOffset MSBs (if 64-bit entry) */
2922         if (max_offset & PCI_EA_IS_64) {
2923                 u32 max_offset_upper;
2924
2925                 pci_read_config_dword(dev, ent_offset, &max_offset_upper);
2926                 ent_offset += 4;
2927
2928                 flags |= IORESOURCE_MEM_64;
2929
2930                 /* entry too big, can't use */
2931                 if (!support_64 && max_offset_upper)
2932                         goto out;
2933
2934                 if (support_64)
2935                         end += ((u64)max_offset_upper << 32);
2936         }
2937
2938         if (end < start) {
2939                 pci_err(dev, "EA Entry crosses address boundary\n");
2940                 goto out;
2941         }
2942
2943         if (ent_size != ent_offset - offset) {
2944                 pci_err(dev, "EA Entry Size (%d) does not match length read (%d)\n",
2945                         ent_size, ent_offset - offset);
2946                 goto out;
2947         }
2948
2949         res->name = pci_name(dev);
2950         res->start = start;
2951         res->end = end;
2952         res->flags = flags;
2953
2954         if (bei <= PCI_EA_BEI_BAR5)
2955                 pci_printk(KERN_DEBUG, dev, "BAR %d: %pR (from Enhanced Allocation, properties %#02x)\n",
2956                            bei, res, prop);
2957         else if (bei == PCI_EA_BEI_ROM)
2958                 pci_printk(KERN_DEBUG, dev, "ROM: %pR (from Enhanced Allocation, properties %#02x)\n",
2959                            res, prop);
2960         else if (bei >= PCI_EA_BEI_VF_BAR0 && bei <= PCI_EA_BEI_VF_BAR5)
2961                 pci_printk(KERN_DEBUG, dev, "VF BAR %d: %pR (from Enhanced Allocation, properties %#02x)\n",
2962                            bei - PCI_EA_BEI_VF_BAR0, res, prop);
2963         else
2964                 pci_printk(KERN_DEBUG, dev, "BEI %d res: %pR (from Enhanced Allocation, properties %#02x)\n",
2965                            bei, res, prop);
2966
2967 out:
2968         return offset + ent_size;
2969 }
2970
2971 /* Enhanced Allocation Initialization */
2972 void pci_ea_init(struct pci_dev *dev)
2973 {
2974         int ea;
2975         u8 num_ent;
2976         int offset;
2977         int i;
2978
2979         /* find PCI EA capability in list */
2980         ea = pci_find_capability(dev, PCI_CAP_ID_EA);
2981         if (!ea)
2982                 return;
2983
2984         /* determine the number of entries */
2985         pci_bus_read_config_byte(dev->bus, dev->devfn, ea + PCI_EA_NUM_ENT,
2986                                         &num_ent);
2987         num_ent &= PCI_EA_NUM_ENT_MASK;
2988
2989         offset = ea + PCI_EA_FIRST_ENT;
2990
2991         /* Skip DWORD 2 for type 1 functions */
2992         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE)
2993                 offset += 4;
2994
2995         /* parse each EA entry */
2996         for (i = 0; i < num_ent; ++i)
2997                 offset = pci_ea_read(dev, offset);
2998 }
2999
3000 static void pci_add_saved_cap(struct pci_dev *pci_dev,
3001         struct pci_cap_saved_state *new_cap)
3002 {
3003         hlist_add_head(&new_cap->next, &pci_dev->saved_cap_space);
3004 }
3005
3006 /**
3007  * _pci_add_cap_save_buffer - allocate buffer for saving given
3008  *                            capability registers
3009  * @dev: the PCI device
3010  * @cap: the capability to allocate the buffer for
3011  * @extended: Standard or Extended capability ID
3012  * @size: requested size of the buffer
3013  */
3014 static int _pci_add_cap_save_buffer(struct pci_dev *dev, u16 cap,
3015                                     bool extended, unsigned int size)
3016 {
3017         int pos;
3018         struct pci_cap_saved_state *save_state;
3019
3020         if (extended)
3021                 pos = pci_find_ext_capability(dev, cap);
3022         else
3023                 pos = pci_find_capability(dev, cap);
3024
3025         if (!pos)
3026                 return 0;
3027
3028         save_state = kzalloc(sizeof(*save_state) + size, GFP_KERNEL);
3029         if (!save_state)
3030                 return -ENOMEM;
3031
3032         save_state->cap.cap_nr = cap;
3033         save_state->cap.cap_extended = extended;
3034         save_state->cap.size = size;
3035         pci_add_saved_cap(dev, save_state);
3036
3037         return 0;
3038 }
3039
3040 int pci_add_cap_save_buffer(struct pci_dev *dev, char cap, unsigned int size)
3041 {
3042         return _pci_add_cap_save_buffer(dev, cap, false, size);
3043 }
3044
3045 int pci_add_ext_cap_save_buffer(struct pci_dev *dev, u16 cap, unsigned int size)
3046 {
3047         return _pci_add_cap_save_buffer(dev, cap, true, size);
3048 }
3049
3050 /**
3051  * pci_allocate_cap_save_buffers - allocate buffers for saving capabilities
3052  * @dev: the PCI device
3053  */
3054 void pci_allocate_cap_save_buffers(struct pci_dev *dev)
3055 {
3056         int error;
3057
3058         error = pci_add_cap_save_buffer(dev, PCI_CAP_ID_EXP,
3059                                         PCI_EXP_SAVE_REGS * sizeof(u16));
3060         if (error)
3061                 pci_err(dev, "unable to preallocate PCI Express save buffer\n");
3062
3063         error = pci_add_cap_save_buffer(dev, PCI_CAP_ID_PCIX, sizeof(u16));
3064         if (error)
3065                 pci_err(dev, "unable to preallocate PCI-X save buffer\n");
3066
3067         error = pci_add_ext_cap_save_buffer(dev, PCI_EXT_CAP_ID_LTR,
3068                                             2 * sizeof(u16));
3069         if (error)
3070                 pci_err(dev, "unable to allocate suspend buffer for LTR\n");
3071
3072         pci_allocate_vc_save_buffers(dev);
3073 }
3074
3075 void pci_free_cap_save_buffers(struct pci_dev *dev)
3076 {
3077         struct pci_cap_saved_state *tmp;
3078         struct hlist_node *n;
3079
3080         hlist_for_each_entry_safe(tmp, n, &dev->saved_cap_space, next)
3081                 kfree(tmp);
3082 }
3083
3084 /**
3085  * pci_configure_ari - enable or disable ARI forwarding
3086  * @dev: the PCI device
3087  *
3088  * If @dev and its upstream bridge both support ARI, enable ARI in the
3089  * bridge.  Otherwise, disable ARI in the bridge.
3090  */
3091 void pci_configure_ari(struct pci_dev *dev)
3092 {
3093         u32 cap;
3094         struct pci_dev *bridge;
3095
3096         if (pcie_ari_disabled || !pci_is_pcie(dev) || dev->devfn)
3097                 return;
3098
3099         bridge = dev->bus->self;
3100         if (!bridge)
3101                 return;
3102
3103         pcie_capability_read_dword(bridge, PCI_EXP_DEVCAP2, &cap);
3104         if (!(cap & PCI_EXP_DEVCAP2_ARI))
3105                 return;
3106
3107         if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI)) {
3108                 pcie_capability_set_word(bridge, PCI_EXP_DEVCTL2,
3109                                          PCI_EXP_DEVCTL2_ARI);
3110                 bridge->ari_enabled = 1;
3111         } else {
3112                 pcie_capability_clear_word(bridge, PCI_EXP_DEVCTL2,
3113                                            PCI_EXP_DEVCTL2_ARI);
3114                 bridge->ari_enabled = 0;
3115         }
3116 }
3117
3118 static int pci_acs_enable;
3119
3120 /**
3121  * pci_request_acs - ask for ACS to be enabled if supported
3122  */
3123 void pci_request_acs(void)
3124 {
3125         pci_acs_enable = 1;
3126 }
3127
3128 static const char *disable_acs_redir_param;
3129
3130 /**
3131  * pci_disable_acs_redir - disable ACS redirect capabilities
3132  * @dev: the PCI device
3133  *
3134  * For only devices specified in the disable_acs_redir parameter.
3135  */
3136 static void pci_disable_acs_redir(struct pci_dev *dev)
3137 {
3138         int ret = 0;
3139         const char *p;
3140         int pos;
3141         u16 ctrl;
3142
3143         if (!disable_acs_redir_param)
3144                 return;
3145
3146         p = disable_acs_redir_param;
3147         while (*p) {
3148                 ret = pci_dev_str_match(dev, p, &p);
3149                 if (ret < 0) {
3150                         pr_info_once("PCI: Can't parse disable_acs_redir parameter: %s\n",
3151                                      disable_acs_redir_param);
3152
3153                         break;
3154                 } else if (ret == 1) {
3155                         /* Found a match */
3156                         break;
3157                 }
3158
3159                 if (*p != ';' && *p != ',') {
3160                         /* End of param or invalid format */
3161                         break;
3162                 }
3163                 p++;
3164         }
3165
3166         if (ret != 1)
3167                 return;
3168
3169         if (!pci_dev_specific_disable_acs_redir(dev))
3170                 return;
3171
3172         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ACS);
3173         if (!pos) {
3174                 pci_warn(dev, "cannot disable ACS redirect for this hardware as it does not have ACS capabilities\n");
3175                 return;
3176         }
3177
3178         pci_read_config_word(dev, pos + PCI_ACS_CTRL, &ctrl);
3179
3180         /* P2P Request & Completion Redirect */
3181         ctrl &= ~(PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_EC);
3182
3183         pci_write_config_word(dev, pos + PCI_ACS_CTRL, ctrl);
3184
3185         pci_info(dev, "disabled ACS redirect\n");
3186 }
3187
3188 /**
3189  * pci_std_enable_acs - enable ACS on devices using standard ACS capabilites
3190  * @dev: the PCI device
3191  */
3192 static void pci_std_enable_acs(struct pci_dev *dev)
3193 {
3194         int pos;
3195         u16 cap;
3196         u16 ctrl;
3197
3198         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ACS);
3199         if (!pos)
3200                 return;
3201
3202         pci_read_config_word(dev, pos + PCI_ACS_CAP, &cap);
3203         pci_read_config_word(dev, pos + PCI_ACS_CTRL, &ctrl);
3204
3205         /* Source Validation */
3206         ctrl |= (cap & PCI_ACS_SV);
3207
3208         /* P2P Request Redirect */
3209         ctrl |= (cap & PCI_ACS_RR);
3210
3211         /* P2P Completion Redirect */
3212         ctrl |= (cap & PCI_ACS_CR);
3213
3214         /* Upstream Forwarding */
3215         ctrl |= (cap & PCI_ACS_UF);
3216
3217         pci_write_config_word(dev, pos + PCI_ACS_CTRL, ctrl);
3218 }
3219
3220 /**
3221  * pci_enable_acs - enable ACS if hardware support it
3222  * @dev: the PCI device
3223  */
3224 void pci_enable_acs(struct pci_dev *dev)
3225 {
3226         if (!pci_acs_enable)
3227                 goto disable_acs_redir;
3228
3229         if (!pci_dev_specific_enable_acs(dev))
3230                 goto disable_acs_redir;
3231
3232         pci_std_enable_acs(dev);
3233
3234 disable_acs_redir:
3235         /*
3236          * Note: pci_disable_acs_redir() must be called even if ACS was not
3237          * enabled by the kernel because it may have been enabled by
3238          * platform firmware.  So if we are told to disable it, we should
3239          * always disable it after setting the kernel's default
3240          * preferences.
3241          */
3242         pci_disable_acs_redir(dev);
3243 }
3244
3245 static bool pci_acs_flags_enabled(struct pci_dev *pdev, u16 acs_flags)
3246 {
3247         int pos;
3248         u16 cap, ctrl;
3249
3250         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ACS);
3251         if (!pos)
3252                 return false;
3253
3254         /*
3255          * Except for egress control, capabilities are either required
3256          * or only required if controllable.  Features missing from the
3257          * capability field can therefore be assumed as hard-wired enabled.
3258          */
3259         pci_read_config_word(pdev, pos + PCI_ACS_CAP, &cap);
3260         acs_flags &= (cap | PCI_ACS_EC);
3261
3262         pci_read_config_word(pdev, pos + PCI_ACS_CTRL, &ctrl);
3263         return (ctrl & acs_flags) == acs_flags;
3264 }
3265
3266 /**
3267  * pci_acs_enabled - test ACS against required flags for a given device
3268  * @pdev: device to test
3269  * @acs_flags: required PCI ACS flags
3270  *
3271  * Return true if the device supports the provided flags.  Automatically
3272  * filters out flags that are not implemented on multifunction devices.
3273  *
3274  * Note that this interface checks the effective ACS capabilities of the
3275  * device rather than the actual capabilities.  For instance, most single
3276  * function endpoints are not required to support ACS because they have no
3277  * opportunity for peer-to-peer access.  We therefore return 'true'
3278  * regardless of whether the device exposes an ACS capability.  This makes
3279  * it much easier for callers of this function to ignore the actual type
3280  * or topology of the device when testing ACS support.
3281  */
3282 bool pci_acs_enabled(struct pci_dev *pdev, u16 acs_flags)
3283 {
3284         int ret;
3285
3286         ret = pci_dev_specific_acs_enabled(pdev, acs_flags);
3287         if (ret >= 0)
3288                 return ret > 0;
3289
3290         /*
3291          * Conventional PCI and PCI-X devices never support ACS, either
3292          * effectively or actually.  The shared bus topology implies that
3293          * any device on the bus can receive or snoop DMA.
3294          */
3295         if (!pci_is_pcie(pdev))
3296                 return false;
3297
3298         switch (pci_pcie_type(pdev)) {
3299         /*
3300          * PCI/X-to-PCIe bridges are not specifically mentioned by the spec,
3301          * but since their primary interface is PCI/X, we conservatively
3302          * handle them as we would a non-PCIe device.
3303          */
3304         case PCI_EXP_TYPE_PCIE_BRIDGE:
3305         /*
3306          * PCIe 3.0, 6.12.1 excludes ACS on these devices.  "ACS is never
3307          * applicable... must never implement an ACS Extended Capability...".
3308          * This seems arbitrary, but we take a conservative interpretation
3309          * of this statement.
3310          */
3311         case PCI_EXP_TYPE_PCI_BRIDGE:
3312         case PCI_EXP_TYPE_RC_EC:
3313                 return false;
3314         /*
3315          * PCIe 3.0, 6.12.1.1 specifies that downstream and root ports should
3316          * implement ACS in order to indicate their peer-to-peer capabilities,
3317          * regardless of whether they are single- or multi-function devices.
3318          */
3319         case PCI_EXP_TYPE_DOWNSTREAM:
3320         case PCI_EXP_TYPE_ROOT_PORT:
3321                 return pci_acs_flags_enabled(pdev, acs_flags);
3322         /*
3323          * PCIe 3.0, 6.12.1.2 specifies ACS capabilities that should be
3324          * implemented by the remaining PCIe types to indicate peer-to-peer
3325          * capabilities, but only when they are part of a multifunction
3326          * device.  The footnote for section 6.12 indicates the specific
3327          * PCIe types included here.
3328          */
3329         case PCI_EXP_TYPE_ENDPOINT:
3330         case PCI_EXP_TYPE_UPSTREAM:
3331         case PCI_EXP_TYPE_LEG_END:
3332         case PCI_EXP_TYPE_RC_END:
3333                 if (!pdev->multifunction)
3334                         break;
3335
3336                 return pci_acs_flags_enabled(pdev, acs_flags);
3337         }
3338
3339         /*
3340          * PCIe 3.0, 6.12.1.3 specifies no ACS capabilities are applicable
3341          * to single function devices with the exception of downstream ports.
3342          */
3343         return true;
3344 }
3345
3346 /**
3347  * pci_acs_path_enable - test ACS flags from start to end in a hierarchy
3348  * @start: starting downstream device
3349  * @end: ending upstream device or NULL to search to the root bus
3350  * @acs_flags: required flags
3351  *
3352  * Walk up a device tree from start to end testing PCI ACS support.  If
3353  * any step along the way does not support the required flags, return false.
3354  */
3355 bool pci_acs_path_enabled(struct pci_dev *start,
3356                           struct pci_dev *end, u16 acs_flags)
3357 {
3358         struct pci_dev *pdev, *parent = start;
3359
3360         do {
3361                 pdev = parent;
3362
3363                 if (!pci_acs_enabled(pdev, acs_flags))
3364                         return false;
3365
3366                 if (pci_is_root_bus(pdev->bus))
3367                         return (end == NULL);
3368
3369                 parent = pdev->bus->self;
3370         } while (pdev != end);
3371
3372         return true;
3373 }
3374
3375 /**
3376  * pci_rebar_find_pos - find position of resize ctrl reg for BAR
3377  * @pdev: PCI device
3378  * @bar: BAR to find
3379  *
3380  * Helper to find the position of the ctrl register for a BAR.
3381  * Returns -ENOTSUPP if resizable BARs are not supported at all.
3382  * Returns -ENOENT if no ctrl register for the BAR could be found.
3383  */
3384 static int pci_rebar_find_pos(struct pci_dev *pdev, int bar)
3385 {
3386         unsigned int pos, nbars, i;
3387         u32 ctrl;
3388
3389         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_REBAR);
3390         if (!pos)
3391                 return -ENOTSUPP;
3392
3393         pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl);
3394         nbars = (ctrl & PCI_REBAR_CTRL_NBAR_MASK) >>
3395                     PCI_REBAR_CTRL_NBAR_SHIFT;
3396
3397         for (i = 0; i < nbars; i++, pos += 8) {
3398                 int bar_idx;
3399
3400                 pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl);
3401                 bar_idx = ctrl & PCI_REBAR_CTRL_BAR_IDX;
3402                 if (bar_idx == bar)
3403                         return pos;
3404         }
3405
3406         return -ENOENT;
3407 }
3408
3409 /**
3410  * pci_rebar_get_possible_sizes - get possible sizes for BAR
3411  * @pdev: PCI device
3412  * @bar: BAR to query
3413  *
3414  * Get the possible sizes of a resizable BAR as bitmask defined in the spec
3415  * (bit 0=1MB, bit 19=512GB). Returns 0 if BAR isn't resizable.
3416  */
3417 u32 pci_rebar_get_possible_sizes(struct pci_dev *pdev, int bar)
3418 {
3419         int pos;
3420         u32 cap;
3421
3422         pos = pci_rebar_find_pos(pdev, bar);
3423         if (pos < 0)
3424                 return 0;
3425
3426         pci_read_config_dword(pdev, pos + PCI_REBAR_CAP, &cap);
3427         return (cap & PCI_REBAR_CAP_SIZES) >> 4;
3428 }
3429
3430 /**
3431  * pci_rebar_get_current_size - get the current size of a BAR
3432  * @pdev: PCI device
3433  * @bar: BAR to set size to
3434  *
3435  * Read the size of a BAR from the resizable BAR config.
3436  * Returns size if found or negative error code.
3437  */
3438 int pci_rebar_get_current_size(struct pci_dev *pdev, int bar)
3439 {
3440         int pos;
3441         u32 ctrl;
3442
3443         pos = pci_rebar_find_pos(pdev, bar);
3444         if (pos < 0)
3445                 return pos;
3446
3447         pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl);
3448         return (ctrl & PCI_REBAR_CTRL_BAR_SIZE) >> PCI_REBAR_CTRL_BAR_SHIFT;
3449 }
3450
3451 /**
3452  * pci_rebar_set_size - set a new size for a BAR