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/module.h>
  16 #include <linux/spinlock.h>
  17 #include <linux/string.h>
  18 #include <linux/log2.h>
  19 #include <linux/pci-aspm.h>
  20 #include <asm/dma.h>    /* isa_dma_bridge_buggy */
  21 #include "pci.h"
  22
  23 unsigned int pci_pm_d3_delay = 10;
  24
  25 #ifdef CONFIG_PCI_DOMAINS
  26 int pci_domains_supported = 1;
  27 #endif
  28
  29 #define DEFAULT_CARDBUS_IO_SIZE         (256)
  30 #define DEFAULT_CARDBUS_MEM_SIZE        (64*1024*1024)
  31 /* pci=cbmemsize=nnM,cbiosize=nn can override this */
  32 unsigned long pci_cardbus_io_size = DEFAULT_CARDBUS_IO_SIZE;
  33 unsigned long pci_cardbus_mem_size = DEFAULT_CARDBUS_MEM_SIZE;
  34
  35 /**
  36  * pci_bus_max_busnr - returns maximum PCI bus number of given bus' children
  37  * @bus: pointer to PCI bus structure to search
  38  *
  39  * Given a PCI bus, returns the highest PCI bus number present in the set
  40  * including the given PCI bus and its list of child PCI buses.
  41  */
  42 unsigned char pci_bus_max_busnr(struct pci_bus* bus)
  43 {
  44         struct list_head *tmp;
  45         unsigned char max, n;
  46
  47         max = bus->subordinate;
  48         list_for_each(tmp, &bus->children) {
  49                 n = pci_bus_max_busnr(pci_bus_b(tmp));
  50                 if(n > max)
  51                         max = n;
  52         }
  53         return max;
  54 }
  55 EXPORT_SYMBOL_GPL(pci_bus_max_busnr);
  56
  57 #if 0
  58 /**
  59  * pci_max_busnr - returns maximum PCI bus number
  60  *
  61  * Returns the highest PCI bus number present in the system global list of
  62  * PCI buses.
  63  */
  64 unsigned char __devinit
  65 pci_max_busnr(void)
  66 {
  67         struct pci_bus *bus = NULL;
  68         unsigned char max, n;
  69
  70         max = 0;
  71         while ((bus = pci_find_next_bus(bus)) != NULL) {
  72                 n = pci_bus_max_busnr(bus);
  73                 if(n > max)
  74                         max = n;
  75         }
  76         return max;
  77 }
  78
  79 #endif  /*  0  */
  80
  81 #define PCI_FIND_CAP_TTL        48
  82
  83 static int __pci_find_next_cap_ttl(struct pci_bus *bus, unsigned int devfn,
  84                                    u8 pos, int cap, int *ttl)
  85 {
  86         u8 id;
  87
  88         while ((*ttl)--) {
  89                 pci_bus_read_config_byte(bus, devfn, pos, &pos);
  90                 if (pos < 0x40)
  91                         break;
  92                 pos &= ~3;
  93                 pci_bus_read_config_byte(bus, devfn, pos + PCI_CAP_LIST_ID,
  94                                          &id);
  95                 if (id == 0xff)
  96                         break;
  97                 if (id == cap)
  98                         return pos;
  99                 pos += PCI_CAP_LIST_NEXT;
 100         }
 101         return 0;
 102 }
 103
 104 static int __pci_find_next_cap(struct pci_bus *bus, unsigned int devfn,
 105                                u8 pos, int cap)
 106 {
 107         int ttl = PCI_FIND_CAP_TTL;
 108
 109         return __pci_find_next_cap_ttl(bus, devfn, pos, cap, &ttl);
 110 }
 111
 112 int pci_find_next_capability(struct pci_dev *dev, u8 pos, int cap)
 113 {
 114         return __pci_find_next_cap(dev->bus, dev->devfn,
 115                                    pos + PCI_CAP_LIST_NEXT, cap);
 116 }
 117 EXPORT_SYMBOL_GPL(pci_find_next_capability);
 118
 119 static int __pci_bus_find_cap_start(struct pci_bus *bus,
 120                                     unsigned int devfn, u8 hdr_type)
 121 {
 122         u16 status;
 123
 124         pci_bus_read_config_word(bus, devfn, PCI_STATUS, &status);
 125         if (!(status & PCI_STATUS_CAP_LIST))
 126                 return 0;
 127
 128         switch (hdr_type) {
 129         case PCI_HEADER_TYPE_NORMAL:
 130         case PCI_HEADER_TYPE_BRIDGE:
 131                 return PCI_CAPABILITY_LIST;
 132         case PCI_HEADER_TYPE_CARDBUS:
 133                 return PCI_CB_CAPABILITY_LIST;
 134         default:
 135                 return 0;
 136         }
 137
 138         return 0;
 139 }
 140
 141 /**
 142  * pci_find_capability - query for devices' capabilities
 143  * @dev: PCI device to query
 144  * @cap: capability code
 145  *
 146  * Tell if a device supports a given PCI capability.
 147  * Returns the address of the requested capability structure within the
 148  * device's PCI configuration space or 0 in case the device does not
 149  * support it.  Possible values for @cap:
 150  *
 151  *  %PCI_CAP_ID_PM           Power Management
 152  *  %PCI_CAP_ID_AGP          Accelerated Graphics Port
 153  *  %PCI_CAP_ID_VPD          Vital Product Data
 154  *  %PCI_CAP_ID_SLOTID       Slot Identification
 155  *  %PCI_CAP_ID_MSI          Message Signalled Interrupts
 156  *  %PCI_CAP_ID_CHSWP        CompactPCI HotSwap
 157  *  %PCI_CAP_ID_PCIX         PCI-X
 158  *  %PCI_CAP_ID_EXP          PCI Express
 159  */
 160 int pci_find_capability(struct pci_dev *dev, int cap)
 161 {
 162         int pos;
 163
 164         pos = __pci_bus_find_cap_start(dev->bus, dev->devfn, dev->hdr_type);
 165         if (pos)
 166                 pos = __pci_find_next_cap(dev->bus, dev->devfn, pos, cap);
 167
 168         return pos;
 169 }
 170
 171 /**
 172  * pci_bus_find_capability - query for devices' capabilities
 173  * @bus:   the PCI bus to query
 174  * @devfn: PCI device to query
 175  * @cap:   capability code
 176  *
 177  * Like pci_find_capability() but works for pci devices that do not have a
 178  * pci_dev structure set up yet.
 179  *
 180  * Returns the address of the requested capability structure within the
 181  * device's PCI configuration space or 0 in case the device does not
 182  * support it.
 183  */
 184 int pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap)
 185 {
 186         int pos;
 187         u8 hdr_type;
 188
 189         pci_bus_read_config_byte(bus, devfn, PCI_HEADER_TYPE, &hdr_type);
 190
 191         pos = __pci_bus_find_cap_start(bus, devfn, hdr_type & 0x7f);
 192         if (pos)
 193                 pos = __pci_find_next_cap(bus, devfn, pos, cap);
 194
 195         return pos;
 196 }
 197
 198 /**
 199  * pci_find_ext_capability - Find an extended capability
 200  * @dev: PCI device to query
 201  * @cap: capability code
 202  *
 203  * Returns the address of the requested extended capability structure
 204  * within the device's PCI configuration space or 0 if the device does
 205  * not support it.  Possible values for @cap:
 206  *
 207  *  %PCI_EXT_CAP_ID_ERR         Advanced Error Reporting
 208  *  %PCI_EXT_CAP_ID_VC          Virtual Channel
 209  *  %PCI_EXT_CAP_ID_DSN         Device Serial Number
 210  *  %PCI_EXT_CAP_ID_PWR         Power Budgeting
 211  */
 212 int pci_find_ext_capability(struct pci_dev *dev, int cap)
 213 {
 214         u32 header;
 215         int ttl = 480; /* 3840 bytes, minimum 8 bytes per capability */
 216         int pos = 0x100;
 217
 218         if (dev->cfg_size <= 256)
 219                 return 0;
 220
 221         if (pci_read_config_dword(dev, pos, &header) != PCIBIOS_SUCCESSFUL)
 222                 return 0;
 223
 224         /*
 225          * If we have no capabilities, this is indicated by cap ID,
 226          * cap version and next pointer all being 0.
 227          */
 228         if (header == 0)
 229                 return 0;
 230
 231         while (ttl-- > 0) {
 232                 if (PCI_EXT_CAP_ID(header) == cap)
 233                         return pos;
 234
 235                 pos = PCI_EXT_CAP_NEXT(header);
 236                 if (pos < 0x100)
 237                         break;
 238
 239                 if (pci_read_config_dword(dev, pos, &header) != PCIBIOS_SUCCESSFUL)
 240                         break;
 241         }
 242
 243         return 0;
 244 }
 245 EXPORT_SYMBOL_GPL(pci_find_ext_capability);
 246
 247 static int __pci_find_next_ht_cap(struct pci_dev *dev, int pos, int ht_cap)
 248 {
 249         int rc, ttl = PCI_FIND_CAP_TTL;
 250         u8 cap, mask;
 251
 252         if (ht_cap == HT_CAPTYPE_SLAVE || ht_cap == HT_CAPTYPE_HOST)
 253                 mask = HT_3BIT_CAP_MASK;
 254         else
 255                 mask = HT_5BIT_CAP_MASK;
 256
 257         pos = __pci_find_next_cap_ttl(dev->bus, dev->devfn, pos,
 258                                       PCI_CAP_ID_HT, &ttl);
 259         while (pos) {
 260                 rc = pci_read_config_byte(dev, pos + 3, &cap);
 261                 if (rc != PCIBIOS_SUCCESSFUL)
 262                         return 0;
 263
 264                 if ((cap & mask) == ht_cap)
 265                         return pos;
 266
 267                 pos = __pci_find_next_cap_ttl(dev->bus, dev->devfn,
 268                                               pos + PCI_CAP_LIST_NEXT,
 269                                               PCI_CAP_ID_HT, &ttl);
 270         }
 271
 272         return 0;
 273 }
 274 /**
 275  * pci_find_next_ht_capability - query a device's Hypertransport capabilities
 276  * @dev: PCI device to query
 277  * @pos: Position from which to continue searching
 278  * @ht_cap: Hypertransport capability code
 279  *
 280  * To be used in conjunction with pci_find_ht_capability() to search for
 281  * all capabilities matching @ht_cap. @pos should always be a value returned
 282  * from pci_find_ht_capability().
 283  *
 284  * NB. To be 100% safe against broken PCI devices, the caller should take
 285  * steps to avoid an infinite loop.
 286  */
 287 int pci_find_next_ht_capability(struct pci_dev *dev, int pos, int ht_cap)
 288 {
 289         return __pci_find_next_ht_cap(dev, pos + PCI_CAP_LIST_NEXT, ht_cap);
 290 }
 291 EXPORT_SYMBOL_GPL(pci_find_next_ht_capability);
 292
 293 /**
 294  * pci_find_ht_capability - query a device's Hypertransport capabilities
 295  * @dev: PCI device to query
 296  * @ht_cap: Hypertransport capability code
 297  *
 298  * Tell if a device supports a given Hypertransport capability.
 299  * Returns an address within the device's PCI configuration space
 300  * or 0 in case the device does not support the request capability.
 301  * The address points to the PCI capability, of type PCI_CAP_ID_HT,
 302  * which has a Hypertransport capability matching @ht_cap.
 303  */
 304 int pci_find_ht_capability(struct pci_dev *dev, int ht_cap)
 305 {
 306         int pos;
 307
 308         pos = __pci_bus_find_cap_start(dev->bus, dev->devfn, dev->hdr_type);
 309         if (pos)
 310                 pos = __pci_find_next_ht_cap(dev, pos, ht_cap);
 311
 312         return pos;
 313 }
 314 EXPORT_SYMBOL_GPL(pci_find_ht_capability);
 315
 316 /**
 317  * pci_find_parent_resource - return resource region of parent bus of given region
 318  * @dev: PCI device structure contains resources to be searched
 319  * @res: child resource record for which parent is sought
 320  *
 321  *  For given resource region of given device, return the resource
 322  *  region of parent bus the given region is contained in or where
 323  *  it should be allocated from.
 324  */
 325 struct resource *
 326 pci_find_parent_resource(const struct pci_dev *dev, struct resource *res)
 327 {
 328         const struct pci_bus *bus = dev->bus;
 329         int i;
 330         struct resource *best = NULL;
 331
 332         for(i = 0; i < PCI_BUS_NUM_RESOURCES; i++) {
 333                 struct resource *r = bus->resource[i];
 334                 if (!r)
 335                         continue;
 336                 if (res->start && !(res->start >= r->start && res->end <= r->end))
 337                         continue;       /* Not contained */
 338                 if ((res->flags ^ r->flags) & (IORESOURCE_IO | IORESOURCE_MEM))
 339                         continue;       /* Wrong type */
 340                 if (!((res->flags ^ r->flags) & IORESOURCE_PREFETCH))
 341                         return r;       /* Exact match */
 342                 if ((res->flags & IORESOURCE_PREFETCH) && !(r->flags & IORESOURCE_PREFETCH))
 343                         best = r;       /* Approximating prefetchable by non-prefetchable */
 344         }
 345         return best;
 346 }
 347
 348 /**
 349  * pci_restore_bars - restore a devices BAR values (e.g. after wake-up)
 350  * @dev: PCI device to have its BARs restored
 351  *
 352  * Restore the BAR values for a given device, so as to make it
 353  * accessible by its driver.
 354  */
 355 static void
 356 pci_restore_bars(struct pci_dev *dev)
 357 {
 358         int i, numres;
 359
 360         switch (dev->hdr_type) {
 361         case PCI_HEADER_TYPE_NORMAL:
 362                 numres = 6;
 363                 break;
 364         case PCI_HEADER_TYPE_BRIDGE:
 365                 numres = 2;
 366                 break;
 367         case PCI_HEADER_TYPE_CARDBUS:
 368                 numres = 1;
 369                 break;
 370         default:
 371                 /* Should never get here, but just in case... */
 372                 return;
 373         }
 374
 375         for (i = 0; i < numres; i ++)
 376                 pci_update_resource(dev, &dev->resource[i], i);
 377 }
 378
 379 static struct pci_platform_pm_ops *pci_platform_pm;
 380
 381 int pci_set_platform_pm(struct pci_platform_pm_ops *ops)
 382 {
 383         if (!ops->is_manageable || !ops->set_state || !ops->choose_state
 384             || !ops->sleep_wake || !ops->can_wakeup)
 385                 return -EINVAL;
 386         pci_platform_pm = ops;
 387         return 0;
 388 }
 389
 390 static inline bool platform_pci_power_manageable(struct pci_dev *dev)
 391 {
 392         return pci_platform_pm ? pci_platform_pm->is_manageable(dev) : false;
 393 }
 394
 395 static inline int platform_pci_set_power_state(struct pci_dev *dev,
 396                                                 pci_power_t t)
 397 {
 398         return pci_platform_pm ? pci_platform_pm->set_state(dev, t) : -ENOSYS;
 399 }
 400
 401 static inline pci_power_t platform_pci_choose_state(struct pci_dev *dev)
 402 {
 403         return pci_platform_pm ?
 404                         pci_platform_pm->choose_state(dev) : PCI_POWER_ERROR;
 405 }
 406
 407 static inline bool platform_pci_can_wakeup(struct pci_dev *dev)
 408 {
 409         return pci_platform_pm ? pci_platform_pm->can_wakeup(dev) : false;
 410 }
 411
 412 static inline int platform_pci_sleep_wake(struct pci_dev *dev, bool enable)
 413 {
 414         return pci_platform_pm ?
 415                         pci_platform_pm->sleep_wake(dev, enable) : -ENODEV;
 416 }
 417
 418 /**
 419  * pci_raw_set_power_state - Use PCI PM registers to set the power state of
 420  *                           given PCI device
 421  * @dev: PCI device to handle.
 422  * @pm: PCI PM capability offset of the device.
 423  * @state: PCI power state (D0, D1, D2, D3hot) to put the device into.
 424  *
 425  * RETURN VALUE:
 426  * -EINVAL if the requested state is invalid.
 427  * -EIO if device does not support PCI PM or its PM capabilities register has a
 428  * wrong version, or device doesn't support the requested state.
 429  * 0 if device already is in the requested state.
 430  * 0 if device's power state has been successfully changed.
 431  */
 432 static int
 433 pci_raw_set_power_state(struct pci_dev *dev, int pm, pci_power_t state)
 434 {
 435         u16 pmcsr, pmc;
 436         bool need_restore = false;
 437
 438         if (!pm)
 439                 return -EIO;
 440
 441         if (state < PCI_D0 || state > PCI_D3hot)
 442                 return -EINVAL;
 443
 444         /* Validate current state:
 445          * Can enter D0 from any state, but if we can only go deeper
 446          * to sleep if we're already in a low power state
 447          */
 448         if (dev->current_state == state) {
 449                 /* we're already there */
 450                 return 0;
 451         } else if (state != PCI_D0 && dev->current_state <= PCI_D3cold
 452             && dev->current_state > state) {
 453                 dev_err(&dev->dev, "invalid power transition "
 454                         "(from state %d to %d)\n", dev->current_state, state);
 455                 return -EINVAL;
 456         }
 457
 458         pci_read_config_word(dev, pm + PCI_PM_PMC, &pmc);
 459
 460         if ((pmc & PCI_PM_CAP_VER_MASK) > 3) {
 461                 dev_err(&dev->dev, "unsupported PM cap regs version (%u)\n",
 462                         pmc & PCI_PM_CAP_VER_MASK);
 463                 return -EIO;
 464         }
 465
 466         /* check if this device supports the desired state */
 467         if ((state == PCI_D1 && !(pmc & PCI_PM_CAP_D1))
 468            || (state == PCI_D2 && !(pmc & PCI_PM_CAP_D2)))
 469                 return -EIO;
 470
 471         pci_read_config_word(dev, pm + PCI_PM_CTRL, &pmcsr);
 472
 473         /* If we're (effectively) in D3, force entire word to 0.
 474          * This doesn't affect PME_Status, disables PME_En, and
 475          * sets PowerState to 0.
 476          */
 477         switch (dev->current_state) {
 478         case PCI_D0:
 479         case PCI_D1:
 480         case PCI_D2:
 481                 pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
 482                 pmcsr |= state;
 483                 break;
 484         case PCI_UNKNOWN: /* Boot-up */
 485                 if ((pmcsr & PCI_PM_CTRL_STATE_MASK) == PCI_D3hot
 486                  && !(pmcsr & PCI_PM_CTRL_NO_SOFT_RESET))
 487                         need_restore = true;
 488                 /* Fall-through: force to D0 */
 489         default:
 490                 pmcsr = 0;
 491                 break;
 492         }
 493
 494         /* enter specified state */
 495         pci_write_config_word(dev, pm + PCI_PM_CTRL, pmcsr);
 496
 497         /* Mandatory power management transition delays */
 498         /* see PCI PM 1.1 5.6.1 table 18 */
 499         if (state == PCI_D3hot || dev->current_state == PCI_D3hot)
 500                 msleep(pci_pm_d3_delay);
 501         else if (state == PCI_D2 || dev->current_state == PCI_D2)
 502                 udelay(200);
 503
 504         dev->current_state = state;
 505
 506         /* According to section 5.4.1 of the "PCI BUS POWER MANAGEMENT
 507          * INTERFACE SPECIFICATION, REV. 1.2", a device transitioning
 508          * from D3hot to D0 _may_ perform an internal reset, thereby
 509          * going to "D0 Uninitialized" rather than "D0 Initialized".
 510          * For example, at least some versions of the 3c905B and the
 511          * 3c556B exhibit this behaviour.
 512          *
 513          * At least some laptop BIOSen (e.g. the Thinkpad T21) leave
 514          * devices in a D3hot state at boot.  Consequently, we need to
 515          * restore at least the BARs so that the device will be
 516          * accessible to its driver.
 517          */
 518         if (need_restore)
 519                 pci_restore_bars(dev);
 520
 521         if (dev->bus->self)
 522                 pcie_aspm_pm_state_change(dev->bus->self);
 523
 524         return 0;
 525 }
 526
 527 /**
 528  * pci_update_current_state - Read PCI power state of given device from its
 529  *                            PCI PM registers and cache it
 530  * @dev: PCI device to handle.
 531  * @pm: PCI PM capability offset of the device.
 532  */
 533 static void pci_update_current_state(struct pci_dev *dev, int pm)
 534 {
 535         if (pm) {
 536                 u16 pmcsr;
 537
 538                 pci_read_config_word(dev, pm + PCI_PM_CTRL, &pmcsr);
 539                 dev->current_state = (pmcsr & PCI_PM_CTRL_STATE_MASK);
 540         }
 541 }
 542
 543 /**
 544  * pci_set_power_state - Set the power state of a PCI device
 545  * @dev: PCI device to handle.
 546  * @state: PCI power state (D0, D1, D2, D3hot) to put the device into.
 547  *
 548  * Transition a device to a new power state, using the platform formware and/or
 549  * the device's PCI PM registers.
 550  *
 551  * RETURN VALUE:
 552  * -EINVAL if the requested state is invalid.
 553  * -EIO if device does not support PCI PM or its PM capabilities register has a
 554  * wrong version, or device doesn't support the requested state.
 555  * 0 if device already is in the requested state.
 556  * 0 if device's power state has been successfully changed.
 557  */
 558 int pci_set_power_state(struct pci_dev *dev, pci_power_t state)
 559 {
 560         int pm, error;
 561
 562         /* bound the state we're entering */
 563         if (state > PCI_D3hot)
 564                 state = PCI_D3hot;
 565         else if (state < PCI_D0)
 566                 state = PCI_D0;
 567         else if ((state == PCI_D1 || state == PCI_D2) && pci_no_d1d2(dev))
 568                 /*
 569                  * If the device or the parent bridge do not support PCI PM,
 570                  * ignore the request if we're doing anything other than putting
 571                  * it into D0 (which would only happen on boot).
 572                  */
 573                 return 0;
 574
 575         /* Find PCI PM capability in the list */
 576         pm = pci_find_capability(dev, PCI_CAP_ID_PM);
 577
 578         if (state == PCI_D0 && platform_pci_power_manageable(dev)) {
 579                 /*
 580                  * Allow the platform to change the state, for example via ACPI
 581                  * _PR0, _PS0 and some such, but do not trust it.
 582                  */
 583                 int ret = platform_pci_set_power_state(dev, PCI_D0);
 584                 if (!ret)
 585                         pci_update_current_state(dev, pm);
 586         }
 587
 588         error = pci_raw_set_power_state(dev, pm, state);
 589
 590         if (state > PCI_D0 && platform_pci_power_manageable(dev)) {
 591                 /* Allow the platform to finalize the transition */
 592                 int ret = platform_pci_set_power_state(dev, state);
 593                 if (!ret) {
 594                         pci_update_current_state(dev, pm);
 595                         error = 0;
 596                 }
 597         }
 598
 599         return error;
 600 }
 601
 602 /**
 603  * pci_choose_state - Choose the power state of a PCI device
 604  * @dev: PCI device to be suspended
 605  * @state: target sleep state for the whole system. This is the value
 606  *      that is passed to suspend() function.
 607  *
 608  * Returns PCI power state suitable for given device and given system
 609  * message.
 610  */
 611
 612 pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state)
 613 {
 614         pci_power_t ret;
 615
 616         if (!pci_find_capability(dev, PCI_CAP_ID_PM))
 617                 return PCI_D0;
 618
 619         ret = platform_pci_choose_state(dev);
 620         if (ret != PCI_POWER_ERROR)
 621                 return ret;
 622
 623         switch (state.event) {
 624         case PM_EVENT_ON:
 625                 return PCI_D0;
 626         case PM_EVENT_FREEZE:
 627         case PM_EVENT_PRETHAW:
 628                 /* REVISIT both freeze and pre-thaw "should" use D0 */
 629         case PM_EVENT_SUSPEND:
 630         case PM_EVENT_HIBERNATE:
 631                 return PCI_D3hot;
 632         default:
 633                 dev_info(&dev->dev, "unrecognized suspend event %d\n",
 634                          state.event);
 635                 BUG();
 636         }
 637         return PCI_D0;
 638 }
 639
 640 EXPORT_SYMBOL(pci_choose_state);
 641
 642 static int pci_save_pcie_state(struct pci_dev *dev)
 643 {
 644         int pos, i = 0;
 645         struct pci_cap_saved_state *save_state;
 646         u16 *cap;
 647         int found = 0;
 648
 649         pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
 650         if (pos <= 0)
 651                 return 0;
 652
 653         save_state = pci_find_saved_cap(dev, PCI_CAP_ID_EXP);
 654         if (!save_state)
 655                 save_state = kzalloc(sizeof(*save_state) + sizeof(u16) * 4, GFP_KERNEL);
 656         else
 657                 found = 1;
 658         if (!save_state) {
 659                 dev_err(&dev->dev, "out of memory in pci_save_pcie_state\n");
 660                 return -ENOMEM;
 661         }
 662         cap = (u16 *)&save_state->data[0];
 663
 664         pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &cap[i++]);
 665         pci_read_config_word(dev, pos + PCI_EXP_LNKCTL, &cap[i++]);
 666         pci_read_config_word(dev, pos + PCI_EXP_SLTCTL, &cap[i++]);
 667         pci_read_config_word(dev, pos + PCI_EXP_RTCTL, &cap[i++]);
 668         save_state->cap_nr = PCI_CAP_ID_EXP;
 669         if (!found)
 670                 pci_add_saved_cap(dev, save_state);
 671         return 0;
 672 }
 673
 674 static void pci_restore_pcie_state(struct pci_dev *dev)
 675 {
 676         int i = 0, pos;
 677         struct pci_cap_saved_state *save_state;
 678         u16 *cap;
 679
 680         save_state = pci_find_saved_cap(dev, PCI_CAP_ID_EXP);
 681         pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
 682         if (!save_state || pos <= 0)
 683                 return;
 684         cap = (u16 *)&save_state->data[0];
 685
 686         pci_write_config_word(dev, pos + PCI_EXP_DEVCTL, cap[i++]);
 687         pci_write_config_word(dev, pos + PCI_EXP_LNKCTL, cap[i++]);
 688         pci_write_config_word(dev, pos + PCI_EXP_SLTCTL, cap[i++]);
 689         pci_write_config_word(dev, pos + PCI_EXP_RTCTL, cap[i++]);
 690 }
 691
 692
 693 static int pci_save_pcix_state(struct pci_dev *dev)
 694 {
 695         int pos, i = 0;
 696         struct pci_cap_saved_state *save_state;
 697         u16 *cap;
 698         int found = 0;
 699
 700         pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
 701         if (pos <= 0)
 702                 return 0;
 703
 704         save_state = pci_find_saved_cap(dev, PCI_CAP_ID_PCIX);
 705         if (!save_state)
 706                 save_state = kzalloc(sizeof(*save_state) + sizeof(u16), GFP_KERNEL);
 707         else
 708                 found = 1;
 709         if (!save_state) {
 710                 dev_err(&dev->dev, "out of memory in pci_save_pcie_state\n");
 711                 return -ENOMEM;
 712         }
 713         cap = (u16 *)&save_state->data[0];
 714
 715         pci_read_config_word(dev, pos + PCI_X_CMD, &cap[i++]);
 716         save_state->cap_nr = PCI_CAP_ID_PCIX;
 717         if (!found)
 718                 pci_add_saved_cap(dev, save_state);
 719         return 0;
 720 }
 721
 722 static void pci_restore_pcix_state(struct pci_dev *dev)
 723 {
 724         int i = 0, pos;
 725         struct pci_cap_saved_state *save_state;
 726         u16 *cap;
 727
 728         save_state = pci_find_saved_cap(dev, PCI_CAP_ID_PCIX);
 729         pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
 730         if (!save_state || pos <= 0)
 731                 return;
 732         cap = (u16 *)&save_state->data[0];
 733
 734         pci_write_config_word(dev, pos + PCI_X_CMD, cap[i++]);
 735 }
 736
 737
 738 /**
 739  * pci_save_state - save the PCI configuration space of a device before suspending
 740  * @dev: - PCI device that we're dealing with
 741  */
 742 int
 743 pci_save_state(struct pci_dev *dev)
 744 {
 745         int i;
 746         /* XXX: 100% dword access ok here? */
 747         for (i = 0; i < 16; i++)
 748                 pci_read_config_dword(dev, i * 4,&dev->saved_config_space[i]);
 749         if ((i = pci_save_pcie_state(dev)) != 0)
 750                 return i;
 751         if ((i = pci_save_pcix_state(dev)) != 0)
 752                 return i;
 753         return 0;
 754 }
 755
 756 /**
 757  * pci_restore_state - Restore the saved state of a PCI device
 758  * @dev: - PCI device that we're dealing with
 759  */
 760 int
 761 pci_restore_state(struct pci_dev *dev)
 762 {
 763         int i;
 764         u32 val;
 765
 766         /* PCI Express register must be restored first */
 767         pci_restore_pcie_state(dev);
 768
 769         /*
 770          * The Base Address register should be programmed before the command
 771          * register(s)
 772          */
 773         for (i = 15; i >= 0; i--) {
 774                 pci_read_config_dword(dev, i * 4, &val);
 775                 if (val != dev->saved_config_space[i]) {
 776                         dev_printk(KERN_DEBUG, &dev->dev, "restoring config "
 777                                 "space at offset %#x (was %#x, writing %#x)\n",
 778                                 i, val, (int)dev->saved_config_space[i]);
 779                         pci_write_config_dword(dev,i * 4,
 780                                 dev->saved_config_space[i]);
 781                 }
 782         }
 783         pci_restore_pcix_state(dev);
 784         pci_restore_msi_state(dev);
 785
 786         return 0;
 787 }
 788
 789 static int do_pci_enable_device(struct pci_dev *dev, int bars)
 790 {
 791         int err;
 792
 793         err = pci_set_power_state(dev, PCI_D0);
 794         if (err < 0 && err != -EIO)
 795                 return err;
 796         err = pcibios_enable_device(dev, bars);
 797         if (err < 0)
 798                 return err;
 799         pci_fixup_device(pci_fixup_enable, dev);
 800
 801         return 0;
 802 }
 803
 804 /**
 805  * pci_reenable_device - Resume abandoned device
 806  * @dev: PCI device to be resumed
 807  *
 808  *  Note this function is a backend of pci_default_resume and is not supposed
 809  *  to be called by normal code, write proper resume handler and use it instead.
 810  */
 811 int pci_reenable_device(struct pci_dev *dev)
 812 {
 813         if (atomic_read(&dev->enable_cnt))
 814                 return do_pci_enable_device(dev, (1 << PCI_NUM_RESOURCES) - 1);
 815         return 0;
 816 }
 817
 818 static int __pci_enable_device_flags(struct pci_dev *dev,
 819                                      resource_size_t flags)
 820 {
 821         int err;
 822         int i, bars = 0;
 823
 824         if (atomic_add_return(1, &dev->enable_cnt) > 1)
 825                 return 0;               /* already enabled */
 826
 827         for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
 828                 if (dev->resource[i].flags & flags)
 829                         bars |= (1 << i);
 830
 831         err = do_pci_enable_device(dev, bars);
 832         if (err < 0)
 833                 atomic_dec(&dev->enable_cnt);
 834         return err;
 835 }
 836
 837 /**
 838  * pci_enable_device_io - Initialize a device for use with IO space
 839  * @dev: PCI device to be initialized
 840  *
 841  *  Initialize device before it's used by a driver. Ask low-level code
 842  *  to enable I/O resources. Wake up the device if it was suspended.
 843  *  Beware, this function can fail.
 844  */
 845 int pci_enable_device_io(struct pci_dev *dev)
 846 {
 847         return __pci_enable_device_flags(dev, IORESOURCE_IO);
 848 }
 849
 850 /**
 851  * pci_enable_device_mem - Initialize a device for use with Memory space
 852  * @dev: PCI device to be initialized
 853  *
 854  *  Initialize device before it's used by a driver. Ask low-level code
 855  *  to enable Memory resources. Wake up the device if it was suspended.
 856  *  Beware, this function can fail.
 857  */
 858 int pci_enable_device_mem(struct pci_dev *dev)
 859 {
 860         return __pci_enable_device_flags(dev, IORESOURCE_MEM);
 861 }
 862
 863 /**
 864  * pci_enable_device - Initialize device before it's used by a driver.
 865  * @dev: PCI device to be initialized
 866  *
 867  *  Initialize device before it's used by a driver. Ask low-level code
 868  *  to enable I/O and memory. Wake up the device if it was suspended.
 869  *  Beware, this function can fail.
 870  *
 871  *  Note we don't actually enable the device many times if we call
 872  *  this function repeatedly (we just increment the count).
 873  */
 874 int pci_enable_device(struct pci_dev *dev)
 875 {
 876         return __pci_enable_device_flags(dev, IORESOURCE_MEM | IORESOURCE_IO);
 877 }
 878
 879 /*
 880  * Managed PCI resources.  This manages device on/off, intx/msi/msix
 881  * on/off and BAR regions.  pci_dev itself records msi/msix status, so
 882  * there's no need to track it separately.  pci_devres is initialized
 883  * when a device is enabled using managed PCI device enable interface.
 884  */
 885 struct pci_devres {
 886         unsigned int enabled:1;
 887         unsigned int pinned:1;
 888         unsigned int orig_intx:1;
 889         unsigned int restore_intx:1;
 890         u32 region_mask;
 891 };
 892
 893 static void pcim_release(struct device *gendev, void *res)
 894 {
 895         struct pci_dev *dev = container_of(gendev, struct pci_dev, dev);
 896         struct pci_devres *this = res;
 897         int i;
 898
 899         if (dev->msi_enabled)
 900                 pci_disable_msi(dev);
 901         if (dev->msix_enabled)
 902                 pci_disable_msix(dev);
 903
 904         for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
 905                 if (this->region_mask & (1 << i))
 906                         pci_release_region(dev, i);
 907
 908         if (this->restore_intx)
 909                 pci_intx(dev, this->orig_intx);
 910
 911         if (this->enabled && !this->pinned)
 912                 pci_disable_device(dev);
 913 }
 914
 915 static struct pci_devres * get_pci_dr(struct pci_dev *pdev)
 916 {
 917         struct pci_devres *dr, *new_dr;
 918
 919         dr = devres_find(&pdev->dev, pcim_release, NULL, NULL);
 920         if (dr)
 921                 return dr;
 922
 923         new_dr = devres_alloc(pcim_release, sizeof(*new_dr), GFP_KERNEL);
 924         if (!new_dr)
 925                 return NULL;
 926         return devres_get(&pdev->dev, new_dr, NULL, NULL);
 927 }
 928
 929 static struct pci_devres * find_pci_dr(struct pci_dev *pdev)
 930 {
 931         if (pci_is_managed(pdev))
 932                 return devres_find(&pdev->dev, pcim_release, NULL, NULL);
 933         return NULL;
 934 }
 935
 936 /**
 937  * pcim_enable_device - Managed pci_enable_device()
 938  * @pdev: PCI device to be initialized
 939  *
 940  * Managed pci_enable_device().
 941  */
 942 int pcim_enable_device(struct pci_dev *pdev)
 943 {
 944         struct pci_devres *dr;
 945         int rc;
 946
 947         dr = get_pci_dr(pdev);
 948         if (unlikely(!dr))
 949                 return -ENOMEM;
 950         if (dr->enabled)
 951                 return 0;
 952
 953         rc = pci_enable_device(pdev);
 954         if (!rc) {
 955                 pdev->is_managed = 1;
 956                 dr->enabled = 1;
 957         }
 958         return rc;
 959 }
 960
 961 /**
 962  * pcim_pin_device - Pin managed PCI device
 963  * @pdev: PCI device to pin
 964  *
 965  * Pin managed PCI device @pdev.  Pinned device won't be disabled on
 966  * driver detach.  @pdev must have been enabled with
 967  * pcim_enable_device().
 968  */
 969 void pcim_pin_device(struct pci_dev *pdev)
 970 {
 971         struct pci_devres *dr;
 972
 973         dr = find_pci_dr(pdev);
 974         WARN_ON(!dr || !dr->enabled);
 975         if (dr)
 976                 dr->pinned = 1;
 977 }
 978
 979 /**
 980  * pcibios_disable_device - disable arch specific PCI resources for device dev
 981  * @dev: the PCI device to disable
 982  *
 983  * Disables architecture specific PCI resources for the device. This
 984  * is the default implementation. Architecture implementations can
 985  * override this.
 986  */
 987 void __attribute__ ((weak)) pcibios_disable_device (struct pci_dev *dev) {}
 988
 989 /**
 990  * pci_disable_device - Disable PCI device after use
 991  * @dev: PCI device to be disabled
 992  *
 993  * Signal to the system that the PCI device is not in use by the system
 994  * anymore.  This only involves disabling PCI bus-mastering, if active.
 995  *
 996  * Note we don't actually disable the device until all callers of
 997  * pci_device_enable() have called pci_device_disable().
 998  */
 999 void
1000 pci_disable_device(struct pci_dev *dev)
1001 {
1002         struct pci_devres *dr;
1003         u16 pci_command;
1004
1005         dr = find_pci_dr(dev);
1006         if (dr)
1007                 dr->enabled = 0;
1008
1009         if (atomic_sub_return(1, &dev->enable_cnt) != 0)
1010                 return;
1011
1012         pci_read_config_word(dev, PCI_COMMAND, &pci_command);
1013         if (pci_command & PCI_COMMAND_MASTER) {
1014                 pci_command &= ~PCI_COMMAND_MASTER;
1015                 pci_write_config_word(dev, PCI_COMMAND, pci_command);
1016         }
1017         dev->is_busmaster = 0;
1018
1019         pcibios_disable_device(dev);
1020 }
1021
1022 /**
1023  * pcibios_set_pcie_reset_state - set reset state for device dev
1024  * @dev: the PCI-E device reset
1025  * @state: Reset state to enter into
1026  *
1027  *
1028  * Sets the PCI-E reset state for the device. This is the default
1029  * implementation. Architecture implementations can override this.
1030  */
1031 int __attribute__ ((weak)) pcibios_set_pcie_reset_state(struct pci_dev *dev,
1032                                                         enum pcie_reset_state state)
1033 {
1034         return -EINVAL;
1035 }
1036
1037 /**
1038  * pci_set_pcie_reset_state - set reset state for device dev
1039  * @dev: the PCI-E device reset
1040  * @state: Reset state to enter into
1041  *
1042  *
1043  * Sets the PCI reset state for the device.
1044  */
1045 int pci_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state)
1046 {
1047         return pcibios_set_pcie_reset_state(dev, state);
1048 }
1049
1050 /**
1051  * pci_pme_capable - check the capability of PCI device to generate PME#
1052  * @dev: PCI device to handle.
1053  * @pm: PCI PM capability offset of the device.
1054  * @state: PCI state from which device will issue PME#.
1055  */
1056 static bool pci_pme_capable(struct pci_dev *dev, int pm, pci_power_t state)
1057 {
1058         u16 pmc;
1059
1060         if (!pm)
1061                 return false;
1062
1063         /* Check device's ability to generate PME# from given state */
1064         pci_read_config_word(dev, pm + PCI_PM_PMC, &pmc);
1065
1066         pmc &= PCI_PM_CAP_PME_MASK;
1067         pmc >>= ffs(PCI_PM_CAP_PME_MASK) - 1;   /* First bit of mask */
1068
1069         return !!(pmc & (1 << state));
1070 }
1071
1072 /**
1073  * pci_pme_active - enable or disable PCI device's PME# function
1074  * @dev: PCI device to handle.
1075  * @pm: PCI PM capability offset of the device.
1076  * @enable: 'true' to enable PME# generation; 'false' to disable it.
1077  *
1078  * The caller must verify that the device is capable of generating PME# before
1079  * calling this function with @enable equal to 'true'.
1080  */
1081 static void pci_pme_active(struct pci_dev *dev, int pm, bool enable)
1082 {
1083         u16 pmcsr;
1084
1085         if (!pm)
1086                 return;
1087
1088         pci_read_config_word(dev, pm + PCI_PM_CTRL, &pmcsr);
1089         /* Clear PME_Status by writing 1 to it and enable PME# */
1090         pmcsr |= PCI_PM_CTRL_PME_STATUS | PCI_PM_CTRL_PME_ENABLE;
1091         if (!enable)
1092                 pmcsr &= ~PCI_PM_CTRL_PME_ENABLE;
1093
1094         pci_write_config_word(dev, pm + PCI_PM_CTRL, pmcsr);
1095
1096         dev_printk(KERN_INFO, &dev->dev, "PME# %s\n",
1097                         enable ? "enabled" : "disabled");
1098 }
1099
1100 /**
1101  * pci_enable_wake - enable PCI device as wakeup event source
1102  * @dev: PCI device affected
1103  * @state: PCI state from which device will issue wakeup events
1104  * @enable: True to enable event generation; false to disable
1105  *
1106  * This enables the device as a wakeup event source, or disables it.
1107  * When such events involves platform-specific hooks, those hooks are
1108  * called automatically by this routine.
1109  *
1110  * Devices with legacy power management (no standard PCI PM capabilities)
1111  * always require such platform hooks.
1112  *
1113  * RETURN VALUE:
1114  * 0 is returned on success
1115  * -EINVAL is returned if device is not supposed to wake up the system
1116  * Error code depending on the platform is returned if both the platform and
1117  * the native mechanism fail to enable the generation of wake-up events
1118  */
1119 int pci_enable_wake(struct pci_dev *dev, pci_power_t state, int enable)
1120 {
1121         int pm;
1122         int error = 0;
1123         bool pme_done = false;
1124
1125         if (!device_may_wakeup(&dev->dev))
1126                 return -EINVAL;
1127
1128         /*
1129          * According to "PCI System Architecture" 4th ed. by Tom Shanley & Don
1130          * Anderson we should be doing PME# wake enable followed by ACPI wake
1131          * enable.  To disable wake-up we call the platform first, for symmetry.
1132          */
1133
1134         if (!enable && platform_pci_can_wakeup(dev))
1135                 error = platform_pci_sleep_wake(dev, false);
1136
1137         pm = pci_find_capability(dev, PCI_CAP_ID_PM);
1138         if (!enable || pci_pme_capable(dev, pm, state)) {
1139                 pci_pme_active(dev, pm, enable);
1140                 pme_done = true;
1141         }
1142
1143         if (enable && platform_pci_can_wakeup(dev))
1144                 error = platform_pci_sleep_wake(dev, true);
1145
1146         return pme_done ? 0 : error;
1147 }
1148
1149 /**
1150  * pci_prepare_to_sleep - prepare PCI device for system-wide transition into
1151  *                        a sleep state
1152  * @dev: Device to handle.
1153  *
1154  * Choose the power state appropriate for the device depending on whether
1155  * it can wake up the system and/or is power manageable by the platform
1156  * (PCI_D3hot is the default) and put the device into that state.
1157  */
1158 int pci_prepare_to_sleep(struct pci_dev *dev)
1159 {
1160         pci_power_t target_state = PCI_D3hot;
1161         int pm = pci_find_capability(dev, PCI_CAP_ID_PM);
1162         int error;
1163
1164         if (platform_pci_power_manageable(dev)) {
1165                 /*
1166                  * Call the platform to choose the target state of the device
1167                  * and enable wake-up from this state if supported.
1168                  */
1169                 pci_power_t state = platform_pci_choose_state(dev);
1170
1171                 switch (state) {
1172                 case PCI_POWER_ERROR:
1173                 case PCI_UNKNOWN:
1174                         break;
1175                 case PCI_D1:
1176                 case PCI_D2:
1177                         if (pci_no_d1d2(dev))
1178                                 break;
1179                 default:
1180                         target_state = state;
1181                         pci_enable_wake(dev, target_state, true);
1182                 }
1183         } else if (device_may_wakeup(&dev->dev)) {
1184                 /*
1185                  * Find the deepest state from which the device can generate
1186                  * wake-up events, make it the target state and enable device
1187                  * to generate PME#.
1188                  */
1189                 u16 pmc;
1190
1191                 if (!pm)
1192                         return -EIO;
1193
1194                 pci_read_config_word(dev, pm + PCI_PM_PMC, &pmc);
1195                 if (pmc & PCI_PM_CAP_PME_MASK) {
1196                         if (!(pmc & PCI_PM_CAP_PME_D3)) {
1197                                 /* Device cannot generate PME# from D3_hot */
1198                                 if (pmc & PCI_PM_CAP_PME_D2)
1199                                         target_state = PCI_D2;
1200                                 else if (pmc & PCI_PM_CAP_PME_D1)
1201                                         target_state = PCI_D1;
1202                                 else
1203                                         target_state = PCI_D0;
1204                         }
1205                         pci_pme_active(dev, pm, true);
1206                 }
1207         }
1208
1209         error = pci_set_power_state(dev, target_state);
1210
1211         if (error)
1212                 pci_enable_wake(dev, target_state, false);
1213
1214         return error;
1215 }
1216
1217 /**
1218  * pci_back_from_sleep - turn PCI device on during system-wide transition into
1219  *                       the working state a sleep state
1220  * @dev: Device to handle.
1221  *
1222  * Disable device's sytem wake-up capability and put it into D0.
1223  */
1224 int pci_back_from_sleep(struct pci_dev *dev)
1225 {
1226         pci_enable_wake(dev, PCI_D0, false);
1227         return pci_set_power_state(dev, PCI_D0);
1228 }
1229
1230 /**
1231  * pci_pm_init - Initialize PM functions of given PCI device
1232  * @dev: PCI device to handle.
1233  */
1234 void pci_pm_init(struct pci_dev *dev)
1235 {
1236         int pm;
1237         u16 pmc;
1238
1239         /* find PCI PM capability in list */
1240         pm = pci_find_capability(dev, PCI_CAP_ID_PM);
1241         if (!pm)
1242                 return;
1243         /* Check device's ability to generate PME# */
1244         pci_read_config_word(dev, pm + PCI_PM_PMC, &pmc);
1245
1246         if ((pmc & PCI_PM_CAP_VER_MASK) > 3) {
1247                 dev_err(&dev->dev, "unsupported PM cap regs version (%u)\n",
1248                         pmc & PCI_PM_CAP_VER_MASK);
1249                 return;
1250         }
1251
1252         if (pmc & PCI_PM_CAP_PME_MASK) {
1253                 dev_printk(KERN_INFO, &dev->dev,
1254                         "PME# supported from%s%s%s%s%s\n",
1255                         (pmc & PCI_PM_CAP_PME_D0) ? " D0" : "",
1256                         (pmc & PCI_PM_CAP_PME_D1) ? " D1" : "",
1257                         (pmc & PCI_PM_CAP_PME_D2) ? " D2" : "",
1258                         (pmc & PCI_PM_CAP_PME_D3) ? " D3hot" : "",
1259                         (pmc & PCI_PM_CAP_PME_D3cold) ? " D3cold" : "");
1260                 /*
1261                  * Make device's PM flags reflect the wake-up capability, but
1262                  * let the user space enable it to wake up the system as needed.
1263                  */
1264                 device_set_wakeup_capable(&dev->dev, true);
1265                 device_set_wakeup_enable(&dev->dev, false);
1266                 /* Disable the PME# generation functionality */
1267                 pci_pme_active(dev, pm, false);
1268         }
1269 }
1270
1271 int
1272 pci_get_interrupt_pin(struct pci_dev *dev, struct pci_dev **bridge)
1273 {
1274         u8 pin;
1275
1276         pin = dev->pin;
1277         if (!pin)
1278                 return -1;
1279         pin--;
1280         while (dev->bus->self) {
1281                 pin = (pin + PCI_SLOT(dev->devfn)) % 4;
1282                 dev = dev->bus->self;
1283         }
1284         *bridge = dev;
1285         return pin;
1286 }
1287
1288 /**
1289  *      pci_release_region - Release a PCI bar
1290  *      @pdev: PCI device whose resources were previously reserved by pci_request_region
1291  *      @bar: BAR to release
1292  *
1293  *      Releases the PCI I/O and memory resources previously reserved by a
1294  *      successful call to pci_request_region.  Call this function only
1295  *      after all use of the PCI regions has ceased.
1296  */
1297 void pci_release_region(struct pci_dev *pdev, int bar)
1298 {
1299         struct pci_devres *dr;
1300
1301         if (pci_resource_len(pdev, bar) == 0)
1302                 return;
1303         if (pci_resource_flags(pdev, bar) & IORESOURCE_IO)
1304                 release_region(pci_resource_start(pdev, bar),
1305                                 pci_resource_len(pdev, bar));
1306         else if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM)
1307                 release_mem_region(pci_resource_start(pdev, bar),
1308                                 pci_resource_len(pdev, bar));
1309
1310         dr = find_pci_dr(pdev);
1311         if (dr)
1312                 dr->region_mask &= ~(1 << bar);
1313 }
1314
1315 /**
1316  *      pci_request_region - Reserved PCI I/O and memory resource
1317  *      @pdev: PCI device whose resources are to be reserved
1318  *      @bar: BAR to be reserved
1319  *      @res_name: Name to be associated with resource.
1320  *
1321  *      Mark the PCI region associated with PCI device @pdev BR @bar as
1322  *      being reserved by owner @res_name.  Do not access any
1323  *      address inside the PCI regions unless this call returns
1324  *      successfully.
1325  *
1326  *      Returns 0 on success, or %EBUSY on error.  A warning
1327  *      message is also printed on failure.
1328  */
1329 int pci_request_region(struct pci_dev *pdev, int bar, const char *res_name)
1330 {
1331         struct pci_devres *dr;
1332
1333         if (pci_resource_len(pdev, bar) == 0)
1334                 return 0;
1335
1336         if (pci_resource_flags(pdev, bar) & IORESOURCE_IO) {
1337                 if (!request_region(pci_resource_start(pdev, bar),
1338                             pci_resource_len(pdev, bar), res_name))
1339                         goto err_out;
1340         }
1341         else if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM) {
1342                 if (!request_mem_region(pci_resource_start(pdev, bar),
1343                                         pci_resource_len(pdev, bar), res_name))
1344                         goto err_out;
1345         }
1346
1347         dr = find_pci_dr(pdev);
1348         if (dr)
1349                 dr->region_mask |= 1 << bar;
1350
1351         return 0;
1352
1353 err_out:
1354         dev_warn(&pdev->dev, "BAR %d: can't reserve %s region [%#llx-%#llx]\n",
1355                  bar,
1356                  pci_resource_flags(pdev, bar) & IORESOURCE_IO ? "I/O" : "mem",
1357                  (unsigned long long)pci_resource_start(pdev, bar),
1358                  (unsigned long long)pci_resource_end(pdev, bar));
1359         return -EBUSY;
1360 }
1361
1362 /**
1363  * pci_release_selected_regions - Release selected PCI I/O and memory resources
1364  * @pdev: PCI device whose resources were previously reserved
1365  * @bars: Bitmask of BARs to be released
1366  *
1367  * Release selected PCI I/O and memory resources previously reserved.
1368  * Call this function only after all use of the PCI regions has ceased.
1369  */
1370 void pci_release_selected_regions(struct pci_dev *pdev, int bars)
1371 {
1372         int i;
1373
1374         for (i = 0; i < 6; i++)
1375                 if (bars & (1 << i))
1376                         pci_release_region(pdev, i);
1377 }
1378
1379 /**
1380  * pci_request_selected_regions - Reserve selected PCI I/O and memory resources
1381  * @pdev: PCI device whose resources are to be reserved
1382  * @bars: Bitmask of BARs to be requested
1383  * @res_name: Name to be associated with resource
1384  */
1385 int pci_request_selected_regions(struct pci_dev *pdev, int bars,
1386                                  const char *res_name)
1387 {
1388         int i;
1389
1390         for (i = 0; i < 6; i++)
1391                 if (bars & (1 << i))
1392                         if(pci_request_region(pdev, i, res_name))
1393                                 goto err_out;
1394         return 0;
1395
1396 err_out:
1397         while(--i >= 0)
1398                 if (bars & (1 << i))
1399                         pci_release_region(pdev, i);
1400
1401         return -EBUSY;
1402 }
1403
1404 /**
1405  *      pci_release_regions - Release reserved PCI I/O and memory resources
1406  *      @pdev: PCI device whose resources were previously reserved by pci_request_regions
1407  *
1408  *      Releases all PCI I/O and memory resources previously reserved by a
1409  *      successful call to pci_request_regions.  Call this function only
1410  *      after all use of the PCI regions has ceased.
1411  */
1412
1413 void pci_release_regions(struct pci_dev *pdev)
1414 {
1415         pci_release_selected_regions(pdev, (1 << 6) - 1);
1416 }
1417
1418 /**
1419  *      pci_request_regions - Reserved PCI I/O and memory resources
1420  *      @pdev: PCI device whose resources are to be reserved
1421  *      @res_name: Name to be associated with resource.
1422  *
1423  *      Mark all PCI regions associated with PCI device @pdev as
1424  *      being reserved by owner @res_name.  Do not access any
1425  *      address inside the PCI regions unless this call returns
1426  *      successfully.
1427  *
1428  *      Returns 0 on success, or %EBUSY on error.  A warning
1429  *      message is also printed on failure.
1430  */
1431 int pci_request_regions(struct pci_dev *pdev, const char *res_name)
1432 {
1433         return pci_request_selected_regions(pdev, ((1 << 6) - 1), res_name);
1434 }
1435
1436 /**
1437  * pci_set_master - enables bus-mastering for device dev
1438  * @dev: the PCI device to enable
1439  *
1440  * Enables bus-mastering on the device and calls pcibios_set_master()
1441  * to do the needed arch specific settings.
1442  */
1443 void
1444 pci_set_master(struct pci_dev *dev)
1445 {
1446         u16 cmd;
1447
1448         pci_read_config_word(dev, PCI_COMMAND, &cmd);
1449         if (! (cmd & PCI_COMMAND_MASTER)) {
1450                 dev_dbg(&dev->dev, "enabling bus mastering\n");
1451                 cmd |= PCI_COMMAND_MASTER;
1452                 pci_write_config_word(dev, PCI_COMMAND, cmd);
1453         }
1454         dev->is_busmaster = 1;
1455         pcibios_set_master(dev);
1456 }
1457
1458 #ifdef PCI_DISABLE_MWI
1459 int pci_set_mwi(struct pci_dev *dev)
1460 {
1461         return 0;
1462 }
1463
1464 int pci_try_set_mwi(struct pci_dev *dev)
1465 {
1466         return 0;
1467 }
1468
1469 void pci_clear_mwi(struct pci_dev *dev)
1470 {
1471 }
1472
1473 #else
1474
1475 #ifndef PCI_CACHE_LINE_BYTES
1476 #define PCI_CACHE_LINE_BYTES L1_CACHE_BYTES
1477 #endif
1478
1479 /* This can be overridden by arch code. */
1480 /* Don't forget this is measured in 32-bit words, not bytes */
1481 u8 pci_cache_line_size = PCI_CACHE_LINE_BYTES / 4;
1482
1483 /**
1484  * pci_set_cacheline_size - ensure the CACHE_LINE_SIZE register is programmed
1485  * @dev: the PCI device for which MWI is to be enabled
1486  *
1487  * Helper function for pci_set_mwi.
1488  * Originally copied from drivers/net/acenic.c.
1489  * Copyright 1998-2001 by Jes Sorensen, <jes@trained-monkey.org>.
1490  *
1491  * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
1492  */
1493 static int
1494 pci_set_cacheline_size(struct pci_dev *dev)
1495 {
1496         u8 cacheline_size;
1497
1498         if (!pci_cache_line_size)
1499                 return -EINVAL;         /* The system doesn't support MWI. */
1500
1501         /* Validate current setting: the PCI_CACHE_LINE_SIZE must be
1502            equal to or multiple of the right value. */
1503         pci_read_config_byte(dev, PCI_CACHE_LINE_SIZE, &cacheline_size);
1504         if (cacheline_size >= pci_cache_line_size &&
1505             (cacheline_size % pci_cache_line_size) == 0)
1506                 return 0;
1507
1508         /* Write the correct value. */
1509         pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, pci_cache_line_size);
1510         /* Read it back. */
1511         pci_read_config_byte(dev, PCI_CACHE_LINE_SIZE, &cacheline_size);
1512         if (cacheline_size == pci_cache_line_size)
1513                 return 0;
1514
1515         dev_printk(KERN_DEBUG, &dev->dev, "cache line size of %d is not "
1516                    "supported\n", pci_cache_line_size << 2);
1517
1518         return -EINVAL;
1519 }
1520
1521 /**
1522  * pci_set_mwi - enables memory-write-invalidate PCI transaction
1523  * @dev: the PCI device for which MWI is enabled
1524  *
1525  * Enables the Memory-Write-Invalidate transaction in %PCI_COMMAND.
1526  *
1527  * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
1528  */
1529 int
1530 pci_set_mwi(struct pci_dev *dev)
1531 {
1532         int rc;
1533         u16 cmd;
1534
1535         rc = pci_set_cacheline_size(dev);
1536         if (rc)
1537                 return rc;
1538
1539         pci_read_config_word(dev, PCI_COMMAND, &cmd);
1540         if (! (cmd & PCI_COMMAND_INVALIDATE)) {
1541                 dev_dbg(&dev->dev, "enabling Mem-Wr-Inval\n");
1542                 cmd |= PCI_COMMAND_INVALIDATE;
1543                 pci_write_config_word(dev, PCI_COMMAND, cmd);
1544         }
1545
1546         return 0;
1547 }
1548
1549 /**
1550  * pci_try_set_mwi - enables memory-write-invalidate PCI transaction
1551  * @dev: the PCI device for which MWI is enabled
1552  *
1553  * Enables the Memory-Write-Invalidate transaction in %PCI_COMMAND.
1554  * Callers are not required to check the return value.
1555  *
1556  * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
1557  */
1558 int pci_try_set_mwi(struct pci_dev *dev)
1559 {
1560         int rc = pci_set_mwi(dev);
1561         return rc;
1562 }
1563
1564 /**
1565  * pci_clear_mwi - disables Memory-Write-Invalidate for device dev
1566  * @dev: the PCI device to disable
1567  *
1568  * Disables PCI Memory-Write-Invalidate transaction on the device
1569  */
1570 void
1571 pci_clear_mwi(struct pci_dev *dev)
1572 {
1573         u16 cmd;
1574
1575         pci_read_config_word(dev, PCI_COMMAND, &cmd);
1576         if (cmd & PCI_COMMAND_INVALIDATE) {
1577                 cmd &= ~PCI_COMMAND_INVALIDATE;
1578                 pci_write_config_word(dev, PCI_COMMAND, cmd);
1579         }
1580 }
1581 #endif /* ! PCI_DISABLE_MWI */
1582
1583 /**
1584  * pci_intx - enables/disables PCI INTx for device dev
1585  * @pdev: the PCI device to operate on
1586  * @enable: boolean: whether to enable or disable PCI INTx
1587  *
1588  * Enables/disables PCI INTx for device dev
1589  */
1590 void
1591 pci_intx(struct pci_dev *pdev, int enable)
1592 {
1593         u16 pci_command, new;
1594
1595         pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
1596
1597         if (enable) {
1598                 new = pci_command & ~PCI_COMMAND_INTX_DISABLE;
1599         } else {
1600                 new = pci_command | PCI_COMMAND_INTX_DISABLE;
1601         }
1602
1603         if (new != pci_command) {
1604                 struct pci_devres *dr;
1605
1606                 pci_write_config_word(pdev, PCI_COMMAND, new);
1607
1608                 dr = find_pci_dr(pdev);
1609                 if (dr && !dr->restore_intx) {
1610                         dr->restore_intx = 1;
1611                         dr->orig_intx = !enable;
1612                 }
1613         }
1614 }
1615
1616 /**
1617  * pci_msi_off - disables any msi or msix capabilities
1618  * @dev: the PCI device to operate on
1619  *
1620  * If you want to use msi see pci_enable_msi and friends.
1621  * This is a lower level primitive that allows us to disable
1622  * msi operation at the device level.
1623  */
1624 void pci_msi_off(struct pci_dev *dev)
1625 {
1626         int pos;
1627         u16 control;
1628
1629         pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
1630         if (pos) {
1631                 pci_read_config_word(dev, pos + PCI_MSI_FLAGS, &control);
1632                 control &= ~PCI_MSI_FLAGS_ENABLE;
1633                 pci_write_config_word(dev, pos + PCI_MSI_FLAGS, control);
1634         }
1635         pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
1636         if (pos) {
1637                 pci_read_config_word(dev, pos + PCI_MSIX_FLAGS, &control);
1638                 control &= ~PCI_MSIX_FLAGS_ENABLE;
1639                 pci_write_config_word(dev, pos + PCI_MSIX_FLAGS, control);
1640         }
1641 }
1642
1643 #ifndef HAVE_ARCH_PCI_SET_DMA_MASK
1644 /*
1645  * These can be overridden by arch-specific implementations
1646  */
1647 int
1648 pci_set_dma_mask(struct pci_dev *dev, u64 mask)
1649 {
1650         if (!pci_dma_supported(dev, mask))
1651                 return -EIO;
1652
1653         dev->dma_mask = mask;
1654
1655         return 0;
1656 }
1657
1658 int
1659 pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
1660 {
1661         if (!pci_dma_supported(dev, mask))
1662                 return -EIO;
1663
1664         dev->dev.coherent_dma_mask = mask;
1665
1666         return 0;
1667 }
1668 #endif
1669
1670 #ifndef HAVE_ARCH_PCI_SET_DMA_MAX_SEGMENT_SIZE
1671 int pci_set_dma_max_seg_size(struct pci_dev *dev, unsigned int size)
1672 {
1673         return dma_set_max_seg_size(&dev->dev, size);
1674 }
1675 EXPORT_SYMBOL(pci_set_dma_max_seg_size);
1676 #endif
1677
1678 #ifndef HAVE_ARCH_PCI_SET_DMA_SEGMENT_BOUNDARY
1679 int pci_set_dma_seg_boundary(struct pci_dev *dev, unsigned long mask)
1680 {
1681         return dma_set_seg_boundary(&dev->dev, mask);
1682 }
1683 EXPORT_SYMBOL(pci_set_dma_seg_boundary);
1684 #endif
1685
1686 /**
1687  * pcix_get_max_mmrbc - get PCI-X maximum designed memory read byte count
1688  * @dev: PCI device to query
1689  *
1690  * Returns mmrbc: maximum designed memory read count in bytes
1691  *    or appropriate error value.
1692  */
1693 int pcix_get_max_mmrbc(struct pci_dev *dev)
1694 {
1695         int err, cap;
1696         u32 stat;
1697
1698         cap = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1699         if (!cap)
1700                 return -EINVAL;
1701
1702         err = pci_read_config_dword(dev, cap + PCI_X_STATUS, &stat);
1703         if (err)
1704                 return -EINVAL;
1705
1706         return (stat & PCI_X_STATUS_MAX_READ) >> 12;
1707 }
1708 EXPORT_SYMBOL(pcix_get_max_mmrbc);
1709
1710 /**
1711  * pcix_get_mmrbc - get PCI-X maximum memory read byte count
1712  * @dev: PCI device to query
1713  *
1714  * Returns mmrbc: maximum memory read count in bytes
1715  *    or appropriate error value.
1716  */
1717 int pcix_get_mmrbc(struct pci_dev *dev)
1718 {
1719         int ret, cap;
1720         u32 cmd;
1721
1722         cap = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1723         if (!cap)
1724                 return -EINVAL;
1725
1726         ret = pci_read_config_dword(dev, cap + PCI_X_CMD, &cmd);
1727         if (!ret)
1728                 ret = 512 << ((cmd & PCI_X_CMD_MAX_READ) >> 2);
1729
1730         return ret;
1731 }
1732 EXPORT_SYMBOL(pcix_get_mmrbc);
1733
1734 /**
1735  * pcix_set_mmrbc - set PCI-X maximum memory read byte count
1736  * @dev: PCI device to query
1737  * @mmrbc: maximum memory read count in bytes
1738  *    valid values are 512, 1024, 2048, 4096
1739  *
1740  * If possible sets maximum memory read byte count, some bridges have erratas
1741  * that prevent this.
1742  */
1743 int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc)
1744 {
1745         int cap, err = -EINVAL;
1746         u32 stat, cmd, v, o;
1747
1748         if (mmrbc < 512 || mmrbc > 4096 || !is_power_of_2(mmrbc))
1749                 goto out;
1750
1751         v = ffs(mmrbc) - 10;
1752
1753         cap = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1754         if (!cap)
1755                 goto out;
1756
1757         err = pci_read_config_dword(dev, cap + PCI_X_STATUS, &stat);
1758         if (err)
1759                 goto out;
1760
1761         if (v > (stat & PCI_X_STATUS_MAX_READ) >> 21)
1762                 return -E2BIG;
1763
1764         err = pci_read_config_dword(dev, cap + PCI_X_CMD, &cmd);
1765         if (err)
1766                 goto out;
1767
1768         o = (cmd & PCI_X_CMD_MAX_READ) >> 2;
1769         if (o != v) {
1770                 if (v > o && dev->bus &&
1771                    (dev->bus->bus_flags & PCI_BUS_FLAGS_NO_MMRBC))
1772                         return -EIO;
1773
1774                 cmd &= ~PCI_X_CMD_MAX_READ;
1775                 cmd |= v << 2;
1776                 err = pci_write_config_dword(dev, cap + PCI_X_CMD, cmd);
1777         }
1778 out:
1779         return err;
1780 }
1781 EXPORT_SYMBOL(pcix_set_mmrbc);
1782
1783 /**
1784  * pcie_get_readrq - get PCI Express read request size
1785  * @dev: PCI device to query
1786  *
1787  * Returns maximum memory read request in bytes
1788  *    or appropriate error value.
1789  */
1790 int pcie_get_readrq(struct pci_dev *dev)
1791 {
1792         int ret, cap;
1793         u16 ctl;
1794
1795         cap = pci_find_capability(dev, PCI_CAP_ID_EXP);
1796         if (!cap)
1797                 return -EINVAL;
1798
1799         ret = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
1800         if (!ret)
1801         ret = 128 << ((ctl & PCI_EXP_DEVCTL_READRQ) >> 12);
1802
1803         return ret;
1804 }
1805 EXPORT_SYMBOL(pcie_get_readrq);
1806
1807 /**
1808  * pcie_set_readrq - set PCI Express maximum memory read request
1809  * @dev: PCI device to query
1810  * @rq: maximum memory read count in bytes
1811  *    valid values are 128, 256, 512, 1024, 2048, 4096
1812  *
1813  * If possible sets maximum read byte count
1814  */
1815 int pcie_set_readrq(struct pci_dev *dev, int rq)
1816 {
1817         int cap, err = -EINVAL;
1818         u16 ctl, v;
1819
1820         if (rq < 128 || rq > 4096 || !is_power_of_2(rq))
1821                 goto out;
1822
1823         v = (ffs(rq) - 8) << 12;
1824
1825         cap = pci_find_capability(dev, PCI_CAP_ID_EXP);
1826         if (!cap)
1827                 goto out;
1828
1829         err = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
1830         if (err)
1831                 goto out;
1832
1833         if ((ctl & PCI_EXP_DEVCTL_READRQ) != v) {
1834                 ctl &= ~PCI_EXP_DEVCTL_READRQ;
1835                 ctl |= v;
1836                 err = pci_write_config_dword(dev, cap + PCI_EXP_DEVCTL, ctl);
1837         }
1838
1839 out:
1840         return err;
1841 }
1842 EXPORT_SYMBOL(pcie_set_readrq);
1843
1844 /**
1845  * pci_select_bars - Make BAR mask from the type of resource
1846  * @dev: the PCI device for which BAR mask is made
1847  * @flags: resource type mask to be selected
1848  *
1849  * This helper routine makes bar mask from the type of resource.
1850  */
1851 int pci_select_bars(struct pci_dev *dev, unsigned long flags)
1852 {
1853         int i, bars = 0;
1854         for (i = 0; i < PCI_NUM_RESOURCES; i++)
1855                 if (pci_resource_flags(dev, i) & flags)
1856                         bars |= (1 << i);
1857         return bars;
1858 }
1859
1860 static void __devinit pci_no_domains(void)
1861 {
1862 #ifdef CONFIG_PCI_DOMAINS
1863         pci_domains_supported = 0;
1864 #endif
1865 }
1866
1867 static int __devinit pci_init(void)
1868 {
1869         struct pci_dev *dev = NULL;
1870
1871         while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
1872                 pci_fixup_device(pci_fixup_final, dev);
1873         }
1874         return 0;
1875 }
1876
1877 static int __devinit pci_setup(char *str)
1878 {
1879         while (str) {
1880                 char *k = strchr(str, ',');
1881                 if (k)
1882                         *k++ = 0;
1883                 if (*str && (str = pcibios_setup(str)) && *str) {
1884                         if (!strcmp(str, "nomsi")) {
1885                                 pci_no_msi();
1886                         } else if (!strcmp(str, "noaer")) {
1887                                 pci_no_aer();
1888                         } else if (!strcmp(str, "nodomains")) {
1889                                 pci_no_domains();
1890                         } else if (!strncmp(str, "cbiosize=", 9)) {
1891                                 pci_cardbus_io_size = memparse(str + 9, &str);
1892                         } else if (!strncmp(str, "cbmemsize=", 10)) {
1893                                 pci_cardbus_mem_size = memparse(str + 10, &str);
1894                         } else {
1895                                 printk(KERN_ERR "PCI: Unknown option `%s'\n",
1896                                                 str);
1897                         }
1898                 }
1899                 str = k;
1900         }
1901         return 0;
1902 }
1903 early_param("pci", pci_setup);
1904
1905 device_initcall(pci_init);
1906
1907 EXPORT_SYMBOL(pci_reenable_device);
1908 EXPORT_SYMBOL(pci_enable_device_io);
1909 EXPORT_SYMBOL(pci_enable_device_mem);
1910 EXPORT_SYMBOL(pci_enable_device);
1911 EXPORT_SYMBOL(pcim_enable_device);
1912 EXPORT_SYMBOL(pcim_pin_device);
1913 EXPORT_SYMBOL(pci_disable_device);
1914 EXPORT_SYMBOL(pci_find_capability);
1915 EXPORT_SYMBOL(pci_bus_find_capability);
1916 EXPORT_SYMBOL(pci_release_regions);
1917 EXPORT_SYMBOL(pci_request_regions);
1918 EXPORT_SYMBOL(pci_release_region);
1919 EXPORT_SYMBOL(pci_request_region);
1920 EXPORT_SYMBOL(pci_release_selected_regions);
1921 EXPORT_SYMBOL(pci_request_selected_regions);
1922 EXPORT_SYMBOL(pci_set_master);
1923 EXPORT_SYMBOL(pci_set_mwi);
1924 EXPORT_SYMBOL(pci_try_set_mwi);
1925 EXPORT_SYMBOL(pci_clear_mwi);
1926 EXPORT_SYMBOL_GPL(pci_intx);
1927 EXPORT_SYMBOL(pci_set_dma_mask);
1928 EXPORT_SYMBOL(pci_set_consistent_dma_mask);
1929 EXPORT_SYMBOL(pci_assign_resource);
1930 EXPORT_SYMBOL(pci_find_parent_resource);
1931 EXPORT_SYMBOL(pci_select_bars);
1932
1933 EXPORT_SYMBOL(pci_set_power_state);
1934 EXPORT_SYMBOL(pci_save_state);
1935 EXPORT_SYMBOL(pci_restore_state);
1936 EXPORT_SYMBOL(pci_enable_wake);
1937 EXPORT_SYMBOL(pci_prepare_to_sleep);
1938 EXPORT_SYMBOL(pci_back_from_sleep);
1939 EXPORT_SYMBOL_GPL(pci_set_pcie_reset_state);
1940