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