Merge tag 'pci-v4.14-changes' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci

Pull PCI updates from Bjorn Helgaas:

 - add enhanced Downstream Port Containment support, which prints more
   details about Root Port Programmed I/O errors (Dongdong Liu)

 - add Layerscape ls1088a and ls2088a support (Hou Zhiqiang)

 - add MediaTek MT2712 and MT7622 support (Ryder Lee)

 - add MediaTek MT2712 and MT7622 MSI support (Honghui Zhang)

 - add Qualcom IPQ8074 support (Varadarajan Narayanan)

 - add R-Car r8a7743/5 device tree support (Biju Das)

 - add Rockchip per-lane PHY support for better power management (Shawn
   Lin)

 - fix IRQ mapping for hot-added devices by replacing the
   pci_fixup_irqs() boot-time design with a host bridge hook called at
   probe-time (Lorenzo Pieralisi, Matthew Minter)

 - fix race when enabling two devices that results in upstream bridge
   not being enabled correctly (Srinath Mannam)

 - fix pciehp power fault infinite loop (Keith Busch)

 - fix SHPC bridge MSI hotplug events by enabling bus mastering
   (Aleksandr Bezzubikov)

 - fix a VFIO issue by correcting PCIe capability sizes (Alex
   Williamson)

 - fix an INTD issue on Xilinx and possibly other drivers by unifying
   INTx IRQ domain support (Paul Burton)

 - avoid IOMMU stalls by marking AMD Stoney GPU ATS as broken (Joerg
   Roedel)

 - allow APM X-Gene device assignment to guests by adding an ACS quirk
   (Feng Kan)

 - fix driver crashes by disabling Extended Tags on Broadcom HT2100
   (Extended Tags support is required for PCIe Receivers but not
   Requesters, and we now enable them by default when Requesters support
   them) (Sinan Kaya)

 - fix MSIs for devices that use phantom RIDs for DMA by assuming MSIs
   use the real Requester ID (not a phantom RID) (Robin Murphy)

 - prevent assignment of Intel VMD children to guests (which may be
   supported eventually, but isn't yet) by not associating an IOMMU with
   them (Jon Derrick)

 - fix Intel VMD suspend/resume by releasing IRQs on suspend (Scott
   Bauer)

 - fix a Function-Level Reset issue with Intel 750 NVMe by waiting
   longer (up to 60sec instead of 1sec) for device to become ready
   (Sinan Kaya)

 - fix a Function-Level Reset issue on iProc Stingray by working around
   hardware defects in the CRS implementation (Oza Pawandeep)

 - fix an issue with Intel NVMe P3700 after an iProc reset by adding a
   delay during shutdown (Oza Pawandeep)

 - fix a Microsoft Hyper-V lockdep issue by polling instead of blocking
   in compose_msi_msg() (Stephen Hemminger)

 - fix a wireless LAN driver timeout by clearing DesignWare MSI
   interrupt status after it is handled, not before (Faiz Abbas)

 - fix DesignWare ATU enable checking (Jisheng Zhang)

 - reduce Layerscape dependencies on the bootloader by doing more
   initialization in the driver (Hou Zhiqiang)

 - improve Intel VMD performance allowing allocation of more IRQ vectors
   than present CPUs (Keith Busch)

 - improve endpoint framework support for initial DMA mask, different
   BAR sizes, configurable page sizes, MSI, test driver, etc (Kishon
   Vijay Abraham I, Stan Drozd)

 - rework CRS support to add periodic messages while we poll during
   enumeration and after Function-Level Reset and prepare for possible
   other uses of CRS (Sinan Kaya)

 - clean up Root Port AER handling by removing unnecessary code and
   moving error handler methods to struct pcie_port_service_driver
   (Christoph Hellwig)

 - clean up error handling paths in various drivers (Bjorn Andersson,
   Fabio Estevam, Gustavo A. R. Silva, Harunobu Kurokawa, Jeffy Chen,
   Lorenzo Pieralisi, Sergei Shtylyov)

 - clean up SR-IOV resource handling by disabling VF decoding before
   updating the corresponding resource structs (Gavin Shan)

 - clean up DesignWare-based drivers by unifying quirks to update Class
   Code and Interrupt Pin and related handling of write-protected
   registers (Hou Zhiqiang)

 - clean up by adding empty generic pcibios_align_resource() and
   pcibios_fixup_bus() and removing empty arch-specific implementations
   (Palmer Dabbelt)

 - request exclusive reset control for several drivers to allow cleanup
   elsewhere (Philipp Zabel)

 - constify various structures (Arvind Yadav, Bhumika Goyal)

 - convert from full_name() to %pOF (Rob Herring)

 - remove unused variables from iProc, HiSi, Altera, Keystone (Shawn
   Lin)

* tag 'pci-v4.14-changes' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci: (170 commits)
  PCI: xgene: Clean up whitespace
  PCI: xgene: Define XGENE_PCI_EXP_CAP and use generic PCI_EXP_RTCTL offset
  PCI: xgene: Fix platform_get_irq() error handling
  PCI: xilinx-nwl: Fix platform_get_irq() error handling
  PCI: rockchip: Fix platform_get_irq() error handling
  PCI: altera: Fix platform_get_irq() error handling
  PCI: spear13xx: Fix platform_get_irq() error handling
  PCI: artpec6: Fix platform_get_irq() error handling
  PCI: armada8k: Fix platform_get_irq() error handling
  PCI: dra7xx: Fix platform_get_irq() error handling
  PCI: exynos: Fix platform_get_irq() error handling
  PCI: iproc: Clean up whitespace
  PCI: iproc: Rename PCI_EXP_CAP to IPROC_PCI_EXP_CAP
  PCI: iproc: Add 500ms delay during device shutdown
  PCI: Fix typos and whitespace errors
  PCI: Remove unused "res" variable from pci_resource_io()
  PCI: Correct kernel-doc of pci_vpd_srdt_size(), pci_vpd_srdt_tag()
  PCI/AER: Reformat AER register definitions
  iommu/vt-d: Prevent VMD child devices from being remapping targets
  x86/PCI: Use is_vmd() rather than relying on the domain number
  ...

1 files changed, 109 insertions, 23 deletions

diff --git a/drivers/misc/pci_endpoint_test.c b/drivers/misc/pci_endpoint_test.c
index 09c10f426b64..deb203026496 100644
--- a/drivers/misc/pci_endpoint_test.c
+++ b/drivers/misc/pci_endpoint_test.c
@@ -72,6 +72,11 @@ static DEFINE_IDA(pci_endpoint_test_ida);
 
 #define to_endpoint_test(priv) container_of((priv), struct pci_endpoint_test, \
                                             miscdev)
+
+static bool no_msi;
+module_param(no_msi, bool, 0444);
+MODULE_PARM_DESC(no_msi, "Disable MSI interrupt in pci_endpoint_test");
+
 enum pci_barno {
         BAR_0,
         BAR_1,
@@ -90,9 +95,15 @@ struct pci_endpoint_test {
         /* mutex to protect the ioctls */
         struct mutex    mutex;
         struct miscdevice miscdev;
+        enum pci_barno test_reg_bar;
+        size_t alignment;
 };
 
-static int bar_size[] = { 4, 512, 1024, 16384, 131072, 1048576 };
+struct pci_endpoint_test_data {
+        enum pci_barno test_reg_bar;
+        size_t alignment;
+        bool no_msi;
+};
 
 static inline u32 pci_endpoint_test_readl(struct pci_endpoint_test *test,
                                           u32 offset)
@@ -141,11 +152,15 @@ static bool pci_endpoint_test_bar(struct pci_endpoint_test *test,
         int j;
         u32 val;
         int size;
+        struct pci_dev *pdev = test->pdev;
 
         if (!test->bar[barno])
                 return false;
 
-        size = bar_size[barno];
+        size = pci_resource_len(pdev, barno);
+
+        if (barno == test->test_reg_bar)
+                size = 0x4;
 
         for (j = 0; j < size; j += 4)
                 pci_endpoint_test_bar_writel(test, barno, j, 0xA0A0A0A0);
@@ -202,16 +217,32 @@ static bool pci_endpoint_test_copy(struct pci_endpoint_test *test, size_t size)
         dma_addr_t dst_phys_addr;
         struct pci_dev *pdev = test->pdev;
         struct device *dev = &pdev->dev;
+        void *orig_src_addr;
+        dma_addr_t orig_src_phys_addr;
+        void *orig_dst_addr;
+        dma_addr_t orig_dst_phys_addr;
+        size_t offset;
+        size_t alignment = test->alignment;
         u32 src_crc32;
         u32 dst_crc32;
 
-        src_addr = dma_alloc_coherent(dev, size, &src_phys_addr, GFP_KERNEL);
-        if (!src_addr) {
+        orig_src_addr = dma_alloc_coherent(dev, size + alignment,
+                                           &orig_src_phys_addr, GFP_KERNEL);
+        if (!orig_src_addr) {
                 dev_err(dev, "failed to allocate source buffer\n");
                 ret = false;
                 goto err;
         }
 
+        if (alignment && !IS_ALIGNED(orig_src_phys_addr, alignment)) {
+                src_phys_addr = PTR_ALIGN(orig_src_phys_addr, alignment);
+                offset = src_phys_addr - orig_src_phys_addr;
+                src_addr = orig_src_addr + offset;
+        } else {
+                src_phys_addr = orig_src_phys_addr;
+                src_addr = orig_src_addr;
+        }
+
         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_LOWER_SRC_ADDR,
                                  lower_32_bits(src_phys_addr));
 
@@ -221,11 +252,21 @@ static bool pci_endpoint_test_copy(struct pci_endpoint_test *test, size_t size)
         get_random_bytes(src_addr, size);
         src_crc32 = crc32_le(~0, src_addr, size);
 
-        dst_addr = dma_alloc_coherent(dev, size, &dst_phys_addr, GFP_KERNEL);
-        if (!dst_addr) {
+        orig_dst_addr = dma_alloc_coherent(dev, size + alignment,
+                                           &orig_dst_phys_addr, GFP_KERNEL);
+        if (!orig_dst_addr) {
                 dev_err(dev, "failed to allocate destination address\n");
                 ret = false;
-                goto err_src_addr;
+                goto err_orig_src_addr;
+        }
+
+        if (alignment && !IS_ALIGNED(orig_dst_phys_addr, alignment)) {
+                dst_phys_addr = PTR_ALIGN(orig_dst_phys_addr, alignment);
+                offset = dst_phys_addr - orig_dst_phys_addr;
+                dst_addr = orig_dst_addr + offset;
+        } else {
+                dst_phys_addr = orig_dst_phys_addr;
+                dst_addr = orig_dst_addr;
         }
 
         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_LOWER_DST_ADDR,
@@ -245,10 +286,12 @@ static bool pci_endpoint_test_copy(struct pci_endpoint_test *test, size_t size)
         if (dst_crc32 == src_crc32)
                 ret = true;
 
-        dma_free_coherent(dev, size, dst_addr, dst_phys_addr);
+        dma_free_coherent(dev, size + alignment, orig_dst_addr,
+                          orig_dst_phys_addr);
 
-err_src_addr:
-        dma_free_coherent(dev, size, src_addr, src_phys_addr);
+err_orig_src_addr:
+        dma_free_coherent(dev, size + alignment, orig_src_addr,
+                          orig_src_phys_addr);
 
 err:
         return ret;
@@ -262,15 +305,29 @@ static bool pci_endpoint_test_write(struct pci_endpoint_test *test, size_t size)
         dma_addr_t phys_addr;
         struct pci_dev *pdev = test->pdev;
         struct device *dev = &pdev->dev;
+        void *orig_addr;
+        dma_addr_t orig_phys_addr;
+        size_t offset;
+        size_t alignment = test->alignment;
         u32 crc32;
 
-        addr = dma_alloc_coherent(dev, size, &phys_addr, GFP_KERNEL);
-        if (!addr) {
+        orig_addr = dma_alloc_coherent(dev, size + alignment, &orig_phys_addr,
+                                       GFP_KERNEL);
+        if (!orig_addr) {
                 dev_err(dev, "failed to allocate address\n");
                 ret = false;
                 goto err;
         }
 
+        if (alignment && !IS_ALIGNED(orig_phys_addr, alignment)) {
+                phys_addr =  PTR_ALIGN(orig_phys_addr, alignment);
+                offset = phys_addr - orig_phys_addr;
+                addr = orig_addr + offset;
+        } else {
+                phys_addr = orig_phys_addr;
+                addr = orig_addr;
+        }
+
         get_random_bytes(addr, size);
 
         crc32 = crc32_le(~0, addr, size);
@@ -293,7 +350,7 @@ static bool pci_endpoint_test_write(struct pci_endpoint_test *test, size_t size)
         if (reg & STATUS_READ_SUCCESS)
                 ret = true;
 
-        dma_free_coherent(dev, size, addr, phys_addr);
+        dma_free_coherent(dev, size + alignment, orig_addr, orig_phys_addr);
 
 err:
         return ret;
@@ -306,15 +363,29 @@ static bool pci_endpoint_test_read(struct pci_endpoint_test *test, size_t size)
         dma_addr_t phys_addr;
         struct pci_dev *pdev = test->pdev;
         struct device *dev = &pdev->dev;
+        void *orig_addr;
+        dma_addr_t orig_phys_addr;
+        size_t offset;
+        size_t alignment = test->alignment;
         u32 crc32;
 
-        addr = dma_alloc_coherent(dev, size, &phys_addr, GFP_KERNEL);
-        if (!addr) {
+        orig_addr = dma_alloc_coherent(dev, size + alignment, &orig_phys_addr,
+                                       GFP_KERNEL);
+        if (!orig_addr) {
                 dev_err(dev, "failed to allocate destination address\n");
                 ret = false;
                 goto err;
         }
 
+        if (alignment && !IS_ALIGNED(orig_phys_addr, alignment)) {
+                phys_addr = PTR_ALIGN(orig_phys_addr, alignment);
+                offset = phys_addr - orig_phys_addr;
+                addr = orig_addr + offset;
+        } else {
+                phys_addr = orig_phys_addr;
+                addr = orig_addr;
+        }
+
         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_LOWER_DST_ADDR,
                                  lower_32_bits(phys_addr));
         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_UPPER_DST_ADDR,
@@ -331,7 +402,7 @@ static bool pci_endpoint_test_read(struct pci_endpoint_test *test, size_t size)
         if (crc32 == pci_endpoint_test_readl(test, PCI_ENDPOINT_TEST_CHECKSUM))
                 ret = true;
 
-        dma_free_coherent(dev, size, addr, phys_addr);
+        dma_free_coherent(dev, size + alignment, orig_addr, orig_phys_addr);
 err:
         return ret;
 }
@@ -383,13 +454,15 @@ static int pci_endpoint_test_probe(struct pci_dev *pdev,
 {
         int i;
         int err;
-        int irq;
+        int irq = 0;
         int id;
         char name[20];
         enum pci_barno bar;
         void __iomem *base;
         struct device *dev = &pdev->dev;
         struct pci_endpoint_test *test;
+        struct pci_endpoint_test_data *data;
+        enum pci_barno test_reg_bar = BAR_0;
         struct miscdevice *misc_device;
 
         if (pci_is_bridge(pdev))
@@ -399,7 +472,17 @@ static int pci_endpoint_test_probe(struct pci_dev *pdev,
         if (!test)
                 return -ENOMEM;
 
+        test->test_reg_bar = 0;
+        test->alignment = 0;
         test->pdev = pdev;
+
+        data = (struct pci_endpoint_test_data *)ent->driver_data;
+        if (data) {
+                test_reg_bar = data->test_reg_bar;
+                test->alignment = data->alignment;
+                no_msi = data->no_msi;
+        }
+
         init_completion(&test->irq_raised);
         mutex_init(&test->mutex);
 
@@ -417,9 +500,11 @@ static int pci_endpoint_test_probe(struct pci_dev *pdev,
 
         pci_set_master(pdev);
 
-        irq = pci_alloc_irq_vectors(pdev, 1, 32, PCI_IRQ_MSI);
-        if (irq < 0)
-                dev_err(dev, "failed to get MSI interrupts\n");
+        if (!no_msi) {
+                irq = pci_alloc_irq_vectors(pdev, 1, 32, PCI_IRQ_MSI);
+                if (irq < 0)
+                        dev_err(dev, "failed to get MSI interrupts\n");
+        }
 
         err = devm_request_irq(dev, pdev->irq, pci_endpoint_test_irqhandler,
                                IRQF_SHARED, DRV_MODULE_NAME, test);
@@ -441,14 +526,15 @@ static int pci_endpoint_test_probe(struct pci_dev *pdev,
                 base = pci_ioremap_bar(pdev, bar);
                 if (!base) {
                         dev_err(dev, "failed to read BAR%d\n", bar);
-                        WARN_ON(bar == BAR_0);
+                        WARN_ON(bar == test_reg_bar);
                 }
                 test->bar[bar] = base;
         }
 
-        test->base = test->bar[0];
+        test->base = test->bar[test_reg_bar];
         if (!test->base) {
-                dev_err(dev, "Cannot perform PCI test without BAR0\n");
+                dev_err(dev, "Cannot perform PCI test without BAR%d\n",
+                        test_reg_bar);
                 goto err_iounmap;
         }