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