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