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