58 files changed, 1809 insertions, 1016 deletions

diff --git a/Documentation/ABI/testing/sysfs-bus-pci b/Documentation/ABI/testing/sysfs-bus-pci
index 5210a51c90fd..a3c5a6685036 100644
--- a/Documentation/ABI/testing/sysfs-bus-pci
+++ b/Documentation/ABI/testing/sysfs-bus-pci
@@ -70,18 +70,15 @@ Date:		September, 2011
 Contact:        Neil Horman <nhorman@tuxdriver.com>
 Description:
                 The /sys/devices/.../msi_irqs directory contains a variable set
-                of sub-directories, with each sub-directory being named after a
-                corresponding msi irq vector allocated to that device.  Each
-                numbered sub-directory N contains attributes of that irq.
-                Note that this directory is not created for device drivers which
-                do not support msi irqs
+                of files, with each file being named after a corresponding msi
+                irq vector allocated to that device.
 
-What:           /sys/bus/pci/devices/.../msi_irqs/<N>/mode
+What:           /sys/bus/pci/devices/.../msi_irqs/<N>
 Date:           September 2011
 Contact:        Neil Horman <nhorman@tuxdriver.com>
 Description:
                 This attribute indicates the mode that the irq vector named by
-                the parent directory is in (msi vs. msix)
+                the file is in (msi vs. msix)
 
 What:           /sys/bus/pci/devices/.../remove
 Date:           January 2009
diff --git a/Documentation/PCI/00-INDEX b/Documentation/PCI/00-INDEX
index 812b17fe3ed0..147231f1613e 100644
--- a/Documentation/PCI/00-INDEX
+++ b/Documentation/PCI/00-INDEX
@@ -2,12 +2,12 @@
         - this file
 MSI-HOWTO.txt
         - the Message Signaled Interrupts (MSI) Driver Guide HOWTO and FAQ.
-PCI-DMA-mapping.txt
-        - info for PCI drivers using DMA portably across all platforms
 PCIEBUS-HOWTO.txt
         - a guide describing the PCI Express Port Bus driver
 pci-error-recovery.txt
         - info on PCI error recovery
+pci-iov-howto.txt
+        - the PCI Express I/O Virtualization HOWTO
 pci.txt
         - info on the PCI subsystem for device driver authors
 pcieaer-howto.txt
diff --git a/Documentation/PCI/MSI-HOWTO.txt b/Documentation/PCI/MSI-HOWTO.txt
index a09178086c30..a8d01005f480 100644
--- a/Documentation/PCI/MSI-HOWTO.txt
+++ b/Documentation/PCI/MSI-HOWTO.txt
@@ -82,93 +82,111 @@ Most of the hard work is done for the driver in the PCI layer.  It simply
 has to request that the PCI layer set up the MSI capability for this
 device.
 
-4.2.1 pci_enable_msi
+4.2.1 pci_enable_msi_range
 
-int pci_enable_msi(struct pci_dev *dev)
+int pci_enable_msi_range(struct pci_dev *dev, int minvec, int maxvec)
 
-A successful call allocates ONE interrupt to the device, regardless
-of how many MSIs the device supports.  The device is switched from
-pin-based interrupt mode to MSI mode.  The dev->irq number is changed
-to a new number which represents the message signaled interrupt;
-consequently, this function should be called before the driver calls
-request_irq(), because an MSI is delivered via a vector that is
-different from the vector of a pin-based interrupt.
+This function allows a device driver to request any number of MSI
+interrupts within specified range from 'minvec' to 'maxvec'.
 
-4.2.2 pci_enable_msi_block
+If this function returns a positive number it indicates the number of
+MSI interrupts that have been successfully allocated.  In this case
+the device is switched from pin-based interrupt mode to MSI mode and
+updates dev->irq to be the lowest of the new interrupts assigned to it.
+The other interrupts assigned to the device are in the range dev->irq
+to dev->irq + returned value - 1.  Device driver can use the returned
+number of successfully allocated MSI interrupts to further allocate
+and initialize device resources.
 
-int pci_enable_msi_block(struct pci_dev *dev, int count)
+If this function returns a negative number, it indicates an error and
+the driver should not attempt to request any more MSI interrupts for
+this device.
 
-This variation on the above call allows a device driver to request multiple
-MSIs.  The MSI specification only allows interrupts to be allocated in
-powers of two, up to a maximum of 2^5 (32).
+This function should be called before the driver calls request_irq(),
+because MSI interrupts are delivered via vectors that are different
+from the vector of a pin-based interrupt.
 
-If this function returns 0, it has succeeded in allocating at least as many
-interrupts as the driver requested (it may have allocated more in order
-to satisfy the power-of-two requirement).  In this case, the function
-enables MSI on this device and updates dev->irq to be the lowest of
-the new interrupts assigned to it.  The other interrupts assigned to
-the device are in the range dev->irq to dev->irq + count - 1.
+It is ideal if drivers can cope with a variable number of MSI interrupts;
+there are many reasons why the platform may not be able to provide the
+exact number that a driver asks for.
 
-If this function returns a negative number, it indicates an error and
-the driver should not attempt to request any more MSI interrupts for
-this device.  If this function returns a positive number, it is
-less than 'count' and indicates the number of interrupts that could have
-been allocated.  In neither case is the irq value updated or the device
-switched into MSI mode.
-
-The device driver must decide what action to take if
-pci_enable_msi_block() returns a value less than the number requested.
-For instance, the driver could still make use of fewer interrupts;
-in this case the driver should call pci_enable_msi_block()
-again.  Note that it is not guaranteed to succeed, even when the
-'count' has been reduced to the value returned from a previous call to
-pci_enable_msi_block().  This is because there are multiple constraints
-on the number of vectors that can be allocated; pci_enable_msi_block()
-returns as soon as it finds any constraint that doesn't allow the
-call to succeed.
-
-4.2.3 pci_enable_msi_block_auto
-
-int pci_enable_msi_block_auto(struct pci_dev *dev, unsigned int *count)
-
-This variation on pci_enable_msi() call allows a device driver to request
-the maximum possible number of MSIs.  The MSI specification only allows
-interrupts to be allocated in powers of two, up to a maximum of 2^5 (32).
-
-If this function returns a positive number, it indicates that it has
-succeeded and the returned value is the number of allocated interrupts. In
-this case, the function enables MSI on this device and updates dev->irq to
-be the lowest of the new interrupts assigned to it.  The other interrupts
-assigned to the device are in the range dev->irq to dev->irq + returned
-value - 1.
+There could be devices that can not operate with just any number of MSI
+interrupts within a range.  See chapter 4.3.1.3 to get the idea how to
+handle such devices for MSI-X - the same logic applies to MSI.
 
-If this function returns a negative number, it indicates an error and
-the driver should not attempt to request any more MSI interrupts for
-this device.
+4.2.1.1 Maximum possible number of MSI interrupts
+
+The typical usage of MSI interrupts is to allocate as many vectors as
+possible, likely up to the limit returned by pci_msi_vec_count() function:
+
+static int foo_driver_enable_msi(struct pci_dev *pdev, int nvec)
+{
+        return pci_enable_msi_range(pdev, 1, nvec);
+}
+
+Note the value of 'minvec' parameter is 1.  As 'minvec' is inclusive,
+the value of 0 would be meaningless and could result in error.
 
-If the device driver needs to know the number of interrupts the device
-supports it can pass the pointer count where that number is stored. The
-device driver must decide what action to take if pci_enable_msi_block_auto()
-succeeds, but returns a value less than the number of interrupts supported.
-If the device driver does not need to know the number of interrupts
-supported, it can set the pointer count to NULL.
+Some devices have a minimal limit on number of MSI interrupts.
+In this case the function could look like this:
 
-4.2.4 pci_disable_msi
+static int foo_driver_enable_msi(struct pci_dev *pdev, int nvec)
+{
+        return pci_enable_msi_range(pdev, FOO_DRIVER_MINIMUM_NVEC, nvec);
+}
+
+4.2.1.2 Exact number of MSI interrupts
+
+If a driver is unable or unwilling to deal with a variable number of MSI
+interrupts it could request a particular number of interrupts by passing
+that number to pci_enable_msi_range() function as both 'minvec' and 'maxvec'
+parameters:
+
+static int foo_driver_enable_msi(struct pci_dev *pdev, int nvec)
+{
+        return pci_enable_msi_range(pdev, nvec, nvec);
+}
+
+4.2.1.3 Single MSI mode
+
+The most notorious example of the request type described above is
+enabling the single MSI mode for a device.  It could be done by passing
+two 1s as 'minvec' and 'maxvec':
+
+static int foo_driver_enable_single_msi(struct pci_dev *pdev)
+{
+        return pci_enable_msi_range(pdev, 1, 1);
+}
+
+4.2.2 pci_disable_msi
 
 void pci_disable_msi(struct pci_dev *dev)
 
-This function should be used to undo the effect of pci_enable_msi() or
-pci_enable_msi_block() or pci_enable_msi_block_auto().  Calling it restores
-dev->irq to the pin-based interrupt number and frees the previously
-allocated message signaled interrupt(s).  The interrupt may subsequently be
-assigned to another device, so drivers should not cache the value of
-dev->irq.
+This function should be used to undo the effect of pci_enable_msi_range().
+Calling it restores dev->irq to the pin-based interrupt number and frees
+the previously allocated MSIs.  The interrupts may subsequently be assigned
+to another device, so drivers should not cache the value of dev->irq.
 
 Before calling this function, a device driver must always call free_irq()
 on any interrupt for which it previously called request_irq().
 Failure to do so results in a BUG_ON(), leaving the device with
 MSI enabled and thus leaking its vector.
 
+4.2.3 pci_msi_vec_count
+
+int pci_msi_vec_count(struct pci_dev *dev)
+
+This function could be used to retrieve the number of MSI vectors the
+device requested (via the Multiple Message Capable register). The MSI
+specification only allows the returned value to be a power of two,
+up to a maximum of 2^5 (32).
+
+If this function returns a negative number, it indicates the device is
+not capable of sending MSIs.
+
+If this function returns a positive number, it indicates the maximum
+number of MSI interrupt vectors that could be allocated.
+
 4.3 Using MSI-X
 
 The MSI-X capability is much more flexible than the MSI capability.
@@ -188,26 +206,31 @@ in each element of the array to indicate for which entries the kernel
 should assign interrupts; it is invalid to fill in two entries with the
 same number.
 
-4.3.1 pci_enable_msix
+4.3.1 pci_enable_msix_range
 
-int pci_enable_msix(struct pci_dev *dev, struct msix_entry *entries, int nvec)
+int pci_enable_msix_range(struct pci_dev *dev, struct msix_entry *entries,
+                          int minvec, int maxvec)
 
-Calling this function asks the PCI subsystem to allocate 'nvec' MSIs.
+Calling this function asks the PCI subsystem to allocate any number of
+MSI-X interrupts within specified range from 'minvec' to 'maxvec'.
 The 'entries' argument is a pointer to an array of msix_entry structs
-which should be at least 'nvec' entries in size.  On success, the
-device is switched into MSI-X mode and the function returns 0.
-The 'vector' member in each entry is populated with the interrupt number;
+which should be at least 'maxvec' entries in size.
+
+On success, the device is switched into MSI-X mode and the function
+returns the number of MSI-X interrupts that have been successfully
+allocated.  In this case the 'vector' member in entries numbered from
+0 to the returned value - 1 is populated with the interrupt number;
 the driver should then call request_irq() for each 'vector' that it
 decides to use.  The device driver is responsible for keeping track of the
 interrupts assigned to the MSI-X vectors so it can free them again later.
+Device driver can use the returned number of successfully allocated MSI-X
+interrupts to further allocate and initialize device resources.
 
 If this function returns a negative number, it indicates an error and
 the driver should not attempt to allocate any more MSI-X interrupts for
-this device.  If it returns a positive number, it indicates the maximum
-number of interrupt vectors that could have been allocated. See example
-below.
+this device.
 
-This function, in contrast with pci_enable_msi(), does not adjust
+This function, in contrast with pci_enable_msi_range(), does not adjust
 dev->irq.  The device will not generate interrupts for this interrupt
 number once MSI-X is enabled.
 
@@ -218,28 +241,103 @@ It is ideal if drivers can cope with a variable number of MSI-X interrupts;
 there are many reasons why the platform may not be able to provide the
 exact number that a driver asks for.
 
-A request loop to achieve that might look like:
+There could be devices that can not operate with just any number of MSI-X
+interrupts within a range.  E.g., an network adapter might need let's say
+four vectors per each queue it provides.  Therefore, a number of MSI-X
+interrupts allocated should be a multiple of four.  In this case interface
+pci_enable_msix_range() can not be used alone to request MSI-X interrupts
+(since it can allocate any number within the range, without any notion of
+the multiple of four) and the device driver should master a custom logic
+to request the required number of MSI-X interrupts.
+
+4.3.1.1 Maximum possible number of MSI-X interrupts
+
+The typical usage of MSI-X interrupts is to allocate as many vectors as
+possible, likely up to the limit returned by pci_msix_vec_count() function:
 
 static int foo_driver_enable_msix(struct foo_adapter *adapter, int nvec)
 {
-        while (nvec >= FOO_DRIVER_MINIMUM_NVEC) {
-                rc = pci_enable_msix(adapter->pdev,
-                                     adapter->msix_entries, nvec);
-                if (rc > 0)
-                        nvec = rc;
-                else
-                        return rc;
+        return pci_enable_msi_range(adapter->pdev, adapter->msix_entries,
+                                    1, nvec);
+}
+
+Note the value of 'minvec' parameter is 1.  As 'minvec' is inclusive,
+the value of 0 would be meaningless and could result in error.
+
+Some devices have a minimal limit on number of MSI-X interrupts.
+In this case the function could look like this:
+
+static int foo_driver_enable_msix(struct foo_adapter *adapter, int nvec)
+{
+        return pci_enable_msi_range(adapter->pdev, adapter->msix_entries,
+                                    FOO_DRIVER_MINIMUM_NVEC, nvec);
+}
+
+4.3.1.2 Exact number of MSI-X interrupts
+
+If a driver is unable or unwilling to deal with a variable number of MSI-X
+interrupts it could request a particular number of interrupts by passing
+that number to pci_enable_msix_range() function as both 'minvec' and 'maxvec'
+parameters:
+
+static int foo_driver_enable_msix(struct foo_adapter *adapter, int nvec)
+{
+        return pci_enable_msi_range(adapter->pdev, adapter->msix_entries,
+                                    nvec, nvec);
+}
+
+4.3.1.3 Specific requirements to the number of MSI-X interrupts
+
+As noted above, there could be devices that can not operate with just any
+number of MSI-X interrupts within a range.  E.g., let's assume a device that
+is only capable sending the number of MSI-X interrupts which is a power of
+two.  A routine that enables MSI-X mode for such device might look like this:
+
+/*
+ * Assume 'minvec' and 'maxvec' are non-zero
+ */
+static int foo_driver_enable_msix(struct foo_adapter *adapter,
+                                  int minvec, int maxvec)
+{
+        int rc;
+
+        minvec = roundup_pow_of_two(minvec);
+        maxvec = rounddown_pow_of_two(maxvec);
+
+        if (minvec > maxvec)
+                return -ERANGE;
+
+retry:
+        rc = pci_enable_msix_range(adapter->pdev, adapter->msix_entries,
+                                   maxvec, maxvec);
+        /*
+         * -ENOSPC is the only error code allowed to be analized
+         */
+        if (rc == -ENOSPC) {
+                if (maxvec == 1)
+                        return -ENOSPC;
+
+                maxvec /= 2;
+
+                if (minvec > maxvec)
+                        return -ENOSPC;
+
+                goto retry;
         }
 
-        return -ENOSPC;
+        return rc;
 }
 
+Note how pci_enable_msix_range() return value is analized for a fallback -
+any error code other than -ENOSPC indicates a fatal error and should not
+be retried.
+
 4.3.2 pci_disable_msix
 
 void pci_disable_msix(struct pci_dev *dev)
 
-This function should be used to undo the effect of pci_enable_msix().  It frees
-the previously allocated message signaled interrupts.  The interrupts may
+This function should be used to undo the effect of pci_enable_msix_range().
+It frees the previously allocated MSI-X interrupts. The interrupts may
 subsequently be assigned to another device, so drivers should not cache
 the value of the 'vector' elements over a call to pci_disable_msix().
 
@@ -255,18 +353,32 @@ MSI-X Table.  This address is mapped by the PCI subsystem, and should not
 be accessed directly by the device driver.  If the driver wishes to
 mask or unmask an interrupt, it should call disable_irq() / enable_irq().
 
+4.3.4 pci_msix_vec_count
+
+int pci_msix_vec_count(struct pci_dev *dev)
+
+This function could be used to retrieve number of entries in the device
+MSI-X table.
+
+If this function returns a negative number, it indicates the device is
+not capable of sending MSI-Xs.
+
+If this function returns a positive number, it indicates the maximum
+number of MSI-X interrupt vectors that could be allocated.
+
 4.4 Handling devices implementing both MSI and MSI-X capabilities
 
 If a device implements both MSI and MSI-X capabilities, it can
 run in either MSI mode or MSI-X mode, but not both simultaneously.
 This is a requirement of the PCI spec, and it is enforced by the
-PCI layer.  Calling pci_enable_msi() when MSI-X is already enabled or
-pci_enable_msix() when MSI is already enabled results in an error.
-If a device driver wishes to switch between MSI and MSI-X at runtime,
-it must first quiesce the device, then switch it back to pin-interrupt
-mode, before calling pci_enable_msi() or pci_enable_msix() and resuming
-operation.  This is not expected to be a common operation but may be
-useful for debugging or testing during development.
+PCI layer.  Calling pci_enable_msi_range() when MSI-X is already
+enabled or pci_enable_msix_range() when MSI is already enabled
+results in an error.  If a device driver wishes to switch between MSI
+and MSI-X at runtime, it must first quiesce the device, then switch
+it back to pin-interrupt mode, before calling pci_enable_msi_range()
+or pci_enable_msix_range() and resuming operation.  This is not expected
+to be a common operation but may be useful for debugging or testing
+during development.
 
 4.5 Considerations when using MSIs
 
@@ -381,5 +493,5 @@ or disabled (0).  If 0 is found in any of the msi_bus files belonging
 to bridges between the PCI root and the device, MSIs are disabled.
 
 It is also worth checking the device driver to see whether it supports MSIs.
-For example, it may contain calls to pci_enable_msi(), pci_enable_msix() or
-pci_enable_msi_block().
+For example, it may contain calls to pci_enable_msi_range() or
+pci_enable_msix_range().
diff --git a/Documentation/PCI/pci.txt b/Documentation/PCI/pci.txt
index 6f458564d625..9518006f6675 100644
--- a/Documentation/PCI/pci.txt
+++ b/Documentation/PCI/pci.txt
@@ -123,8 +123,10 @@ initialization with a pointer to a structure describing the driver
 
 
 The ID table is an array of struct pci_device_id entries ending with an
-all-zero entry; use of the macro DEFINE_PCI_DEVICE_TABLE is the preferred
-method of declaring the table.  Each entry consists of:
+all-zero entry.  Definitions with static const are generally preferred.
+Use of the deprecated macro DEFINE_PCI_DEVICE_TABLE should be avoided.
+
+Each entry consists of:
 
         vendor,device   Vendor and device ID to match (or PCI_ANY_ID)
 
diff --git a/Documentation/devicetree/bindings/pci/designware-pcie.txt b/Documentation/devicetree/bindings/pci/designware-pcie.txt
index d5d26d443693..d6fae13ff062 100644
--- a/Documentation/devicetree/bindings/pci/designware-pcie.txt
+++ b/Documentation/devicetree/bindings/pci/designware-pcie.txt
@@ -19,6 +19,8 @@ Required properties:
         to define the mapping of the PCIe interface to interrupt
         numbers.
 - num-lanes: number of lanes to use
+
+Optional properties:
 - reset-gpio: gpio pin number of power good signal
 
 Optional properties for fsl,imx6q-pcie
diff --git a/MAINTAINERS b/MAINTAINERS
index 8285ed4676b6..624e6516fdd3 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -6449,19 +6449,52 @@ F:	drivers/pci/
 F:      include/linux/pci*
 F:      arch/x86/pci/
 
+PCI DRIVER FOR IMX6
+M:      Richard Zhu <r65037@freescale.com>
+M:      Shawn Guo <shawn.guo@linaro.org>
+L:      linux-pci@vger.kernel.org
+L:      linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
+S:      Maintained
+F:      drivers/pci/host/*imx6*
+
+PCI DRIVER FOR MVEBU (Marvell Armada 370 and Armada XP SOC support)
+M:      Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+M:      Jason Cooper <jason@lakedaemon.net>
+L:      linux-pci@vger.kernel.org
+L:      linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
+S:      Maintained
+F:      drivers/pci/host/*mvebu*
+
 PCI DRIVER FOR NVIDIA TEGRA
 M:      Thierry Reding <thierry.reding@gmail.com>
 L:      linux-tegra@vger.kernel.org
+L:      linux-pci@vger.kernel.org
 S:      Supported
 F:      Documentation/devicetree/bindings/pci/nvidia,tegra20-pcie.txt
 F:      drivers/pci/host/pci-tegra.c
 
+PCI DRIVER FOR RENESAS R-CAR
+M:      Simon Horman <horms@verge.net.au>
+L:      linux-pci@vger.kernel.org
+L:      linux-sh@vger.kernel.org
+S:      Maintained
+F:      drivers/pci/host/*rcar*
+
 PCI DRIVER FOR SAMSUNG EXYNOS
 M:      Jingoo Han <jg1.han@samsung.com>
 L:      linux-pci@vger.kernel.org
+L:      linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
+L:      linux-samsung-soc@vger.kernel.org (moderated for non-subscribers)
 S:      Maintained
 F:      drivers/pci/host/pci-exynos.c
 
+PCI DRIVER FOR SYNOPSIS DESIGNWARE
+M:      Mohit Kumar <mohit.kumar@st.com>
+M:      Jingoo Han <jg1.han@samsung.com>
+L:      linux-pci@vger.kernel.org
+S:      Maintained
+F:      drivers/pci/host/*designware*
+
 PCMCIA SUBSYSTEM
 P:      Linux PCMCIA Team
 L:      linux-pcmcia@lists.infradead.org
diff --git a/arch/alpha/kernel/pci_iommu.c b/arch/alpha/kernel/pci_iommu.c
index a21d0ab3b19e..eddee7720343 100644
--- a/arch/alpha/kernel/pci_iommu.c
+++ b/arch/alpha/kernel/pci_iommu.c
@@ -325,7 +325,7 @@ pci_map_single_1(struct pci_dev *pdev, void *cpu_addr, size_t size,
 /* Helper for generic DMA-mapping functions. */
 static struct pci_dev *alpha_gendev_to_pci(struct device *dev)
 {
-        if (dev && dev->bus == &pci_bus_type)
+        if (dev && dev_is_pci(dev))
                 return to_pci_dev(dev);
 
         /* Assume that non-PCI devices asking for DMA are either ISA or EISA,
diff --git a/arch/arm/common/it8152.c b/arch/arm/common/it8152.c
index 001f4913799c..5114b68e99d5 100644
--- a/arch/arm/common/it8152.c
+++ b/arch/arm/common/it8152.c
@@ -257,7 +257,7 @@ static int it8152_needs_bounce(struct device *dev, dma_addr_t dma_addr, size_t s
  */
 static int it8152_pci_platform_notify(struct device *dev)
 {
-        if (dev->bus == &pci_bus_type) {
+        if (dev_is_pci(dev)) {
                 if (dev->dma_mask)
                         *dev->dma_mask = (SZ_64M - 1) | PHYS_OFFSET;
                 dev->coherent_dma_mask = (SZ_64M - 1) | PHYS_OFFSET;
@@ -268,7 +268,7 @@ static int it8152_pci_platform_notify(struct device *dev)
 
 static int it8152_pci_platform_notify_remove(struct device *dev)
 {
-        if (dev->bus == &pci_bus_type)
+        if (dev_is_pci(dev))
                 dmabounce_unregister_dev(dev);
 
         return 0;
diff --git a/arch/arm/mach-ixp4xx/common-pci.c b/arch/arm/mach-ixp4xx/common-pci.c
index 6d6bde3e15fa..200970d56f6d 100644
--- a/arch/arm/mach-ixp4xx/common-pci.c
+++ b/arch/arm/mach-ixp4xx/common-pci.c
@@ -326,7 +326,7 @@ static int ixp4xx_needs_bounce(struct device *dev, dma_addr_t dma_addr, size_t s
  */
 static int ixp4xx_pci_platform_notify(struct device *dev)
 {
-        if(dev->bus == &pci_bus_type) {
+        if (dev_is_pci(dev)) {
                 *dev->dma_mask =  SZ_64M - 1;
                 dev->coherent_dma_mask = SZ_64M - 1;
                 dmabounce_register_dev(dev, 2048, 4096, ixp4xx_needs_bounce);
@@ -336,9 +336,9 @@ static int ixp4xx_pci_platform_notify(struct device *dev)
 
 static int ixp4xx_pci_platform_notify_remove(struct device *dev)
 {
-        if(dev->bus == &pci_bus_type) {
+        if (dev_is_pci(dev))
                 dmabounce_unregister_dev(dev);
-        }
+
         return 0;
 }
 
diff --git a/arch/ia64/hp/common/sba_iommu.c b/arch/ia64/hp/common/sba_iommu.c
index 4c530a82fc46..8e858b593e4f 100644
--- a/arch/ia64/hp/common/sba_iommu.c
+++ b/arch/ia64/hp/common/sba_iommu.c
@@ -255,7 +255,7 @@ static u64 prefetch_spill_page;
 #endif
 
 #ifdef CONFIG_PCI
-# define GET_IOC(dev)   (((dev)->bus == &pci_bus_type)                                          \
+# define GET_IOC(dev)   ((dev_is_pci(dev))                                              \
                          ? ((struct ioc *) PCI_CONTROLLER(to_pci_dev(dev))->iommu) : NULL)
 #else
 # define GET_IOC(dev)   NULL
diff --git a/arch/ia64/sn/pci/pci_dma.c b/arch/ia64/sn/pci/pci_dma.c
index 3290d6e00c31..d0853e8e8623 100644
--- a/arch/ia64/sn/pci/pci_dma.c
+++ b/arch/ia64/sn/pci/pci_dma.c
@@ -34,7 +34,7 @@
  */
 static int sn_dma_supported(struct device *dev, u64 mask)
 {
-        BUG_ON(dev->bus != &pci_bus_type);
+        BUG_ON(!dev_is_pci(dev));
 
         if (mask < 0x7fffffff)
                 return 0;
@@ -50,7 +50,7 @@ static int sn_dma_supported(struct device *dev, u64 mask)
  */
 int sn_dma_set_mask(struct device *dev, u64 dma_mask)
 {
-        BUG_ON(dev->bus != &pci_bus_type);
+        BUG_ON(!dev_is_pci(dev));
 
         if (!sn_dma_supported(dev, dma_mask))
                 return 0;
@@ -85,7 +85,7 @@ static void *sn_dma_alloc_coherent(struct device *dev, size_t size,
         struct pci_dev *pdev = to_pci_dev(dev);
         struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
 
-        BUG_ON(dev->bus != &pci_bus_type);
+        BUG_ON(!dev_is_pci(dev));
 
         /*
          * Allocate the memory.
@@ -143,7 +143,7 @@ static void sn_dma_free_coherent(struct device *dev, size_t size, void *cpu_addr
         struct pci_dev *pdev = to_pci_dev(dev);
         struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
 
-        BUG_ON(dev->bus != &pci_bus_type);
+        BUG_ON(!dev_is_pci(dev));
 
         provider->dma_unmap(pdev, dma_handle, 0);
         free_pages((unsigned long)cpu_addr, get_order(size));
@@ -187,7 +187,7 @@ static dma_addr_t sn_dma_map_page(struct device *dev, struct page *page,
 
         dmabarr = dma_get_attr(DMA_ATTR_WRITE_BARRIER, attrs);
 
-        BUG_ON(dev->bus != &pci_bus_type);
+        BUG_ON(!dev_is_pci(dev));
 
         phys_addr = __pa(cpu_addr);
         if (dmabarr)
@@ -223,7 +223,7 @@ static void sn_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
         struct pci_dev *pdev = to_pci_dev(dev);
         struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
 
-        BUG_ON(dev->bus != &pci_bus_type);
+        BUG_ON(!dev_is_pci(dev));
 
         provider->dma_unmap(pdev, dma_addr, dir);
 }
@@ -247,7 +247,7 @@ static void sn_dma_unmap_sg(struct device *dev, struct scatterlist *sgl,
         struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
         struct scatterlist *sg;
 
-        BUG_ON(dev->bus != &pci_bus_type);
+        BUG_ON(!dev_is_pci(dev));
 
         for_each_sg(sgl, sg, nhwentries, i) {
                 provider->dma_unmap(pdev, sg->dma_address, dir);
@@ -284,7 +284,7 @@ static int sn_dma_map_sg(struct device *dev, struct scatterlist *sgl,
 
         dmabarr = dma_get_attr(DMA_ATTR_WRITE_BARRIER, attrs);
 
-        BUG_ON(dev->bus != &pci_bus_type);
+        BUG_ON(!dev_is_pci(dev));
 
         /*
          * Setup a DMA address for each entry in the scatterlist.
@@ -323,26 +323,26 @@ static int sn_dma_map_sg(struct device *dev, struct scatterlist *sgl,
 static void sn_dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle,
                                        size_t size, enum dma_data_direction dir)
 {
-        BUG_ON(dev->bus != &pci_bus_type);
+        BUG_ON(!dev_is_pci(dev));
 }
 
 static void sn_dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle,
                                           size_t size,
                                           enum dma_data_direction dir)
 {
-        BUG_ON(dev->bus != &pci_bus_type);
+        BUG_ON(!dev_is_pci(dev));
 }
 
 static void sn_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
                                    int nelems, enum dma_data_direction dir)
 {
-        BUG_ON(dev->bus != &pci_bus_type);
+        BUG_ON(!dev_is_pci(dev));
 }
 
 static void sn_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
                                       int nelems, enum dma_data_direction dir)
 {
-        BUG_ON(dev->bus != &pci_bus_type);
+        BUG_ON(!dev_is_pci(dev));
 }
 
 static int sn_dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
diff --git a/arch/parisc/kernel/drivers.c b/arch/parisc/kernel/drivers.c
index 14285caec71a..dba508fe1683 100644
--- a/arch/parisc/kernel/drivers.c
+++ b/arch/parisc/kernel/drivers.c
@@ -282,18 +282,6 @@ find_pa_parent_type(const struct parisc_device *padev, int type)
         return NULL;
 }
 
-#ifdef CONFIG_PCI
-static inline int is_pci_dev(struct device *dev)
-{
-        return dev->bus == &pci_bus_type;
-}
-#else
-static inline int is_pci_dev(struct device *dev)
-{
-        return 0;
-}
-#endif
-
 /*
  * get_node_path fills in @path with the firmware path to the device.
  * Note that if @node is a parisc device, we don't fill in the 'mod' field.
@@ -306,7 +294,7 @@ static void get_node_path(struct device *dev, struct hardware_path *path)
         int i = 5;
         memset(&path->bc, -1, 6);
 
-        if (is_pci_dev(dev)) {
+        if (dev_is_pci(dev)) {
                 unsigned int devfn = to_pci_dev(dev)->devfn;
                 path->mod = PCI_FUNC(devfn);
                 path->bc[i--] = PCI_SLOT(devfn);
@@ -314,7 +302,7 @@ static void get_node_path(struct device *dev, struct hardware_path *path)
         }
 
         while (dev != &root) {
-                if (is_pci_dev(dev)) {
+                if (dev_is_pci(dev)) {
                         unsigned int devfn = to_pci_dev(dev)->devfn;
                         path->bc[i--] = PCI_SLOT(devfn) | (PCI_FUNC(devfn)<< 5);
                 } else if (dev->bus == &parisc_bus_type) {
@@ -695,7 +683,7 @@ static int check_parent(struct device * dev, void * data)
                 if (dev->bus == &parisc_bus_type) {
                         if (match_parisc_device(dev, d->index, d->modpath))
                                 d->dev = dev;
-                } else if (is_pci_dev(dev)) {
+                } else if (dev_is_pci(dev)) {
                         if (match_pci_device(dev, d->index, d->modpath))
                                 d->dev = dev;
                 } else if (dev->bus == NULL) {
@@ -753,7 +741,7 @@ struct device *hwpath_to_device(struct hardware_path *modpath)
                 if (!parent)
                         return NULL;
         }
-        if (is_pci_dev(parent)) /* pci devices already parse MOD */
+        if (dev_is_pci(parent)) /* pci devices already parse MOD */
                 return parent;
         else
                 return parse_tree_node(parent, 6, modpath);
@@ -772,7 +760,7 @@ void device_to_hwpath(struct device *dev, struct hardware_path *path)
                 padev = to_parisc_device(dev);
                 get_node_path(dev->parent, path);
                 path->mod = padev->hw_path;
-        } else if (is_pci_dev(dev)) {
+        } else if (dev_is_pci(dev)) {
                 get_node_path(dev, path);
         }
 }
diff --git a/arch/s390/pci/pci.c b/arch/s390/pci/pci.c
index bf7c73d71eef..4859c401b75e 100644
--- a/arch/s390/pci/pci.c
+++ b/arch/s390/pci/pci.c
@@ -407,8 +407,8 @@ int arch_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type)
         struct msi_msg msg;
         int rc;
 
-        if (type != PCI_CAP_ID_MSIX && type != PCI_CAP_ID_MSI)
-                return -EINVAL;
+        if (type == PCI_CAP_ID_MSI && nvec > 1)
+                return 1;
         msi_vecs = min(nvec, ZPCI_MSI_VEC_MAX);
         msi_vecs = min_t(unsigned int, msi_vecs, CONFIG_PCI_NR_MSI);
 
diff --git a/arch/sparc/kernel/iommu.c b/arch/sparc/kernel/iommu.c
index 070ed141aac7..76663b019eb5 100644
--- a/arch/sparc/kernel/iommu.c
+++ b/arch/sparc/kernel/iommu.c
@@ -854,7 +854,7 @@ int dma_supported(struct device *dev, u64 device_mask)
                 return 1;
 
 #ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type)
+        if (dev_is_pci(dev))
                 return pci64_dma_supported(to_pci_dev(dev), device_mask);
 #endif
 
diff --git a/arch/sparc/kernel/ioport.c b/arch/sparc/kernel/ioport.c
index 2096468de9b2..e7e215dfa866 100644
--- a/arch/sparc/kernel/ioport.c
+++ b/arch/sparc/kernel/ioport.c
@@ -666,10 +666,9 @@ EXPORT_SYMBOL(dma_ops);
  */
 int dma_supported(struct device *dev, u64 mask)
 {
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type)
+        if (dev_is_pci(dev))
                 return 1;
-#endif
+
         return 0;
 }
 EXPORT_SYMBOL(dma_supported);
diff --git a/arch/x86/include/asm/pci.h b/arch/x86/include/asm/pci.h
index 122c299e90c8..1ac6114c9ea5 100644
--- a/arch/x86/include/asm/pci.h
+++ b/arch/x86/include/asm/pci.h
@@ -104,7 +104,7 @@ extern void pci_iommu_alloc(void);
 struct msi_desc;
 int native_setup_msi_irqs(struct pci_dev *dev, int nvec, int type);
 void native_teardown_msi_irq(unsigned int irq);
-void native_restore_msi_irqs(struct pci_dev *dev, int irq);
+void native_restore_msi_irqs(struct pci_dev *dev);
 int setup_msi_irq(struct pci_dev *dev, struct msi_desc *msidesc,
                   unsigned int irq_base, unsigned int irq_offset);
 #else
diff --git a/arch/x86/include/asm/x86_init.h b/arch/x86/include/asm/x86_init.h
index 0f1be11e43d2..e45e4da96bf1 100644
--- a/arch/x86/include/asm/x86_init.h
+++ b/arch/x86/include/asm/x86_init.h
@@ -181,7 +181,7 @@ struct x86_msi_ops {
                                u8 hpet_id);
         void (*teardown_msi_irq)(unsigned int irq);
         void (*teardown_msi_irqs)(struct pci_dev *dev);
-        void (*restore_msi_irqs)(struct pci_dev *dev, int irq);
+        void (*restore_msi_irqs)(struct pci_dev *dev);
         int  (*setup_hpet_msi)(unsigned int irq, unsigned int id);
         u32 (*msi_mask_irq)(struct msi_desc *desc, u32 mask, u32 flag);
         u32 (*msix_mask_irq)(struct msi_desc *desc, u32 flag);
diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c
index 6c0b43bd024b..d359d0fffa50 100644
--- a/arch/x86/kernel/acpi/boot.c
+++ b/arch/x86/kernel/acpi/boot.c
@@ -1034,9 +1034,7 @@ static int mp_config_acpi_gsi(struct device *dev, u32 gsi, int trigger,
 
         if (!acpi_ioapic)
                 return 0;
-        if (!dev)
-                return 0;
-        if (dev->bus != &pci_bus_type)
+        if (!dev || !dev_is_pci(dev))
                 return 0;
 
         pdev = to_pci_dev(dev);
diff --git a/arch/x86/kernel/x86_init.c b/arch/x86/kernel/x86_init.c
index 021783b1f46a..e48b674639cc 100644
--- a/arch/x86/kernel/x86_init.c
+++ b/arch/x86/kernel/x86_init.c
@@ -136,9 +136,9 @@ void arch_teardown_msi_irq(unsigned int irq)
         x86_msi.teardown_msi_irq(irq);
 }
 
-void arch_restore_msi_irqs(struct pci_dev *dev, int irq)
+void arch_restore_msi_irqs(struct pci_dev *dev)
 {
-        x86_msi.restore_msi_irqs(dev, irq);
+        x86_msi.restore_msi_irqs(dev);
 }
 u32 arch_msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
 {
diff --git a/arch/x86/pci/xen.c b/arch/x86/pci/xen.c
index 5eee4959785d..103e702ec5a7 100644
--- a/arch/x86/pci/xen.c
+++ b/arch/x86/pci/xen.c
@@ -337,7 +337,7 @@ out:
         return ret;
 }
 
-static void xen_initdom_restore_msi_irqs(struct pci_dev *dev, int irq)
+static void xen_initdom_restore_msi_irqs(struct pci_dev *dev)
 {
         int ret = 0;
 
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index e2903d03180e..8516f4d47893 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -1095,26 +1095,40 @@ static inline void ahci_gtf_filter_workaround(struct ata_host *host)
 {}
 #endif
 
-int ahci_init_interrupts(struct pci_dev *pdev, struct ahci_host_priv *hpriv)
+int ahci_init_interrupts(struct pci_dev *pdev, unsigned int n_ports,
+                         struct ahci_host_priv *hpriv)
 {
-        int rc;
-        unsigned int maxvec;
+        int rc, nvec;
 
-        if (!(hpriv->flags & AHCI_HFLAG_NO_MSI)) {
-                rc = pci_enable_msi_block_auto(pdev, &maxvec);
-                if (rc > 0) {
-                        if ((rc == maxvec) || (rc == 1))
-                                return rc;
-                        /*
-                         * Assume that advantage of multipe MSIs is negated,
-                         * so fallback to single MSI mode to save resources
-                         */
-                        pci_disable_msi(pdev);
-                        if (!pci_enable_msi(pdev))
-                                return 1;
-                }
-        }
+        if (hpriv->flags & AHCI_HFLAG_NO_MSI)
+                goto intx;
+
+        rc = pci_msi_vec_count(pdev);
+        if (rc < 0)
+                goto intx;
+
+        /*
+         * If number of MSIs is less than number of ports then Sharing Last
+         * Message mode could be enforced. In this case assume that advantage
+         * of multipe MSIs is negated and use single MSI mode instead.
+         */
+        if (rc < n_ports)
+                goto single_msi;
+
+        nvec = rc;
+        rc = pci_enable_msi_block(pdev, nvec);
+        if (rc)
+                goto intx;
 
+        return nvec;
+
+single_msi:
+        rc = pci_enable_msi(pdev);
+        if (rc)
+                goto intx;
+        return 1;
+
+intx:
         pci_intx(pdev, 1);
         return 0;
 }
@@ -1281,10 +1295,6 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         hpriv->mmio = pcim_iomap_table(pdev)[ahci_pci_bar];
 
-        n_msis = ahci_init_interrupts(pdev, hpriv);
-        if (n_msis > 1)
-                hpriv->flags |= AHCI_HFLAG_MULTI_MSI;
-
         /* save initial config */
         ahci_pci_save_initial_config(pdev, hpriv);
 
@@ -1339,6 +1349,10 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
          */
         n_ports = max(ahci_nr_ports(hpriv->cap), fls(hpriv->port_map));
 
+        n_msis = ahci_init_interrupts(pdev, n_ports, hpriv);
+        if (n_msis > 1)
+                hpriv->flags |= AHCI_HFLAG_MULTI_MSI;
+
         host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
         if (!host)
                 return -ENOMEM;
diff --git a/drivers/eisa/eisa-bus.c b/drivers/eisa/eisa-bus.c
index 272a3ec35957..8842cde69177 100644
--- a/drivers/eisa/eisa-bus.c
+++ b/drivers/eisa/eisa-bus.c
@@ -232,8 +232,10 @@ static int __init eisa_init_device(struct eisa_root_device *root,
 static int __init eisa_register_device(struct eisa_device *edev)
 {
         int rc = device_register(&edev->dev);
-        if (rc)
+        if (rc) {
+                put_device(&edev->dev);
                 return rc;
+        }
 
         rc = device_create_file(&edev->dev, &dev_attr_signature);
         if (rc)
diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index b6a99f7a9b20..893503fa1782 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -105,9 +105,10 @@ config PCI_PASID
           If unsure, say N.
 
 config PCI_IOAPIC
-        tristate "PCI IO-APIC hotplug support" if X86
+        bool "PCI IO-APIC hotplug support" if X86
         depends on PCI
         depends on ACPI
+        depends on X86_IO_APIC
         default !X86
 
 config PCI_LABEL
diff --git a/drivers/pci/Makefile b/drivers/pci/Makefile
index 6ebf5bf8e7a7..17d2b07ee67c 100644
--- a/drivers/pci/Makefile
+++ b/drivers/pci/Makefile
@@ -4,7 +4,7 @@
 
 obj-y           += access.o bus.o probe.o host-bridge.o remove.o pci.o \
                         pci-driver.o search.o pci-sysfs.o rom.o setup-res.o \
-                        irq.o vpd.o setup-bus.o
+                        irq.o vpd.o setup-bus.o vc.o
 obj-$(CONFIG_PROC_FS) += proc.o
 obj-$(CONFIG_SYSFS) += slot.o
 
diff --git a/drivers/pci/bus.c b/drivers/pci/bus.c
index 86fb8ec5e448..00660cc502c5 100644
--- a/drivers/pci/bus.c
+++ b/drivers/pci/bus.c
@@ -248,6 +248,7 @@ int pci_bus_add_device(struct pci_dev *dev)
          */
         pci_fixup_device(pci_fixup_final, dev);
         pci_create_sysfs_dev_files(dev);
+        pci_proc_attach_device(dev);
 
         dev->match_driver = true;
         retval = device_attach(&dev->dev);
diff --git a/drivers/pci/host/pci-exynos.c b/drivers/pci/host/pci-exynos.c
index 24beed38ddc7..3de6bfbbe8e9 100644
--- a/drivers/pci/host/pci-exynos.c
+++ b/drivers/pci/host/pci-exynos.c
@@ -468,7 +468,7 @@ static int exynos_pcie_rd_own_conf(struct pcie_port *pp, int where, int size,
         int ret;
 
         exynos_pcie_sideband_dbi_r_mode(pp, true);
-        ret = cfg_read(pp->dbi_base + (where & ~0x3), where, size, val);
+        ret = dw_pcie_cfg_read(pp->dbi_base + (where & ~0x3), where, size, val);
         exynos_pcie_sideband_dbi_r_mode(pp, false);
         return ret;
 }
@@ -479,7 +479,8 @@ static int exynos_pcie_wr_own_conf(struct pcie_port *pp, int where, int size,
         int ret;
 
         exynos_pcie_sideband_dbi_w_mode(pp, true);
-        ret = cfg_write(pp->dbi_base + (where & ~0x3), where, size, val);
+        ret = dw_pcie_cfg_write(pp->dbi_base + (where & ~0x3),
+                        where, size, val);
         exynos_pcie_sideband_dbi_w_mode(pp, false);
         return ret;
 }
diff --git a/drivers/pci/host/pci-imx6.c b/drivers/pci/host/pci-imx6.c
index bd70af8f31ac..e8663a8c3406 100644
--- a/drivers/pci/host/pci-imx6.c
+++ b/drivers/pci/host/pci-imx6.c
@@ -44,10 +44,18 @@ struct imx6_pcie {
         void __iomem            *mem_base;
 };
 
+/* PCIe Root Complex registers (memory-mapped) */
+#define PCIE_RC_LCR                             0x7c
+#define PCIE_RC_LCR_MAX_LINK_SPEEDS_GEN1        0x1
+#define PCIE_RC_LCR_MAX_LINK_SPEEDS_GEN2        0x2
+#define PCIE_RC_LCR_MAX_LINK_SPEEDS_MASK        0xf
+
 /* PCIe Port Logic registers (memory-mapped) */
 #define PL_OFFSET 0x700
 #define PCIE_PHY_DEBUG_R0 (PL_OFFSET + 0x28)
 #define PCIE_PHY_DEBUG_R1 (PL_OFFSET + 0x2c)
+#define PCIE_PHY_DEBUG_R1_XMLH_LINK_IN_TRAINING (1 << 29)
+#define PCIE_PHY_DEBUG_R1_XMLH_LINK_UP          (1 << 4)
 
 #define PCIE_PHY_CTRL (PL_OFFSET + 0x114)
 #define PCIE_PHY_CTRL_DATA_LOC 0
@@ -59,6 +67,9 @@ struct imx6_pcie {
 #define PCIE_PHY_STAT (PL_OFFSET + 0x110)
 #define PCIE_PHY_STAT_ACK_LOC 16
 
+#define PCIE_LINK_WIDTH_SPEED_CONTROL   0x80C
+#define PORT_LOGIC_SPEED_CHANGE         (0x1 << 17)
+
 /* PHY registers (not memory-mapped) */
 #define PCIE_PHY_RX_ASIC_OUT 0x100D
 
@@ -209,15 +220,9 @@ static int imx6_pcie_assert_core_reset(struct pcie_port *pp)
 
         regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR1,
                         IMX6Q_GPR1_PCIE_TEST_PD, 1 << 18);
-        regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR12,
-                        IMX6Q_GPR12_PCIE_CTL_2, 1 << 10);
         regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR1,
                         IMX6Q_GPR1_PCIE_REF_CLK_EN, 0 << 16);
 
-        gpio_set_value(imx6_pcie->reset_gpio, 0);
-        msleep(100);
-        gpio_set_value(imx6_pcie->reset_gpio, 1);
-
         return 0;
 }
 
@@ -261,6 +266,12 @@ static int imx6_pcie_deassert_core_reset(struct pcie_port *pp)
         /* allow the clocks to stabilize */
         usleep_range(200, 500);
 
+        /* Some boards don't have PCIe reset GPIO. */
+        if (gpio_is_valid(imx6_pcie->reset_gpio)) {
+                gpio_set_value(imx6_pcie->reset_gpio, 0);
+                msleep(100);
+                gpio_set_value(imx6_pcie->reset_gpio, 1);
+        }
         return 0;
 
 err_pcie_axi:
@@ -299,11 +310,90 @@ static void imx6_pcie_init_phy(struct pcie_port *pp)
                         IMX6Q_GPR8_TX_SWING_LOW, 127 << 25);
 }
 
-static void imx6_pcie_host_init(struct pcie_port *pp)
+static int imx6_pcie_wait_for_link(struct pcie_port *pp)
+{
+        int count = 200;
+
+        while (!dw_pcie_link_up(pp)) {
+                usleep_range(100, 1000);
+                if (--count)
+                        continue;
+
+                dev_err(pp->dev, "phy link never came up\n");
+                dev_dbg(pp->dev, "DEBUG_R0: 0x%08x, DEBUG_R1: 0x%08x\n",
+                        readl(pp->dbi_base + PCIE_PHY_DEBUG_R0),
+                        readl(pp->dbi_base + PCIE_PHY_DEBUG_R1));
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int imx6_pcie_start_link(struct pcie_port *pp)
 {
-        int count = 0;
         struct imx6_pcie *imx6_pcie = to_imx6_pcie(pp);
+        uint32_t tmp;
+        int ret, count;
 
+        /*
+         * Force Gen1 operation when starting the link.  In case the link is
+         * started in Gen2 mode, there is a possibility the devices on the
+         * bus will not be detected at all.  This happens with PCIe switches.
+         */
+        tmp = readl(pp->dbi_base + PCIE_RC_LCR);
+        tmp &= ~PCIE_RC_LCR_MAX_LINK_SPEEDS_MASK;
+        tmp |= PCIE_RC_LCR_MAX_LINK_SPEEDS_GEN1;
+        writel(tmp, pp->dbi_base + PCIE_RC_LCR);
+
+        /* Start LTSSM. */
+        regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR12,
+                        IMX6Q_GPR12_PCIE_CTL_2, 1 << 10);
+
+        ret = imx6_pcie_wait_for_link(pp);
+        if (ret)
+                return ret;
+
+        /* Allow Gen2 mode after the link is up. */
+        tmp = readl(pp->dbi_base + PCIE_RC_LCR);
+        tmp &= ~PCIE_RC_LCR_MAX_LINK_SPEEDS_MASK;
+        tmp |= PCIE_RC_LCR_MAX_LINK_SPEEDS_GEN2;
+        writel(tmp, pp->dbi_base + PCIE_RC_LCR);
+
+        /*
+         * Start Directed Speed Change so the best possible speed both link
+         * partners support can be negotiated.
+         */
+        tmp = readl(pp->dbi_base + PCIE_LINK_WIDTH_SPEED_CONTROL);
+        tmp |= PORT_LOGIC_SPEED_CHANGE;
+        writel(tmp, pp->dbi_base + PCIE_LINK_WIDTH_SPEED_CONTROL);
+
+        count = 200;
+        while (count--) {
+                tmp = readl(pp->dbi_base + PCIE_LINK_WIDTH_SPEED_CONTROL);
+                /* Test if the speed change finished. */
+                if (!(tmp & PORT_LOGIC_SPEED_CHANGE))
+                        break;
+                usleep_range(100, 1000);
+        }
+
+        /* Make sure link training is finished as well! */
+        if (count)
+                ret = imx6_pcie_wait_for_link(pp);
+        else
+                ret = -EINVAL;
+
+        if (ret) {
+                dev_err(pp->dev, "Failed to bring link up!\n");
+        } else {
+                tmp = readl(pp->dbi_base + 0x80);
+                dev_dbg(pp->dev, "Link up, Gen=%i\n", (tmp >> 16) & 0xf);
+        }
+
+        return ret;
+}
+
+static void imx6_pcie_host_init(struct pcie_port *pp)
+{
         imx6_pcie_assert_core_reset(pp);
 
         imx6_pcie_init_phy(pp);
@@ -312,33 +402,41 @@ static void imx6_pcie_host_init(struct pcie_port *pp)
 
         dw_pcie_setup_rc(pp);
 
-        regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR12,
-                        IMX6Q_GPR12_PCIE_CTL_2, 1 << 10);
+        imx6_pcie_start_link(pp);
+}
 
-        while (!dw_pcie_link_up(pp)) {
-                usleep_range(100, 1000);
-                count++;
-                if (count >= 200) {
-                        dev_err(pp->dev, "phy link never came up\n");
-                        dev_dbg(pp->dev,
-                                "DEBUG_R0: 0x%08x, DEBUG_R1: 0x%08x\n",
-                                readl(pp->dbi_base + PCIE_PHY_DEBUG_R0),
-                                readl(pp->dbi_base + PCIE_PHY_DEBUG_R1));
-                        break;
-                }
-        }
+static void imx6_pcie_reset_phy(struct pcie_port *pp)
+{
+        uint32_t temp;
+
+        pcie_phy_read(pp->dbi_base, PHY_RX_OVRD_IN_LO, &temp);
+        temp |= (PHY_RX_OVRD_IN_LO_RX_DATA_EN |
+                 PHY_RX_OVRD_IN_LO_RX_PLL_EN);
+        pcie_phy_write(pp->dbi_base, PHY_RX_OVRD_IN_LO, temp);
+
+        usleep_range(2000, 3000);
 
-        return;
+        pcie_phy_read(pp->dbi_base, PHY_RX_OVRD_IN_LO, &temp);
+        temp &= ~(PHY_RX_OVRD_IN_LO_RX_DATA_EN |
+                  PHY_RX_OVRD_IN_LO_RX_PLL_EN);
+        pcie_phy_write(pp->dbi_base, PHY_RX_OVRD_IN_LO, temp);
 }
 
 static int imx6_pcie_link_up(struct pcie_port *pp)
 {
-        u32 rc, ltssm, rx_valid, temp;
+        u32 rc, ltssm, rx_valid;
 
-        /* link is debug bit 36, debug register 1 starts at bit 32 */
-        rc = readl(pp->dbi_base + PCIE_PHY_DEBUG_R1) & (0x1 << (36 - 32));
-        if (rc)
-                return -EAGAIN;
+        /*
+         * Test if the PHY reports that the link is up and also that
+         * the link training finished.  It might happen that the PHY
+         * reports the link is already up, but the link training bit
+         * is still set, so make sure to check the training is done
+         * as well here.
+         */
+        rc = readl(pp->dbi_base + PCIE_PHY_DEBUG_R1);
+        if ((rc & PCIE_PHY_DEBUG_R1_XMLH_LINK_UP) &&
+            !(rc & PCIE_PHY_DEBUG_R1_XMLH_LINK_IN_TRAINING))
+                return 1;
 
         /*
          * From L0, initiate MAC entry to gen2 if EP/RC supports gen2.
@@ -358,21 +456,7 @@ static int imx6_pcie_link_up(struct pcie_port *pp)
 
         dev_err(pp->dev, "transition to gen2 is stuck, reset PHY!\n");
 
-        pcie_phy_read(pp->dbi_base,
-                PHY_RX_OVRD_IN_LO, &temp);
-        temp |= (PHY_RX_OVRD_IN_LO_RX_DATA_EN
-                | PHY_RX_OVRD_IN_LO_RX_PLL_EN);
-        pcie_phy_write(pp->dbi_base,
-                PHY_RX_OVRD_IN_LO, temp);
-
-        usleep_range(2000, 3000);
-
-        pcie_phy_read(pp->dbi_base,
-                PHY_RX_OVRD_IN_LO, &temp);
-        temp &= ~(PHY_RX_OVRD_IN_LO_RX_DATA_EN
-                | PHY_RX_OVRD_IN_LO_RX_PLL_EN);
-        pcie_phy_write(pp->dbi_base,
-                PHY_RX_OVRD_IN_LO, temp);
+        imx6_pcie_reset_phy(pp);
 
         return 0;
 }
@@ -426,30 +510,19 @@ static int __init imx6_pcie_probe(struct platform_device *pdev)
                 "imprecise external abort");
 
         dbi_base = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!dbi_base) {
-                dev_err(&pdev->dev, "dbi_base memory resource not found\n");
-                return -ENODEV;
-        }
-
         pp->dbi_base = devm_ioremap_resource(&pdev->dev, dbi_base);
-        if (IS_ERR(pp->dbi_base)) {
-                ret = PTR_ERR(pp->dbi_base);
-                goto err;
-        }
+        if (IS_ERR(pp->dbi_base))
+                return PTR_ERR(pp->dbi_base);
 
         /* Fetch GPIOs */
         imx6_pcie->reset_gpio = of_get_named_gpio(np, "reset-gpio", 0);
-        if (!gpio_is_valid(imx6_pcie->reset_gpio)) {
-                dev_err(&pdev->dev, "no reset-gpio defined\n");
-                ret = -ENODEV;
-        }
-        ret = devm_gpio_request_one(&pdev->dev,
-                                imx6_pcie->reset_gpio,
-                                GPIOF_OUT_INIT_LOW,
-                                "PCIe reset");
-        if (ret) {
-                dev_err(&pdev->dev, "unable to get reset gpio\n");
-                goto err;
+        if (gpio_is_valid(imx6_pcie->reset_gpio)) {
+                ret = devm_gpio_request_one(&pdev->dev, imx6_pcie->reset_gpio,
+                                            GPIOF_OUT_INIT_LOW, "PCIe reset");
+                if (ret) {
+                        dev_err(&pdev->dev, "unable to get reset gpio\n");
+                        return ret;
+                }
         }
 
         imx6_pcie->power_on_gpio = of_get_named_gpio(np, "power-on-gpio", 0);
@@ -460,7 +533,7 @@ static int __init imx6_pcie_probe(struct platform_device *pdev)
                                         "PCIe power enable");
                 if (ret) {
                         dev_err(&pdev->dev, "unable to get power-on gpio\n");
-                        goto err;
+                        return ret;
                 }
         }
 
@@ -472,7 +545,7 @@ static int __init imx6_pcie_probe(struct platform_device *pdev)
                                         "PCIe wake up");
                 if (ret) {
                         dev_err(&pdev->dev, "unable to get wake-up gpio\n");
-                        goto err;
+                        return ret;
                 }
         }
 
@@ -484,7 +557,7 @@ static int __init imx6_pcie_probe(struct platform_device *pdev)
                                         "PCIe disable endpoint");
                 if (ret) {
                         dev_err(&pdev->dev, "unable to get disable-ep gpio\n");
-                        goto err;
+                        return ret;
                 }
         }
 
@@ -493,32 +566,28 @@ static int __init imx6_pcie_probe(struct platform_device *pdev)
         if (IS_ERR(imx6_pcie->lvds_gate)) {
                 dev_err(&pdev->dev,
                         "lvds_gate clock select missing or invalid\n");
-                ret = PTR_ERR(imx6_pcie->lvds_gate);
-                goto err;
+                return PTR_ERR(imx6_pcie->lvds_gate);
         }
 
         imx6_pcie->sata_ref_100m = devm_clk_get(&pdev->dev, "sata_ref_100m");
         if (IS_ERR(imx6_pcie->sata_ref_100m)) {
                 dev_err(&pdev->dev,
                         "sata_ref_100m clock source missing or invalid\n");
-                ret = PTR_ERR(imx6_pcie->sata_ref_100m);
-                goto err;
+                return PTR_ERR(imx6_pcie->sata_ref_100m);
         }
 
         imx6_pcie->pcie_ref_125m = devm_clk_get(&pdev->dev, "pcie_ref_125m");
         if (IS_ERR(imx6_pcie->pcie_ref_125m)) {
                 dev_err(&pdev->dev,
                         "pcie_ref_125m clock source missing or invalid\n");
-                ret = PTR_ERR(imx6_pcie->pcie_ref_125m);
-                goto err;
+                return PTR_ERR(imx6_pcie->pcie_ref_125m);
         }
 
         imx6_pcie->pcie_axi = devm_clk_get(&pdev->dev, "pcie_axi");
         if (IS_ERR(imx6_pcie->pcie_axi)) {
                 dev_err(&pdev->dev,
                         "pcie_axi clock source missing or invalid\n");
-                ret = PTR_ERR(imx6_pcie->pcie_axi);
-                goto err;
+                return PTR_ERR(imx6_pcie->pcie_axi);
         }
 
         /* Grab GPR config register range */
@@ -526,19 +595,15 @@ static int __init imx6_pcie_probe(struct platform_device *pdev)
                  syscon_regmap_lookup_by_compatible("fsl,imx6q-iomuxc-gpr");
         if (IS_ERR(imx6_pcie->iomuxc_gpr)) {
                 dev_err(&pdev->dev, "unable to find iomuxc registers\n");
-                ret = PTR_ERR(imx6_pcie->iomuxc_gpr);
-                goto err;
+                return PTR_ERR(imx6_pcie->iomuxc_gpr);
         }
 
         ret = imx6_add_pcie_port(pp, pdev);
         if (ret < 0)
-                goto err;
+                return ret;
 
         platform_set_drvdata(pdev, imx6_pcie);
         return 0;
-
-err:
-        return ret;
 }
 
 static const struct of_device_id imx6_pcie_of_match[] = {
diff --git a/drivers/pci/host/pci-mvebu.c b/drivers/pci/host/pci-mvebu.c
index c269e430c760..13478ecd4113 100644
--- a/drivers/pci/host/pci-mvebu.c
+++ b/drivers/pci/host/pci-mvebu.c
@@ -150,6 +150,11 @@ static inline u32 mvebu_readl(struct mvebu_pcie_port *port, u32 reg)
         return readl(port->base + reg);
 }
 
+static inline bool mvebu_has_ioport(struct mvebu_pcie_port *port)
+{
+        return port->io_target != -1 && port->io_attr != -1;
+}
+
 static bool mvebu_pcie_link_up(struct mvebu_pcie_port *port)
 {
         return !(mvebu_readl(port, PCIE_STAT_OFF) & PCIE_STAT_LINK_DOWN);
@@ -300,7 +305,8 @@ static void mvebu_pcie_handle_iobase_change(struct mvebu_pcie_port *port)
 
         /* Are the new iobase/iolimit values invalid? */
         if (port->bridge.iolimit < port->bridge.iobase ||
-            port->bridge.iolimitupper < port->bridge.iobaseupper) {
+            port->bridge.iolimitupper < port->bridge.iobaseupper ||
+            !(port->bridge.command & PCI_COMMAND_IO)) {
 
                 /* If a window was configured, remove it */
                 if (port->iowin_base) {
@@ -313,6 +319,12 @@ static void mvebu_pcie_handle_iobase_change(struct mvebu_pcie_port *port)
                 return;
         }
 
+        if (!mvebu_has_ioport(port)) {
+                dev_WARN(&port->pcie->pdev->dev,
+                         "Attempt to set IO when IO is disabled\n");
+                return;
+        }
+
         /*
          * We read the PCI-to-PCI bridge emulated registers, and
          * calculate the base address and size of the address decoding
@@ -330,14 +342,13 @@ static void mvebu_pcie_handle_iobase_change(struct mvebu_pcie_port *port)
         mvebu_mbus_add_window_remap_by_id(port->io_target, port->io_attr,
                                           port->iowin_base, port->iowin_size,
                                           iobase);
-
-        pci_ioremap_io(iobase, port->iowin_base);
 }
 
 static void mvebu_pcie_handle_membase_change(struct mvebu_pcie_port *port)
 {
         /* Are the new membase/memlimit values invalid? */
-        if (port->bridge.memlimit < port->bridge.membase) {
+        if (port->bridge.memlimit < port->bridge.membase ||
+            !(port->bridge.command & PCI_COMMAND_MEMORY)) {
 
                 /* If a window was configured, remove it */
                 if (port->memwin_base) {
@@ -426,9 +437,12 @@ static int mvebu_sw_pci_bridge_read(struct mvebu_pcie_port *port,
                 break;
 
         case PCI_IO_BASE:
-                *value = (bridge->secondary_status << 16 |
-                          bridge->iolimit          <<  8 |
-                          bridge->iobase);
+                if (!mvebu_has_ioport(port))
+                        *value = bridge->secondary_status << 16;
+                else
+                        *value = (bridge->secondary_status << 16 |
+                                  bridge->iolimit          <<  8 |
+                                  bridge->iobase);
                 break;
 
         case PCI_MEMORY_BASE:
@@ -447,6 +461,11 @@ static int mvebu_sw_pci_bridge_read(struct mvebu_pcie_port *port,
                 *value = 0;
                 break;
 
+        case PCI_INTERRUPT_LINE:
+                /* LINE PIN MIN_GNT MAX_LAT */
+                *value = 0;
+                break;
+
         default:
                 *value = 0xffffffff;
                 return PCIBIOS_BAD_REGISTER_NUMBER;
@@ -485,8 +504,19 @@ static int mvebu_sw_pci_bridge_write(struct mvebu_pcie_port *port,
 
         switch (where & ~3) {
         case PCI_COMMAND:
+        {
+                u32 old = bridge->command;
+
+                if (!mvebu_has_ioport(port))
+                        value &= ~PCI_COMMAND_IO;
+
                 bridge->command = value & 0xffff;
+                if ((old ^ bridge->command) & PCI_COMMAND_IO)
+                        mvebu_pcie_handle_iobase_change(port);
+                if ((old ^ bridge->command) & PCI_COMMAND_MEMORY)
+                        mvebu_pcie_handle_membase_change(port);
                 break;
+        }
 
         case PCI_BASE_ADDRESS_0 ... PCI_BASE_ADDRESS_1:
                 bridge->bar[((where & ~3) - PCI_BASE_ADDRESS_0) / 4] = value;
@@ -500,7 +530,6 @@ static int mvebu_sw_pci_bridge_write(struct mvebu_pcie_port *port,
                  */
                 bridge->iobase = (value & 0xff) | PCI_IO_RANGE_TYPE_32;
                 bridge->iolimit = ((value >> 8) & 0xff) | PCI_IO_RANGE_TYPE_32;
-                bridge->secondary_status = value >> 16;
                 mvebu_pcie_handle_iobase_change(port);
                 break;
 
@@ -651,7 +680,9 @@ static int mvebu_pcie_setup(int nr, struct pci_sys_data *sys)
         struct mvebu_pcie *pcie = sys_to_pcie(sys);
         int i;
 
-        pci_add_resource_offset(&sys->resources, &pcie->realio, sys->io_offset);
+        if (resource_size(&pcie->realio) != 0)
+                pci_add_resource_offset(&sys->resources, &pcie->realio,
+                                        sys->io_offset);
         pci_add_resource_offset(&sys->resources, &pcie->mem, sys->mem_offset);
         pci_add_resource(&sys->resources, &pcie->busn);
 
@@ -702,9 +733,9 @@ static resource_size_t mvebu_pcie_align_resource(struct pci_dev *dev,
          * aligned on their size
          */
         if (res->flags & IORESOURCE_IO)
-                return round_up(start, max((resource_size_t)SZ_64K, size));
+                return round_up(start, max_t(resource_size_t, SZ_64K, size));
         else if (res->flags & IORESOURCE_MEM)
-                return round_up(start, max((resource_size_t)SZ_1M, size));
+                return round_up(start, max_t(resource_size_t, SZ_1M, size));
         else
                 return start;
 }
@@ -752,12 +783,17 @@ static void __iomem *mvebu_pcie_map_registers(struct platform_device *pdev,
 #define DT_CPUADDR_TO_ATTR(cpuaddr)   (((cpuaddr) >> 48) & 0xFF)
 
 static int mvebu_get_tgt_attr(struct device_node *np, int devfn,
-                              unsigned long type, int *tgt, int *attr)
+                              unsigned long type,
+                              unsigned int *tgt,
+                              unsigned int *attr)
 {
         const int na = 3, ns = 2;
         const __be32 *range;
         int rlen, nranges, rangesz, pna, i;
 
+        *tgt = -1;
+        *attr = -1;
+
         range = of_get_property(np, "ranges", &rlen);
         if (!range)
                 return -EINVAL;
@@ -827,16 +863,15 @@ static int mvebu_pcie_probe(struct platform_device *pdev)
         }
 
         mvebu_mbus_get_pcie_io_aperture(&pcie->io);
-        if (resource_size(&pcie->io) == 0) {
-                dev_err(&pdev->dev, "invalid I/O aperture size\n");
-                return -EINVAL;
-        }
 
-        pcie->realio.flags = pcie->io.flags;
-        pcie->realio.start = PCIBIOS_MIN_IO;
-        pcie->realio.end = min_t(resource_size_t,
-                                  IO_SPACE_LIMIT,
-                                  resource_size(&pcie->io));
+        if (resource_size(&pcie->io) != 0) {
+                pcie->realio.flags = pcie->io.flags;
+                pcie->realio.start = PCIBIOS_MIN_IO;
+                pcie->realio.end = min_t(resource_size_t,
+                                         IO_SPACE_LIMIT,
+                                         resource_size(&pcie->io));
+        } else
+                pcie->realio = pcie->io;
 
         /* Get the bus range */
         ret = of_pci_parse_bus_range(np, &pcie->busn);
@@ -895,12 +930,12 @@ static int mvebu_pcie_probe(struct platform_device *pdev)
                         continue;
                 }
 
-                ret = mvebu_get_tgt_attr(np, port->devfn, IORESOURCE_IO,
-                                         &port->io_target, &port->io_attr);
-                if (ret < 0) {
-                        dev_err(&pdev->dev, "PCIe%d.%d: cannot get tgt/attr for io window\n",
-                                port->port, port->lane);
-                        continue;
+                if (resource_size(&pcie->io) != 0)
+                        mvebu_get_tgt_attr(np, port->devfn, IORESOURCE_IO,
+                                           &port->io_target, &port->io_attr);
+                else {
+                        port->io_target = -1;
+                        port->io_attr = -1;
                 }
 
                 port->reset_gpio = of_get_named_gpio_flags(child,
@@ -949,14 +984,6 @@ static int mvebu_pcie_probe(struct platform_device *pdev)
 
                 mvebu_pcie_set_local_dev_nr(port, 1);
 
-                port->clk = of_clk_get_by_name(child, NULL);
-                if (IS_ERR(port->clk)) {
-                        dev_err(&pdev->dev, "PCIe%d.%d: cannot get clock\n",
-                               port->port, port->lane);
-                        iounmap(port->base);
-                        continue;
-                }
-
                 port->dn = child;
                 spin_lock_init(&port->conf_lock);
                 mvebu_sw_pci_bridge_init(port);
@@ -964,6 +991,10 @@ static int mvebu_pcie_probe(struct platform_device *pdev)
         }
 
         pcie->nports = i;
+
+        for (i = 0; i < (IO_SPACE_LIMIT - SZ_64K); i += SZ_64K)
+                pci_ioremap_io(i, pcie->io.start + i);
+
         mvebu_pcie_msi_enable(pcie);
         mvebu_pcie_enable(pcie);
 
@@ -983,8 +1014,7 @@ static struct platform_driver mvebu_pcie_driver = {
         .driver = {
                 .owner = THIS_MODULE,
                 .name = "mvebu-pcie",
-                .of_match_table =
-                   of_match_ptr(mvebu_pcie_of_match_table),
+                .of_match_table = mvebu_pcie_of_match_table,
                 /* driver unloading/unbinding currently not supported */
                 .suppress_bind_attrs = true,
         },
diff --git a/drivers/pci/host/pci-rcar-gen2.c b/drivers/pci/host/pci-rcar-gen2.c
index cbaa5c4397e3..ceec147baec3 100644
--- a/drivers/pci/host/pci-rcar-gen2.c
+++ b/drivers/pci/host/pci-rcar-gen2.c
@@ -17,6 +17,7 @@
 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/slab.h>
 
 /* AHB-PCI Bridge PCI communication registers */
@@ -77,6 +78,7 @@
 #define RCAR_PCI_NR_CONTROLLERS         3
 
 struct rcar_pci_priv {
+        struct device *dev;
         void __iomem *reg;
         struct resource io_res;
         struct resource mem_res;
@@ -169,8 +171,11 @@ static int __init rcar_pci_setup(int nr, struct pci_sys_data *sys)
         void __iomem *reg = priv->reg;
         u32 val;
 
+        pm_runtime_enable(priv->dev);
+        pm_runtime_get_sync(priv->dev);
+
         val = ioread32(reg + RCAR_PCI_UNIT_REV_REG);
-        pr_info("PCI: bus%u revision %x\n", sys->busnr, val);
+        dev_info(priv->dev, "PCI: bus%u revision %x\n", sys->busnr, val);
 
         /* Disable Direct Power Down State and assert reset */
         val = ioread32(reg + RCAR_USBCTR_REG) & ~RCAR_USBCTR_DIRPD;
@@ -276,8 +281,8 @@ static int __init rcar_pci_probe(struct platform_device *pdev)
 
         cfg_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         reg = devm_ioremap_resource(&pdev->dev, cfg_res);
-        if (!reg)
-                return -ENODEV;
+        if (IS_ERR(reg))
+                return PTR_ERR(reg);
 
         mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
         if (!mem_res || !mem_res->start)
@@ -301,6 +306,7 @@ static int __init rcar_pci_probe(struct platform_device *pdev)
 
         priv->irq = platform_get_irq(pdev, 0);
         priv->reg = reg;
+        priv->dev = &pdev->dev;
 
         return rcar_pci_add_controller(priv);
 }
diff --git a/drivers/pci/host/pci-tegra.c b/drivers/pci/host/pci-tegra.c
index 0afbbbc55c81..b8ba2f794559 100644
--- a/drivers/pci/host/pci-tegra.c
+++ b/drivers/pci/host/pci-tegra.c
@@ -805,7 +805,7 @@ static int tegra_pcie_enable_controller(struct tegra_pcie *pcie)
         afi_writel(pcie, value, AFI_PCIE_CONFIG);
 
         value = afi_readl(pcie, AFI_FUSE);
-        value &= ~AFI_FUSE_PCIE_T0_GEN2_DIS;
+        value |= AFI_FUSE_PCIE_T0_GEN2_DIS;
         afi_writel(pcie, value, AFI_FUSE);
 
         /* initialize internal PHY, enable up to 16 PCIE lanes */
diff --git a/drivers/pci/host/pcie-designware.c b/drivers/pci/host/pcie-designware.c
index e33b68be0391..17ce88f79d2b 100644
--- a/drivers/pci/host/pcie-designware.c
+++ b/drivers/pci/host/pcie-designware.c
@@ -74,7 +74,7 @@ static inline struct pcie_port *sys_to_pcie(struct pci_sys_data *sys)
         return sys->private_data;
 }
 
-int cfg_read(void __iomem *addr, int where, int size, u32 *val)
+int dw_pcie_cfg_read(void __iomem *addr, int where, int size, u32 *val)
 {
         *val = readl(addr);
 
@@ -88,7 +88,7 @@ int cfg_read(void __iomem *addr, int where, int size, u32 *val)
         return PCIBIOS_SUCCESSFUL;
 }
 
-int cfg_write(void __iomem *addr, int where, int size, u32 val)
+int dw_pcie_cfg_write(void __iomem *addr, int where, int size, u32 val)
 {
         if (size == 4)
                 writel(val, addr);
@@ -126,7 +126,8 @@ static int dw_pcie_rd_own_conf(struct pcie_port *pp, int where, int size,
         if (pp->ops->rd_own_conf)
                 ret = pp->ops->rd_own_conf(pp, where, size, val);
         else
-                ret = cfg_read(pp->dbi_base + (where & ~0x3), where, size, val);
+                ret = dw_pcie_cfg_read(pp->dbi_base + (where & ~0x3), where,
+                                size, val);
 
         return ret;
 }
@@ -139,8 +140,8 @@ static int dw_pcie_wr_own_conf(struct pcie_port *pp, int where, int size,
         if (pp->ops->wr_own_conf)
                 ret = pp->ops->wr_own_conf(pp, where, size, val);
         else
-                ret = cfg_write(pp->dbi_base + (where & ~0x3), where, size,
-                                val);
+                ret = dw_pcie_cfg_write(pp->dbi_base + (where & ~0x3), where,
+                                size, val);
 
         return ret;
 }
@@ -167,11 +168,13 @@ void dw_handle_msi_irq(struct pcie_port *pp)
                         while ((pos = find_next_bit(&val, 32, pos)) != 32) {
                                 irq = irq_find_mapping(pp->irq_domain,
                                                 i * 32 + pos);
+                                dw_pcie_wr_own_conf(pp,
+                                                PCIE_MSI_INTR0_STATUS + i * 12,
+                                                4, 1 << pos);
                                 generic_handle_irq(irq);
                                 pos++;
                         }
                 }
-                dw_pcie_wr_own_conf(pp, PCIE_MSI_INTR0_STATUS + i * 12, 4, val);
         }
 }
 
@@ -209,6 +212,23 @@ static int find_valid_pos0(struct pcie_port *pp, int msgvec, int pos, int *pos0)
         return 0;
 }
 
+static void clear_irq_range(struct pcie_port *pp, unsigned int irq_base,
+                            unsigned int nvec, unsigned int pos)
+{
+        unsigned int i, res, bit, val;
+
+        for (i = 0; i < nvec; i++) {
+                irq_set_msi_desc_off(irq_base, i, NULL);
+                clear_bit(pos + i, pp->msi_irq_in_use);
+                /* Disable corresponding interrupt on MSI controller */
+                res = ((pos + i) / 32) * 12;
+                bit = (pos + i) % 32;
+                dw_pcie_rd_own_conf(pp, PCIE_MSI_INTR0_ENABLE + res, 4, &val);
+                val &= ~(1 << bit);
+                dw_pcie_wr_own_conf(pp, PCIE_MSI_INTR0_ENABLE + res, 4, val);
+        }
+}
+
 static int assign_irq(int no_irqs, struct msi_desc *desc, int *pos)
 {
         int res, bit, irq, pos0, pos1, i;
@@ -242,18 +262,25 @@ static int assign_irq(int no_irqs, struct msi_desc *desc, int *pos)
         if (!irq)
                 goto no_valid_irq;
 
-        i = 0;
-        while (i < no_irqs) {
+        /*
+         * irq_create_mapping (called from dw_pcie_host_init) pre-allocates
+         * descs so there is no need to allocate descs here. We can therefore
+         * assume that if irq_find_mapping above returns non-zero, then the
+         * descs are also successfully allocated.
+         */
+
+        for (i = 0; i < no_irqs; i++) {
+                if (irq_set_msi_desc_off(irq, i, desc) != 0) {
+                        clear_irq_range(pp, irq, i, pos0);
+                        goto no_valid_irq;
+                }
                 set_bit(pos0 + i, pp->msi_irq_in_use);
-                irq_alloc_descs((irq + i), (irq + i), 1, 0);
-                irq_set_msi_desc(irq + i, desc);
                 /*Enable corresponding interrupt in MSI interrupt controller */
                 res = ((pos0 + i) / 32) * 12;
                 bit = (pos0 + i) % 32;
                 dw_pcie_rd_own_conf(pp, PCIE_MSI_INTR0_ENABLE + res, 4, &val);
                 val |= 1 << bit;
                 dw_pcie_wr_own_conf(pp, PCIE_MSI_INTR0_ENABLE + res, 4, val);
-                i++;
         }
 
         *pos = pos0;
@@ -266,7 +293,7 @@ no_valid_irq:
 
 static void clear_irq(unsigned int irq)
 {
-        int res, bit, val, pos;
+        unsigned int pos, nvec;
         struct irq_desc *desc;
         struct msi_desc *msi;
         struct pcie_port *pp;
@@ -281,18 +308,15 @@ static void clear_irq(unsigned int irq)
                 return;
         }
 
+        /* undo what was done in assign_irq */
         pos = data->hwirq;
+        nvec = 1 << msi->msi_attrib.multiple;
 
-        irq_free_desc(irq);
-
-        clear_bit(pos, pp->msi_irq_in_use);
+        clear_irq_range(pp, irq, nvec, pos);
 
-        /* Disable corresponding interrupt on MSI interrupt controller */
-        res = (pos / 32) * 12;
-        bit = pos % 32;
-        dw_pcie_rd_own_conf(pp, PCIE_MSI_INTR0_ENABLE + res, 4, &val);
-        val &= ~(1 << bit);
-        dw_pcie_wr_own_conf(pp, PCIE_MSI_INTR0_ENABLE + res, 4, val);
+        /* all irqs cleared; reset attributes */
+        msi->irq = 0;
+        msi->msi_attrib.multiple = 0;
 }
 
 static int dw_msi_setup_irq(struct msi_chip *chip, struct pci_dev *pdev,
@@ -320,10 +344,10 @@ static int dw_msi_setup_irq(struct msi_chip *chip, struct pci_dev *pdev,
         if (irq < 0)
                 return irq;
 
-        msg_ctr &= ~PCI_MSI_FLAGS_QSIZE;
-        msg_ctr |= msgvec << 4;
-        pci_write_config_word(pdev, desc->msi_attrib.pos + PCI_MSI_FLAGS,
-                                msg_ctr);
+        /*
+         * write_msi_msg() will update PCI_MSI_FLAGS so there is
+         * no need to explicitly call pci_write_config_word().
+         */
         desc->msi_attrib.multiple = msgvec;
 
         msg.address_lo = virt_to_phys((void *)pp->msi_data);
@@ -394,6 +418,7 @@ int __init dw_pcie_host_init(struct pcie_port *pp)
                                            + global_io_offset);
                         pp->config.io_size = resource_size(&pp->io);
                         pp->config.io_bus_addr = range.pci_addr;
+                        pp->io_base = range.cpu_addr;
                 }
                 if (restype == IORESOURCE_MEM) {
                         of_pci_range_to_resource(&range, np, &pp->mem);
@@ -419,7 +444,6 @@ int __init dw_pcie_host_init(struct pcie_port *pp)
 
         pp->cfg0_base = pp->cfg.start;
         pp->cfg1_base = pp->cfg.start + pp->config.cfg0_size;
-        pp->io_base = pp->io.start;
         pp->mem_base = pp->mem.start;
 
         pp->va_cfg0_base = devm_ioremap(pp->dev, pp->cfg0_base,
@@ -551,11 +575,13 @@ static int dw_pcie_rd_other_conf(struct pcie_port *pp, struct pci_bus *bus,
 
         if (bus->parent->number == pp->root_bus_nr) {
                 dw_pcie_prog_viewport_cfg0(pp, busdev);
-                ret = cfg_read(pp->va_cfg0_base + address, where, size, val);
+                ret = dw_pcie_cfg_read(pp->va_cfg0_base + address, where, size,
+                                val);
                 dw_pcie_prog_viewport_mem_outbound(pp);
         } else {
                 dw_pcie_prog_viewport_cfg1(pp, busdev);
-                ret = cfg_read(pp->va_cfg1_base + address, where, size, val);
+                ret = dw_pcie_cfg_read(pp->va_cfg1_base + address, where, size,
+                                val);
                 dw_pcie_prog_viewport_io_outbound(pp);
         }
 
@@ -574,18 +600,19 @@ static int dw_pcie_wr_other_conf(struct pcie_port *pp, struct pci_bus *bus,
 
         if (bus->parent->number == pp->root_bus_nr) {
                 dw_pcie_prog_viewport_cfg0(pp, busdev);
-                ret = cfg_write(pp->va_cfg0_base + address, where, size, val);
+                ret = dw_pcie_cfg_write(pp->va_cfg0_base + address, where, size,
+                                val);
                 dw_pcie_prog_viewport_mem_outbound(pp);
         } else {
                 dw_pcie_prog_viewport_cfg1(pp, busdev);
-                ret = cfg_write(pp->va_cfg1_base + address, where, size, val);
+                ret = dw_pcie_cfg_write(pp->va_cfg1_base + address, where, size,
+                                val);
                 dw_pcie_prog_viewport_io_outbound(pp);
         }
 
         return ret;
 }
 
-
 static int dw_pcie_valid_config(struct pcie_port *pp,
                                 struct pci_bus *bus, int dev)
 {
@@ -679,7 +706,7 @@ static int dw_pcie_setup(int nr, struct pci_sys_data *sys)
 
         if (global_io_offset < SZ_1M && pp->config.io_size > 0) {
                 sys->io_offset = global_io_offset - pp->config.io_bus_addr;
-                pci_ioremap_io(sys->io_offset, pp->io.start);
+                pci_ioremap_io(global_io_offset, pp->io_base);
                 global_io_offset += SZ_64K;
                 pci_add_resource_offset(&sys->resources, &pp->io,
                                         sys->io_offset);
diff --git a/drivers/pci/host/pcie-designware.h b/drivers/pci/host/pcie-designware.h
index c15379be2372..3063b3594d88 100644
--- a/drivers/pci/host/pcie-designware.h
+++ b/drivers/pci/host/pcie-designware.h
@@ -66,8 +66,8 @@ struct pcie_host_ops {
         void (*host_init)(struct pcie_port *pp);
 };
 
-int cfg_read(void __iomem *addr, int where, int size, u32 *val);
-int cfg_write(void __iomem *addr, int where, int size, u32 val);
+int dw_pcie_cfg_read(void __iomem *addr, int where, int size, u32 *val);
+int dw_pcie_cfg_write(void __iomem *addr, int where, int size, u32 val);
 void dw_handle_msi_irq(struct pcie_port *pp);
 void dw_pcie_msi_init(struct pcie_port *pp);
 int dw_pcie_link_up(struct pcie_port *pp);
diff --git a/drivers/pci/hotplug/pciehp.h b/drivers/pci/hotplug/pciehp.h
index 21e865ded1dc..ffe6a6b336cf 100644
--- a/drivers/pci/hotplug/pciehp.h
+++ b/drivers/pci/hotplug/pciehp.h
@@ -140,15 +140,15 @@ struct controller *pcie_init(struct pcie_device *dev);
 int pcie_init_notification(struct controller *ctrl);
 int pciehp_enable_slot(struct slot *p_slot);
 int pciehp_disable_slot(struct slot *p_slot);
-int pcie_enable_notification(struct controller *ctrl);
+void pcie_enable_notification(struct controller *ctrl);
 int pciehp_power_on_slot(struct slot *slot);
-int pciehp_power_off_slot(struct slot *slot);
-int pciehp_get_power_status(struct slot *slot, u8 *status);
-int pciehp_get_attention_status(struct slot *slot, u8 *status);
+void pciehp_power_off_slot(struct slot *slot);
+void pciehp_get_power_status(struct slot *slot, u8 *status);
+void pciehp_get_attention_status(struct slot *slot, u8 *status);
 
-int pciehp_set_attention_status(struct slot *slot, u8 status);
-int pciehp_get_latch_status(struct slot *slot, u8 *status);
-int pciehp_get_adapter_status(struct slot *slot, u8 *status);
+void pciehp_set_attention_status(struct slot *slot, u8 status);
+void pciehp_get_latch_status(struct slot *slot, u8 *status);
+void pciehp_get_adapter_status(struct slot *slot, u8 *status);
 int pciehp_query_power_fault(struct slot *slot);
 void pciehp_green_led_on(struct slot *slot);
 void pciehp_green_led_off(struct slot *slot);
diff --git a/drivers/pci/hotplug/pciehp_core.c b/drivers/pci/hotplug/pciehp_core.c
index bbd48bbe4e9b..143a389d81fa 100644
--- a/drivers/pci/hotplug/pciehp_core.c
+++ b/drivers/pci/hotplug/pciehp_core.c
@@ -160,7 +160,8 @@ static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
                   __func__, slot_name(slot));
 
-        return pciehp_set_attention_status(slot, status);
+        pciehp_set_attention_status(slot, status);
+        return 0;
 }
 
 
@@ -192,7 +193,8 @@ static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
                   __func__, slot_name(slot));
 
-        return pciehp_get_power_status(slot, value);
+        pciehp_get_power_status(slot, value);
+        return 0;
 }
 
 static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
@@ -202,7 +204,8 @@ static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
                   __func__, slot_name(slot));
 
-        return pciehp_get_attention_status(slot, value);
+        pciehp_get_attention_status(slot, value);
+        return 0;
 }
 
 static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
@@ -212,7 +215,8 @@ static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
                  __func__, slot_name(slot));
 
-        return pciehp_get_latch_status(slot, value);
+        pciehp_get_latch_status(slot, value);
+        return 0;
 }
 
 static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
@@ -222,7 +226,8 @@ static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
                  __func__, slot_name(slot));
 
-        return pciehp_get_adapter_status(slot, value);
+        pciehp_get_adapter_status(slot, value);
+        return 0;
 }
 
 static int reset_slot(struct hotplug_slot *hotplug_slot, int probe)
diff --git a/drivers/pci/hotplug/pciehp_ctrl.c b/drivers/pci/hotplug/pciehp_ctrl.c
index 38f018679175..50628487597d 100644
--- a/drivers/pci/hotplug/pciehp_ctrl.c
+++ b/drivers/pci/hotplug/pciehp_ctrl.c
@@ -158,11 +158,8 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
 {
         /* turn off slot, turn on Amber LED, turn off Green LED if supported*/
         if (POWER_CTRL(ctrl)) {
-                if (pciehp_power_off_slot(pslot)) {
-                        ctrl_err(ctrl,
-                                 "Issue of Slot Power Off command failed\n");
-                        return;
-                }
+                pciehp_power_off_slot(pslot);
+
                 /*
                  * After turning power off, we must wait for at least 1 second
                  * before taking any action that relies on power having been
@@ -171,16 +168,8 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
                 msleep(1000);
         }
 
-        if (PWR_LED(ctrl))
-                pciehp_green_led_off(pslot);
-
-        if (ATTN_LED(ctrl)) {
-                if (pciehp_set_attention_status(pslot, 1)) {
-                        ctrl_err(ctrl,
-                                 "Issue of Set Attention Led command failed\n");
-                        return;
-                }
-        }
+        pciehp_green_led_off(pslot);
+        pciehp_set_attention_status(pslot, 1);
 }
 
 /**
@@ -203,8 +192,7 @@ static int board_added(struct slot *p_slot)
                         return retval;
         }
 
-        if (PWR_LED(ctrl))
-                pciehp_green_led_blink(p_slot);
+        pciehp_green_led_blink(p_slot);
 
         /* Check link training status */
         retval = pciehp_check_link_status(ctrl);
@@ -227,9 +215,7 @@ static int board_added(struct slot *p_slot)
                 goto err_exit;
         }
 
-        if (PWR_LED(ctrl))
-                pciehp_green_led_on(p_slot);
-
+        pciehp_green_led_on(p_slot);
         return 0;
 
 err_exit:
@@ -243,7 +229,7 @@ err_exit:
  */
 static int remove_board(struct slot *p_slot)
 {
-        int retval = 0;
+        int retval;
         struct controller *ctrl = p_slot->ctrl;
 
         retval = pciehp_unconfigure_device(p_slot);
@@ -251,13 +237,8 @@ static int remove_board(struct slot *p_slot)
                 return retval;
 
         if (POWER_CTRL(ctrl)) {
-                /* power off slot */
-                retval = pciehp_power_off_slot(p_slot);
-                if (retval) {
-                        ctrl_err(ctrl,
-                                 "Issue of Slot Disable command failed\n");
-                        return retval;
-                }
+                pciehp_power_off_slot(p_slot);
+
                 /*
                  * After turning power off, we must wait for at least 1 second
                  * before taking any action that relies on power having been
@@ -267,9 +248,7 @@ static int remove_board(struct slot *p_slot)
         }
 
         /* turn off Green LED */
-        if (PWR_LED(ctrl))
-                pciehp_green_led_off(p_slot);
-
+        pciehp_green_led_off(p_slot);
         return 0;
 }
 
@@ -305,7 +284,7 @@ static void pciehp_power_thread(struct work_struct *work)
                 break;
         case POWERON_STATE:
                 mutex_unlock(&p_slot->lock);
-                if (pciehp_enable_slot(p_slot) && PWR_LED(p_slot->ctrl))
+                if (pciehp_enable_slot(p_slot))
                         pciehp_green_led_off(p_slot);
                 mutex_lock(&p_slot->lock);
                 p_slot->state = STATIC_STATE;
@@ -372,11 +351,8 @@ static void handle_button_press_event(struct slot *p_slot)
                                   "press.\n", slot_name(p_slot));
                 }
                 /* blink green LED and turn off amber */
-                if (PWR_LED(ctrl))
-                        pciehp_green_led_blink(p_slot);
-                if (ATTN_LED(ctrl))
-                        pciehp_set_attention_status(p_slot, 0);
-
+                pciehp_green_led_blink(p_slot);
+                pciehp_set_attention_status(p_slot, 0);
                 queue_delayed_work(p_slot->wq, &p_slot->work, 5*HZ);
                 break;
         case BLINKINGOFF_STATE:
@@ -389,14 +365,11 @@ static void handle_button_press_event(struct slot *p_slot)
                 ctrl_info(ctrl, "Button cancel on Slot(%s)\n", slot_name(p_slot));
                 cancel_delayed_work(&p_slot->work);
                 if (p_slot->state == BLINKINGOFF_STATE) {
-                        if (PWR_LED(ctrl))
-                                pciehp_green_led_on(p_slot);
+                        pciehp_green_led_on(p_slot);
                 } else {
-                        if (PWR_LED(ctrl))
-                                pciehp_green_led_off(p_slot);
+                        pciehp_green_led_off(p_slot);
                 }
-                if (ATTN_LED(ctrl))
-                        pciehp_set_attention_status(p_slot, 0);
+                pciehp_set_attention_status(p_slot, 0);
                 ctrl_info(ctrl, "PCI slot #%s - action canceled "
                           "due to button press\n", slot_name(p_slot));
                 p_slot->state = STATIC_STATE;
@@ -456,10 +429,8 @@ static void interrupt_event_handler(struct work_struct *work)
         case INT_POWER_FAULT:
                 if (!POWER_CTRL(ctrl))
                         break;
-                if (ATTN_LED(ctrl))
-                        pciehp_set_attention_status(p_slot, 1);
-                if (PWR_LED(ctrl))
-                        pciehp_green_led_off(p_slot);
+                pciehp_set_attention_status(p_slot, 1);
+                pciehp_green_led_off(p_slot);
                 break;
         case INT_PRESENCE_ON:
         case INT_PRESENCE_OFF:
@@ -482,14 +453,14 @@ int pciehp_enable_slot(struct slot *p_slot)
         int rc;
         struct controller *ctrl = p_slot->ctrl;
 
-        rc = pciehp_get_adapter_status(p_slot, &getstatus);
-        if (rc || !getstatus) {
+        pciehp_get_adapter_status(p_slot, &getstatus);
+        if (!getstatus) {
                 ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot));
                 return -ENODEV;
         }
         if (MRL_SENS(p_slot->ctrl)) {
-                rc = pciehp_get_latch_status(p_slot, &getstatus);
-                if (rc || getstatus) {
+                pciehp_get_latch_status(p_slot, &getstatus);
+                if (getstatus) {
                         ctrl_info(ctrl, "Latch open on slot(%s)\n",
                                   slot_name(p_slot));
                         return -ENODEV;
@@ -497,8 +468,8 @@ int pciehp_enable_slot(struct slot *p_slot)
         }
 
         if (POWER_CTRL(p_slot->ctrl)) {
-                rc = pciehp_get_power_status(p_slot, &getstatus);
-                if (rc || getstatus) {
+                pciehp_get_power_status(p_slot, &getstatus);
+                if (getstatus) {
                         ctrl_info(ctrl, "Already enabled on slot(%s)\n",
                                   slot_name(p_slot));
                         return -EINVAL;
@@ -518,15 +489,14 @@ int pciehp_enable_slot(struct slot *p_slot)
 int pciehp_disable_slot(struct slot *p_slot)
 {
         u8 getstatus = 0;
-        int ret = 0;
         struct controller *ctrl = p_slot->ctrl;
 
         if (!p_slot->ctrl)
                 return 1;
 
         if (!HP_SUPR_RM(p_slot->ctrl)) {
-                ret = pciehp_get_adapter_status(p_slot, &getstatus);
-                if (ret || !getstatus) {
+                pciehp_get_adapter_status(p_slot, &getstatus);
+                if (!getstatus) {
                         ctrl_info(ctrl, "No adapter on slot(%s)\n",
                                   slot_name(p_slot));
                         return -ENODEV;
@@ -534,8 +504,8 @@ int pciehp_disable_slot(struct slot *p_slot)
         }
 
         if (MRL_SENS(p_slot->ctrl)) {
-                ret = pciehp_get_latch_status(p_slot, &getstatus);
-                if (ret || getstatus) {
+                pciehp_get_latch_status(p_slot, &getstatus);
+                if (getstatus) {
                         ctrl_info(ctrl, "Latch open on slot(%s)\n",
                                   slot_name(p_slot));
                         return -ENODEV;
@@ -543,8 +513,8 @@ int pciehp_disable_slot(struct slot *p_slot)
         }
 
         if (POWER_CTRL(p_slot->ctrl)) {
-                ret = pciehp_get_power_status(p_slot, &getstatus);
-                if (ret || !getstatus) {
+                pciehp_get_power_status(p_slot, &getstatus);
+                if (!getstatus) {
                         ctrl_info(ctrl, "Already disabled on slot(%s)\n",
                                   slot_name(p_slot));
                         return -EINVAL;
diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index 3eea3fdd4b0b..14acfccb7670 100644
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -41,34 +41,11 @@
 #include "../pci.h"
 #include "pciehp.h"
 
-static inline int pciehp_readw(struct controller *ctrl, int reg, u16 *value)
+static inline struct pci_dev *ctrl_dev(struct controller *ctrl)
 {
-        struct pci_dev *dev = ctrl->pcie->port;
-        return pcie_capability_read_word(dev, reg, value);
+        return ctrl->pcie->port;
 }
 
-static inline int pciehp_readl(struct controller *ctrl, int reg, u32 *value)
-{
-        struct pci_dev *dev = ctrl->pcie->port;
-        return pcie_capability_read_dword(dev, reg, value);
-}
-
-static inline int pciehp_writew(struct controller *ctrl, int reg, u16 value)
-{
-        struct pci_dev *dev = ctrl->pcie->port;
-        return pcie_capability_write_word(dev, reg, value);
-}
-
-static inline int pciehp_writel(struct controller *ctrl, int reg, u32 value)
-{
-        struct pci_dev *dev = ctrl->pcie->port;
-        return pcie_capability_write_dword(dev, reg, value);
-}
-
-/* Power Control Command */
-#define POWER_ON        0
-#define POWER_OFF       PCI_EXP_SLTCTL_PCC
-
 static irqreturn_t pcie_isr(int irq, void *dev_id);
 static void start_int_poll_timer(struct controller *ctrl, int sec);
 
@@ -129,20 +106,23 @@ static inline void pciehp_free_irq(struct controller *ctrl)
 
 static int pcie_poll_cmd(struct controller *ctrl)
 {
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         u16 slot_status;
-        int err, timeout = 1000;
+        int timeout = 1000;
 
-        err = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
-        if (!err && (slot_status & PCI_EXP_SLTSTA_CC)) {
-                pciehp_writew(ctrl, PCI_EXP_SLTSTA, PCI_EXP_SLTSTA_CC);
+        pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
+        if (slot_status & PCI_EXP_SLTSTA_CC) {
+                pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
+                                           PCI_EXP_SLTSTA_CC);
                 return 1;
         }
         while (timeout > 0) {
                 msleep(10);
                 timeout -= 10;
-                err = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
-                if (!err && (slot_status & PCI_EXP_SLTSTA_CC)) {
-                        pciehp_writew(ctrl, PCI_EXP_SLTSTA, PCI_EXP_SLTSTA_CC);
+                pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
+                if (slot_status & PCI_EXP_SLTSTA_CC) {
+                        pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
+                                                   PCI_EXP_SLTSTA_CC);
                         return 1;
                 }
         }
@@ -169,21 +149,15 @@ static void pcie_wait_cmd(struct controller *ctrl, int poll)
  * @cmd:  command value written to slot control register
  * @mask: bitmask of slot control register to be modified
  */
-static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
+static void pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
 {
-        int retval = 0;
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         u16 slot_status;
         u16 slot_ctrl;
 
         mutex_lock(&ctrl->ctrl_lock);
 
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
-                         __func__);
-                goto out;
-        }
-
+        pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
         if (slot_status & PCI_EXP_SLTSTA_CC) {
                 if (!ctrl->no_cmd_complete) {
                         /*
@@ -207,24 +181,17 @@ static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
                 }
         }
 
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTCTL, &slot_ctrl);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
-                goto out;
-        }
-
+        pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &slot_ctrl);
         slot_ctrl &= ~mask;
         slot_ctrl |= (cmd & mask);
         ctrl->cmd_busy = 1;
         smp_mb();
-        retval = pciehp_writew(ctrl, PCI_EXP_SLTCTL, slot_ctrl);
-        if (retval)
-                ctrl_err(ctrl, "Cannot write to SLOTCTRL register\n");
+        pcie_capability_write_word(pdev, PCI_EXP_SLTCTL, slot_ctrl);
 
         /*
          * Wait for command completion.
          */
-        if (!retval && !ctrl->no_cmd_complete) {
+        if (!ctrl->no_cmd_complete) {
                 int poll = 0;
                 /*
                  * if hotplug interrupt is not enabled or command
@@ -236,19 +203,16 @@ static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
                         poll = 1;
                 pcie_wait_cmd(ctrl, poll);
         }
- out:
         mutex_unlock(&ctrl->ctrl_lock);
-        return retval;
 }
 
 static bool check_link_active(struct controller *ctrl)
 {
-        bool ret = false;
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         u16 lnk_status;
+        bool ret;
 
-        if (pciehp_readw(ctrl, PCI_EXP_LNKSTA, &lnk_status))
-                return ret;
-
+        pcie_capability_read_word(pdev, PCI_EXP_LNKSTA, &lnk_status);
         ret = !!(lnk_status & PCI_EXP_LNKSTA_DLLLA);
 
         if (ret)
@@ -311,9 +275,9 @@ static bool pci_bus_check_dev(struct pci_bus *bus, int devfn)
 
 int pciehp_check_link_status(struct controller *ctrl)
 {
+        struct pci_dev *pdev = ctrl_dev(ctrl);
+        bool found;
         u16 lnk_status;
-        int retval = 0;
-        bool found = false;
 
         /*
          * Data Link Layer Link Active Reporting must be capable for
@@ -330,52 +294,37 @@ int pciehp_check_link_status(struct controller *ctrl)
         found = pci_bus_check_dev(ctrl->pcie->port->subordinate,
                                         PCI_DEVFN(0, 0));
 
-        retval = pciehp_readw(ctrl, PCI_EXP_LNKSTA, &lnk_status);
-        if (retval) {
-                ctrl_err(ctrl, "Cannot read LNKSTATUS register\n");
-                return retval;
-        }
-
+        pcie_capability_read_word(pdev, PCI_EXP_LNKSTA, &lnk_status);
         ctrl_dbg(ctrl, "%s: lnk_status = %x\n", __func__, lnk_status);
         if ((lnk_status & PCI_EXP_LNKSTA_LT) ||
             !(lnk_status & PCI_EXP_LNKSTA_NLW)) {
                 ctrl_err(ctrl, "Link Training Error occurs \n");
-                retval = -1;
-                return retval;
+                return -1;
         }
 
         pcie_update_link_speed(ctrl->pcie->port->subordinate, lnk_status);
 
-        if (!found && !retval)
-                retval = -1;
+        if (!found)
+                return -1;
 
-        return retval;
+        return 0;
 }
 
 static int __pciehp_link_set(struct controller *ctrl, bool enable)
 {
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         u16 lnk_ctrl;
-        int retval = 0;
 
-        retval = pciehp_readw(ctrl, PCI_EXP_LNKCTL, &lnk_ctrl);
-        if (retval) {
-                ctrl_err(ctrl, "Cannot read LNKCTRL register\n");
-                return retval;
-        }
+        pcie_capability_read_word(pdev, PCI_EXP_LNKCTL, &lnk_ctrl);
 
         if (enable)
                 lnk_ctrl &= ~PCI_EXP_LNKCTL_LD;
         else
                 lnk_ctrl |= PCI_EXP_LNKCTL_LD;
 
-        retval = pciehp_writew(ctrl, PCI_EXP_LNKCTL, lnk_ctrl);
-        if (retval) {
-                ctrl_err(ctrl, "Cannot write LNKCTRL register\n");
-                return retval;
-        }
+        pcie_capability_write_word(pdev, PCI_EXP_LNKCTL, lnk_ctrl);
         ctrl_dbg(ctrl, "%s: lnk_ctrl = %x\n", __func__, lnk_ctrl);
-
-        return retval;
+        return 0;
 }
 
 static int pciehp_link_enable(struct controller *ctrl)
@@ -388,223 +337,165 @@ static int pciehp_link_disable(struct controller *ctrl)
         return __pciehp_link_set(ctrl, false);
 }
 
-int pciehp_get_attention_status(struct slot *slot, u8 *status)
+void pciehp_get_attention_status(struct slot *slot, u8 *status)
 {
         struct controller *ctrl = slot->ctrl;
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         u16 slot_ctrl;
-        u8 atten_led_state;
-        int retval = 0;
-
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTCTL, &slot_ctrl);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
-                return retval;
-        }
 
+        pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &slot_ctrl);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x, value read %x\n", __func__,
                  pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_ctrl);
 
-        atten_led_state = (slot_ctrl & PCI_EXP_SLTCTL_AIC) >> 6;
-
-        switch (atten_led_state) {
-        case 0:
-                *status = 0xFF; /* Reserved */
-                break;
-        case 1:
+        switch (slot_ctrl & PCI_EXP_SLTCTL_AIC) {
+        case PCI_EXP_SLTCTL_ATTN_IND_ON:
                 *status = 1;    /* On */
                 break;
-        case 2:
+        case PCI_EXP_SLTCTL_ATTN_IND_BLINK:
                 *status = 2;    /* Blink */
                 break;
-        case 3:
+        case PCI_EXP_SLTCTL_ATTN_IND_OFF:
                 *status = 0;    /* Off */
                 break;
         default:
                 *status = 0xFF;
                 break;
         }
-
-        return 0;
 }
 
-int pciehp_get_power_status(struct slot *slot, u8 *status)
+void pciehp_get_power_status(struct slot *slot, u8 *status)
 {
         struct controller *ctrl = slot->ctrl;
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         u16 slot_ctrl;
-        u8 pwr_state;
-        int     retval = 0;
 
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTCTL, &slot_ctrl);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
-                return retval;
-        }
+        pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &slot_ctrl);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x value read %x\n", __func__,
                  pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_ctrl);
 
-        pwr_state = (slot_ctrl & PCI_EXP_SLTCTL_PCC) >> 10;
-
-        switch (pwr_state) {
-        case 0:
-                *status = 1;
+        switch (slot_ctrl & PCI_EXP_SLTCTL_PCC) {
+        case PCI_EXP_SLTCTL_PWR_ON:
+                *status = 1;    /* On */
                 break;
-        case 1:
-                *status = 0;
+        case PCI_EXP_SLTCTL_PWR_OFF:
+                *status = 0;    /* Off */
                 break;
         default:
                 *status = 0xFF;
                 break;
         }
-
-        return retval;
 }
 
-int pciehp_get_latch_status(struct slot *slot, u8 *status)
+void pciehp_get_latch_status(struct slot *slot, u8 *status)
 {
-        struct controller *ctrl = slot->ctrl;
+        struct pci_dev *pdev = ctrl_dev(slot->ctrl);
         u16 slot_status;
-        int retval;
 
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
-                         __func__);
-                return retval;
-        }
+        pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
         *status = !!(slot_status & PCI_EXP_SLTSTA_MRLSS);
-        return 0;
 }
 
-int pciehp_get_adapter_status(struct slot *slot, u8 *status)
+void pciehp_get_adapter_status(struct slot *slot, u8 *status)
 {
-        struct controller *ctrl = slot->ctrl;
+        struct pci_dev *pdev = ctrl_dev(slot->ctrl);
         u16 slot_status;
-        int retval;
 
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
-                         __func__);
-                return retval;
-        }
+        pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
         *status = !!(slot_status & PCI_EXP_SLTSTA_PDS);
-        return 0;
 }
 
 int pciehp_query_power_fault(struct slot *slot)
 {
-        struct controller *ctrl = slot->ctrl;
+        struct pci_dev *pdev = ctrl_dev(slot->ctrl);
         u16 slot_status;
-        int retval;
 
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
-        if (retval) {
-                ctrl_err(ctrl, "Cannot check for power fault\n");
-                return retval;
-        }
+        pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
         return !!(slot_status & PCI_EXP_SLTSTA_PFD);
 }
 
-int pciehp_set_attention_status(struct slot *slot, u8 value)
+void pciehp_set_attention_status(struct slot *slot, u8 value)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
-        u16 cmd_mask;
 
-        cmd_mask = PCI_EXP_SLTCTL_AIC;
+        if (!ATTN_LED(ctrl))
+                return;
+
         switch (value) {
         case 0 :        /* turn off */
-                slot_cmd = 0x00C0;
+                slot_cmd = PCI_EXP_SLTCTL_ATTN_IND_OFF;
                 break;
         case 1:         /* turn on */
-                slot_cmd = 0x0040;
+                slot_cmd = PCI_EXP_SLTCTL_ATTN_IND_ON;
                 break;
         case 2:         /* turn blink */
-                slot_cmd = 0x0080;
+                slot_cmd = PCI_EXP_SLTCTL_ATTN_IND_BLINK;
                 break;
         default:
-                return -EINVAL;
+                return;
         }
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
                  pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
-        return pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
+        pcie_write_cmd(ctrl, slot_cmd, PCI_EXP_SLTCTL_AIC);
 }
 
 void pciehp_green_led_on(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
-        u16 slot_cmd;
-        u16 cmd_mask;
 
-        slot_cmd = 0x0100;
-        cmd_mask = PCI_EXP_SLTCTL_PIC;
-        pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
+        if (!PWR_LED(ctrl))
+                return;
+
+        pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_IND_ON, PCI_EXP_SLTCTL_PIC);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
-                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
+                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL,
+                 PCI_EXP_SLTCTL_PWR_IND_ON);
 }
 
 void pciehp_green_led_off(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
-        u16 slot_cmd;
-        u16 cmd_mask;
 
-        slot_cmd = 0x0300;
-        cmd_mask = PCI_EXP_SLTCTL_PIC;
-        pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
+        if (!PWR_LED(ctrl))
+                return;
+
+        pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_IND_OFF, PCI_EXP_SLTCTL_PIC);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
-                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
+                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL,
+                 PCI_EXP_SLTCTL_PWR_IND_OFF);
 }
 
 void pciehp_green_led_blink(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
-        u16 slot_cmd;
-        u16 cmd_mask;
 
-        slot_cmd = 0x0200;
-        cmd_mask = PCI_EXP_SLTCTL_PIC;
-        pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
+        if (!PWR_LED(ctrl))
+                return;
+
+        pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_IND_BLINK, PCI_EXP_SLTCTL_PIC);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
-                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
+                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL,
+                 PCI_EXP_SLTCTL_PWR_IND_BLINK);
 }
 
 int pciehp_power_on_slot(struct slot * slot)
 {
         struct controller *ctrl = slot->ctrl;
-        u16 slot_cmd;
-        u16 cmd_mask;
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         u16 slot_status;
-        int retval = 0;
+        int retval;
 
         /* Clear sticky power-fault bit from previous power failures */
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
-                         __func__);
-                return retval;
-        }
-        slot_status &= PCI_EXP_SLTSTA_PFD;
-        if (slot_status) {
-                retval = pciehp_writew(ctrl, PCI_EXP_SLTSTA, slot_status);
-                if (retval) {
-                        ctrl_err(ctrl,
-                                 "%s: Cannot write to SLOTSTATUS register\n",
-                                 __func__);
-                        return retval;
-                }
-        }
+        pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
+        if (slot_status & PCI_EXP_SLTSTA_PFD)
+                pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
+                                           PCI_EXP_SLTSTA_PFD);
         ctrl->power_fault_detected = 0;
 
-        slot_cmd = POWER_ON;
-        cmd_mask = PCI_EXP_SLTCTL_PCC;
-        retval = pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
-        if (retval) {
-                ctrl_err(ctrl, "Write %x command failed!\n", slot_cmd);
-                return retval;
-        }
+        pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_ON, PCI_EXP_SLTCTL_PCC);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
-                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
+                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL,
+                 PCI_EXP_SLTCTL_PWR_ON);
 
         retval = pciehp_link_enable(ctrl);
         if (retval)
@@ -613,12 +504,9 @@ int pciehp_power_on_slot(struct slot * slot)
         return retval;
 }
 
-int pciehp_power_off_slot(struct slot * slot)
+void pciehp_power_off_slot(struct slot * slot)
 {
         struct controller *ctrl = slot->ctrl;
-        u16 slot_cmd;
-        u16 cmd_mask;
-        int retval;
 
         /* Disable the link at first */
         pciehp_link_disable(ctrl);
@@ -628,21 +516,16 @@ int pciehp_power_off_slot(struct slot * slot)
         else
                 msleep(1000);
 
-        slot_cmd = POWER_OFF;
-        cmd_mask = PCI_EXP_SLTCTL_PCC;
-        retval = pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
-        if (retval) {
-                ctrl_err(ctrl, "Write command failed!\n");
-                return retval;
-        }
+        pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_OFF, PCI_EXP_SLTCTL_PCC);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
-                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
-        return 0;
+                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL,
+                 PCI_EXP_SLTCTL_PWR_OFF);
 }
 
 static irqreturn_t pcie_isr(int irq, void *dev_id)
 {
         struct controller *ctrl = (struct controller *)dev_id;
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         struct slot *slot = ctrl->slot;
         u16 detected, intr_loc;
 
@@ -653,11 +536,7 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
          */
         intr_loc = 0;
         do {
-                if (pciehp_readw(ctrl, PCI_EXP_SLTSTA, &detected)) {
-                        ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS\n",
-                                 __func__);
-                        return IRQ_NONE;
-                }
+                pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &detected);
 
                 detected &= (PCI_EXP_SLTSTA_ABP | PCI_EXP_SLTSTA_PFD |
                              PCI_EXP_SLTSTA_MRLSC | PCI_EXP_SLTSTA_PDC |
@@ -666,11 +545,9 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
                 intr_loc |= detected;
                 if (!intr_loc)
                         return IRQ_NONE;
-                if (detected && pciehp_writew(ctrl, PCI_EXP_SLTSTA, intr_loc)) {
-                        ctrl_err(ctrl, "%s: Cannot write to SLOTSTATUS\n",
-                                 __func__);
-                        return IRQ_NONE;
-                }
+                if (detected)
+                        pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
+                                                   intr_loc);
         } while (detected);
 
         ctrl_dbg(ctrl, "%s: intr_loc %x\n", __func__, intr_loc);
@@ -705,7 +582,7 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-int pcie_enable_notification(struct controller *ctrl)
+void pcie_enable_notification(struct controller *ctrl)
 {
         u16 cmd, mask;
 
@@ -731,22 +608,18 @@ int pcie_enable_notification(struct controller *ctrl)
                 PCI_EXP_SLTCTL_MRLSCE | PCI_EXP_SLTCTL_PFDE |
                 PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_CCIE);
 
-        if (pcie_write_cmd(ctrl, cmd, mask)) {
-                ctrl_err(ctrl, "Cannot enable software notification\n");
-                return -1;
-        }
-        return 0;
+        pcie_write_cmd(ctrl, cmd, mask);
 }
 
 static void pcie_disable_notification(struct controller *ctrl)
 {
         u16 mask;
+
         mask = (PCI_EXP_SLTCTL_PDCE | PCI_EXP_SLTCTL_ABPE |
                 PCI_EXP_SLTCTL_MRLSCE | PCI_EXP_SLTCTL_PFDE |
                 PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_CCIE |
                 PCI_EXP_SLTCTL_DLLSCE);
-        if (pcie_write_cmd(ctrl, 0, mask))
-                ctrl_warn(ctrl, "Cannot disable software notification\n");
+        pcie_write_cmd(ctrl, 0, mask);
 }
 
 /*
@@ -758,6 +631,7 @@ static void pcie_disable_notification(struct controller *ctrl)
 int pciehp_reset_slot(struct slot *slot, int probe)
 {
         struct controller *ctrl = slot->ctrl;
+        struct pci_dev *pdev = ctrl_dev(ctrl);
 
         if (probe)
                 return 0;
@@ -771,7 +645,8 @@ int pciehp_reset_slot(struct slot *slot, int probe)
         pci_reset_bridge_secondary_bus(ctrl->pcie->port);
 
         if (HP_SUPR_RM(ctrl)) {
-                pciehp_writew(ctrl, PCI_EXP_SLTSTA, PCI_EXP_SLTSTA_PDC);
+                pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
+                                           PCI_EXP_SLTSTA_PDC);
                 pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PDCE, PCI_EXP_SLTCTL_PDCE);
                 if (pciehp_poll_mode)
                         int_poll_timeout(ctrl->poll_timer.data);
@@ -784,10 +659,7 @@ int pcie_init_notification(struct controller *ctrl)
 {
         if (pciehp_request_irq(ctrl))
                 return -1;
-        if (pcie_enable_notification(ctrl)) {
-                pciehp_free_irq(ctrl);
-                return -1;
-        }
+        pcie_enable_notification(ctrl);
         ctrl->notification_enabled = 1;
         return 0;
 }
@@ -875,12 +747,14 @@ static inline void dbg_ctrl(struct controller *ctrl)
                   EMI(ctrl)        ? "yes" : "no");
         ctrl_info(ctrl, "  Command Completed    : %3s\n",
                   NO_CMD_CMPL(ctrl) ? "no" : "yes");
-        pciehp_readw(ctrl, PCI_EXP_SLTSTA, &reg16);
+        pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &reg16);
         ctrl_info(ctrl, "Slot Status            : 0x%04x\n", reg16);
-        pciehp_readw(ctrl, PCI_EXP_SLTCTL, &reg16);
+        pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &reg16);
         ctrl_info(ctrl, "Slot Control           : 0x%04x\n", reg16);
 }
 
+#define FLAG(x,y)       (((x) & (y)) ? '+' : '-')
+
 struct controller *pcie_init(struct pcie_device *dev)
 {
         struct controller *ctrl;
@@ -893,11 +767,7 @@ struct controller *pcie_init(struct pcie_device *dev)
                 goto abort;
         }
         ctrl->pcie = dev;
-        if (pciehp_readl(ctrl, PCI_EXP_SLTCAP, &slot_cap)) {
-                ctrl_err(ctrl, "Cannot read SLOTCAP register\n");
-                goto abort_ctrl;
-        }
-
+        pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, &slot_cap);
         ctrl->slot_cap = slot_cap;
         mutex_init(&ctrl->ctrl_lock);
         init_waitqueue_head(&ctrl->queue);
@@ -913,25 +783,31 @@ struct controller *pcie_init(struct pcie_device *dev)
             ctrl->no_cmd_complete = 1;
 
         /* Check if Data Link Layer Link Active Reporting is implemented */
-        if (pciehp_readl(ctrl, PCI_EXP_LNKCAP, &link_cap)) {
-                ctrl_err(ctrl, "%s: Cannot read LNKCAP register\n", __func__);
-                goto abort_ctrl;
-        }
+        pcie_capability_read_dword(pdev, PCI_EXP_LNKCAP, &link_cap);
         if (link_cap & PCI_EXP_LNKCAP_DLLLARC) {
                 ctrl_dbg(ctrl, "Link Active Reporting supported\n");
                 ctrl->link_active_reporting = 1;
         }
 
         /* Clear all remaining event bits in Slot Status register */
-        if (pciehp_writew(ctrl, PCI_EXP_SLTSTA, 0x1f))
-                goto abort_ctrl;
+        pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
+                PCI_EXP_SLTSTA_ABP | PCI_EXP_SLTSTA_PFD |
+                PCI_EXP_SLTSTA_MRLSC | PCI_EXP_SLTSTA_PDC |
+                PCI_EXP_SLTSTA_CC);
 
         /* Disable software notification */
         pcie_disable_notification(ctrl);
 
-        ctrl_info(ctrl, "HPC vendor_id %x device_id %x ss_vid %x ss_did %x\n",
-                  pdev->vendor, pdev->device, pdev->subsystem_vendor,
-                  pdev->subsystem_device);
+        ctrl_info(ctrl, "Slot #%d AttnBtn%c AttnInd%c PwrInd%c PwrCtrl%c MRL%c Interlock%c NoCompl%c LLActRep%c\n",
+                (slot_cap & PCI_EXP_SLTCAP_PSN) >> 19,
+                FLAG(slot_cap, PCI_EXP_SLTCAP_ABP),
+                FLAG(slot_cap, PCI_EXP_SLTCAP_AIP),
+                FLAG(slot_cap, PCI_EXP_SLTCAP_PIP),
+                FLAG(slot_cap, PCI_EXP_SLTCAP_PCP),
+                FLAG(slot_cap, PCI_EXP_SLTCAP_MRLSP),
+                FLAG(slot_cap, PCI_EXP_SLTCAP_EIP),
+                FLAG(slot_cap, PCI_EXP_SLTCAP_NCCS),
+                FLAG(link_cap, PCI_EXP_LNKCAP_DLLLARC));
 
         if (pcie_init_slot(ctrl))
                 goto abort_ctrl;
diff --git a/drivers/pci/hotplug/pciehp_pci.c b/drivers/pci/hotplug/pciehp_pci.c
index 0e0d0f7f63fd..198355112ee7 100644
--- a/drivers/pci/hotplug/pciehp_pci.c
+++ b/drivers/pci/hotplug/pciehp_pci.c
@@ -78,7 +78,7 @@ int pciehp_configure_device(struct slot *p_slot)
 
 int pciehp_unconfigure_device(struct slot *p_slot)
 {
-        int ret, rc = 0;
+        int rc = 0;
         u8 bctl = 0;
         u8 presence = 0;
         struct pci_dev *dev, *temp;
@@ -88,9 +88,7 @@ int pciehp_unconfigure_device(struct slot *p_slot)
 
         ctrl_dbg(ctrl, "%s: domain:bus:dev = %04x:%02x:00\n",
                  __func__, pci_domain_nr(parent), parent->number);
-        ret = pciehp_get_adapter_status(p_slot, &presence);
-        if (ret)
-                presence = 0;
+        pciehp_get_adapter_status(p_slot, &presence);
 
         /*
          * Stopping an SR-IOV PF device removes all the associated VFs,
diff --git a/drivers/pci/ioapic.c b/drivers/pci/ioapic.c
index 50ce68098298..2c2930ea06ad 100644
--- a/drivers/pci/ioapic.c
+++ b/drivers/pci/ioapic.c
@@ -113,6 +113,10 @@ static struct pci_driver ioapic_driver = {
         .remove         = ioapic_remove,
 };
 
-module_pci_driver(ioapic_driver);
+static int __init ioapic_init(void)
+{
+        return pci_register_driver(&ioapic_driver);
+}
+module_init(ioapic_init);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/pci/iov.c b/drivers/pci/iov.c
index 1fe2d6fb19d5..68311ec849ee 100644
--- a/drivers/pci/iov.c
+++ b/drivers/pci/iov.c
@@ -441,6 +441,7 @@ static int sriov_init(struct pci_dev *dev, int pos)
 
 found:
         pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, ctrl);
+        pci_write_config_word(dev, pos + PCI_SRIOV_NUM_VF, 0);
         pci_read_config_word(dev, pos + PCI_SRIOV_VF_OFFSET, &offset);
         pci_read_config_word(dev, pos + PCI_SRIOV_VF_STRIDE, &stride);
         if (!offset || (total > 1 && !stride))
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 3fcd67a16677..7a0fec6ce571 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -116,7 +116,7 @@ void __weak arch_teardown_msi_irqs(struct pci_dev *dev)
         return default_teardown_msi_irqs(dev);
 }
 
-void default_restore_msi_irqs(struct pci_dev *dev, int irq)
+static void default_restore_msi_irq(struct pci_dev *dev, int irq)
 {
         struct msi_desc *entry;
 
@@ -134,9 +134,9 @@ void default_restore_msi_irqs(struct pci_dev *dev, int irq)
                 write_msi_msg(irq, &entry->msg);
 }
 
-void __weak arch_restore_msi_irqs(struct pci_dev *dev, int irq)
+void __weak arch_restore_msi_irqs(struct pci_dev *dev)
 {
-        return default_restore_msi_irqs(dev, irq);
+        return default_restore_msi_irqs(dev);
 }
 
 static void msi_set_enable(struct pci_dev *dev, int enable)
@@ -262,6 +262,15 @@ void unmask_msi_irq(struct irq_data *data)
         msi_set_mask_bit(data, 0);
 }
 
+void default_restore_msi_irqs(struct pci_dev *dev)
+{
+        struct msi_desc *entry;
+
+        list_for_each_entry(entry, &dev->msi_list, list) {
+                default_restore_msi_irq(dev, entry->irq);
+        }
+}
+
 void __read_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
 {
         BUG_ON(entry->dev->current_state != PCI_D0);
@@ -363,6 +372,9 @@ void write_msi_msg(unsigned int irq, struct msi_msg *msg)
 static void free_msi_irqs(struct pci_dev *dev)
 {
         struct msi_desc *entry, *tmp;
+        struct attribute **msi_attrs;
+        struct device_attribute *dev_attr;
+        int count = 0;
 
         list_for_each_entry(entry, &dev->msi_list, list) {
                 int i, nvec;
@@ -398,6 +410,22 @@ static void free_msi_irqs(struct pci_dev *dev)
                 list_del(&entry->list);
                 kfree(entry);
         }
+
+        if (dev->msi_irq_groups) {
+                sysfs_remove_groups(&dev->dev.kobj, dev->msi_irq_groups);
+                msi_attrs = dev->msi_irq_groups[0]->attrs;
+                list_for_each_entry(entry, &dev->msi_list, list) {
+                        dev_attr = container_of(msi_attrs[count],
+                                                struct device_attribute, attr);
+                        kfree(dev_attr->attr.name);
+                        kfree(dev_attr);
+                        ++count;
+                }
+                kfree(msi_attrs);
+                kfree(dev->msi_irq_groups[0]);
+                kfree(dev->msi_irq_groups);
+                dev->msi_irq_groups = NULL;
+        }
 }
 
 static struct msi_desc *alloc_msi_entry(struct pci_dev *dev)
@@ -430,7 +458,7 @@ static void __pci_restore_msi_state(struct pci_dev *dev)
 
         pci_intx_for_msi(dev, 0);
         msi_set_enable(dev, 0);
-        arch_restore_msi_irqs(dev, dev->irq);
+        arch_restore_msi_irqs(dev);
 
         pci_read_config_word(dev, dev->msi_cap + PCI_MSI_FLAGS, &control);
         msi_mask_irq(entry, msi_capable_mask(control), entry->masked);
@@ -455,8 +483,8 @@ static void __pci_restore_msix_state(struct pci_dev *dev)
         control |= PCI_MSIX_FLAGS_ENABLE | PCI_MSIX_FLAGS_MASKALL;
         pci_write_config_word(dev, dev->msix_cap + PCI_MSIX_FLAGS, control);
 
+        arch_restore_msi_irqs(dev);
         list_for_each_entry(entry, &dev->msi_list, list) {
-                arch_restore_msi_irqs(dev, entry->irq);
                 msix_mask_irq(entry, entry->masked);
         }
 
@@ -471,94 +499,95 @@ void pci_restore_msi_state(struct pci_dev *dev)
 }
 EXPORT_SYMBOL_GPL(pci_restore_msi_state);
 
-
-#define to_msi_attr(obj) container_of(obj, struct msi_attribute, attr)
-#define to_msi_desc(obj) container_of(obj, struct msi_desc, kobj)
-
-struct msi_attribute {
-        struct attribute        attr;
-        ssize_t (*show)(struct msi_desc *entry, struct msi_attribute *attr,
-                        char *buf);
-        ssize_t (*store)(struct msi_desc *entry, struct msi_attribute *attr,
-                         const char *buf, size_t count);
-};
-
-static ssize_t show_msi_mode(struct msi_desc *entry, struct msi_attribute *atr,
+static ssize_t msi_mode_show(struct device *dev, struct device_attribute *attr,
                              char *buf)
 {
-        return sprintf(buf, "%s\n", entry->msi_attrib.is_msix ? "msix" : "msi");
-}
-
-static ssize_t msi_irq_attr_show(struct kobject *kobj,
-                                 struct attribute *attr, char *buf)
-{
-        struct msi_attribute *attribute = to_msi_attr(attr);
-        struct msi_desc *entry = to_msi_desc(kobj);
-
-        if (!attribute->show)
-                return -EIO;
-
-        return attribute->show(entry, attribute, buf);
-}
-
-static const struct sysfs_ops msi_irq_sysfs_ops = {
-        .show = msi_irq_attr_show,
-};
-
-static struct msi_attribute mode_attribute =
-        __ATTR(mode, S_IRUGO, show_msi_mode, NULL);
-
+        struct pci_dev *pdev = to_pci_dev(dev);
+        struct msi_desc *entry;
+        unsigned long irq;
+        int retval;
 
-static struct attribute *msi_irq_default_attrs[] = {
-        &mode_attribute.attr,
-        NULL
-};
+        retval = kstrtoul(attr->attr.name, 10, &irq);
+        if (retval)
+                return retval;
 
-static void msi_kobj_release(struct kobject *kobj)
-{
-        struct msi_desc *entry = to_msi_desc(kobj);
-
-        pci_dev_put(entry->dev);
+        list_for_each_entry(entry, &pdev->msi_list, list) {
+                if (entry->irq == irq) {
+                        return sprintf(buf, "%s\n",
+                                       entry->msi_attrib.is_msix ? "msix" : "msi");
+                }
+        }
+        return -ENODEV;
 }
 
-static struct kobj_type msi_irq_ktype = {
-        .release = msi_kobj_release,
-        .sysfs_ops = &msi_irq_sysfs_ops,
-        .default_attrs = msi_irq_default_attrs,
-};
-
 static int populate_msi_sysfs(struct pci_dev *pdev)
 {
+        struct attribute **msi_attrs;
+        struct attribute *msi_attr;
+        struct device_attribute *msi_dev_attr;
+        struct attribute_group *msi_irq_group;
+        const struct attribute_group **msi_irq_groups;
         struct msi_desc *entry;
-        struct kobject *kobj;
-        int ret;
+        int ret = -ENOMEM;
+        int num_msi = 0;
         int count = 0;
 
-        pdev->msi_kset = kset_create_and_add("msi_irqs", NULL, &pdev->dev.kobj);
-        if (!pdev->msi_kset)
-                return -ENOMEM;
+        /* Determine how many msi entries we have */
+        list_for_each_entry(entry, &pdev->msi_list, list) {
+                ++num_msi;
+        }
+        if (!num_msi)
+                return 0;
 
+        /* Dynamically create the MSI attributes for the PCI device */
+        msi_attrs = kzalloc(sizeof(void *) * (num_msi + 1), GFP_KERNEL);
+        if (!msi_attrs)
+                return -ENOMEM;
         list_for_each_entry(entry, &pdev->msi_list, list) {
-                kobj = &entry->kobj;
-                kobj->kset = pdev->msi_kset;
-                pci_dev_get(pdev);
-                ret = kobject_init_and_add(kobj, &msi_irq_ktype, NULL,
-                                     "%u", entry->irq);
-                if (ret)
-                        goto out_unroll;
-
-                count++;
+                char *name = kmalloc(20, GFP_KERNEL);
+                msi_dev_attr = kzalloc(sizeof(*msi_dev_attr), GFP_KERNEL);
+                if (!msi_dev_attr)
+                        goto error_attrs;
+                sprintf(name, "%d", entry->irq);
+                sysfs_attr_init(&msi_dev_attr->attr);
+                msi_dev_attr->attr.name = name;
+                msi_dev_attr->attr.mode = S_IRUGO;
+                msi_dev_attr->show = msi_mode_show;
+                msi_attrs[count] = &msi_dev_attr->attr;
+                ++count;
         }
 
+        msi_irq_group = kzalloc(sizeof(*msi_irq_group), GFP_KERNEL);
+        if (!msi_irq_group)
+                goto error_attrs;
+        msi_irq_group->name = "msi_irqs";
+        msi_irq_group->attrs = msi_attrs;
+
+        msi_irq_groups = kzalloc(sizeof(void *) * 2, GFP_KERNEL);
+        if (!msi_irq_groups)
+                goto error_irq_group;
+        msi_irq_groups[0] = msi_irq_group;
+
+        ret = sysfs_create_groups(&pdev->dev.kobj, msi_irq_groups);
+        if (ret)
+                goto error_irq_groups;
+        pdev->msi_irq_groups = msi_irq_groups;
+
         return 0;
 
-out_unroll:
-        list_for_each_entry(entry, &pdev->msi_list, list) {
-                if (!count)
-                        break;
-                kobject_del(&entry->kobj);
-                kobject_put(&entry->kobj);
-                count--;
+error_irq_groups:
+        kfree(msi_irq_groups);
+error_irq_group:
+        kfree(msi_irq_group);
+error_attrs:
+        count = 0;
+        msi_attr = msi_attrs[count];
+        while (msi_attr) {
+                msi_dev_attr = container_of(msi_attr, struct device_attribute, attr);
+                kfree(msi_attr->name);
+                kfree(msi_dev_attr);
+                ++count;
+                msi_attr = msi_attrs[count];
         }
         return ret;
 }
@@ -729,7 +758,7 @@ static int msix_capability_init(struct pci_dev *dev,
 
         ret = arch_setup_msi_irqs(dev, nvec, PCI_CAP_ID_MSIX);
         if (ret)
-                goto error;
+                goto out_avail;
 
         /*
          * Some devices require MSI-X to be enabled before we can touch the
@@ -742,10 +771,8 @@ static int msix_capability_init(struct pci_dev *dev,
         msix_program_entries(dev, entries);
 
         ret = populate_msi_sysfs(dev);
-        if (ret) {
-                ret = 0;
-                goto error;
-        }
+        if (ret)
+                goto out_free;
 
         /* Set MSI-X enabled bits and unmask the function */
         pci_intx_for_msi(dev, 0);
@@ -756,7 +783,7 @@ static int msix_capability_init(struct pci_dev *dev,
 
         return 0;
 
-error:
+out_avail:
         if (ret < 0) {
                 /*
                  * If we had some success, report the number of irqs
@@ -773,6 +800,7 @@ error:
                         ret = avail;
         }
 
+out_free:
         free_msi_irqs(dev);
 
         return ret;
@@ -824,6 +852,31 @@ static int pci_msi_check_device(struct pci_dev *dev, int nvec, int type)
 }
 
 /**
+ * pci_msi_vec_count - Return the number of MSI vectors a device can send
+ * @dev: device to report about
+ *
+ * This function returns the number of MSI vectors a device requested via
+ * Multiple Message Capable register. It returns a negative errno if the
+ * device is not capable sending MSI interrupts. Otherwise, the call succeeds
+ * and returns a power of two, up to a maximum of 2^5 (32), according to the
+ * MSI specification.
+ **/
+int pci_msi_vec_count(struct pci_dev *dev)
+{
+        int ret;
+        u16 msgctl;
+
+        if (!dev->msi_cap)
+                return -EINVAL;
+
+        pci_read_config_word(dev, dev->msi_cap + PCI_MSI_FLAGS, &msgctl);
+        ret = 1 << ((msgctl & PCI_MSI_FLAGS_QMASK) >> 1);
+
+        return ret;
+}
+EXPORT_SYMBOL(pci_msi_vec_count);
+
+/**
  * pci_enable_msi_block - configure device's MSI capability structure
  * @dev: device to configure
  * @nvec: number of interrupts to configure
@@ -836,16 +889,16 @@ static int pci_msi_check_device(struct pci_dev *dev, int nvec, int type)
  * updates the @dev's irq member to the lowest new interrupt number; the
  * other interrupt numbers allocated to this device are consecutive.
  */
-int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec)
+int pci_enable_msi_block(struct pci_dev *dev, int nvec)
 {
         int status, maxvec;
-        u16 msgctl;
 
-        if (!dev->msi_cap || dev->current_state != PCI_D0)
+        if (dev->current_state != PCI_D0)
                 return -EINVAL;
 
-        pci_read_config_word(dev, dev->msi_cap + PCI_MSI_FLAGS, &msgctl);
-        maxvec = 1 << ((msgctl & PCI_MSI_FLAGS_QMASK) >> 1);
+        maxvec = pci_msi_vec_count(dev);
+        if (maxvec < 0)
+                return maxvec;
         if (nvec > maxvec)
                 return maxvec;
 
@@ -867,31 +920,6 @@ int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec)
 }
 EXPORT_SYMBOL(pci_enable_msi_block);
 
-int pci_enable_msi_block_auto(struct pci_dev *dev, unsigned int *maxvec)
-{
-        int ret, nvec;
-        u16 msgctl;
-
-        if (!dev->msi_cap || dev->current_state != PCI_D0)
-                return -EINVAL;
-
-        pci_read_config_word(dev, dev->msi_cap + PCI_MSI_FLAGS, &msgctl);
-        ret = 1 << ((msgctl & PCI_MSI_FLAGS_QMASK) >> 1);
-
-        if (maxvec)
-                *maxvec = ret;
-
-        do {
-                nvec = ret;
-                ret = pci_enable_msi_block(dev, nvec);
-        } while (ret > 0);
-
-        if (ret < 0)
-                return ret;
-        return nvec;
-}
-EXPORT_SYMBOL(pci_enable_msi_block_auto);
-
 void pci_msi_shutdown(struct pci_dev *dev)
 {
         struct msi_desc *desc;
@@ -925,25 +953,29 @@ void pci_disable_msi(struct pci_dev *dev)
 
         pci_msi_shutdown(dev);
         free_msi_irqs(dev);
-        kset_unregister(dev->msi_kset);
-        dev->msi_kset = NULL;
 }
 EXPORT_SYMBOL(pci_disable_msi);
 
 /**
- * pci_msix_table_size - return the number of device's MSI-X table entries
+ * pci_msix_vec_count - return the number of device's MSI-X table entries
  * @dev: pointer to the pci_dev data structure of MSI-X device function
- */
-int pci_msix_table_size(struct pci_dev *dev)
+
+ * This function returns the number of device's MSI-X table entries and
+ * therefore the number of MSI-X vectors device is capable of sending.
+ * It returns a negative errno if the device is not capable of sending MSI-X
+ * interrupts.
+ **/
+int pci_msix_vec_count(struct pci_dev *dev)
 {
         u16 control;
 
         if (!dev->msix_cap)
-                return 0;
+                return -EINVAL;
 
         pci_read_config_word(dev, dev->msix_cap + PCI_MSIX_FLAGS, &control);
         return msix_table_size(control);
 }
+EXPORT_SYMBOL(pci_msix_vec_count);
 
 /**
  * pci_enable_msix - configure device's MSI-X capability structure
@@ -972,7 +1004,9 @@ int pci_enable_msix(struct pci_dev *dev, struct msix_entry *entries, int nvec)
         if (status)
                 return status;
 
-        nr_entries = pci_msix_table_size(dev);
+        nr_entries = pci_msix_vec_count(dev);
+        if (nr_entries < 0)
+                return nr_entries;
         if (nvec > nr_entries)
                 return nr_entries;
 
@@ -1023,8 +1057,6 @@ void pci_disable_msix(struct pci_dev *dev)
 
         pci_msix_shutdown(dev);
         free_msi_irqs(dev);
-        kset_unregister(dev->msi_kset);
-        dev->msi_kset = NULL;
 }
 EXPORT_SYMBOL(pci_disable_msix);
 
@@ -1079,3 +1111,77 @@ void pci_msi_init_pci_dev(struct pci_dev *dev)
         if (dev->msix_cap)
                 msix_set_enable(dev, 0);
 }
+
+/**
+ * pci_enable_msi_range - configure device's MSI capability structure
+ * @dev: device to configure
+ * @minvec: minimal number of interrupts to configure
+ * @maxvec: maximum number of interrupts to configure
+ *
+ * This function tries to allocate a maximum possible number of interrupts in a
+ * range between @minvec and @maxvec. It returns a negative errno if an error
+ * occurs. If it succeeds, it returns the actual number of interrupts allocated
+ * and updates the @dev's irq member to the lowest new interrupt number;
+ * the other interrupt numbers allocated to this device are consecutive.
+ **/
+int pci_enable_msi_range(struct pci_dev *dev, int minvec, int maxvec)
+{
+        int nvec = maxvec;
+        int rc;
+
+        if (maxvec < minvec)
+                return -ERANGE;
+
+        do {
+                rc = pci_enable_msi_block(dev, nvec);
+                if (rc < 0) {
+                        return rc;
+                } else if (rc > 0) {
+                        if (rc < minvec)
+                                return -ENOSPC;
+                        nvec = rc;
+                }
+        } while (rc);
+
+        return nvec;
+}
+EXPORT_SYMBOL(pci_enable_msi_range);
+
+/**
+ * pci_enable_msix_range - configure device's MSI-X capability structure
+ * @dev: pointer to the pci_dev data structure of MSI-X device function
+ * @entries: pointer to an array of MSI-X entries
+ * @minvec: minimum number of MSI-X irqs requested
+ * @maxvec: maximum number of MSI-X irqs requested
+ *
+ * Setup the MSI-X capability structure of device function with a maximum
+ * possible number of interrupts in the range between @minvec and @maxvec
+ * upon its software driver call to request for MSI-X mode enabled on its
+ * hardware device function. It returns a negative errno if an error occurs.
+ * If it succeeds, it returns the actual number of interrupts allocated and
+ * indicates the successful configuration of MSI-X capability structure
+ * with new allocated MSI-X interrupts.
+ **/
+int pci_enable_msix_range(struct pci_dev *dev, struct msix_entry *entries,
+                               int minvec, int maxvec)
+{
+        int nvec = maxvec;
+        int rc;
+
+        if (maxvec < minvec)
+                return -ERANGE;
+
+        do {
+                rc = pci_enable_msix(dev, entries, nvec);
+                if (rc < 0) {
+                        return rc;
+                } else if (rc > 0) {
+                        if (rc < minvec)
+                                return -ENOSPC;
+                        nvec = rc;
+                }
+        } while (rc);
+
+        return nvec;
+}
+EXPORT_SYMBOL(pci_enable_msix_range);
diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index 577074efbe62..e0431f1af33b 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -358,7 +358,7 @@ static void pci_acpi_cleanup(struct device *dev)
 
 static bool pci_acpi_bus_match(struct device *dev)
 {
-        return dev->bus == &pci_bus_type;
+        return dev_is_pci(dev);
 }
 
 static struct acpi_bus_type acpi_pci_bus = {
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 9042fdbd7244..25f0bc659164 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -19,6 +19,7 @@
 #include <linux/cpu.h>
 #include <linux/pm_runtime.h>
 #include <linux/suspend.h>
+#include <linux/kexec.h>
 #include "pci.h"
 
 struct pci_dynid {
@@ -288,12 +289,27 @@ static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
         int error, node;
         struct drv_dev_and_id ddi = { drv, dev, id };
 
-        /* Execute driver initialization on node where the device's
-           bus is attached to.  This way the driver likely allocates
-           its local memory on the right node without any need to
-           change it. */
+        /*
+         * Execute driver initialization on node where the device is
+         * attached.  This way the driver likely allocates its local memory
+         * on the right node.
+         */
         node = dev_to_node(&dev->dev);
-        if (node >= 0) {
+
+        /*
+         * On NUMA systems, we are likely to call a PF probe function using
+         * work_on_cpu().  If that probe calls pci_enable_sriov() (which
+         * adds the VF devices via pci_bus_add_device()), we may re-enter
+         * this function to call the VF probe function.  Calling
+         * work_on_cpu() again will cause a lockdep warning.  Since VFs are
+         * always on the same node as the PF, we can work around this by
+         * avoiding work_on_cpu() when we're already on the correct node.
+         *
+         * Preemption is enabled, so it's theoretically unsafe to use
+         * numa_node_id(), but even if we run the probe function on the
+         * wrong node, it should be functionally correct.
+         */
+        if (node >= 0 && node != numa_node_id()) {
                 int cpu;
 
                 get_online_cpus();
@@ -305,6 +321,7 @@ static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
                 put_online_cpus();
         } else
                 error = local_pci_probe(&ddi);
+
         return error;
 }
 
@@ -399,12 +416,17 @@ static void pci_device_shutdown(struct device *dev)
         pci_msi_shutdown(pci_dev);
         pci_msix_shutdown(pci_dev);
 
+#ifdef CONFIG_KEXEC
         /*
-         * Turn off Bus Master bit on the device to tell it to not
-         * continue to do DMA. Don't touch devices in D3cold or unknown states.
+         * If this is a kexec reboot, turn off Bus Master bit on the
+         * device to tell it to not continue to do DMA. Don't touch
+         * devices in D3cold or unknown states.
+         * If it is not a kexec reboot, firmware will hit the PCI
+         * devices with big hammer and stop their DMA any way.
          */
-        if (pci_dev->current_state <= PCI_D3hot)
+        if (kexec_in_progress && (pci_dev->current_state <= PCI_D3hot))
                 pci_clear_master(pci_dev);
+#endif
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 33120d156668..508e560b7d2a 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -431,6 +431,32 @@ pci_find_parent_resource(const struct pci_dev *dev, struct resource *res)
 }
 
 /**
+ * pci_wait_for_pending - wait for @mask bit(s) to clear in status word @pos
+ * @dev: the PCI device to operate on
+ * @pos: config space offset of status word
+ * @mask: mask of bit(s) to care about in status word
+ *
+ * Return 1 when mask bit(s) in status word clear, 0 otherwise.
+ */
+int pci_wait_for_pending(struct pci_dev *dev, int pos, u16 mask)
+{
+        int i;
+
+        /* Wait for Transaction Pending bit clean */
+        for (i = 0; i < 4; i++) {
+                u16 status;
+                if (i)
+                        msleep((1 << (i - 1)) * 100);
+
+                pci_read_config_word(dev, pos, &status);
+                if (!(status & mask))
+                        return 1;
+        }
+
+        return 0;
+}
+
+/**
  * pci_restore_bars - restore a devices BAR values (e.g. after wake-up)
  * @dev: PCI device to have its BARs restored
  *
@@ -835,18 +861,28 @@ EXPORT_SYMBOL(pci_choose_state);
 #define PCI_EXP_SAVE_REGS       7
 
 
-static struct pci_cap_saved_state *pci_find_saved_cap(
-        struct pci_dev *pci_dev, char cap)
+static struct pci_cap_saved_state *_pci_find_saved_cap(struct pci_dev *pci_dev,
+                                                       u16 cap, bool extended)
 {
         struct pci_cap_saved_state *tmp;
 
         hlist_for_each_entry(tmp, &pci_dev->saved_cap_space, next) {
-                if (tmp->cap.cap_nr == cap)
+                if (tmp->cap.cap_extended == extended && tmp->cap.cap_nr == cap)
                         return tmp;
         }
         return NULL;
 }
 
+struct pci_cap_saved_state *pci_find_saved_cap(struct pci_dev *dev, char cap)
+{
+        return _pci_find_saved_cap(dev, cap, false);
+}
+
+struct pci_cap_saved_state *pci_find_saved_ext_cap(struct pci_dev *dev, u16 cap)
+{
+        return _pci_find_saved_cap(dev, cap, true);
+}
+
 static int pci_save_pcie_state(struct pci_dev *dev)
 {
         int i = 0;
@@ -948,6 +984,8 @@ pci_save_state(struct pci_dev *dev)
                 return i;
         if ((i = pci_save_pcix_state(dev)) != 0)
                 return i;
+        if ((i = pci_save_vc_state(dev)) != 0)
+                return i;
         return 0;
 }
 
@@ -1010,6 +1048,7 @@ void pci_restore_state(struct pci_dev *dev)
         /* PCI Express register must be restored first */
         pci_restore_pcie_state(dev);
         pci_restore_ats_state(dev);
+        pci_restore_vc_state(dev);
 
         pci_restore_config_space(dev);
 
@@ -1087,7 +1126,7 @@ int pci_load_saved_state(struct pci_dev *dev, struct pci_saved_state *state)
         while (cap->size) {
                 struct pci_cap_saved_state *tmp;
 
-                tmp = pci_find_saved_cap(dev, cap->cap_nr);
+                tmp = _pci_find_saved_cap(dev, cap->cap_nr, cap->cap_extended);
                 if (!tmp || tmp->cap.size != cap->size)
                         return -EINVAL;
 
@@ -2021,18 +2060,24 @@ static void pci_add_saved_cap(struct pci_dev *pci_dev,
 }
 
 /**
- * pci_add_cap_save_buffer - allocate buffer for saving given capability registers
+ * _pci_add_cap_save_buffer - allocate buffer for saving given
+ *                            capability registers
  * @dev: the PCI device
  * @cap: the capability to allocate the buffer for
+ * @extended: Standard or Extended capability ID
  * @size: requested size of the buffer
  */
-static int pci_add_cap_save_buffer(
-        struct pci_dev *dev, char cap, unsigned int size)
+static int _pci_add_cap_save_buffer(struct pci_dev *dev, u16 cap,
+                                    bool extended, unsigned int size)
 {
         int pos;
         struct pci_cap_saved_state *save_state;
 
-        pos = pci_find_capability(dev, cap);
+        if (extended)
+                pos = pci_find_ext_capability(dev, cap);
+        else
+                pos = pci_find_capability(dev, cap);
+
         if (pos <= 0)
                 return 0;
 
@@ -2041,12 +2086,23 @@ static int pci_add_cap_save_buffer(
                 return -ENOMEM;
 
         save_state->cap.cap_nr = cap;
+        save_state->cap.cap_extended = extended;
         save_state->cap.size = size;
         pci_add_saved_cap(dev, save_state);
 
         return 0;
 }
 
+int pci_add_cap_save_buffer(struct pci_dev *dev, char cap, unsigned int size)
+{
+        return _pci_add_cap_save_buffer(dev, cap, false, size);
+}
+
+int pci_add_ext_cap_save_buffer(struct pci_dev *dev, u16 cap, unsigned int size)
+{
+        return _pci_add_cap_save_buffer(dev, cap, true, size);
+}
+
 /**
  * pci_allocate_cap_save_buffers - allocate buffers for saving capabilities
  * @dev: the PCI device
@@ -2065,6 +2121,8 @@ void pci_allocate_cap_save_buffers(struct pci_dev *dev)
         if (error)
                 dev_err(&dev->dev,
                         "unable to preallocate PCI-X save buffer\n");
+
+        pci_allocate_vc_save_buffers(dev);
 }
 
 void pci_free_cap_save_buffers(struct pci_dev *dev)
@@ -3204,20 +3262,10 @@ EXPORT_SYMBOL(pci_set_dma_seg_boundary);
  */
 int pci_wait_for_pending_transaction(struct pci_dev *dev)
 {
-        int i;
-        u16 status;
-
-        /* Wait for Transaction Pending bit clean */
-        for (i = 0; i < 4; i++) {
-                if (i)
-                        msleep((1 << (i - 1)) * 100);
-
-                pcie_capability_read_word(dev, PCI_EXP_DEVSTA, &status);
-                if (!(status & PCI_EXP_DEVSTA_TRPND))
-                        return 1;
-        }
+        if (!pci_is_pcie(dev))
+                return 1;
 
-        return 0;
+        return pci_wait_for_pending(dev, PCI_EXP_DEVSTA, PCI_EXP_DEVSTA_TRPND);
 }
 EXPORT_SYMBOL(pci_wait_for_pending_transaction);
 
@@ -3244,10 +3292,8 @@ static int pcie_flr(struct pci_dev *dev, int probe)
 
 static int pci_af_flr(struct pci_dev *dev, int probe)
 {
-        int i;
         int pos;
         u8 cap;
-        u8 status;
 
         pos = pci_find_capability(dev, PCI_CAP_ID_AF);
         if (!pos)
@@ -3261,14 +3307,8 @@ static int pci_af_flr(struct pci_dev *dev, int probe)
                 return 0;
 
         /* Wait for Transaction Pending bit clean */
-        for (i = 0; i < 4; i++) {
-                if (i)
-                        msleep((1 << (i - 1)) * 100);
-
-                pci_read_config_byte(dev, pos + PCI_AF_STATUS, &status);
-                if (!(status & PCI_AF_STATUS_TP))
-                        goto clear;
-        }
+        if (pci_wait_for_pending(dev, PCI_AF_STATUS, PCI_AF_STATUS_TP))
+                goto clear;
 
         dev_err(&dev->dev, "transaction is not cleared; "
                         "proceeding with reset anyway\n");
diff --git a/drivers/pci/pcie/aer/aerdrv_acpi.c b/drivers/pci/pcie/aer/aerdrv_acpi.c
index cf611ab2193a..4d6991794fa2 100644
--- a/drivers/pci/pcie/aer/aerdrv_acpi.c
+++ b/drivers/pci/pcie/aer/aerdrv_acpi.c
@@ -50,14 +50,37 @@ struct aer_hest_parse_info {
         int firmware_first;
 };
 
+static int hest_source_is_pcie_aer(struct acpi_hest_header *hest_hdr)
+{
+        if (hest_hdr->type == ACPI_HEST_TYPE_AER_ROOT_PORT ||
+            hest_hdr->type == ACPI_HEST_TYPE_AER_ENDPOINT ||
+            hest_hdr->type == ACPI_HEST_TYPE_AER_BRIDGE)
+                return 1;
+        return 0;
+}
+
 static int aer_hest_parse(struct acpi_hest_header *hest_hdr, void *data)
 {
         struct aer_hest_parse_info *info = data;
         struct acpi_hest_aer_common *p;
         int ff;
 
+        if (!hest_source_is_pcie_aer(hest_hdr))
+                return 0;
+
         p = (struct acpi_hest_aer_common *)(hest_hdr + 1);
         ff = !!(p->flags & ACPI_HEST_FIRMWARE_FIRST);
+
+        /*
+         * If no specific device is supplied, determine whether
+         * FIRMWARE_FIRST is set for *any* PCIe device.
+         */
+        if (!info->pci_dev) {
+                info->firmware_first |= ff;
+                return 0;
+        }
+
+        /* Otherwise, check the specific device */
         if (p->flags & ACPI_HEST_GLOBAL) {
                 if (hest_match_type(hest_hdr, info->pci_dev))
                         info->firmware_first = ff;
@@ -97,33 +120,20 @@ int pcie_aer_get_firmware_first(struct pci_dev *dev)
 
 static bool aer_firmware_first;
 
-static int aer_hest_parse_aff(struct acpi_hest_header *hest_hdr, void *data)
-{
-        struct acpi_hest_aer_common *p;
-
-        if (aer_firmware_first)
-                return 0;
-
-        switch (hest_hdr->type) {
-        case ACPI_HEST_TYPE_AER_ROOT_PORT:
-        case ACPI_HEST_TYPE_AER_ENDPOINT:
-        case ACPI_HEST_TYPE_AER_BRIDGE:
-                p = (struct acpi_hest_aer_common *)(hest_hdr + 1);
-                aer_firmware_first = !!(p->flags & ACPI_HEST_FIRMWARE_FIRST);
-        default:
-                return 0;
-        }
-}
-
 /**
  * aer_acpi_firmware_first - Check if APEI should control AER.
  */
 bool aer_acpi_firmware_first(void)
 {
         static bool parsed = false;
+        struct aer_hest_parse_info info = {
+                .pci_dev        = NULL, /* Check all PCIe devices */
+                .firmware_first = 0,
+        };
 
         if (!parsed) {
-                apei_hest_parse(aer_hest_parse_aff, NULL);
+                apei_hest_parse(aer_hest_parse, &info);
+                aer_firmware_first = info.firmware_first;
                 parsed = true;
         }
         return aer_firmware_first;
diff --git a/drivers/pci/pcie/aer/aerdrv_errprint.c b/drivers/pci/pcie/aer/aerdrv_errprint.c
index 2c7c9f5f592c..34ff7026440c 100644
--- a/drivers/pci/pcie/aer/aerdrv_errprint.c
+++ b/drivers/pci/pcie/aer/aerdrv_errprint.c
@@ -124,6 +124,21 @@ static const char *aer_agent_string[] = {
         "Transmitter ID"
 };
 
+static void __print_tlp_header(struct pci_dev *dev,
+                               struct aer_header_log_regs *t)
+{
+        unsigned char *tlp = (unsigned char *)&t;
+
+        dev_err(&dev->dev, "  TLP Header:"
+                " %02x%02x%02x%02x %02x%02x%02x%02x"
+                " %02x%02x%02x%02x %02x%02x%02x%02x\n",
+                *(tlp + 3), *(tlp + 2), *(tlp + 1), *tlp,
+                *(tlp + 7), *(tlp + 6), *(tlp + 5), *(tlp + 4),
+                *(tlp + 11), *(tlp + 10), *(tlp + 9),
+                *(tlp + 8), *(tlp + 15), *(tlp + 14),
+                *(tlp + 13), *(tlp + 12));
+}
+
 static void __aer_print_error(struct pci_dev *dev,
                               struct aer_err_info *info)
 {
@@ -153,48 +168,39 @@ static void __aer_print_error(struct pci_dev *dev,
 
 void aer_print_error(struct pci_dev *dev, struct aer_err_info *info)
 {
+        int layer, agent;
         int id = ((dev->bus->number << 8) | dev->devfn);
 
-        if (info->status == 0) {
+        if (!info->status) {
                 dev_err(&dev->dev,
                         "PCIe Bus Error: severity=%s, type=Unaccessible, "
                         "id=%04x(Unregistered Agent ID)\n",
                         aer_error_severity_string[info->severity], id);
-        } else {
-                int layer, agent;
+                goto out;
+        }
 
-                layer = AER_GET_LAYER_ERROR(info->severity, info->status);
-                agent = AER_GET_AGENT(info->severity, info->status);
+        layer = AER_GET_LAYER_ERROR(info->severity, info->status);
+        agent = AER_GET_AGENT(info->severity, info->status);
 
-                dev_err(&dev->dev,
-                        "PCIe Bus Error: severity=%s, type=%s, id=%04x(%s)\n",
-                        aer_error_severity_string[info->severity],
-                        aer_error_layer[layer], id, aer_agent_string[agent]);
+        dev_err(&dev->dev,
+                "PCIe Bus Error: severity=%s, type=%s, id=%04x(%s)\n",
+                aer_error_severity_string[info->severity],
+                aer_error_layer[layer], id, aer_agent_string[agent]);
 
-                dev_err(&dev->dev,
-                        "  device [%04x:%04x] error status/mask=%08x/%08x\n",
-                        dev->vendor, dev->device,
-                        info->status, info->mask);
-
-                __aer_print_error(dev, info);
-
-                if (info->tlp_header_valid) {
-                        unsigned char *tlp = (unsigned char *) &info->tlp;
-                        dev_err(&dev->dev, "  TLP Header:"
-                                " %02x%02x%02x%02x %02x%02x%02x%02x"
-                                " %02x%02x%02x%02x %02x%02x%02x%02x\n",
-                                *(tlp + 3), *(tlp + 2), *(tlp + 1), *tlp,
-                                *(tlp + 7), *(tlp + 6), *(tlp + 5), *(tlp + 4),
-                                *(tlp + 11), *(tlp + 10), *(tlp + 9),
-                                *(tlp + 8), *(tlp + 15), *(tlp + 14),
-                                *(tlp + 13), *(tlp + 12));
-                }
-        }
+        dev_err(&dev->dev,
+                "  device [%04x:%04x] error status/mask=%08x/%08x\n",
+                dev->vendor, dev->device,
+                info->status, info->mask);
+
+        __aer_print_error(dev, info);
 
+        if (info->tlp_header_valid)
+                __print_tlp_header(dev, &info->tlp);
+
+out:
         if (info->id && info->error_dev_num > 1 && info->id == id)
-                dev_err(&dev->dev,
-                           "  Error of this Agent(%04x) is reported first\n",
-                        id);
+                dev_err(&dev->dev, "  Error of this Agent(%04x) is reported first\n", id);
+
         trace_aer_event(dev_name(&dev->dev), (info->status & ~info->mask),
                         info->severity);
 }
@@ -228,6 +234,7 @@ void cper_print_aer(struct pci_dev *dev, int cper_severity,
         const char **status_strs;
 
         aer_severity = cper_severity_to_aer(cper_severity);
+
         if (aer_severity == AER_CORRECTABLE) {
                 status = aer->cor_status;
                 mask = aer->cor_mask;
@@ -240,28 +247,22 @@ void cper_print_aer(struct pci_dev *dev, int cper_severity,
                 status_strs_size = ARRAY_SIZE(aer_uncorrectable_error_string);
                 tlp_header_valid = status & AER_LOG_TLP_MASKS;
         }
+
         layer = AER_GET_LAYER_ERROR(aer_severity, status);
         agent = AER_GET_AGENT(aer_severity, status);
-        dev_err(&dev->dev, "aer_status: 0x%08x, aer_mask: 0x%08x\n",
-               status, mask);
+
+        dev_err(&dev->dev, "aer_status: 0x%08x, aer_mask: 0x%08x\n", status, mask);
         cper_print_bits("", status, status_strs, status_strs_size);
         dev_err(&dev->dev, "aer_layer=%s, aer_agent=%s\n",
-               aer_error_layer[layer], aer_agent_string[agent]);
+                aer_error_layer[layer], aer_agent_string[agent]);
+
         if (aer_severity != AER_CORRECTABLE)
                 dev_err(&dev->dev, "aer_uncor_severity: 0x%08x\n",
-                       aer->uncor_severity);
-        if (tlp_header_valid) {
-                const unsigned char *tlp;
-                tlp = (const unsigned char *)&aer->header_log;
-                dev_err(&dev->dev, "aer_tlp_header:"
-                        " %02x%02x%02x%02x %02x%02x%02x%02x"
-                        " %02x%02x%02x%02x %02x%02x%02x%02x\n",
-                        *(tlp + 3), *(tlp + 2), *(tlp + 1), *tlp,
-                        *(tlp + 7), *(tlp + 6), *(tlp + 5), *(tlp + 4),
-                        *(tlp + 11), *(tlp + 10), *(tlp + 9),
-                        *(tlp + 8), *(tlp + 15), *(tlp + 14),
-                        *(tlp + 13), *(tlp + 12));
-        }
+                        aer->uncor_severity);
+
+        if (tlp_header_valid)
+                __print_tlp_header(dev, &aer->header_log);
+
         trace_aer_event(dev_name(&dev->dev), (status & ~mask),
                         aer_severity);
 }
diff --git a/drivers/pci/pcie/portdrv_core.c b/drivers/pci/pcie/portdrv_core.c
index 0b6e76604068..986f8eadfd39 100644
--- a/drivers/pci/pcie/portdrv_core.c
+++ b/drivers/pci/pcie/portdrv_core.c
@@ -79,9 +79,10 @@ static int pcie_port_enable_msix(struct pci_dev *dev, int *vectors, int mask)
         u16 reg16;
         u32 reg32;
 
-        nr_entries = pci_msix_table_size(dev);
-        if (!nr_entries)
-                return -EINVAL;
+        nr_entries = pci_msix_vec_count(dev);
+        if (nr_entries < 0)
+                return nr_entries;
+        BUG_ON(!nr_entries);
         if (nr_entries > PCIE_PORT_MAX_MSIX_ENTRIES)
                 nr_entries = PCIE_PORT_MAX_MSIX_ENTRIES;
 
@@ -344,11 +345,12 @@ static int pcie_device_init(struct pci_dev *pdev, int service, int irq)
         device_enable_async_suspend(device);
 
         retval = device_register(device);
-        if (retval)
-                kfree(pcie);
-        else
-                get_device(device);
-        return retval;
+        if (retval) {
+                put_device(device);
+                return retval;
+        }
+
+        return 0;
 }
 
 /**
@@ -454,10 +456,8 @@ int pcie_port_device_resume(struct device *dev)
 
 static int remove_iter(struct device *dev, void *data)
 {
-        if (dev->bus == &pcie_port_bus_type) {
-                put_device(dev);
+        if (dev->bus == &pcie_port_bus_type)
                 device_unregister(dev);
-        }
         return 0;
 }
 
@@ -498,12 +498,12 @@ static int pcie_port_probe_service(struct device *dev)
 
         pciedev = to_pcie_device(dev);
         status = driver->probe(pciedev);
-        if (!status) {
-                dev_printk(KERN_DEBUG, dev, "service driver %s loaded\n",
-                        driver->name);
-                get_device(dev);
-        }
-        return status;
+        if (status)
+                return status;
+
+        dev_printk(KERN_DEBUG, dev, "service driver %s loaded\n", driver->name);
+        get_device(dev);
+        return 0;
 }
 
 /**
@@ -554,7 +554,7 @@ int pcie_port_service_register(struct pcie_port_service_driver *new)
         if (pcie_ports_disabled)
                 return -ENODEV;
 
-        new->driver.name = (char *)new->name;
+        new->driver.name = new->name;
         new->driver.bus = &pcie_port_bus_type;
         new->driver.probe = pcie_port_probe_service;
         new->driver.remove = pcie_port_remove_service;
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index f049e3f53fcc..23cdfac0bdb3 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -1154,6 +1154,18 @@ static void pci_release_capabilities(struct pci_dev *dev)
         pci_free_cap_save_buffers(dev);
 }
 
+static void pci_free_resources(struct pci_dev *dev)
+{
+        int i;
+
+        pci_cleanup_rom(dev);
+        for (i = 0; i < PCI_NUM_RESOURCES; i++) {
+                struct resource *res = dev->resource + i;
+                if (res->parent)
+                        release_resource(res);
+        }
+}
+
 /**
  * pci_release_dev - free a pci device structure when all users of it are finished.
  * @dev: device that's been disconnected
@@ -1163,9 +1175,14 @@ static void pci_release_capabilities(struct pci_dev *dev)
  */
 static void pci_release_dev(struct device *dev)
 {
-        struct pci_dev *pci_dev;
+        struct pci_dev *pci_dev = to_pci_dev(dev);
+
+        down_write(&pci_bus_sem);
+        list_del(&pci_dev->bus_list);
+        up_write(&pci_bus_sem);
+
+        pci_free_resources(pci_dev);
 
-        pci_dev = to_pci_dev(dev);
         pci_release_capabilities(pci_dev);
         pci_release_of_node(pci_dev);
         pcibios_release_device(pci_dev);
@@ -1381,8 +1398,6 @@ void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
         dev->match_driver = false;
         ret = device_add(&dev->dev);
         WARN_ON(ret < 0);
-
-        pci_proc_attach_device(dev);
 }
 
 struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
diff --git a/drivers/pci/remove.c b/drivers/pci/remove.c
index 1576851028db..f452148e6d55 100644
--- a/drivers/pci/remove.c
+++ b/drivers/pci/remove.c
@@ -3,20 +3,6 @@
 #include <linux/pci-aspm.h>
 #include "pci.h"
 
-static void pci_free_resources(struct pci_dev *dev)
-{
-        int i;
-
-        msi_remove_pci_irq_vectors(dev);
-
-        pci_cleanup_rom(dev);
-        for (i = 0; i < PCI_NUM_RESOURCES; i++) {
-                struct resource *res = dev->resource + i;
-                if (res->parent)
-                        release_resource(res);
-        }
-}
-
 static void pci_stop_dev(struct pci_dev *dev)
 {
         pci_pme_active(dev, false);
@@ -24,7 +10,7 @@ static void pci_stop_dev(struct pci_dev *dev)
         if (dev->is_added) {
                 pci_proc_detach_device(dev);
                 pci_remove_sysfs_dev_files(dev);
-                device_del(&dev->dev);
+                device_release_driver(&dev->dev);
                 dev->is_added = 0;
         }
 
@@ -34,11 +20,8 @@ static void pci_stop_dev(struct pci_dev *dev)
 
 static void pci_destroy_dev(struct pci_dev *dev)
 {
-        down_write(&pci_bus_sem);
-        list_del(&dev->bus_list);
-        up_write(&pci_bus_sem);
+        device_del(&dev->dev);
 
-        pci_free_resources(dev);
         put_device(&dev->dev);
 }
 
@@ -126,7 +109,7 @@ void pci_stop_root_bus(struct pci_bus *bus)
                 pci_stop_bus_device(child);
 
         /* stop the host bridge */
-        device_del(&host_bridge->dev);
+        device_release_driver(&host_bridge->dev);
 }
 
 void pci_remove_root_bus(struct pci_bus *bus)
@@ -145,5 +128,5 @@ void pci_remove_root_bus(struct pci_bus *bus)
         host_bridge->bus = NULL;
 
         /* remove the host bridge */
-        put_device(&host_bridge->dev);
+        device_unregister(&host_bridge->dev);
 }
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index 79339822d80e..138bdd6393be 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -538,7 +538,8 @@ static void pci_setup_bridge_io(struct pci_bus *bus)
         struct pci_bus_region region;
         unsigned long io_mask;
         u8 io_base_lo, io_limit_lo;
-        u32 l, io_upper16;
+        u16 l;
+        u32 io_upper16;
 
         io_mask = PCI_IO_RANGE_MASK;
         if (bridge->io_window_1k)
@@ -548,11 +549,10 @@ static void pci_setup_bridge_io(struct pci_bus *bus)
         res = bus->resource[0];
         pcibios_resource_to_bus(bridge->bus, &region, res);
         if (res->flags & IORESOURCE_IO) {
-                pci_read_config_dword(bridge, PCI_IO_BASE, &l);
-                l &= 0xffff0000;
+                pci_read_config_word(bridge, PCI_IO_BASE, &l);
                 io_base_lo = (region.start >> 8) & io_mask;
                 io_limit_lo = (region.end >> 8) & io_mask;
-                l |= ((u32) io_limit_lo << 8) | io_base_lo;
+                l = ((u16) io_limit_lo << 8) | io_base_lo;
                 /* Set up upper 16 bits of I/O base/limit. */
                 io_upper16 = (region.end & 0xffff0000) | (region.start >> 16);
                 dev_info(&bridge->dev, "  bridge window %pR\n", res);
@@ -564,7 +564,7 @@ static void pci_setup_bridge_io(struct pci_bus *bus)
         /* Temporarily disable the I/O range before updating PCI_IO_BASE. */
         pci_write_config_dword(bridge, PCI_IO_BASE_UPPER16, 0x0000ffff);
         /* Update lower 16 bits of I/O base/limit. */
-        pci_write_config_dword(bridge, PCI_IO_BASE, l);
+        pci_write_config_word(bridge, PCI_IO_BASE, l);
         /* Update upper 16 bits of I/O base/limit. */
         pci_write_config_dword(bridge, PCI_IO_BASE_UPPER16, io_upper16);
 }
@@ -665,21 +665,23 @@ static void pci_bridge_check_ranges(struct pci_bus *bus)
 
         pci_read_config_word(bridge, PCI_IO_BASE, &io);
         if (!io) {
-                pci_write_config_word(bridge, PCI_IO_BASE, 0xf0f0);
+                pci_write_config_word(bridge, PCI_IO_BASE, 0xe0f0);
                 pci_read_config_word(bridge, PCI_IO_BASE, &io);
                 pci_write_config_word(bridge, PCI_IO_BASE, 0x0);
         }
         if (io)
                 b_res[0].flags |= IORESOURCE_IO;
+
         /*  DECchip 21050 pass 2 errata: the bridge may miss an address
             disconnect boundary by one PCI data phase.
             Workaround: do not use prefetching on this device. */
         if (bridge->vendor == PCI_VENDOR_ID_DEC && bridge->device == 0x0001)
                 return;
+
         pci_read_config_dword(bridge, PCI_PREF_MEMORY_BASE, &pmem);
         if (!pmem) {
                 pci_write_config_dword(bridge, PCI_PREF_MEMORY_BASE,
-                                               0xfff0fff0);
+                                               0xffe0fff0);
                 pci_read_config_dword(bridge, PCI_PREF_MEMORY_BASE, &pmem);
                 pci_write_config_dword(bridge, PCI_PREF_MEMORY_BASE, 0x0);
         }
diff --git a/drivers/pci/vc.c b/drivers/pci/vc.c
new file mode 100644
index 000000000000..7e1304d2e389
--- /dev/null
+++ b/drivers/pci/vc.c
@@ -0,0 +1,434 @@
+/*
+ * PCI Virtual Channel support
+ *
+ * Copyright (C) 2013 Red Hat, Inc.  All rights reserved.
+ *     Author: Alex Williamson <alex.williamson@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/pci_regs.h>
+#include <linux/types.h>
+
+/**
+ * pci_vc_save_restore_dwords - Save or restore a series of dwords
+ * @dev: device
+ * @pos: starting config space position
+ * @buf: buffer to save to or restore from
+ * @dwords: number of dwords to save/restore
+ * @save: whether to save or restore
+ */
+static void pci_vc_save_restore_dwords(struct pci_dev *dev, int pos,
+                                       u32 *buf, int dwords, bool save)
+{
+        int i;
+
+        for (i = 0; i < dwords; i++, buf++) {
+                if (save)
+                        pci_read_config_dword(dev, pos + (i * 4), buf);
+                else
+                        pci_write_config_dword(dev, pos + (i * 4), *buf);
+        }
+}
+
+/**
+ * pci_vc_load_arb_table - load and wait for VC arbitration table
+ * @dev: device
+ * @pos: starting position of VC capability (VC/VC9/MFVC)
+ *
+ * Set Load VC Arbitration Table bit requesting hardware to apply the VC
+ * Arbitration Table (previously loaded).  When the VC Arbitration Table
+ * Status clears, hardware has latched the table into VC arbitration logic.
+ */
+static void pci_vc_load_arb_table(struct pci_dev *dev, int pos)
+{
+        u16 ctrl;
+
+        pci_read_config_word(dev, pos + PCI_VC_PORT_CTRL, &ctrl);
+        pci_write_config_word(dev, pos + PCI_VC_PORT_CTRL,
+                              ctrl | PCI_VC_PORT_CTRL_LOAD_TABLE);
+        if (pci_wait_for_pending(dev, pos + PCI_VC_PORT_STATUS,
+                                 PCI_VC_PORT_STATUS_TABLE))
+                return;
+
+        dev_err(&dev->dev, "VC arbitration table failed to load\n");
+}
+
+/**
+ * pci_vc_load_port_arb_table - Load and wait for VC port arbitration table
+ * @dev: device
+ * @pos: starting position of VC capability (VC/VC9/MFVC)
+ * @res: VC resource number, ie. VCn (0-7)
+ *
+ * Set Load Port Arbitration Table bit requesting hardware to apply the Port
+ * Arbitration Table (previously loaded).  When the Port Arbitration Table
+ * Status clears, hardware has latched the table into port arbitration logic.
+ */
+static void pci_vc_load_port_arb_table(struct pci_dev *dev, int pos, int res)
+{
+        int ctrl_pos, status_pos;
+        u32 ctrl;
+
+        ctrl_pos = pos + PCI_VC_RES_CTRL + (res * PCI_CAP_VC_PER_VC_SIZEOF);
+        status_pos = pos + PCI_VC_RES_STATUS + (res * PCI_CAP_VC_PER_VC_SIZEOF);
+
+        pci_read_config_dword(dev, ctrl_pos, &ctrl);
+        pci_write_config_dword(dev, ctrl_pos,
+                               ctrl | PCI_VC_RES_CTRL_LOAD_TABLE);
+
+        if (pci_wait_for_pending(dev, status_pos, PCI_VC_RES_STATUS_TABLE))
+                return;
+
+        dev_err(&dev->dev, "VC%d port arbitration table failed to load\n", res);
+}
+
+/**
+ * pci_vc_enable - Enable virtual channel
+ * @dev: device
+ * @pos: starting position of VC capability (VC/VC9/MFVC)
+ * @res: VC res number, ie. VCn (0-7)
+ *
+ * A VC is enabled by setting the enable bit in matching resource control
+ * registers on both sides of a link.  We therefore need to find the opposite
+ * end of the link.  To keep this simple we enable from the downstream device.
+ * RC devices do not have an upstream device, nor does it seem that VC9 do
+ * (spec is unclear).  Once we find the upstream device, match the VC ID to
+ * get the correct resource, disable and enable on both ends.
+ */
+static void pci_vc_enable(struct pci_dev *dev, int pos, int res)
+{
+        int ctrl_pos, status_pos, id, pos2, evcc, i, ctrl_pos2, status_pos2;
+        u32 ctrl, header, cap1, ctrl2;
+        struct pci_dev *link = NULL;
+
+        /* Enable VCs from the downstream device */
+        if (pci_pcie_type(dev) == PCI_EXP_TYPE_ROOT_PORT ||
+            pci_pcie_type(dev) == PCI_EXP_TYPE_DOWNSTREAM)
+                return;
+
+        ctrl_pos = pos + PCI_VC_RES_CTRL + (res * PCI_CAP_VC_PER_VC_SIZEOF);
+        status_pos = pos + PCI_VC_RES_STATUS + (res * PCI_CAP_VC_PER_VC_SIZEOF);
+
+        pci_read_config_dword(dev, ctrl_pos, &ctrl);
+        id = ctrl & PCI_VC_RES_CTRL_ID;
+
+        pci_read_config_dword(dev, pos, &header);
+
+        /* If there is no opposite end of the link, skip to enable */
+        if (PCI_EXT_CAP_ID(header) == PCI_EXT_CAP_ID_VC9 ||
+            pci_is_root_bus(dev->bus))
+                goto enable;
+
+        pos2 = pci_find_ext_capability(dev->bus->self, PCI_EXT_CAP_ID_VC);
+        if (!pos2)
+                goto enable;
+
+        pci_read_config_dword(dev->bus->self, pos2 + PCI_VC_PORT_CAP1, &cap1);
+        evcc = cap1 & PCI_VC_CAP1_EVCC;
+
+        /* VC0 is hardwired enabled, so we can start with 1 */
+        for (i = 1; i < evcc + 1; i++) {
+                ctrl_pos2 = pos2 + PCI_VC_RES_CTRL +
+                                (i * PCI_CAP_VC_PER_VC_SIZEOF);
+                status_pos2 = pos2 + PCI_VC_RES_STATUS +
+                                (i * PCI_CAP_VC_PER_VC_SIZEOF);
+                pci_read_config_dword(dev->bus->self, ctrl_pos2, &ctrl2);
+                if ((ctrl2 & PCI_VC_RES_CTRL_ID) == id) {
+                        link = dev->bus->self;
+                        break;
+                }
+        }
+
+        if (!link)
+                goto enable;
+
+        /* Disable if enabled */
+        if (ctrl2 & PCI_VC_RES_CTRL_ENABLE) {
+                ctrl2 &= ~PCI_VC_RES_CTRL_ENABLE;
+                pci_write_config_dword(link, ctrl_pos2, ctrl2);
+        }
+
+        /* Enable on both ends */
+        ctrl2 |= PCI_VC_RES_CTRL_ENABLE;
+        pci_write_config_dword(link, ctrl_pos2, ctrl2);
+enable:
+        ctrl |= PCI_VC_RES_CTRL_ENABLE;
+        pci_write_config_dword(dev, ctrl_pos, ctrl);
+
+        if (!pci_wait_for_pending(dev, status_pos, PCI_VC_RES_STATUS_NEGO))
+                dev_err(&dev->dev, "VC%d negotiation stuck pending\n", id);
+
+        if (link && !pci_wait_for_pending(link, status_pos2,
+                                          PCI_VC_RES_STATUS_NEGO))
+                dev_err(&link->dev, "VC%d negotiation stuck pending\n", id);
+}
+
+/**
+ * pci_vc_do_save_buffer - Size, save, or restore VC state
+ * @dev: device
+ * @pos: starting position of VC capability (VC/VC9/MFVC)
+ * @save_state: buffer for save/restore
+ * @name: for error message
+ * @save: if provided a buffer, this indicates what to do with it
+ *
+ * Walking Virtual Channel config space to size, save, or restore it
+ * is complicated, so we do it all from one function to reduce code and
+ * guarantee ordering matches in the buffer.  When called with NULL
+ * @save_state, return the size of the necessary save buffer.  When called
+ * with a non-NULL @save_state, @save determines whether we save to the
+ * buffer or restore from it.
+ */
+static int pci_vc_do_save_buffer(struct pci_dev *dev, int pos,
+                                 struct pci_cap_saved_state *save_state,
+                                 bool save)
+{
+        u32 cap1;
+        char evcc, lpevcc, parb_size;
+        int i, len = 0;
+        u8 *buf = save_state ? (u8 *)save_state->cap.data : NULL;
+
+        /* Sanity check buffer size for save/restore */
+        if (buf && save_state->cap.size !=
+            pci_vc_do_save_buffer(dev, pos, NULL, save)) {
+                dev_err(&dev->dev,
+                        "VC save buffer size does not match @0x%x\n", pos);
+                return -ENOMEM;
+        }
+
+        pci_read_config_dword(dev, pos + PCI_VC_PORT_CAP1, &cap1);
+        /* Extended VC Count (not counting VC0) */
+        evcc = cap1 & PCI_VC_CAP1_EVCC;
+        /* Low Priority Extended VC Count (not counting VC0) */
+        lpevcc = (cap1 & PCI_VC_CAP1_LPEVCC) >> 4;
+        /* Port Arbitration Table Entry Size (bits) */
+        parb_size = 1 << ((cap1 & PCI_VC_CAP1_ARB_SIZE) >> 10);
+
+        /*
+         * Port VC Control Register contains VC Arbitration Select, which
+         * cannot be modified when more than one LPVC is in operation.  We
+         * therefore save/restore it first, as only VC0 should be enabled
+         * after device reset.
+         */
+        if (buf) {
+                if (save)
+                        pci_read_config_word(dev, pos + PCI_VC_PORT_CTRL,
+                                             (u16 *)buf);
+                else
+                        pci_write_config_word(dev, pos + PCI_VC_PORT_CTRL,
+                                              *(u16 *)buf);
+                buf += 2;
+        }
+        len += 2;
+
+        /*
+         * If we have any Low Priority VCs and a VC Arbitration Table Offset
+         * in Port VC Capability Register 2 then save/restore it next.
+         */
+        if (lpevcc) {
+                u32 cap2;
+                int vcarb_offset;
+
+                pci_read_config_dword(dev, pos + PCI_VC_PORT_CAP2, &cap2);
+                vcarb_offset = ((cap2 & PCI_VC_CAP2_ARB_OFF) >> 24) * 16;
+
+                if (vcarb_offset) {
+                        int size, vcarb_phases = 0;
+
+                        if (cap2 & PCI_VC_CAP2_128_PHASE)
+                                vcarb_phases = 128;
+                        else if (cap2 & PCI_VC_CAP2_64_PHASE)
+                                vcarb_phases = 64;
+                        else if (cap2 & PCI_VC_CAP2_32_PHASE)
+                                vcarb_phases = 32;
+
+                        /* Fixed 4 bits per phase per lpevcc (plus VC0) */
+                        size = ((lpevcc + 1) * vcarb_phases * 4) / 8;
+
+                        if (size && buf) {
+                                pci_vc_save_restore_dwords(dev,
+                                                           pos + vcarb_offset,
+                                                           (u32 *)buf,
+                                                           size / 4, save);
+                                /*
+                                 * On restore, we need to signal hardware to
+                                 * re-load the VC Arbitration Table.
+                                 */
+                                if (!save)
+                                        pci_vc_load_arb_table(dev, pos);
+
+                                buf += size;
+                        }
+                        len += size;
+                }
+        }
+
+        /*
+         * In addition to each VC Resource Control Register, we may have a
+         * Port Arbitration Table attached to each VC.  The Port Arbitration
+         * Table Offset in each VC Resource Capability Register tells us if
+         * it exists.  The entry size is global from the Port VC Capability
+         * Register1 above.  The number of phases is determined per VC.
+         */
+        for (i = 0; i < evcc + 1; i++) {
+                u32 cap;
+                int parb_offset;
+
+                pci_read_config_dword(dev, pos + PCI_VC_RES_CAP +
+                                      (i * PCI_CAP_VC_PER_VC_SIZEOF), &cap);
+                parb_offset = ((cap & PCI_VC_RES_CAP_ARB_OFF) >> 24) * 16;
+                if (parb_offset) {
+                        int size, parb_phases = 0;
+
+                        if (cap & PCI_VC_RES_CAP_256_PHASE)
+                                parb_phases = 256;
+                        else if (cap & (PCI_VC_RES_CAP_128_PHASE |
+                                        PCI_VC_RES_CAP_128_PHASE_TB))
+                                parb_phases = 128;
+                        else if (cap & PCI_VC_RES_CAP_64_PHASE)
+                                parb_phases = 64;
+                        else if (cap & PCI_VC_RES_CAP_32_PHASE)
+                                parb_phases = 32;
+
+                        size = (parb_size * parb_phases) / 8;
+
+                        if (size && buf) {
+                                pci_vc_save_restore_dwords(dev,
+                                                           pos + parb_offset,
+                                                           (u32 *)buf,
+                                                           size / 4, save);
+                                buf += size;
+                        }
+                        len += size;
+                }
+
+                /* VC Resource Control Register */
+                if (buf) {
+                        int ctrl_pos = pos + PCI_VC_RES_CTRL +
+                                                (i * PCI_CAP_VC_PER_VC_SIZEOF);
+                        if (save)
+                                pci_read_config_dword(dev, ctrl_pos,
+                                                      (u32 *)buf);
+                        else {
+                                u32 tmp, ctrl = *(u32 *)buf;
+                                /*
+                                 * For an FLR case, the VC config may remain.
+                                 * Preserve enable bit, restore the rest.
+                                 */
+                                pci_read_config_dword(dev, ctrl_pos, &tmp);
+                                tmp &= PCI_VC_RES_CTRL_ENABLE;
+                                tmp |= ctrl & ~PCI_VC_RES_CTRL_ENABLE;
+                                pci_write_config_dword(dev, ctrl_pos, tmp);
+                                /* Load port arbitration table if used */
+                                if (ctrl & PCI_VC_RES_CTRL_ARB_SELECT)
+                                        pci_vc_load_port_arb_table(dev, pos, i);
+                                /* Re-enable if needed */
+                                if ((ctrl ^ tmp) & PCI_VC_RES_CTRL_ENABLE)
+                                        pci_vc_enable(dev, pos, i);
+                        }
+                        buf += 4;
+                }
+                len += 4;
+        }
+
+        return buf ? 0 : len;
+}
+
+static struct {
+        u16 id;
+        const char *name;
+} vc_caps[] = { { PCI_EXT_CAP_ID_MFVC, "MFVC" },
+                { PCI_EXT_CAP_ID_VC, "VC" },
+                { PCI_EXT_CAP_ID_VC9, "VC9" } };
+
+/**
+ * pci_save_vc_state - Save VC state to pre-allocate save buffer
+ * @dev: device
+ *
+ * For each type of VC capability, VC/VC9/MFVC, find the capability and
+ * save it to the pre-allocated save buffer.
+ */
+int pci_save_vc_state(struct pci_dev *dev)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(vc_caps); i++) {
+                int pos, ret;
+                struct pci_cap_saved_state *save_state;
+
+                pos = pci_find_ext_capability(dev, vc_caps[i].id);
+                if (!pos)
+                        continue;
+
+                save_state = pci_find_saved_ext_cap(dev, vc_caps[i].id);
+                if (!save_state) {
+                        dev_err(&dev->dev, "%s buffer not found in %s\n",
+                                vc_caps[i].name, __func__);
+                        return -ENOMEM;
+                }
+
+                ret = pci_vc_do_save_buffer(dev, pos, save_state, true);
+                if (ret) {
+                        dev_err(&dev->dev, "%s save unsuccessful %s\n",
+                                vc_caps[i].name, __func__);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+/**
+ * pci_restore_vc_state - Restore VC state from save buffer
+ * @dev: device
+ *
+ * For each type of VC capability, VC/VC9/MFVC, find the capability and
+ * restore it from the previously saved buffer.
+ */
+void pci_restore_vc_state(struct pci_dev *dev)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(vc_caps); i++) {
+                int pos;
+                struct pci_cap_saved_state *save_state;
+
+                pos = pci_find_ext_capability(dev, vc_caps[i].id);
+                save_state = pci_find_saved_ext_cap(dev, vc_caps[i].id);
+                if (!save_state || !pos)
+                        continue;
+
+                pci_vc_do_save_buffer(dev, pos, save_state, false);
+        }
+}
+
+/**
+ * pci_allocate_vc_save_buffers - Allocate save buffers for VC caps
+ * @dev: device
+ *
+ * For each type of VC capability, VC/VC9/MFVC, find the capability, size
+ * it, and allocate a buffer for save/restore.
+ */
+
+void pci_allocate_vc_save_buffers(struct pci_dev *dev)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(vc_caps); i++) {
+                int len, pos = pci_find_ext_capability(dev, vc_caps[i].id);
+
+                if (!pos)
+                        continue;
+
+                len = pci_vc_do_save_buffer(dev, pos, NULL, false);
+                if (pci_add_ext_cap_save_buffer(dev, vc_caps[i].id, len))
+                        dev_err(&dev->dev,
+                                "unable to preallocate %s save buffer\n",
+                                vc_caps[i].name);
+        }
+}
diff --git a/drivers/vfio/pci/vfio_pci_config.c b/drivers/vfio/pci/vfio_pci_config.c
index ffd0632c3cbc..83cd1574c810 100644
--- a/drivers/vfio/pci/vfio_pci_config.c
+++ b/drivers/vfio/pci/vfio_pci_config.c
@@ -975,20 +975,20 @@ static int vfio_vc_cap_len(struct vfio_pci_device *vdev, u16 pos)
         int ret, evcc, phases, vc_arb;
         int len = PCI_CAP_VC_BASE_SIZEOF;
 
-        ret = pci_read_config_dword(pdev, pos + PCI_VC_PORT_REG1, &tmp);
+        ret = pci_read_config_dword(pdev, pos + PCI_VC_PORT_CAP1, &tmp);
         if (ret)
                 return pcibios_err_to_errno(ret);
 
-        evcc = tmp & PCI_VC_REG1_EVCC; /* extended vc count */
-        ret = pci_read_config_dword(pdev, pos + PCI_VC_PORT_REG2, &tmp);
+        evcc = tmp & PCI_VC_CAP1_EVCC; /* extended vc count */
+        ret = pci_read_config_dword(pdev, pos + PCI_VC_PORT_CAP2, &tmp);
         if (ret)
                 return pcibios_err_to_errno(ret);
 
-        if (tmp & PCI_VC_REG2_128_PHASE)
+        if (tmp & PCI_VC_CAP2_128_PHASE)
                 phases = 128;
-        else if (tmp & PCI_VC_REG2_64_PHASE)
+        else if (tmp & PCI_VC_CAP2_64_PHASE)
                 phases = 64;
-        else if (tmp & PCI_VC_REG2_32_PHASE)
+        else if (tmp & PCI_VC_CAP2_32_PHASE)
                 phases = 32;
         else
                 phases = 0;
diff --git a/include/linux/kexec.h b/include/linux/kexec.h
index d78d28a733b1..5fd33dc1fe3a 100644
--- a/include/linux/kexec.h
+++ b/include/linux/kexec.h
@@ -198,6 +198,9 @@ extern u32 vmcoreinfo_note[VMCOREINFO_NOTE_SIZE/4];
 extern size_t vmcoreinfo_size;
 extern size_t vmcoreinfo_max_size;
 
+/* flag to track if kexec reboot is in progress */
+extern bool kexec_in_progress;
+
 int __init parse_crashkernel(char *cmdline, unsigned long long system_ram,
                 unsigned long long *crash_size, unsigned long long *crash_base);
 int parse_crashkernel_high(char *cmdline, unsigned long long system_ram,
diff --git a/include/linux/msi.h b/include/linux/msi.h
index 009b02481436..92a2f991262a 100644
--- a/include/linux/msi.h
+++ b/include/linux/msi.h
@@ -60,10 +60,10 @@ void arch_teardown_msi_irq(unsigned int irq);
 int arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type);
 void arch_teardown_msi_irqs(struct pci_dev *dev);
 int arch_msi_check_device(struct pci_dev* dev, int nvec, int type);
-void arch_restore_msi_irqs(struct pci_dev *dev, int irq);
+void arch_restore_msi_irqs(struct pci_dev *dev);
 
 void default_teardown_msi_irqs(struct pci_dev *dev);
-void default_restore_msi_irqs(struct pci_dev *dev, int irq);
+void default_restore_msi_irqs(struct pci_dev *dev);
 u32 default_msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag);
 u32 default_msix_mask_irq(struct msi_desc *desc, u32 flag);
 
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 095eb44fcbb6..f7d1dcc002fa 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -224,7 +224,8 @@ enum pci_bus_speed {
 };
 
 struct pci_cap_saved_data {
-        char cap_nr;
+        u16 cap_nr;
+        bool cap_extended;
         unsigned int size;
         u32 data[0];
 };
@@ -351,7 +352,7 @@ struct pci_dev {
         struct bin_attribute *res_attr_wc[DEVICE_COUNT_RESOURCE]; /* sysfs file for WC mapping of resources */
 #ifdef CONFIG_PCI_MSI
         struct list_head msi_list;
-        struct kset *msi_kset;
+        const struct attribute_group **msi_irq_groups;
 #endif
         struct pci_vpd *vpd;
 #ifdef CONFIG_PCI_ATS
@@ -634,8 +635,7 @@ struct pci_driver {
  * DEFINE_PCI_DEVICE_TABLE - macro used to describe a pci device table
  * @_table: device table name
  *
- * This macro is used to create a struct pci_device_id array (a device table)
- * in a generic manner.
+ * This macro is deprecated and should not be used in new code.
  */
 #define DEFINE_PCI_DEVICE_TABLE(_table) \
         const struct pci_device_id _table[]
@@ -938,6 +938,7 @@ bool pci_check_and_unmask_intx(struct pci_dev *dev);
 void pci_msi_off(struct pci_dev *dev);
 int pci_set_dma_max_seg_size(struct pci_dev *dev, unsigned int size);
 int pci_set_dma_seg_boundary(struct pci_dev *dev, unsigned long mask);
+int pci_wait_for_pending(struct pci_dev *dev, int pos, u16 mask);
 int pci_wait_for_pending_transaction(struct pci_dev *dev);
 int pcix_get_max_mmrbc(struct pci_dev *dev);
 int pcix_get_mmrbc(struct pci_dev *dev);
@@ -976,6 +977,12 @@ struct pci_saved_state *pci_store_saved_state(struct pci_dev *dev);
 int pci_load_saved_state(struct pci_dev *dev, struct pci_saved_state *state);
 int pci_load_and_free_saved_state(struct pci_dev *dev,
                                   struct pci_saved_state **state);
+struct pci_cap_saved_state *pci_find_saved_cap(struct pci_dev *dev, char cap);
+struct pci_cap_saved_state *pci_find_saved_ext_cap(struct pci_dev *dev,
+                                                   u16 cap);
+int pci_add_cap_save_buffer(struct pci_dev *dev, char cap, unsigned int size);
+int pci_add_ext_cap_save_buffer(struct pci_dev *dev,
+                                u16 cap, unsigned int size);
 int __pci_complete_power_transition(struct pci_dev *dev, pci_power_t state);
 int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
 pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
@@ -997,6 +1004,11 @@ static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state,
         return __pci_enable_wake(dev, state, false, enable);
 }
 
+/* PCI Virtual Channel */
+int pci_save_vc_state(struct pci_dev *dev);
+void pci_restore_vc_state(struct pci_dev *dev);
+void pci_allocate_vc_save_buffers(struct pci_dev *dev);
+
 #define PCI_EXP_IDO_REQUEST     (1<<0)
 #define PCI_EXP_IDO_COMPLETION  (1<<1)
 void pci_enable_ido(struct pci_dev *dev, unsigned long type);
@@ -1162,15 +1174,14 @@ struct msix_entry {
 
 
 #ifndef CONFIG_PCI_MSI
-static inline int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec)
+static inline int pci_msi_vec_count(struct pci_dev *dev)
 {
-        return -1;
+        return -ENOSYS;
 }
 
-static inline int
-pci_enable_msi_block_auto(struct pci_dev *dev, unsigned int *maxvec)
+static inline int pci_enable_msi_block(struct pci_dev *dev, int nvec)
 {
-        return -1;
+        return -ENOSYS;
 }
 
 static inline void pci_msi_shutdown(struct pci_dev *dev)
@@ -1178,14 +1189,14 @@ static inline void pci_msi_shutdown(struct pci_dev *dev)
 static inline void pci_disable_msi(struct pci_dev *dev)
 { }
 
-static inline int pci_msix_table_size(struct pci_dev *dev)
+static inline int pci_msix_vec_count(struct pci_dev *dev)
 {
-        return 0;
+        return -ENOSYS;
 }
 static inline int pci_enable_msix(struct pci_dev *dev,
                                   struct msix_entry *entries, int nvec)
 {
-        return -1;
+        return -ENOSYS;
 }
 
 static inline void pci_msix_shutdown(struct pci_dev *dev)
@@ -1202,18 +1213,32 @@ static inline int pci_msi_enabled(void)
 {
         return 0;
 }
+
+static inline int pci_enable_msi_range(struct pci_dev *dev, int minvec,
+                                       int maxvec)
+{
+        return -ENOSYS;
+}
+static inline int pci_enable_msix_range(struct pci_dev *dev,
+                      struct msix_entry *entries, int minvec, int maxvec)
+{
+        return -ENOSYS;
+}
 #else
-int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec);
-int pci_enable_msi_block_auto(struct pci_dev *dev, unsigned int *maxvec);
+int pci_msi_vec_count(struct pci_dev *dev);
+int pci_enable_msi_block(struct pci_dev *dev, int nvec);
 void pci_msi_shutdown(struct pci_dev *dev);
 void pci_disable_msi(struct pci_dev *dev);
-int pci_msix_table_size(struct pci_dev *dev);
+int pci_msix_vec_count(struct pci_dev *dev);
 int pci_enable_msix(struct pci_dev *dev, struct msix_entry *entries, int nvec);
 void pci_msix_shutdown(struct pci_dev *dev);
 void pci_disable_msix(struct pci_dev *dev);
 void msi_remove_pci_irq_vectors(struct pci_dev *dev);
 void pci_restore_msi_state(struct pci_dev *dev);
 int pci_msi_enabled(void);
+int pci_enable_msi_range(struct pci_dev *dev, int minvec, int maxvec);
+int pci_enable_msix_range(struct pci_dev *dev, struct msix_entry *entries,
+                          int minvec, int maxvec);
 #endif
 
 #ifdef CONFIG_PCIEPORTBUS
@@ -1571,65 +1596,65 @@ enum pci_fixup_pass {
 /* Anonymous variables would be nice... */
 #define DECLARE_PCI_FIXUP_SECTION(section, name, vendor, device, class, \
                                   class_shift, hook)                    \
-        static const struct pci_fixup __pci_fixup_##name __used         \
+        static const struct pci_fixup __PASTE(__pci_fixup_##name,__LINE__) __used       \
         __attribute__((__section__(#section), aligned((sizeof(void *)))))    \
                 = { vendor, device, class, class_shift, hook };
 
 #define DECLARE_PCI_FIXUP_CLASS_EARLY(vendor, device, class,            \
                                          class_shift, hook)             \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_early,                     \
-                vendor##device##hook, vendor, device, class, class_shift, hook)
+                hook, vendor, device, class, class_shift, hook)
 #define DECLARE_PCI_FIXUP_CLASS_HEADER(vendor, device, class,           \
                                          class_shift, hook)             \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_header,                    \
-                vendor##device##hook, vendor, device, class, class_shift, hook)
+                hook, vendor, device, class, class_shift, hook)
 #define DECLARE_PCI_FIXUP_CLASS_FINAL(vendor, device, class,            \
                                          class_shift, hook)             \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_final,                     \
-                vendor##device##hook, vendor, device, class, class_shift, hook)
+                hook, vendor, device, class, class_shift, hook)
 #define DECLARE_PCI_FIXUP_CLASS_ENABLE(vendor, device, class,           \
                                          class_shift, hook)             \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_enable,                    \
-                vendor##device##hook, vendor, device, class, class_shift, hook)
+                hook, vendor, device, class, class_shift, hook)
 #define DECLARE_PCI_FIXUP_CLASS_RESUME(vendor, device, class,           \
                                          class_shift, hook)             \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume,                    \
-                resume##vendor##device##hook, vendor, device, class,    \
+                resume##hook, vendor, device, class,    \
                 class_shift, hook)
 #define DECLARE_PCI_FIXUP_CLASS_RESUME_EARLY(vendor, device, class,     \
                                          class_shift, hook)             \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume_early,              \
-                resume_early##vendor##device##hook, vendor, device,     \
+                resume_early##hook, vendor, device,     \
                 class, class_shift, hook)
 #define DECLARE_PCI_FIXUP_CLASS_SUSPEND(vendor, device, class,          \
                                          class_shift, hook)             \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend,                   \
-                suspend##vendor##device##hook, vendor, device, class,   \
+                suspend##hook, vendor, device, class,   \
                 class_shift, hook)
 
 #define DECLARE_PCI_FIXUP_EARLY(vendor, device, hook)                   \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_early,                     \
-                vendor##device##hook, vendor, device, PCI_ANY_ID, 0, hook)
+                hook, vendor, device, PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_HEADER(vendor, device, hook)                  \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_header,                    \
-                vendor##device##hook, vendor, device, PCI_ANY_ID, 0, hook)
+                hook, vendor, device, PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_FINAL(vendor, device, hook)                   \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_final,                     \
-                vendor##device##hook, vendor, device, PCI_ANY_ID, 0, hook)
+                hook, vendor, device, PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_ENABLE(vendor, device, hook)                  \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_enable,                    \
-                vendor##device##hook, vendor, device, PCI_ANY_ID, 0, hook)
+                hook, vendor, device, PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_RESUME(vendor, device, hook)                  \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume,                    \
-                resume##vendor##device##hook, vendor, device,           \
+                resume##hook, vendor, device,           \
                 PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_RESUME_EARLY(vendor, device, hook)            \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume_early,              \
-                resume_early##vendor##device##hook, vendor, device,     \
+                resume_early##hook, vendor, device,     \
                 PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_SUSPEND(vendor, device, hook)                 \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend,                   \
-                suspend##vendor##device##hook, vendor, device,          \
+                suspend##hook, vendor, device,          \
                 PCI_ANY_ID, 0, hook)
 
 #ifdef CONFIG_PCI_QUIRKS
diff --git a/include/uapi/linux/pci_regs.h b/include/uapi/linux/pci_regs.h
index 4a98e85438a7..ab6b4e7f6657 100644
--- a/include/uapi/linux/pci_regs.h
+++ b/include/uapi/linux/pci_regs.h
@@ -518,8 +518,16 @@
 #define  PCI_EXP_SLTCTL_CCIE    0x0010  /* Command Completed Interrupt Enable */
 #define  PCI_EXP_SLTCTL_HPIE    0x0020  /* Hot-Plug Interrupt Enable */
 #define  PCI_EXP_SLTCTL_AIC     0x00c0  /* Attention Indicator Control */
+#define  PCI_EXP_SLTCTL_ATTN_IND_ON    0x0040 /* Attention Indicator on */
+#define  PCI_EXP_SLTCTL_ATTN_IND_BLINK 0x0080 /* Attention Indicator blinking */
+#define  PCI_EXP_SLTCTL_ATTN_IND_OFF   0x00c0 /* Attention Indicator off */
 #define  PCI_EXP_SLTCTL_PIC     0x0300  /* Power Indicator Control */
+#define  PCI_EXP_SLTCTL_PWR_IND_ON     0x0100 /* Power Indicator on */
+#define  PCI_EXP_SLTCTL_PWR_IND_BLINK  0x0200 /* Power Indicator blinking */
+#define  PCI_EXP_SLTCTL_PWR_IND_OFF    0x0300 /* Power Indicator off */
 #define  PCI_EXP_SLTCTL_PCC     0x0400  /* Power Controller Control */
+#define  PCI_EXP_SLTCTL_PWR_ON         0x0000 /* Power On */
+#define  PCI_EXP_SLTCTL_PWR_OFF        0x0400 /* Power Off */
 #define  PCI_EXP_SLTCTL_EIC     0x0800  /* Electromechanical Interlock Control */
 #define  PCI_EXP_SLTCTL_DLLSCE  0x1000  /* Data Link Layer State Changed Enable */
 #define PCI_EXP_SLTSTA          26      /* Slot Status */
@@ -677,17 +685,34 @@
 #define PCI_ERR_ROOT_ERR_SRC    52      /* Error Source Identification */
 
 /* Virtual Channel */
-#define PCI_VC_PORT_REG1        4
-#define  PCI_VC_REG1_EVCC       0x7     /* extended VC count */
-#define PCI_VC_PORT_REG2        8
-#define  PCI_VC_REG2_32_PHASE   0x2
-#define  PCI_VC_REG2_64_PHASE   0x4
-#define  PCI_VC_REG2_128_PHASE  0x8
+#define PCI_VC_PORT_CAP1        4
+#define  PCI_VC_CAP1_EVCC       0x00000007      /* extended VC count */
+#define  PCI_VC_CAP1_LPEVCC     0x00000070      /* low prio extended VC count */
+#define  PCI_VC_CAP1_ARB_SIZE   0x00000c00
+#define PCI_VC_PORT_CAP2        8
+#define  PCI_VC_CAP2_32_PHASE           0x00000002
+#define  PCI_VC_CAP2_64_PHASE           0x00000004
+#define  PCI_VC_CAP2_128_PHASE          0x00000008
+#define  PCI_VC_CAP2_ARB_OFF            0xff000000
 #define PCI_VC_PORT_CTRL        12
+#define  PCI_VC_PORT_CTRL_LOAD_TABLE    0x00000001
 #define PCI_VC_PORT_STATUS      14
+#define  PCI_VC_PORT_STATUS_TABLE       0x00000001
 #define PCI_VC_RES_CAP          16
+#define  PCI_VC_RES_CAP_32_PHASE        0x00000002
+#define  PCI_VC_RES_CAP_64_PHASE        0x00000004
+#define  PCI_VC_RES_CAP_128_PHASE       0x00000008
+#define  PCI_VC_RES_CAP_128_PHASE_TB    0x00000010
+#define  PCI_VC_RES_CAP_256_PHASE       0x00000020
+#define  PCI_VC_RES_CAP_ARB_OFF         0xff000000
 #define PCI_VC_RES_CTRL         20
+#define  PCI_VC_RES_CTRL_LOAD_TABLE     0x00010000
+#define  PCI_VC_RES_CTRL_ARB_SELECT     0x000e0000
+#define  PCI_VC_RES_CTRL_ID             0x07000000
+#define  PCI_VC_RES_CTRL_ENABLE         0x80000000
 #define PCI_VC_RES_STATUS       26
+#define  PCI_VC_RES_STATUS_TABLE        0x00000001
+#define  PCI_VC_RES_STATUS_NEGO         0x00000002
 #define PCI_CAP_VC_BASE_SIZEOF          0x10
 #define PCI_CAP_VC_PER_VC_SIZEOF        0x0C
 
diff --git a/kernel/kexec.c b/kernel/kexec.c
index 490afc03627e..d0d8fca54065 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -47,6 +47,9 @@ u32 vmcoreinfo_note[VMCOREINFO_NOTE_SIZE/4];
 size_t vmcoreinfo_size;
 size_t vmcoreinfo_max_size = sizeof(vmcoreinfo_data);
 
+/* Flag to indicate we are going to kexec a new kernel */
+bool kexec_in_progress = false;
+
 /* Location of the reserved area for the crash kernel */
 struct resource crashk_res = {
         .name  = "Crash kernel",
@@ -1675,6 +1678,7 @@ int kernel_kexec(void)
         } else
 #endif
         {
+                kexec_in_progress = true;
                 kernel_restart_prepare(NULL);
                 printk(KERN_EMERG "Starting new kernel\n");
                 machine_shutdown();
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 987293d03ebc..5690b8eabfbc 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -2840,19 +2840,6 @@ already_gone:
         return false;
 }
 
-static bool __flush_work(struct work_struct *work)
-{
-        struct wq_barrier barr;
-
-        if (start_flush_work(work, &barr)) {
-                wait_for_completion(&barr.done);
-                destroy_work_on_stack(&barr.work);
-                return true;
-        } else {
-                return false;
-        }
-}
-
 /**
  * flush_work - wait for a work to finish executing the last queueing instance
  * @work: the work to flush
@@ -2866,10 +2853,18 @@ static bool __flush_work(struct work_struct *work)
  */
 bool flush_work(struct work_struct *work)
 {
+        struct wq_barrier barr;
+
         lock_map_acquire(&work->lockdep_map);
         lock_map_release(&work->lockdep_map);
 
-        return __flush_work(work);
+        if (start_flush_work(work, &barr)) {
+                wait_for_completion(&barr.done);
+                destroy_work_on_stack(&barr.work);
+                return true;
+        } else {
+                return false;
+        }
 }
 EXPORT_SYMBOL_GPL(flush_work);
 
@@ -4814,14 +4809,7 @@ long work_on_cpu(int cpu, long (*fn)(void *), void *arg)
 
         INIT_WORK_ONSTACK(&wfc.work, work_for_cpu_fn);
         schedule_work_on(cpu, &wfc.work);
-
-        /*
-         * The work item is on-stack and can't lead to deadlock through
-         * flushing.  Use __flush_work() to avoid spurious lockdep warnings
-         * when work_on_cpu()s are nested.
-         */
-        __flush_work(&wfc.work);
-
+        flush_work(&wfc.work);
         return wfc.ret;
 }
 EXPORT_SYMBOL_GPL(work_on_cpu);
diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index 9c9810030377..9fb30b15c9dc 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -2634,10 +2634,13 @@ sub process {
                                 $herecurr);
                }
 
-# check for declarations of struct pci_device_id
-                if ($line =~ /\bstruct\s+pci_device_id\s+\w+\s*\[\s*\]\s*\=\s*\{/) {
-                        WARN("DEFINE_PCI_DEVICE_TABLE",
-                             "Use DEFINE_PCI_DEVICE_TABLE for struct pci_device_id\n" . $herecurr);
+# check for uses of DEFINE_PCI_DEVICE_TABLE
+                if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
+                        if (WARN("DEFINE_PCI_DEVICE_TABLE",
+                                 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
+                            $fix) {
+                                $fixed[$linenr - 1] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
+                        }
                 }
 
 # check for new typedefs, only function parameters and sparse annotations