Merge commit 'v3.6-rc5' into next
[linux-3.10.git] / drivers / pci / pci.c
index ab4bf5a..028bbc2 100644 (file)
@@ -254,52 +254,17 @@ int pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap)
 }
 
 /**
- * pci_pcie_cap2 - query for devices' PCI_CAP_ID_EXP v2 capability structure
- * @dev: PCI device to check
- *
- * Like pci_pcie_cap() but also checks that the PCIe capability version is
- * >= 2.  Note that v1 capability structures could be sparse in that not
- * all register fields were required.  v2 requires the entire structure to
- * be present size wise, while still allowing for non-implemented registers
- * to exist but they must be hardwired to 0.
- *
- * Due to the differences in the versions of capability structures, one
- * must be careful not to try and access non-existant registers that may
- * exist in early versions - v1 - of Express devices.
- *
- * Returns the offset of the PCIe capability structure as long as the
- * capability version is >= 2; otherwise 0 is returned.
- */
-static int pci_pcie_cap2(struct pci_dev *dev)
-{
-       u16 flags;
-       int pos;
-
-       pos = pci_pcie_cap(dev);
-       if (pos) {
-               pci_read_config_word(dev, pos + PCI_EXP_FLAGS, &flags);
-               if ((flags & PCI_EXP_FLAGS_VERS) < 2)
-                       pos = 0;
-       }
-
-       return pos;
-}
-
-/**
- * pci_find_ext_capability - Find an extended capability
+ * pci_find_next_ext_capability - Find an extended capability
  * @dev: PCI device to query
+ * @start: address at which to start looking (0 to start at beginning of list)
  * @cap: capability code
  *
- * Returns the address of the requested extended capability structure
+ * Returns the address of the next matching extended capability structure
  * within the device's PCI configuration space or 0 if the device does
- * not support it.  Possible values for @cap:
- *
- *  %PCI_EXT_CAP_ID_ERR                Advanced Error Reporting
- *  %PCI_EXT_CAP_ID_VC         Virtual Channel
- *  %PCI_EXT_CAP_ID_DSN                Device Serial Number
- *  %PCI_EXT_CAP_ID_PWR                Power Budgeting
+ * not support it.  Some capabilities can occur several times, e.g., the
+ * vendor-specific capability, and this provides a way to find them all.
  */
-int pci_find_ext_capability(struct pci_dev *dev, int cap)
+int pci_find_next_ext_capability(struct pci_dev *dev, int start, int cap)
 {
        u32 header;
        int ttl;
@@ -311,6 +276,9 @@ int pci_find_ext_capability(struct pci_dev *dev, int cap)
        if (dev->cfg_size <= PCI_CFG_SPACE_SIZE)
                return 0;
 
+       if (start)
+               pos = start;
+
        if (pci_read_config_dword(dev, pos, &header) != PCIBIOS_SUCCESSFUL)
                return 0;
 
@@ -322,7 +290,7 @@ int pci_find_ext_capability(struct pci_dev *dev, int cap)
                return 0;
 
        while (ttl-- > 0) {
-               if (PCI_EXT_CAP_ID(header) == cap)
+               if (PCI_EXT_CAP_ID(header) == cap && pos != start)
                        return pos;
 
                pos = PCI_EXT_CAP_NEXT(header);
@@ -335,6 +303,26 @@ int pci_find_ext_capability(struct pci_dev *dev, int cap)
 
        return 0;
 }
+EXPORT_SYMBOL_GPL(pci_find_next_ext_capability);
+
+/**
+ * pci_find_ext_capability - Find an extended capability
+ * @dev: PCI device to query
+ * @cap: capability code
+ *
+ * Returns the address of the requested extended capability structure
+ * within the device's PCI configuration space or 0 if the device does
+ * not support it.  Possible values for @cap:
+ *
+ *  %PCI_EXT_CAP_ID_ERR                Advanced Error Reporting
+ *  %PCI_EXT_CAP_ID_VC         Virtual Channel
+ *  %PCI_EXT_CAP_ID_DSN                Device Serial Number
+ *  %PCI_EXT_CAP_ID_PWR                Power Budgeting
+ */
+int pci_find_ext_capability(struct pci_dev *dev, int cap)
+{
+       return pci_find_next_ext_capability(dev, 0, cap);
+}
 EXPORT_SYMBOL_GPL(pci_find_ext_capability);
 
 static int __pci_find_next_ht_cap(struct pci_dev *dev, int pos, int ht_cap)
@@ -854,21 +842,6 @@ EXPORT_SYMBOL(pci_choose_state);
 
 #define PCI_EXP_SAVE_REGS      7
 
-#define pcie_cap_has_devctl(type, flags)       1
-#define pcie_cap_has_lnkctl(type, flags)               \
-               ((flags & PCI_EXP_FLAGS_VERS) > 1 ||    \
-                (type == PCI_EXP_TYPE_ROOT_PORT ||     \
-                 type == PCI_EXP_TYPE_ENDPOINT ||      \
-                 type == PCI_EXP_TYPE_LEG_END))
-#define pcie_cap_has_sltctl(type, flags)               \
-               ((flags & PCI_EXP_FLAGS_VERS) > 1 ||    \
-                ((type == PCI_EXP_TYPE_ROOT_PORT) ||   \
-                 (type == PCI_EXP_TYPE_DOWNSTREAM &&   \
-                  (flags & PCI_EXP_FLAGS_SLOT))))
-#define pcie_cap_has_rtctl(type, flags)                        \
-               ((flags & PCI_EXP_FLAGS_VERS) > 1 ||    \
-                (type == PCI_EXP_TYPE_ROOT_PORT ||     \
-                 type == PCI_EXP_TYPE_RC_EC))
 
 static struct pci_cap_saved_state *pci_find_saved_cap(
        struct pci_dev *pci_dev, char cap)
@@ -885,13 +858,11 @@ static struct pci_cap_saved_state *pci_find_saved_cap(
 
 static int pci_save_pcie_state(struct pci_dev *dev)
 {
-       int pos, i = 0;
+       int i = 0;
        struct pci_cap_saved_state *save_state;
        u16 *cap;
-       u16 flags;
 
-       pos = pci_pcie_cap(dev);
-       if (!pos)
+       if (!pci_is_pcie(dev))
                return 0;
 
        save_state = pci_find_saved_cap(dev, PCI_CAP_ID_EXP);
@@ -899,60 +870,37 @@ static int pci_save_pcie_state(struct pci_dev *dev)
                dev_err(&dev->dev, "buffer not found in %s\n", __func__);
                return -ENOMEM;
        }
-       cap = (u16 *)&save_state->cap.data[0];
-
-       pci_read_config_word(dev, pos + PCI_EXP_FLAGS, &flags);
 
-       if (pcie_cap_has_devctl(dev->pcie_type, flags))
-               pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &cap[i++]);
-       if (pcie_cap_has_lnkctl(dev->pcie_type, flags))
-               pci_read_config_word(dev, pos + PCI_EXP_LNKCTL, &cap[i++]);
-       if (pcie_cap_has_sltctl(dev->pcie_type, flags))
-               pci_read_config_word(dev, pos + PCI_EXP_SLTCTL, &cap[i++]);
-       if (pcie_cap_has_rtctl(dev->pcie_type, flags))
-               pci_read_config_word(dev, pos + PCI_EXP_RTCTL, &cap[i++]);
-
-       pos = pci_pcie_cap2(dev);
-       if (!pos)
-               return 0;
+       cap = (u16 *)&save_state->cap.data[0];
+       pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &cap[i++]);
+       pcie_capability_read_word(dev, PCI_EXP_LNKCTL, &cap[i++]);
+       pcie_capability_read_word(dev, PCI_EXP_SLTCTL, &cap[i++]);
+       pcie_capability_read_word(dev, PCI_EXP_RTCTL,  &cap[i++]);
+       pcie_capability_read_word(dev, PCI_EXP_DEVCTL2, &cap[i++]);
+       pcie_capability_read_word(dev, PCI_EXP_LNKCTL2, &cap[i++]);
+       pcie_capability_read_word(dev, PCI_EXP_SLTCTL2, &cap[i++]);
 
-       pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &cap[i++]);
-       pci_read_config_word(dev, pos + PCI_EXP_LNKCTL2, &cap[i++]);
-       pci_read_config_word(dev, pos + PCI_EXP_SLTCTL2, &cap[i++]);
        return 0;
 }
 
 static void pci_restore_pcie_state(struct pci_dev *dev)
 {
-       int i = 0, pos;
+       int i = 0;
        struct pci_cap_saved_state *save_state;
        u16 *cap;
-       u16 flags;
 
        save_state = pci_find_saved_cap(dev, PCI_CAP_ID_EXP);
-       pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
-       if (!save_state || pos <= 0)
-               return;
-       cap = (u16 *)&save_state->cap.data[0];
-
-       pci_read_config_word(dev, pos + PCI_EXP_FLAGS, &flags);
-
-       if (pcie_cap_has_devctl(dev->pcie_type, flags))
-               pci_write_config_word(dev, pos + PCI_EXP_DEVCTL, cap[i++]);
-       if (pcie_cap_has_lnkctl(dev->pcie_type, flags))
-               pci_write_config_word(dev, pos + PCI_EXP_LNKCTL, cap[i++]);
-       if (pcie_cap_has_sltctl(dev->pcie_type, flags))
-               pci_write_config_word(dev, pos + PCI_EXP_SLTCTL, cap[i++]);
-       if (pcie_cap_has_rtctl(dev->pcie_type, flags))
-               pci_write_config_word(dev, pos + PCI_EXP_RTCTL, cap[i++]);
-
-       pos = pci_pcie_cap2(dev);
-       if (!pos)
+       if (!save_state)
                return;
 
-       pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, cap[i++]);
-       pci_write_config_word(dev, pos + PCI_EXP_LNKCTL2, cap[i++]);
-       pci_write_config_word(dev, pos + PCI_EXP_SLTCTL2, cap[i++]);
+       cap = (u16 *)&save_state->cap.data[0];
+       pcie_capability_write_word(dev, PCI_EXP_DEVCTL, cap[i++]);
+       pcie_capability_write_word(dev, PCI_EXP_LNKCTL, cap[i++]);
+       pcie_capability_write_word(dev, PCI_EXP_SLTCTL, cap[i++]);
+       pcie_capability_write_word(dev, PCI_EXP_RTCTL, cap[i++]);
+       pcie_capability_write_word(dev, PCI_EXP_DEVCTL2, cap[i++]);
+       pcie_capability_write_word(dev, PCI_EXP_LNKCTL2, cap[i++]);
+       pcie_capability_write_word(dev, PCI_EXP_SLTCTL2, cap[i++]);
 }
 
 
@@ -2067,35 +2015,24 @@ void pci_free_cap_save_buffers(struct pci_dev *dev)
  */
 void pci_enable_ari(struct pci_dev *dev)
 {
-       int pos;
        u32 cap;
-       u16 ctrl;
        struct pci_dev *bridge;
 
        if (pcie_ari_disabled || !pci_is_pcie(dev) || dev->devfn)
                return;
 
-       pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI);
-       if (!pos)
+       if (!pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI))
                return;
 
        bridge = dev->bus->self;
        if (!bridge)
                return;
 
-       /* ARI is a PCIe cap v2 feature */
-       pos = pci_pcie_cap2(bridge);
-       if (!pos)
-               return;
-
-       pci_read_config_dword(bridge, pos + PCI_EXP_DEVCAP2, &cap);
+       pcie_capability_read_dword(bridge, PCI_EXP_DEVCAP2, &cap);
        if (!(cap & PCI_EXP_DEVCAP2_ARI))
                return;
 
-       pci_read_config_word(bridge, pos + PCI_EXP_DEVCTL2, &ctrl);
-       ctrl |= PCI_EXP_DEVCTL2_ARI;
-       pci_write_config_word(bridge, pos + PCI_EXP_DEVCTL2, ctrl);
-
+       pcie_capability_set_word(bridge, PCI_EXP_DEVCTL2, PCI_EXP_DEVCTL2_ARI);
        bridge->ari_enabled = 1;
 }
 
@@ -2110,20 +2047,14 @@ void pci_enable_ari(struct pci_dev *dev)
  */
 void pci_enable_ido(struct pci_dev *dev, unsigned long type)
 {
-       int pos;
-       u16 ctrl;
+       u16 ctrl = 0;
 
-       /* ID-based Ordering is a PCIe cap v2 feature */
-       pos = pci_pcie_cap2(dev);
-       if (!pos)
-               return;
-
-       pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &ctrl);
        if (type & PCI_EXP_IDO_REQUEST)
                ctrl |= PCI_EXP_IDO_REQ_EN;
        if (type & PCI_EXP_IDO_COMPLETION)
                ctrl |= PCI_EXP_IDO_CMP_EN;
-       pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, ctrl);
+       if (ctrl)
+               pcie_capability_set_word(dev, PCI_EXP_DEVCTL2, ctrl);
 }
 EXPORT_SYMBOL(pci_enable_ido);
 
@@ -2134,20 +2065,14 @@ EXPORT_SYMBOL(pci_enable_ido);
  */
 void pci_disable_ido(struct pci_dev *dev, unsigned long type)
 {
-       int pos;
-       u16 ctrl;
+       u16 ctrl = 0;
 
-       /* ID-based Ordering is a PCIe cap v2 feature */
-       pos = pci_pcie_cap2(dev);
-       if (!pos)
-               return;
-
-       pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &ctrl);
        if (type & PCI_EXP_IDO_REQUEST)
-               ctrl &= ~PCI_EXP_IDO_REQ_EN;
+               ctrl |= PCI_EXP_IDO_REQ_EN;
        if (type & PCI_EXP_IDO_COMPLETION)
-               ctrl &= ~PCI_EXP_IDO_CMP_EN;
-       pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, ctrl);
+               ctrl |= PCI_EXP_IDO_CMP_EN;
+       if (ctrl)
+               pcie_capability_clear_word(dev, PCI_EXP_DEVCTL2, ctrl);
 }
 EXPORT_SYMBOL(pci_disable_ido);
 
@@ -2172,17 +2097,11 @@ EXPORT_SYMBOL(pci_disable_ido);
  */
 int pci_enable_obff(struct pci_dev *dev, enum pci_obff_signal_type type)
 {
-       int pos;
        u32 cap;
        u16 ctrl;
        int ret;
 
-       /* OBFF is a PCIe cap v2 feature */
-       pos = pci_pcie_cap2(dev);
-       if (!pos)
-               return -ENOTSUPP;
-
-       pci_read_config_dword(dev, pos + PCI_EXP_DEVCAP2, &cap);
+       pcie_capability_read_dword(dev, PCI_EXP_DEVCAP2, &cap);
        if (!(cap & PCI_EXP_OBFF_MASK))
                return -ENOTSUPP; /* no OBFF support at all */
 
@@ -2193,7 +2112,7 @@ int pci_enable_obff(struct pci_dev *dev, enum pci_obff_signal_type type)
                        return ret;
        }
 
-       pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &ctrl);
+       pcie_capability_read_word(dev, PCI_EXP_DEVCTL2, &ctrl);
        if (cap & PCI_EXP_OBFF_WAKE)
                ctrl |= PCI_EXP_OBFF_WAKE_EN;
        else {
@@ -2211,7 +2130,7 @@ int pci_enable_obff(struct pci_dev *dev, enum pci_obff_signal_type type)
                        return -ENOTSUPP;
                }
        }
-       pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, ctrl);
+       pcie_capability_write_word(dev, PCI_EXP_DEVCTL2, ctrl);
 
        return 0;
 }
@@ -2225,17 +2144,7 @@ EXPORT_SYMBOL(pci_enable_obff);
  */
 void pci_disable_obff(struct pci_dev *dev)
 {
-       int pos;
-       u16 ctrl;
-
-       /* OBFF is a PCIe cap v2 feature */
-       pos = pci_pcie_cap2(dev);
-       if (!pos)
-               return;
-
-       pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &ctrl);
-       ctrl &= ~PCI_EXP_OBFF_WAKE_EN;
-       pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, ctrl);
+       pcie_capability_clear_word(dev, PCI_EXP_DEVCTL2, PCI_EXP_OBFF_WAKE_EN);
 }
 EXPORT_SYMBOL(pci_disable_obff);
 
@@ -2248,15 +2157,9 @@ EXPORT_SYMBOL(pci_disable_obff);
  */
 static bool pci_ltr_supported(struct pci_dev *dev)
 {
-       int pos;
        u32 cap;
 
-       /* LTR is a PCIe cap v2 feature */
-       pos = pci_pcie_cap2(dev);
-       if (!pos)
-               return false;
-
-       pci_read_config_dword(dev, pos + PCI_EXP_DEVCAP2, &cap);
+       pcie_capability_read_dword(dev, PCI_EXP_DEVCAP2, &cap);
 
        return cap & PCI_EXP_DEVCAP2_LTR;
 }
@@ -2273,22 +2176,15 @@ static bool pci_ltr_supported(struct pci_dev *dev)
  */
 int pci_enable_ltr(struct pci_dev *dev)
 {
-       int pos;
-       u16 ctrl;
        int ret;
 
-       if (!pci_ltr_supported(dev))
-               return -ENOTSUPP;
-
-       /* LTR is a PCIe cap v2 feature */
-       pos = pci_pcie_cap2(dev);
-       if (!pos)
-               return -ENOTSUPP;
-
        /* Only primary function can enable/disable LTR */
        if (PCI_FUNC(dev->devfn) != 0)
                return -EINVAL;
 
+       if (!pci_ltr_supported(dev))
+               return -ENOTSUPP;
+
        /* Enable upstream ports first */
        if (dev->bus->self) {
                ret = pci_enable_ltr(dev->bus->self);
@@ -2296,11 +2192,7 @@ int pci_enable_ltr(struct pci_dev *dev)
                        return ret;
        }
 
-       pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &ctrl);
-       ctrl |= PCI_EXP_LTR_EN;
-       pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, ctrl);
-
-       return 0;
+       return pcie_capability_set_word(dev, PCI_EXP_DEVCTL2, PCI_EXP_LTR_EN);
 }
 EXPORT_SYMBOL(pci_enable_ltr);
 
@@ -2310,24 +2202,14 @@ EXPORT_SYMBOL(pci_enable_ltr);
  */
 void pci_disable_ltr(struct pci_dev *dev)
 {
-       int pos;
-       u16 ctrl;
-
-       if (!pci_ltr_supported(dev))
-               return;
-
-       /* LTR is a PCIe cap v2 feature */
-       pos = pci_pcie_cap2(dev);
-       if (!pos)
-               return;
-
        /* Only primary function can enable/disable LTR */
        if (PCI_FUNC(dev->devfn) != 0)
                return;
 
-       pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &ctrl);
-       ctrl &= ~PCI_EXP_LTR_EN;
-       pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, ctrl);
+       if (!pci_ltr_supported(dev))
+               return;
+
+       pcie_capability_clear_word(dev, PCI_EXP_DEVCTL2, PCI_EXP_LTR_EN);
 }
 EXPORT_SYMBOL(pci_disable_ltr);
 
@@ -2410,9 +2292,6 @@ void pci_enable_acs(struct pci_dev *dev)
        if (!pci_acs_enable)
                return;
 
-       if (!pci_is_pcie(dev))
-               return;
-
        pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ACS);
        if (!pos)
                return;
@@ -2460,8 +2339,8 @@ bool pci_acs_enabled(struct pci_dev *pdev, u16 acs_flags)
                acs_flags &= (PCI_ACS_RR | PCI_ACS_CR |
                              PCI_ACS_EC | PCI_ACS_DT);
 
-       if (pdev->pcie_type == PCI_EXP_TYPE_DOWNSTREAM ||
-           pdev->pcie_type == PCI_EXP_TYPE_ROOT_PORT ||
+       if (pci_pcie_type(pdev) == PCI_EXP_TYPE_DOWNSTREAM ||
+           pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT ||
            pdev->multifunction) {
                pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ACS);
                if (!pos)
@@ -3177,15 +3056,10 @@ EXPORT_SYMBOL(pci_set_dma_seg_boundary);
 static int pcie_flr(struct pci_dev *dev, int probe)
 {
        int i;
-       int pos;
        u32 cap;
-       u16 status, control;
-
-       pos = pci_pcie_cap(dev);
-       if (!pos)
-               return -ENOTTY;
+       u16 status;
 
-       pci_read_config_dword(dev, pos + PCI_EXP_DEVCAP, &cap);
+       pcie_capability_read_dword(dev, PCI_EXP_DEVCAP, &cap);
        if (!(cap & PCI_EXP_DEVCAP_FLR))
                return -ENOTTY;
 
@@ -3197,7 +3071,7 @@ static int pcie_flr(struct pci_dev *dev, int probe)
                if (i)
                        msleep((1 << (i - 1)) * 100);
 
-               pci_read_config_word(dev, pos + PCI_EXP_DEVSTA, &status);
+               pcie_capability_read_word(dev, PCI_EXP_DEVSTA, &status);
                if (!(status & PCI_EXP_DEVSTA_TRPND))
                        goto clear;
        }
@@ -3206,9 +3080,7 @@ static int pcie_flr(struct pci_dev *dev, int probe)
                        "proceeding with reset anyway\n");
 
 clear:
-       pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &control);
-       control |= PCI_EXP_DEVCTL_BCR_FLR;
-       pci_write_config_word(dev, pos + PCI_EXP_DEVCTL, control);
+       pcie_capability_set_word(dev, PCI_EXP_DEVCTL, PCI_EXP_DEVCTL_BCR_FLR);
 
        msleep(100);
 
@@ -3576,18 +3448,11 @@ EXPORT_SYMBOL(pcix_set_mmrbc);
  */
 int pcie_get_readrq(struct pci_dev *dev)
 {
-       int ret, cap;
        u16 ctl;
 
-       cap = pci_pcie_cap(dev);
-       if (!cap)
-               return -EINVAL;
-
-       ret = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
-       if (!ret)
-               ret = 128 << ((ctl & PCI_EXP_DEVCTL_READRQ) >> 12);
+       pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &ctl);
 
-       return ret;
+       return 128 << ((ctl & PCI_EXP_DEVCTL_READRQ) >> 12);
 }
 EXPORT_SYMBOL(pcie_get_readrq);
 
@@ -3601,19 +3466,11 @@ EXPORT_SYMBOL(pcie_get_readrq);
  */
 int pcie_set_readrq(struct pci_dev *dev, int rq)
 {
-       int cap, err = -EINVAL;
-       u16 ctl, v;
+       u16 v;
 
        if (rq < 128 || rq > 4096 || !is_power_of_2(rq))
-               goto out;
-
-       cap = pci_pcie_cap(dev);
-       if (!cap)
-               goto out;
+               return -EINVAL;
 
-       err = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
-       if (err)
-               goto out;
        /*
         * If using the "performance" PCIe config, we clamp the
         * read rq size to the max packet size to prevent the
@@ -3631,14 +3488,8 @@ int pcie_set_readrq(struct pci_dev *dev, int rq)
 
        v = (ffs(rq) - 8) << 12;
 
-       if ((ctl & PCI_EXP_DEVCTL_READRQ) != v) {
-               ctl &= ~PCI_EXP_DEVCTL_READRQ;
-               ctl |= v;
-               err = pci_write_config_word(dev, cap + PCI_EXP_DEVCTL, ctl);
-       }
-
-out:
-       return err;
+       return pcie_capability_clear_and_set_word(dev, PCI_EXP_DEVCTL,
+                                                 PCI_EXP_DEVCTL_READRQ, v);
 }
 EXPORT_SYMBOL(pcie_set_readrq);
 
@@ -3651,18 +3502,11 @@ EXPORT_SYMBOL(pcie_set_readrq);
  */
 int pcie_get_mps(struct pci_dev *dev)
 {
-       int ret, cap;
        u16 ctl;
 
-       cap = pci_pcie_cap(dev);
-       if (!cap)
-               return -EINVAL;
-
-       ret = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
-       if (!ret)
-               ret = 128 << ((ctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5);
+       pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &ctl);
 
-       return ret;
+       return 128 << ((ctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5);
 }
 
 /**
@@ -3675,32 +3519,18 @@ int pcie_get_mps(struct pci_dev *dev)
  */
 int pcie_set_mps(struct pci_dev *dev, int mps)
 {
-       int cap, err = -EINVAL;
-       u16 ctl, v;
+       u16 v;
 
        if (mps < 128 || mps > 4096 || !is_power_of_2(mps))
-               goto out;
+               return -EINVAL;
 
        v = ffs(mps) - 8;
        if (v > dev->pcie_mpss) 
-               goto out;
+               return -EINVAL;
        v <<= 5;
 
-       cap = pci_pcie_cap(dev);
-       if (!cap)
-               goto out;
-
-       err = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
-       if (err)
-               goto out;
-
-       if ((ctl & PCI_EXP_DEVCTL_PAYLOAD) != v) {
-               ctl &= ~PCI_EXP_DEVCTL_PAYLOAD;
-               ctl |= v;
-               err = pci_write_config_word(dev, cap + PCI_EXP_DEVCTL, ctl);
-       }
-out:
-       return err;
+       return pcie_capability_clear_and_set_word(dev, PCI_EXP_DEVCTL,
+                                                 PCI_EXP_DEVCTL_PAYLOAD, v);
 }
 
 /**