[PATCH 1/7] PCI: iproc: Rename accessors

[PATCH 1/7] PCI: iproc: Rename accessors

[Bjorn Helgaas]

Rename iproc_pcie_read_reg() to iproc_readl() and iproc_pcie_write_reg() to
iproc_writel() for consistency with other drivers.  Uninline them; there's
no performance issue here, and the compiler can inline them if it's
worthwhile.  No functional change intended.

Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
 drivers/pci/host/pcie-iproc.c |   29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/drivers/pci/host/pcie-iproc.c b/drivers/pci/host/pcie-iproc.c
index e167b2f..f1ae9e1 100644
--- a/drivers/pci/host/pcie-iproc.c
+++ b/drivers/pci/host/pcie-iproc.c
@@ -135,8 +135,7 @@ static inline u16 iproc_pcie_reg_offset(struct iproc_pcie *pcie,
 	return pcie->reg_offsets[reg];
 }
 
-static inline u32 iproc_pcie_read_reg(struct iproc_pcie *pcie,
-				      enum iproc_pcie_reg reg)
+static u32 iproc_readl(struct iproc_pcie *pcie, enum iproc_pcie_reg reg)
 {
 	u16 offset = iproc_pcie_reg_offset(pcie, reg);
 
@@ -146,8 +145,8 @@ static inline u32 iproc_pcie_read_reg(struct iproc_pcie *pcie,
 	return readl(pcie->base + offset);
 }
 
-static inline void iproc_pcie_write_reg(struct iproc_pcie *pcie,
-					enum iproc_pcie_reg reg, u32 val)
+static void iproc_writel(struct iproc_pcie *pcie, enum iproc_pcie_reg reg,
+			 u32 val)
 {
 	u16 offset = iproc_pcie_reg_offset(pcie, reg);
 
@@ -189,8 +188,8 @@ static void __iomem *iproc_pcie_map_cfg_bus(struct pci_bus *bus,
 		if (slot > 0 || fn > 0)
 			return NULL;
 
-		iproc_pcie_write_reg(pcie, IPROC_PCIE_CFG_IND_ADDR,
-				     where & CFG_IND_ADDR_MASK);
+		iproc_writel(pcie, IPROC_PCIE_CFG_IND_ADDR,
+			     where & CFG_IND_ADDR_MASK);
 		offset = iproc_pcie_reg_offset(pcie, IPROC_PCIE_CFG_IND_DATA);
 		if (iproc_pcie_reg_is_invalid(offset))
 			return NULL;
@@ -212,7 +211,7 @@ static void __iomem *iproc_pcie_map_cfg_bus(struct pci_bus *bus,
 		(fn << CFG_ADDR_FUNC_NUM_SHIFT) |
 		(where & CFG_ADDR_REG_NUM_MASK) |
 		(1 & CFG_ADDR_CFG_TYPE_MASK);
-	iproc_pcie_write_reg(pcie, IPROC_PCIE_CFG_ADDR, val);
+	iproc_writel(pcie, IPROC_PCIE_CFG_ADDR, val);
 	offset = iproc_pcie_reg_offset(pcie, IPROC_PCIE_CFG_DATA);
 	if (iproc_pcie_reg_is_invalid(offset))
 		return NULL;
@@ -231,12 +230,12 @@ static void iproc_pcie_reset(struct iproc_pcie *pcie)
 	u32 val;
 
 	if (pcie->type == IPROC_PCIE_PAXC) {
-		val = iproc_pcie_read_reg(pcie, IPROC_PCIE_CLK_CTRL);
+		val = iproc_readl(pcie, IPROC_PCIE_CLK_CTRL);
 		val &= ~PAXC_RESET_MASK;
-		iproc_pcie_write_reg(pcie, IPROC_PCIE_CLK_CTRL, val);
+		iproc_writel(pcie, IPROC_PCIE_CLK_CTRL, val);
 		udelay(100);
 		val |= PAXC_RESET_MASK;
-		iproc_pcie_write_reg(pcie, IPROC_PCIE_CLK_CTRL, val);
+		iproc_writel(pcie, IPROC_PCIE_CLK_CTRL, val);
 		udelay(100);
 		return;
 	}
@@ -245,14 +244,14 @@ static void iproc_pcie_reset(struct iproc_pcie *pcie)
 	 * Select perst_b signal as reset source. Put the device into reset,
 	 * and then bring it out of reset
 	 */
-	val = iproc_pcie_read_reg(pcie, IPROC_PCIE_CLK_CTRL);
+	val = iproc_readl(pcie, IPROC_PCIE_CLK_CTRL);
 	val &= ~EP_PERST_SOURCE_SELECT & ~EP_MODE_SURVIVE_PERST &
 		~RC_PCIE_RST_OUTPUT;
-	iproc_pcie_write_reg(pcie, IPROC_PCIE_CLK_CTRL, val);
+	iproc_writel(pcie, IPROC_PCIE_CLK_CTRL, val);
 	udelay(250);
 
 	val |= RC_PCIE_RST_OUTPUT;
-	iproc_pcie_write_reg(pcie, IPROC_PCIE_CLK_CTRL, val);
+	iproc_writel(pcie, IPROC_PCIE_CLK_CTRL, val);
 	msleep(100);
 }
 
@@ -270,7 +269,7 @@ static int iproc_pcie_check_link(struct iproc_pcie *pcie, struct pci_bus *bus)
 	if (pcie->type == IPROC_PCIE_PAXC)
 		return 0;
 
-	val = iproc_pcie_read_reg(pcie, IPROC_PCIE_LINK_STATUS);
+	val = iproc_readl(pcie, IPROC_PCIE_LINK_STATUS);
 	if (!(val & PCIE_PHYLINKUP) || !(val & PCIE_DL_ACTIVE)) {
 		dev_err(pcie->dev, "PHY or data link is INACTIVE!\n");
 		return -ENODEV;
@@ -331,7 +330,7 @@ static int iproc_pcie_check_link(struct iproc_pcie *pcie, struct pci_bus *bus)
 
 static void iproc_pcie_enable(struct iproc_pcie *pcie)
 {
-	iproc_pcie_write_reg(pcie, IPROC_PCIE_INTX_EN, SYS_RC_INTX_MASK);
+	iproc_writel(pcie, IPROC_PCIE_INTX_EN, SYS_RC_INTX_MASK);
 }
 
 /**

[PATCH 2/7] PCI: iproc: Name private struct pointer "iproc" consistently

[Bjorn Helgaas]

Use a device-specific name, "iproc", for struct iproc_pcie pointers
to hint that this is device-specific information.  No functional change
intended.

Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
 drivers/pci/host/pcie-iproc-bcma.c     |   28 ++---
 drivers/pci/host/pcie-iproc-msi.c      |   66 ++++++------
 drivers/pci/host/pcie-iproc-platform.c |   54 +++++----
 drivers/pci/host/pcie-iproc.c          |  182 ++++++++++++++++----------------
 4 files changed, 165 insertions(+), 165 deletions(-)

diff --git a/drivers/pci/host/pcie-iproc-bcma.c b/drivers/pci/host/pcie-iproc-bcma.c
index 0d7bee4..72273ff 100644
--- a/drivers/pci/host/pcie-iproc-bcma.c
+++ b/drivers/pci/host/pcie-iproc-bcma.c
@@ -34,28 +34,28 @@ DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_BROADCOM, 0x8012, bcma_pcie2_fixup_class);
 static int iproc_pcie_bcma_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
 {
 	struct pci_sys_data *sys = dev->sysdata;
-	struct iproc_pcie *pcie = sys->private_data;
-	struct bcma_device *bdev = container_of(pcie->dev, struct bcma_device, dev);
+	struct iproc_pcie *iproc = sys->private_data;
+	struct bcma_device *bdev = container_of(iproc->dev, struct bcma_device, dev);
 
 	return bcma_core_irq(bdev, 5);
 }
 
 static int iproc_pcie_bcma_probe(struct bcma_device *bdev)
 {
-	struct iproc_pcie *pcie;
+	struct iproc_pcie *iproc;
 	LIST_HEAD(res);
 	struct resource res_mem;
 	int ret;
 
-	pcie = devm_kzalloc(&bdev->dev, sizeof(*pcie), GFP_KERNEL);
-	if (!pcie)
+	iproc = devm_kzalloc(&bdev->dev, sizeof(*iproc), GFP_KERNEL);
+	if (!iproc)
 		return -ENOMEM;
 
-	pcie->dev = &bdev->dev;
-	bcma_set_drvdata(bdev, pcie);
+	iproc->dev = &bdev->dev;
+	bcma_set_drvdata(bdev, iproc);
 
-	pcie->base = bdev->io_addr;
-	pcie->base_addr = bdev->addr;
+	iproc->base = bdev->io_addr;
+	iproc->base_addr = bdev->addr;
 
 	res_mem.start = bdev->addr_s[0];
 	res_mem.end = bdev->addr_s[0] + SZ_128M - 1;
@@ -63,11 +63,11 @@ static int iproc_pcie_bcma_probe(struct bcma_device *bdev)
 	res_mem.flags = IORESOURCE_MEM;
 	pci_add_resource(&res, &res_mem);
 
-	pcie->map_irq = iproc_pcie_bcma_map_irq;
+	iproc->map_irq = iproc_pcie_bcma_map_irq;
 
-	ret = iproc_pcie_setup(pcie, &res);
+	ret = iproc_pcie_setup(iproc, &res);
 	if (ret)
-		dev_err(pcie->dev, "PCIe controller setup failed\n");
+		dev_err(iproc->dev, "PCIe controller setup failed\n");
 
 	pci_free_resource_list(&res);
 
@@ -76,9 +76,9 @@ static int iproc_pcie_bcma_probe(struct bcma_device *bdev)
 
 static void iproc_pcie_bcma_remove(struct bcma_device *bdev)
 {
-	struct iproc_pcie *pcie = bcma_get_drvdata(bdev);
+	struct iproc_pcie *iproc = bcma_get_drvdata(bdev);
 
-	iproc_pcie_remove(pcie);
+	iproc_pcie_remove(iproc);
 }
 
 static const struct bcma_device_id iproc_pcie_bcma_table[] = {
diff --git a/drivers/pci/host/pcie-iproc-msi.c b/drivers/pci/host/pcie-iproc-msi.c
index 9a2973b..4e682a7 100644
--- a/drivers/pci/host/pcie-iproc-msi.c
+++ b/drivers/pci/host/pcie-iproc-msi.c
@@ -78,7 +78,7 @@ struct iproc_msi_grp {
  * Only meant to be used on platforms without MSI support integrated into the
  * GIC.
  *
- * @pcie: pointer to iProc PCIe data
+ * @iproc: pointer to iProc PCIe data
  * @reg_offsets: MSI register offsets
  * @grps: MSI groups
  * @nr_irqs: number of total interrupts connected to GIC
@@ -99,7 +99,7 @@ struct iproc_msi_grp {
  * @msi_addr: MSI address
  */
 struct iproc_msi {
-	struct iproc_pcie *pcie;
+	struct iproc_pcie *iproc;
 	const u16 (*reg_offsets)[IPROC_MSI_REG_SIZE];
 	struct iproc_msi_grp *grps;
 	int nr_irqs;
@@ -137,18 +137,18 @@ static inline u32 iproc_msi_read_reg(struct iproc_msi *msi,
 				     enum iproc_msi_reg reg,
 				     unsigned int eq)
 {
-	struct iproc_pcie *pcie = msi->pcie;
+	struct iproc_pcie *iproc = msi->iproc;
 
-	return readl_relaxed(pcie->base + msi->reg_offsets[eq][reg]);
+	return readl_relaxed(iproc->base + msi->reg_offsets[eq][reg]);
 }
 
 static inline void iproc_msi_write_reg(struct iproc_msi *msi,
 				       enum iproc_msi_reg reg,
 				       int eq, u32 val)
 {
-	struct iproc_pcie *pcie = msi->pcie;
+	struct iproc_pcie *iproc = msi->iproc;
 
-	writel_relaxed(val, pcie->base + msi->reg_offsets[eq][reg]);
+	writel_relaxed(val, iproc->base + msi->reg_offsets[eq][reg]);
 }
 
 static inline u32 hwirq_to_group(struct iproc_msi *msi, unsigned long hwirq)
@@ -317,7 +317,7 @@ static void iproc_msi_handler(struct irq_desc *desc)
 	struct irq_chip *chip = irq_desc_get_chip(desc);
 	struct iproc_msi_grp *grp;
 	struct iproc_msi *msi;
-	struct iproc_pcie *pcie;
+	struct iproc_pcie *iproc;
 	u32 eq, head, tail, nr_events;
 	unsigned long hwirq;
 	int virq;
@@ -326,7 +326,7 @@ static void iproc_msi_handler(struct irq_desc *desc)
 
 	grp = irq_desc_get_handler_data(desc);
 	msi = grp->msi;
-	pcie = msi->pcie;
+	iproc = msi->iproc;
 	eq = grp->eq;
 
 	/*
@@ -482,7 +482,7 @@ static int iproc_msi_irq_setup(struct iproc_msi *msi, unsigned int cpu)
 {
 	int i, ret;
 	cpumask_var_t mask;
-	struct iproc_pcie *pcie = msi->pcie;
+	struct iproc_pcie *iproc = msi->iproc;
 
 	for (i = cpu; i < msi->nr_irqs; i += msi->nr_cpus) {
 		irq_set_chained_handler_and_data(msi->grps[i].gic_irq,
@@ -494,12 +494,12 @@ static int iproc_msi_irq_setup(struct iproc_msi *msi, unsigned int cpu)
 			cpumask_set_cpu(cpu, mask);
 			ret = irq_set_affinity(msi->grps[i].gic_irq, mask);
 			if (ret)
-				dev_err(pcie->dev,
+				dev_err(iproc->dev,
 					"failed to set affinity for IRQ%d\n",
 					msi->grps[i].gic_irq);
 			free_cpumask_var(mask);
 		} else {
-			dev_err(pcie->dev, "failed to alloc CPU mask\n");
+			dev_err(iproc->dev, "failed to alloc CPU mask\n");
 			ret = -EINVAL;
 		}
 
@@ -513,7 +513,7 @@ static int iproc_msi_irq_setup(struct iproc_msi *msi, unsigned int cpu)
 	return 0;
 }
 
-int iproc_msi_init(struct iproc_pcie *pcie, struct device_node *node)
+int iproc_msi_init(struct iproc_pcie *iproc, struct device_node *node)
 {
 	struct iproc_msi *msi;
 	int i, ret;
@@ -525,44 +525,44 @@ int iproc_msi_init(struct iproc_pcie *pcie, struct device_node *node)
 	if (!of_find_property(node, "msi-controller", NULL))
 		return -ENODEV;
 
-	if (pcie->msi)
+	if (iproc->msi)
 		return -EBUSY;
 
-	msi = devm_kzalloc(pcie->dev, sizeof(*msi), GFP_KERNEL);
+	msi = devm_kzalloc(iproc->dev, sizeof(*msi), GFP_KERNEL);
 	if (!msi)
 		return -ENOMEM;
 
-	msi->pcie = pcie;
-	pcie->msi = msi;
-	msi->msi_addr = pcie->base_addr;
+	msi->iproc = iproc;
+	iproc->msi = msi;
+	msi->msi_addr = iproc->base_addr;
 	mutex_init(&msi->bitmap_lock);
 	msi->nr_cpus = num_possible_cpus();
 
 	msi->nr_irqs = of_irq_count(node);
 	if (!msi->nr_irqs) {
-		dev_err(pcie->dev, "found no MSI GIC interrupt\n");
+		dev_err(iproc->dev, "found no MSI GIC interrupt\n");
 		return -ENODEV;
 	}
 
 	if (msi->nr_irqs > NR_HW_IRQS) {
-		dev_warn(pcie->dev, "too many MSI GIC interrupts defined %d\n",
+		dev_warn(iproc->dev, "too many MSI GIC interrupts defined %d\n",
 			 msi->nr_irqs);
 		msi->nr_irqs = NR_HW_IRQS;
 	}
 
 	if (msi->nr_irqs < msi->nr_cpus) {
-		dev_err(pcie->dev,
+		dev_err(iproc->dev,
 			"not enough GIC interrupts for MSI affinity\n");
 		return -EINVAL;
 	}
 
 	if (msi->nr_irqs % msi->nr_cpus != 0) {
 		msi->nr_irqs -= msi->nr_irqs % msi->nr_cpus;
-		dev_warn(pcie->dev, "Reducing number of interrupts to %d\n",
+		dev_warn(iproc->dev, "Reducing number of interrupts to %d\n",
 			 msi->nr_irqs);
 	}
 
-	switch (pcie->type) {
+	switch (iproc->type) {
 	case IPROC_PCIE_PAXB:
 		msi->reg_offsets = iproc_msi_reg_paxb;
 		msi->nr_eq_region = 1;
@@ -574,7 +574,7 @@ int iproc_msi_init(struct iproc_pcie *pcie, struct device_node *node)
 		msi->nr_msi_region = msi->nr_irqs;
 		break;
 	default:
-		dev_err(pcie->dev, "incompatible iProc PCIe interface\n");
+		dev_err(iproc->dev, "incompatible iProc PCIe interface\n");
 		return -EINVAL;
 	}
 
@@ -582,12 +582,12 @@ int iproc_msi_init(struct iproc_pcie *pcie, struct device_node *node)
 		msi->has_inten_reg = true;
 
 	msi->nr_msi_vecs = msi->nr_irqs * EQ_LEN;
-	msi->bitmap = devm_kcalloc(pcie->dev, BITS_TO_LONGS(msi->nr_msi_vecs),
+	msi->bitmap = devm_kcalloc(iproc->dev, BITS_TO_LONGS(msi->nr_msi_vecs),
 				   sizeof(*msi->bitmap), GFP_KERNEL);
 	if (!msi->bitmap)
 		return -ENOMEM;
 
-	msi->grps = devm_kcalloc(pcie->dev, msi->nr_irqs, sizeof(*msi->grps),
+	msi->grps = devm_kcalloc(iproc->dev, msi->nr_irqs, sizeof(*msi->grps),
 				 GFP_KERNEL);
 	if (!msi->grps)
 		return -ENOMEM;
@@ -596,7 +596,7 @@ int iproc_msi_init(struct iproc_pcie *pcie, struct device_node *node)
 		unsigned int irq = irq_of_parse_and_map(node, i);
 
 		if (!irq) {
-			dev_err(pcie->dev, "unable to parse/map interrupt\n");
+			dev_err(iproc->dev, "unable to parse/map interrupt\n");
 			ret = -ENODEV;
 			goto free_irqs;
 		}
@@ -606,7 +606,7 @@ int iproc_msi_init(struct iproc_pcie *pcie, struct device_node *node)
 	}
 
 	/* Reserve memory for event queue and make sure memories are zeroed */
-	msi->eq_cpu = dma_zalloc_coherent(pcie->dev,
+	msi->eq_cpu = dma_zalloc_coherent(iproc->dev,
 					  msi->nr_eq_region * EQ_MEM_REGION_SIZE,
 					  &msi->eq_dma, GFP_KERNEL);
 	if (!msi->eq_cpu) {
@@ -616,7 +616,7 @@ int iproc_msi_init(struct iproc_pcie *pcie, struct device_node *node)
 
 	ret = iproc_msi_alloc_domains(node, msi);
 	if (ret) {
-		dev_err(pcie->dev, "failed to create MSI domains\n");
+		dev_err(iproc->dev, "failed to create MSI domains\n");
 		goto free_eq_dma;
 	}
 
@@ -636,7 +636,7 @@ free_msi_irq:
 	iproc_msi_free_domains(msi);
 
 free_eq_dma:
-	dma_free_coherent(pcie->dev, msi->nr_eq_region * EQ_MEM_REGION_SIZE,
+	dma_free_coherent(iproc->dev, msi->nr_eq_region * EQ_MEM_REGION_SIZE,
 			  msi->eq_cpu, msi->eq_dma);
 
 free_irqs:
@@ -644,14 +644,14 @@ free_irqs:
 		if (msi->grps[i].gic_irq)
 			irq_dispose_mapping(msi->grps[i].gic_irq);
 	}
-	pcie->msi = NULL;
+	iproc->msi = NULL;
 	return ret;
 }
 EXPORT_SYMBOL(iproc_msi_init);
 
-void iproc_msi_exit(struct iproc_pcie *pcie)
+void iproc_msi_exit(struct iproc_pcie *iproc)
 {
-	struct iproc_msi *msi = pcie->msi;
+	struct iproc_msi *msi = iproc->msi;
 	unsigned int i, cpu;
 
 	if (!msi)
@@ -664,7 +664,7 @@ void iproc_msi_exit(struct iproc_pcie *pcie)
 
 	iproc_msi_free_domains(msi);
 
-	dma_free_coherent(pcie->dev, msi->nr_eq_region * EQ_MEM_REGION_SIZE,
+	dma_free_coherent(iproc->dev, msi->nr_eq_region * EQ_MEM_REGION_SIZE,
 			  msi->eq_cpu, msi->eq_dma);
 
 	for (i = 0; i < msi->nr_irqs; i++) {
diff --git a/drivers/pci/host/pcie-iproc-platform.c b/drivers/pci/host/pcie-iproc-platform.c
index 1738c52..d348635 100644
--- a/drivers/pci/host/pcie-iproc-platform.c
+++ b/drivers/pci/host/pcie-iproc-platform.c
@@ -41,7 +41,7 @@ MODULE_DEVICE_TABLE(of, iproc_pcie_of_match_table);
 static int iproc_pcie_pltfm_probe(struct platform_device *pdev)
 {
 	const struct of_device_id *of_id;
-	struct iproc_pcie *pcie;
+	struct iproc_pcie *iproc;
 	struct device_node *np = pdev->dev.of_node;
 	struct resource reg;
 	resource_size_t iobase = 0;
@@ -52,26 +52,26 @@ static int iproc_pcie_pltfm_probe(struct platform_device *pdev)
 	if (!of_id)
 		return -EINVAL;
 
-	pcie = devm_kzalloc(&pdev->dev, sizeof(struct iproc_pcie), GFP_KERNEL);
-	if (!pcie)
+	iproc = devm_kzalloc(&pdev->dev, sizeof(*iproc), GFP_KERNEL);
+	if (!iproc)
 		return -ENOMEM;
 
-	pcie->dev = &pdev->dev;
-	pcie->type = (enum iproc_pcie_type)of_id->data;
-	platform_set_drvdata(pdev, pcie);
+	iproc->dev = &pdev->dev;
+	iproc->type = (enum iproc_pcie_type)of_id->data;
+	platform_set_drvdata(pdev, iproc);
 
 	ret = of_address_to_resource(np, 0, &reg);
 	if (ret < 0) {
-		dev_err(pcie->dev, "unable to obtain controller resources\n");
+		dev_err(iproc->dev, "unable to obtain controller resources\n");
 		return ret;
 	}
 
-	pcie->base = devm_ioremap(pcie->dev, reg.start, resource_size(&reg));
-	if (!pcie->base) {
-		dev_err(pcie->dev, "unable to map controller registers\n");
+	iproc->base = devm_ioremap(iproc->dev, reg.start, resource_size(&reg));
+	if (!iproc->base) {
+		dev_err(iproc->dev, "unable to map controller registers\n");
 		return -ENOMEM;
 	}
-	pcie->base_addr = reg.start;
+	iproc->base_addr = reg.start;
 
 	if (of_property_read_bool(np, "brcm,pcie-ob")) {
 		u32 val;
@@ -79,47 +79,47 @@ static int iproc_pcie_pltfm_probe(struct platform_device *pdev)
 		ret = of_property_read_u32(np, "brcm,pcie-ob-axi-offset",
 					   &val);
 		if (ret) {
-			dev_err(pcie->dev,
+			dev_err(iproc->dev,
 				"missing brcm,pcie-ob-axi-offset property\n");
 			return ret;
 		}
-		pcie->ob.axi_offset = val;
+		iproc->ob.axi_offset = val;
 
 		ret = of_property_read_u32(np, "brcm,pcie-ob-window-size",
 					   &val);
 		if (ret) {
-			dev_err(pcie->dev,
+			dev_err(iproc->dev,
 				"missing brcm,pcie-ob-window-size property\n");
 			return ret;
 		}
-		pcie->ob.window_size = (resource_size_t)val * SZ_1M;
+		iproc->ob.window_size = (resource_size_t)val * SZ_1M;
 
 		if (of_property_read_bool(np, "brcm,pcie-ob-oarr-size"))
-			pcie->ob.set_oarr_size = true;
+			iproc->ob.set_oarr_size = true;
 
-		pcie->need_ob_cfg = true;
+		iproc->need_ob_cfg = true;
 	}
 
 	/* PHY use is optional */
-	pcie->phy = devm_phy_get(&pdev->dev, "pcie-phy");
-	if (IS_ERR(pcie->phy)) {
-		if (PTR_ERR(pcie->phy) == -EPROBE_DEFER)
+	iproc->phy = devm_phy_get(&pdev->dev, "pcie-phy");
+	if (IS_ERR(iproc->phy)) {
+		if (PTR_ERR(iproc->phy) == -EPROBE_DEFER)
 			return -EPROBE_DEFER;
-		pcie->phy = NULL;
+		iproc->phy = NULL;
 	}
 
 	ret = of_pci_get_host_bridge_resources(np, 0, 0xff, &res, &iobase);
 	if (ret) {
-		dev_err(pcie->dev,
+		dev_err(iproc->dev,
 			"unable to get PCI host bridge resources\n");
 		return ret;
 	}
 
-	pcie->map_irq = of_irq_parse_and_map_pci;
+	iproc->map_irq = of_irq_parse_and_map_pci;
 
-	ret = iproc_pcie_setup(pcie, &res);
+	ret = iproc_pcie_setup(iproc, &res);
 	if (ret)
-		dev_err(pcie->dev, "PCIe controller setup failed\n");
+		dev_err(iproc->dev, "PCIe controller setup failed\n");
 
 	pci_free_resource_list(&res);
 
@@ -128,9 +128,9 @@ static int iproc_pcie_pltfm_probe(struct platform_device *pdev)
 
 static int iproc_pcie_pltfm_remove(struct platform_device *pdev)
 {
-	struct iproc_pcie *pcie = platform_get_drvdata(pdev);
+	struct iproc_pcie *iproc = platform_get_drvdata(pdev);
 
-	return iproc_pcie_remove(pcie);
+	return iproc_pcie_remove(iproc);
 }
 
 static struct platform_driver iproc_pcie_pltfm_driver = {
diff --git a/drivers/pci/host/pcie-iproc.c b/drivers/pci/host/pcie-iproc.c
index f1ae9e1..408e99d 100644
--- a/drivers/pci/host/pcie-iproc.c
+++ b/drivers/pci/host/pcie-iproc.c
@@ -113,15 +113,15 @@ static const u16 iproc_pcie_reg_paxc[] = {
 
 static inline struct iproc_pcie *iproc_data(struct pci_bus *bus)
 {
-	struct iproc_pcie *pcie;
+	struct iproc_pcie *iproc;
 #ifdef CONFIG_ARM
 	struct pci_sys_data *sys = bus->sysdata;
 
-	pcie = sys->private_data;
+	iproc = sys->private_data;
 #else
-	pcie = bus->sysdata;
+	iproc = bus->sysdata;
 #endif
-	return pcie;
+	return iproc;
 }
 
 static inline bool iproc_pcie_reg_is_invalid(u16 reg_offset)
@@ -129,43 +129,43 @@ static inline bool iproc_pcie_reg_is_invalid(u16 reg_offset)
 	return !!(reg_offset == IPROC_PCIE_REG_INVALID);
 }
 
-static inline u16 iproc_pcie_reg_offset(struct iproc_pcie *pcie,
+static inline u16 iproc_pcie_reg_offset(struct iproc_pcie *iproc,
 					enum iproc_pcie_reg reg)
 {
-	return pcie->reg_offsets[reg];
+	return iproc->reg_offsets[reg];
 }
 
-static u32 iproc_readl(struct iproc_pcie *pcie, enum iproc_pcie_reg reg)
+static u32 iproc_readl(struct iproc_pcie *iproc, enum iproc_pcie_reg reg)
 {
-	u16 offset = iproc_pcie_reg_offset(pcie, reg);
+	u16 offset = iproc_pcie_reg_offset(iproc, reg);
 
 	if (iproc_pcie_reg_is_invalid(offset))
 		return 0;
 
-	return readl(pcie->base + offset);
+	return readl(iproc->base + offset);
 }
 
-static void iproc_writel(struct iproc_pcie *pcie, enum iproc_pcie_reg reg,
+static void iproc_writel(struct iproc_pcie *iproc, enum iproc_pcie_reg reg,
 			 u32 val)
 {
-	u16 offset = iproc_pcie_reg_offset(pcie, reg);
+	u16 offset = iproc_pcie_reg_offset(iproc, reg);
 
 	if (iproc_pcie_reg_is_invalid(offset))
 		return;
 
-	writel(val, pcie->base + offset);
+	writel(val, iproc->base + offset);
 }
 
-static inline void iproc_pcie_ob_write(struct iproc_pcie *pcie,
+static inline void iproc_pcie_ob_write(struct iproc_pcie *iproc,
 				       enum iproc_pcie_reg reg,
 				       unsigned window, u32 val)
 {
-	u16 offset = iproc_pcie_reg_offset(pcie, reg);
+	u16 offset = iproc_pcie_reg_offset(iproc, reg);
 
 	if (iproc_pcie_reg_is_invalid(offset))
 		return;
 
-	writel(val, pcie->base + offset + (window * 8));
+	writel(val, iproc->base + offset + (window * 8));
 }
 
 /**
@@ -176,7 +176,7 @@ static void __iomem *iproc_pcie_map_cfg_bus(struct pci_bus *bus,
 					    unsigned int devfn,
 					    int where)
 {
-	struct iproc_pcie *pcie = iproc_data(bus);
+	struct iproc_pcie *iproc = iproc_data(bus);
 	unsigned slot = PCI_SLOT(devfn);
 	unsigned fn = PCI_FUNC(devfn);
 	unsigned busno = bus->number;
@@ -188,20 +188,20 @@ static void __iomem *iproc_pcie_map_cfg_bus(struct pci_bus *bus,
 		if (slot > 0 || fn > 0)
 			return NULL;
 
-		iproc_writel(pcie, IPROC_PCIE_CFG_IND_ADDR,
+		iproc_writel(iproc, IPROC_PCIE_CFG_IND_ADDR,
 			     where & CFG_IND_ADDR_MASK);
-		offset = iproc_pcie_reg_offset(pcie, IPROC_PCIE_CFG_IND_DATA);
+		offset = iproc_pcie_reg_offset(iproc, IPROC_PCIE_CFG_IND_DATA);
 		if (iproc_pcie_reg_is_invalid(offset))
 			return NULL;
 		else
-			return (pcie->base + offset);
+			return (iproc->base + offset);
 	}
 
 	/*
 	 * PAXC is connected to an internally emulated EP within the SoC.  It
 	 * allows only one device.
 	 */
-	if (pcie->type == IPROC_PCIE_PAXC)
+	if (iproc->type == IPROC_PCIE_PAXC)
 		if (slot > 0)
 			return NULL;
 
@@ -211,12 +211,12 @@ static void __iomem *iproc_pcie_map_cfg_bus(struct pci_bus *bus,
 		(fn << CFG_ADDR_FUNC_NUM_SHIFT) |
 		(where & CFG_ADDR_REG_NUM_MASK) |
 		(1 & CFG_ADDR_CFG_TYPE_MASK);
-	iproc_writel(pcie, IPROC_PCIE_CFG_ADDR, val);
-	offset = iproc_pcie_reg_offset(pcie, IPROC_PCIE_CFG_DATA);
+	iproc_writel(iproc, IPROC_PCIE_CFG_ADDR, val);
+	offset = iproc_pcie_reg_offset(iproc, IPROC_PCIE_CFG_DATA);
 	if (iproc_pcie_reg_is_invalid(offset))
 		return NULL;
 	else
-		return (pcie->base + offset);
+		return (iproc->base + offset);
 }
 
 static struct pci_ops iproc_pcie_ops = {
@@ -225,17 +225,17 @@ static struct pci_ops iproc_pcie_ops = {
 	.write = pci_generic_config_write32,
 };
 
-static void iproc_pcie_reset(struct iproc_pcie *pcie)
+static void iproc_pcie_reset(struct iproc_pcie *iproc)
 {
 	u32 val;
 
-	if (pcie->type == IPROC_PCIE_PAXC) {
-		val = iproc_readl(pcie, IPROC_PCIE_CLK_CTRL);
+	if (iproc->type == IPROC_PCIE_PAXC) {
+		val = iproc_readl(iproc, IPROC_PCIE_CLK_CTRL);
 		val &= ~PAXC_RESET_MASK;
-		iproc_writel(pcie, IPROC_PCIE_CLK_CTRL, val);
+		iproc_writel(iproc, IPROC_PCIE_CLK_CTRL, val);
 		udelay(100);
 		val |= PAXC_RESET_MASK;
-		iproc_writel(pcie, IPROC_PCIE_CLK_CTRL, val);
+		iproc_writel(iproc, IPROC_PCIE_CLK_CTRL, val);
 		udelay(100);
 		return;
 	}
@@ -244,18 +244,18 @@ static void iproc_pcie_reset(struct iproc_pcie *pcie)
 	 * Select perst_b signal as reset source. Put the device into reset,
 	 * and then bring it out of reset
 	 */
-	val = iproc_readl(pcie, IPROC_PCIE_CLK_CTRL);
+	val = iproc_readl(iproc, IPROC_PCIE_CLK_CTRL);
 	val &= ~EP_PERST_SOURCE_SELECT & ~EP_MODE_SURVIVE_PERST &
 		~RC_PCIE_RST_OUTPUT;
-	iproc_writel(pcie, IPROC_PCIE_CLK_CTRL, val);
+	iproc_writel(iproc, IPROC_PCIE_CLK_CTRL, val);
 	udelay(250);
 
 	val |= RC_PCIE_RST_OUTPUT;
-	iproc_writel(pcie, IPROC_PCIE_CLK_CTRL, val);
+	iproc_writel(iproc, IPROC_PCIE_CLK_CTRL, val);
 	msleep(100);
 }
 
-static int iproc_pcie_check_link(struct iproc_pcie *pcie, struct pci_bus *bus)
+static int iproc_pcie_check_link(struct iproc_pcie *iproc, struct pci_bus *bus)
 {
 	u8 hdr_type;
 	u32 link_ctrl, class, val;
@@ -266,19 +266,19 @@ static int iproc_pcie_check_link(struct iproc_pcie *pcie, struct pci_bus *bus)
 	 * PAXC connects to emulated endpoint devices directly and does not
 	 * have a Serdes.  Therefore skip the link detection logic here.
 	 */
-	if (pcie->type == IPROC_PCIE_PAXC)
+	if (iproc->type == IPROC_PCIE_PAXC)
 		return 0;
 
-	val = iproc_readl(pcie, IPROC_PCIE_LINK_STATUS);
+	val = iproc_readl(iproc, IPROC_PCIE_LINK_STATUS);
 	if (!(val & PCIE_PHYLINKUP) || !(val & PCIE_DL_ACTIVE)) {
-		dev_err(pcie->dev, "PHY or data link is INACTIVE!\n");
+		dev_err(iproc->dev, "PHY or data link is INACTIVE!\n");
 		return -ENODEV;
 	}
 
 	/* make sure we are not in EP mode */
 	pci_bus_read_config_byte(bus, 0, PCI_HEADER_TYPE, &hdr_type);
 	if ((hdr_type & 0x7f) != PCI_HEADER_TYPE_BRIDGE) {
-		dev_err(pcie->dev, "in EP mode, hdr=%#02x\n", hdr_type);
+		dev_err(iproc->dev, "in EP mode, hdr=%#02x\n", hdr_type);
 		return -EFAULT;
 	}
 
@@ -323,14 +323,14 @@ static int iproc_pcie_check_link(struct iproc_pcie *pcie, struct pci_bus *bus)
 		}
 	}
 
-	dev_info(pcie->dev, "link: %s\n", link_is_active ? "UP" : "DOWN");
+	dev_info(iproc->dev, "link: %s\n", link_is_active ? "UP" : "DOWN");
 
 	return link_is_active ? 0 : -ENODEV;
 }
 
-static void iproc_pcie_enable(struct iproc_pcie *pcie)
+static void iproc_pcie_enable(struct iproc_pcie *iproc)
 {
-	iproc_writel(pcie, IPROC_PCIE_INTX_EN, SYS_RC_INTX_MASK);
+	iproc_writel(iproc, IPROC_PCIE_INTX_EN, SYS_RC_INTX_MASK);
 }
 
 /**
@@ -344,16 +344,16 @@ static void iproc_pcie_enable(struct iproc_pcie *pcie)
  *
  * axi_addr -> iproc_pcie_address -> OARR -> OMAP -> pci_address
  */
-static int iproc_pcie_setup_ob(struct iproc_pcie *pcie, u64 axi_addr,
+static int iproc_pcie_setup_ob(struct iproc_pcie *iproc, u64 axi_addr,
 			       u64 pci_addr, resource_size_t size)
 {
-	struct iproc_pcie_ob *ob = &pcie->ob;
+	struct iproc_pcie_ob *ob = &iproc->ob;
 	unsigned i;
 	u64 max_size = (u64)ob->window_size * MAX_NUM_OB_WINDOWS;
 	u64 remainder;
 
 	if (size > max_size) {
-		dev_err(pcie->dev,
+		dev_err(iproc->dev,
 			"res size %pap exceeds max supported size 0x%llx\n",
 			&size, max_size);
 		return -EINVAL;
@@ -361,14 +361,14 @@ static int iproc_pcie_setup_ob(struct iproc_pcie *pcie, u64 axi_addr,
 
 	div64_u64_rem(size, ob->window_size, &remainder);
 	if (remainder) {
-		dev_err(pcie->dev,
+		dev_err(iproc->dev,
 			"res size %pap needs to be multiple of window size %pap\n",
 			&size, &ob->window_size);
 		return -EINVAL;
 	}
 
 	if (axi_addr < ob->axi_offset) {
-		dev_err(pcie->dev,
+		dev_err(iproc->dev,
 			"axi address %pap less than offset %pap\n",
 			&axi_addr, &ob->axi_offset);
 		return -EINVAL;
@@ -381,14 +381,14 @@ static int iproc_pcie_setup_ob(struct iproc_pcie *pcie, u64 axi_addr,
 	axi_addr -= ob->axi_offset;
 
 	for (i = 0; i < MAX_NUM_OB_WINDOWS; i++) {
-		iproc_pcie_ob_write(pcie, IPROC_PCIE_OARR_LO, i,
+		iproc_pcie_ob_write(iproc, IPROC_PCIE_OARR_LO, i,
 				    lower_32_bits(axi_addr) | OARR_VALID |
 				    (ob->set_oarr_size ? 1 : 0));
-		iproc_pcie_ob_write(pcie, IPROC_PCIE_OARR_HI, i,
+		iproc_pcie_ob_write(iproc, IPROC_PCIE_OARR_HI, i,
 				    upper_32_bits(axi_addr));
-		iproc_pcie_ob_write(pcie, IPROC_PCIE_OMAP_LO, i,
+		iproc_pcie_ob_write(iproc, IPROC_PCIE_OMAP_LO, i,
 				    lower_32_bits(pci_addr));
-		iproc_pcie_ob_write(pcie, IPROC_PCIE_OMAP_HI, i,
+		iproc_pcie_ob_write(iproc, IPROC_PCIE_OMAP_HI, i,
 				    upper_32_bits(pci_addr));
 
 		size -= ob->window_size;
@@ -402,7 +402,7 @@ static int iproc_pcie_setup_ob(struct iproc_pcie *pcie, u64 axi_addr,
 	return 0;
 }
 
-static int iproc_pcie_map_ranges(struct iproc_pcie *pcie,
+static int iproc_pcie_map_ranges(struct iproc_pcie *iproc,
 				 struct list_head *resources)
 {
 	struct resource_entry *window;
@@ -417,14 +417,14 @@ static int iproc_pcie_map_ranges(struct iproc_pcie *pcie,
 		case IORESOURCE_BUS:
 			break;
 		case IORESOURCE_MEM:
-			ret = iproc_pcie_setup_ob(pcie, res->start,
+			ret = iproc_pcie_setup_ob(iproc, res->start,
 						  res->start - window->offset,
 						  resource_size(res));
 			if (ret)
 				return ret;
 			break;
 		default:
-			dev_err(pcie->dev, "invalid resource %pR\n", res);
+			dev_err(iproc->dev, "invalid resource %pR\n", res);
 			return -EINVAL;
 		}
 	}
@@ -432,11 +432,11 @@ static int iproc_pcie_map_ranges(struct iproc_pcie *pcie,
 	return 0;
 }
 
-static int iproc_pcie_msi_enable(struct iproc_pcie *pcie)
+static int iproc_pcie_msi_enable(struct iproc_pcie *iproc)
 {
 	struct device_node *msi_node;
 
-	msi_node = of_parse_phandle(pcie->dev->of_node, "msi-parent", 0);
+	msi_node = of_parse_phandle(iproc->dev->of_node, "msi-parent", 0);
 	if (!msi_node)
 		return -ENODEV;
 
@@ -444,92 +444,92 @@ static int iproc_pcie_msi_enable(struct iproc_pcie *pcie)
 	 * If another MSI controller is being used, the call below should fail
 	 * but that is okay
 	 */
-	return iproc_msi_init(pcie, msi_node);
+	return iproc_msi_init(iproc, msi_node);
 }
 
-static void iproc_pcie_msi_disable(struct iproc_pcie *pcie)
+static void iproc_pcie_msi_disable(struct iproc_pcie *iproc)
 {
-	iproc_msi_exit(pcie);
+	iproc_msi_exit(iproc);
 }
 
-int iproc_pcie_setup(struct iproc_pcie *pcie, struct list_head *res)
+int iproc_pcie_setup(struct iproc_pcie *iproc, struct list_head *res)
 {
 	int ret;
 	void *sysdata;
 	struct pci_bus *bus;
 
-	if (!pcie || !pcie->dev || !pcie->base)
+	if (!iproc || !iproc->dev || !iproc->base)
 		return -EINVAL;
 
-	ret = devm_request_pci_bus_resources(pcie->dev, res);
+	ret = devm_request_pci_bus_resources(iproc->dev, res);
 	if (ret)
 		return ret;
 
-	ret = phy_init(pcie->phy);
+	ret = phy_init(iproc->phy);
 	if (ret) {
-		dev_err(pcie->dev, "unable to initialize PCIe PHY\n");
+		dev_err(iproc->dev, "unable to initialize PCIe PHY\n");
 		return ret;
 	}
 
-	ret = phy_power_on(pcie->phy);
+	ret = phy_power_on(iproc->phy);
 	if (ret) {
-		dev_err(pcie->dev, "unable to power on PCIe PHY\n");
+		dev_err(iproc->dev, "unable to power on PCIe PHY\n");
 		goto err_exit_phy;
 	}
 
-	switch (pcie->type) {
+	switch (iproc->type) {
 	case IPROC_PCIE_PAXB:
-		pcie->reg_offsets = iproc_pcie_reg_paxb;
+		iproc->reg_offsets = iproc_pcie_reg_paxb;
 		break;
 	case IPROC_PCIE_PAXC:
-		pcie->reg_offsets = iproc_pcie_reg_paxc;
+		iproc->reg_offsets = iproc_pcie_reg_paxc;
 		break;
 	default:
-		dev_err(pcie->dev, "incompatible iProc PCIe interface\n");
+		dev_err(iproc->dev, "incompatible iProc PCIe interface\n");
 		ret = -EINVAL;
 		goto err_power_off_phy;
 	}
 
-	iproc_pcie_reset(pcie);
+	iproc_pcie_reset(iproc);
 
-	if (pcie->need_ob_cfg) {
-		ret = iproc_pcie_map_ranges(pcie, res);
+	if (iproc->need_ob_cfg) {
+		ret = iproc_pcie_map_ranges(iproc, res);
 		if (ret) {
-			dev_err(pcie->dev, "map failed\n");
+			dev_err(iproc->dev, "map failed\n");
 			goto err_power_off_phy;
 		}
 	}
 
 #ifdef CONFIG_ARM
-	pcie->sysdata.private_data = pcie;
-	sysdata = &pcie->sysdata;
+	iproc->sysdata.private_data = iproc;
+	sysdata = &iproc->sysdata;
 #else
-	sysdata = pcie;
+	sysdata = iproc;
 #endif
 
-	bus = pci_create_root_bus(pcie->dev, 0, &iproc_pcie_ops, sysdata, res);
+	bus = pci_create_root_bus(iproc->dev, 0, &iproc_pcie_ops, sysdata, res);
 	if (!bus) {
-		dev_err(pcie->dev, "unable to create PCI root bus\n");
+		dev_err(iproc->dev, "unable to create PCI root bus\n");
 		ret = -ENOMEM;
 		goto err_power_off_phy;
 	}
-	pcie->root_bus = bus;
+	iproc->root_bus = bus;
 
-	ret = iproc_pcie_check_link(pcie, bus);
+	ret = iproc_pcie_check_link(iproc, bus);
 	if (ret) {
-		dev_err(pcie->dev, "no PCIe EP device detected\n");
+		dev_err(iproc->dev, "no PCIe EP device detected\n");
 		goto err_rm_root_bus;
 	}
 
-	iproc_pcie_enable(pcie);
+	iproc_pcie_enable(iproc);
 
 	if (IS_ENABLED(CONFIG_PCI_MSI))
-		if (iproc_pcie_msi_enable(pcie))
-			dev_info(pcie->dev, "not using iProc MSI\n");
+		if (iproc_pcie_msi_enable(iproc))
+			dev_info(iproc->dev, "not using iProc MSI\n");
 
 	pci_scan_child_bus(bus);
 	pci_assign_unassigned_bus_resources(bus);
-	pci_fixup_irqs(pci_common_swizzle, pcie->map_irq);
+	pci_fixup_irqs(pci_common_swizzle, iproc->map_irq);
 	pci_bus_add_devices(bus);
 
 	return 0;
@@ -539,22 +539,22 @@ err_rm_root_bus:
 	pci_remove_root_bus(bus);
 
 err_power_off_phy:
-	phy_power_off(pcie->phy);
+	phy_power_off(iproc->phy);
 err_exit_phy:
-	phy_exit(pcie->phy);
+	phy_exit(iproc->phy);
 	return ret;
 }
 EXPORT_SYMBOL(iproc_pcie_setup);
 
-int iproc_pcie_remove(struct iproc_pcie *pcie)
+int iproc_pcie_remove(struct iproc_pcie *iproc)
 {
-	pci_stop_root_bus(pcie->root_bus);
-	pci_remove_root_bus(pcie->root_bus);
+	pci_stop_root_bus(iproc->root_bus);
+	pci_remove_root_bus(iproc->root_bus);
 
-	iproc_pcie_msi_disable(pcie);
+	iproc_pcie_msi_disable(iproc);
 
-	phy_power_off(pcie->phy);
-	phy_exit(pcie->phy);
+	phy_power_off(iproc->phy);
+	phy_exit(iproc->phy);
 
 	return 0;
 }

[PATCH 3/7] PCI: iproc: Hard-code PCIe capability offset instead of searching

[Bjorn Helgaas]

We know where the PCIe capability lives in the host bridge's config space;
in fact, we already hard-coded the offset of the Link Control 2 register.

The hard-coded Link Control 2 offset was 0xdc.  Link Control 2 is at offset
0x30 into the PCIe capability, so the capability itself must be at
0xdc - 0x30 = 0xac.

Hard-code the PCIe capability offset, which means we don't have to search
for it and we can use the standard definitions for registers within the
capability.

No functional change intended.

Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
 drivers/pci/host/pcie-iproc.c |   11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/drivers/pci/host/pcie-iproc.c b/drivers/pci/host/pcie-iproc.c
index 408e99d..38f5ee0 100644
--- a/drivers/pci/host/pcie-iproc.c
+++ b/drivers/pci/host/pcie-iproc.c
@@ -63,6 +63,8 @@
 #define OARR_SIZE_CFG_SHIFT          1
 #define OARR_SIZE_CFG                BIT(OARR_SIZE_CFG_SHIFT)
 
+#define PCI_EXP_CAP			0xac
+
 #define MAX_NUM_OB_WINDOWS           2
 
 #define IPROC_PCIE_REG_INVALID 0xffff
@@ -259,7 +261,7 @@ static int iproc_pcie_check_link(struct iproc_pcie *iproc, struct pci_bus *bus)
 {
 	u8 hdr_type;
 	u32 link_ctrl, class, val;
-	u16 pos, link_status;
+	u16 pos = PCI_EXP_CAP, link_status;
 	bool link_is_active = false;
 
 	/*
@@ -292,30 +294,27 @@ static int iproc_pcie_check_link(struct iproc_pcie *iproc, struct pci_bus *bus)
 	pci_bus_write_config_dword(bus, 0, PCI_BRIDGE_CTRL_REG_OFFSET, class);
 
 	/* check link status to see if link is active */
-	pos = pci_bus_find_capability(bus, 0, PCI_CAP_ID_EXP);
 	pci_bus_read_config_word(bus, 0, pos + PCI_EXP_LNKSTA, &link_status);
 	if (link_status & PCI_EXP_LNKSTA_NLW)
 		link_is_active = true;
 
 	if (!link_is_active) {
 		/* try GEN 1 link speed */
-#define PCI_LINK_STATUS_CTRL_2_OFFSET 0x0dc
 #define PCI_TARGET_LINK_SPEED_MASK    0xf
 #define PCI_TARGET_LINK_SPEED_GEN2    0x2
 #define PCI_TARGET_LINK_SPEED_GEN1    0x1
 		pci_bus_read_config_dword(bus, 0,
-					  PCI_LINK_STATUS_CTRL_2_OFFSET,
+					  pos + PCI_EXP_LNKCTL2,
 					  &link_ctrl);
 		if ((link_ctrl & PCI_TARGET_LINK_SPEED_MASK) ==
 		    PCI_TARGET_LINK_SPEED_GEN2) {
 			link_ctrl &= ~PCI_TARGET_LINK_SPEED_MASK;
 			link_ctrl |= PCI_TARGET_LINK_SPEED_GEN1;
 			pci_bus_write_config_dword(bus, 0,
-					   PCI_LINK_STATUS_CTRL_2_OFFSET,
+					   pos + PCI_EXP_LNKCTL2,
 					   link_ctrl);
 			msleep(100);
 
-			pos = pci_bus_find_capability(bus, 0, PCI_CAP_ID_EXP);
 			pci_bus_read_config_word(bus, 0, pos + PCI_EXP_LNKSTA,
 						 &link_status);
 			if (link_status & PCI_EXP_LNKSTA_NLW)

[PATCH 4/7] PCI: iproc: Validate CSR base in BCMA setup code

[Bjorn Helgaas]

Validate iproc->base for BCMA devices just like we already do for platform
devices in iproc_pcie_pltfm_probe().  No functional change intended.

Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
 drivers/pci/host/pcie-iproc-bcma.c |    5 +++++
 drivers/pci/host/pcie-iproc.c      |    2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/drivers/pci/host/pcie-iproc-bcma.c b/drivers/pci/host/pcie-iproc-bcma.c
index 72273ff..5377328 100644
--- a/drivers/pci/host/pcie-iproc-bcma.c
+++ b/drivers/pci/host/pcie-iproc-bcma.c
@@ -55,6 +55,11 @@ static int iproc_pcie_bcma_probe(struct bcma_device *bdev)
 	bcma_set_drvdata(bdev, iproc);
 
 	iproc->base = bdev->io_addr;
+	if (!iproc->base) {
+		dev_err(&bdev->dev, "no controller registers\n");
+		return -ENOMEM;
+	}
+
 	iproc->base_addr = bdev->addr;
 
 	res_mem.start = bdev->addr_s[0];
diff --git a/drivers/pci/host/pcie-iproc.c b/drivers/pci/host/pcie-iproc.c
index 38f5ee0..3de157a 100644
--- a/drivers/pci/host/pcie-iproc.c
+++ b/drivers/pci/host/pcie-iproc.c
@@ -457,7 +457,7 @@ int iproc_pcie_setup(struct iproc_pcie *iproc, struct list_head *res)
 	void *sysdata;
 	struct pci_bus *bus;
 
-	if (!iproc || !iproc->dev || !iproc->base)
+	if (!iproc || !iproc->dev)
 		return -EINVAL;
 
 	ret = devm_request_pci_bus_resources(iproc->dev, res);

[PATCH 5/7] PCI: iproc: Remove redundant null pointer checking

[Bjorn Helgaas]

The callers never pass null pointers here, so remove redundant checking
here.  No functional change intended.

Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
 drivers/pci/host/pcie-iproc.c |    3 ---
 1 file changed, 3 deletions(-)

diff --git a/drivers/pci/host/pcie-iproc.c b/drivers/pci/host/pcie-iproc.c
index 3de157a..950622d 100644
--- a/drivers/pci/host/pcie-iproc.c
+++ b/drivers/pci/host/pcie-iproc.c
@@ -457,9 +457,6 @@ int iproc_pcie_setup(struct iproc_pcie *iproc, struct list_head *res)
 	void *sysdata;
 	struct pci_bus *bus;
 
-	if (!iproc || !iproc->dev)
-		return -EINVAL;
-
 	ret = devm_request_pci_bus_resources(iproc->dev, res);
 	if (ret)
 		return ret;

[PATCH 6/7] PCI: iproc: Add local struct device pointers

[Bjorn Helgaas]

Use a local "struct device *dev" for brevity and consistency with other
drivers.  No functional change intended.

Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
 drivers/pci/host/pcie-iproc-bcma.c     |    9 ++++----
 drivers/pci/host/pcie-iproc-platform.c |   25 +++++++++++-----------
 drivers/pci/host/pcie-iproc.c          |   37 +++++++++++++++++---------------
 3 files changed, 38 insertions(+), 33 deletions(-)

diff --git a/drivers/pci/host/pcie-iproc-bcma.c b/drivers/pci/host/pcie-iproc-bcma.c
index 5377328..bc364a7 100644
--- a/drivers/pci/host/pcie-iproc-bcma.c
+++ b/drivers/pci/host/pcie-iproc-bcma.c
@@ -42,21 +42,22 @@ static int iproc_pcie_bcma_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
 
 static int iproc_pcie_bcma_probe(struct bcma_device *bdev)
 {
+	struct device *dev = &bdev->dev;
 	struct iproc_pcie *iproc;
 	LIST_HEAD(res);
 	struct resource res_mem;
 	int ret;
 
-	iproc = devm_kzalloc(&bdev->dev, sizeof(*iproc), GFP_KERNEL);
+	iproc = devm_kzalloc(dev, sizeof(*iproc), GFP_KERNEL);
 	if (!iproc)
 		return -ENOMEM;
 
-	iproc->dev = &bdev->dev;
+	iproc->dev = dev;
 	bcma_set_drvdata(bdev, iproc);
 
 	iproc->base = bdev->io_addr;
 	if (!iproc->base) {
-		dev_err(&bdev->dev, "no controller registers\n");
+		dev_err(dev, "no controller registers\n");
 		return -ENOMEM;
 	}
 
@@ -72,7 +73,7 @@ static int iproc_pcie_bcma_probe(struct bcma_device *bdev)
 
 	ret = iproc_pcie_setup(iproc, &res);
 	if (ret)
-		dev_err(iproc->dev, "PCIe controller setup failed\n");
+		dev_err(dev, "PCIe controller setup failed\n");
 
 	pci_free_resource_list(&res);
 
diff --git a/drivers/pci/host/pcie-iproc-platform.c b/drivers/pci/host/pcie-iproc-platform.c
index d348635..6baaae1 100644
--- a/drivers/pci/host/pcie-iproc-platform.c
+++ b/drivers/pci/host/pcie-iproc-platform.c
@@ -40,35 +40,36 @@ MODULE_DEVICE_TABLE(of, iproc_pcie_of_match_table);
 
 static int iproc_pcie_pltfm_probe(struct platform_device *pdev)
 {
+	struct device *dev = &pdev->dev;
 	const struct of_device_id *of_id;
 	struct iproc_pcie *iproc;
-	struct device_node *np = pdev->dev.of_node;
+	struct device_node *np = dev->of_node;
 	struct resource reg;
 	resource_size_t iobase = 0;
 	LIST_HEAD(res);
 	int ret;
 
-	of_id = of_match_device(iproc_pcie_of_match_table, &pdev->dev);
+	of_id = of_match_device(iproc_pcie_of_match_table, dev);
 	if (!of_id)
 		return -EINVAL;
 
-	iproc = devm_kzalloc(&pdev->dev, sizeof(*iproc), GFP_KERNEL);
+	iproc = devm_kzalloc(dev, sizeof(*iproc), GFP_KERNEL);
 	if (!iproc)
 		return -ENOMEM;
 
-	iproc->dev = &pdev->dev;
+	iproc->dev = dev;
 	iproc->type = (enum iproc_pcie_type)of_id->data;
 	platform_set_drvdata(pdev, iproc);
 
 	ret = of_address_to_resource(np, 0, &reg);
 	if (ret < 0) {
-		dev_err(iproc->dev, "unable to obtain controller resources\n");
+		dev_err(dev, "unable to obtain controller resources\n");
 		return ret;
 	}
 
-	iproc->base = devm_ioremap(iproc->dev, reg.start, resource_size(&reg));
+	iproc->base = devm_ioremap(dev, reg.start, resource_size(&reg));
 	if (!iproc->base) {
-		dev_err(iproc->dev, "unable to map controller registers\n");
+		dev_err(dev, "unable to map controller registers\n");
 		return -ENOMEM;
 	}
 	iproc->base_addr = reg.start;
@@ -79,7 +80,7 @@ static int iproc_pcie_pltfm_probe(struct platform_device *pdev)
 		ret = of_property_read_u32(np, "brcm,pcie-ob-axi-offset",
 					   &val);
 		if (ret) {
-			dev_err(iproc->dev,
+			dev_err(dev,
 				"missing brcm,pcie-ob-axi-offset property\n");
 			return ret;
 		}
@@ -88,7 +89,7 @@ static int iproc_pcie_pltfm_probe(struct platform_device *pdev)
 		ret = of_property_read_u32(np, "brcm,pcie-ob-window-size",
 					   &val);
 		if (ret) {
-			dev_err(iproc->dev,
+			dev_err(dev,
 				"missing brcm,pcie-ob-window-size property\n");
 			return ret;
 		}
@@ -101,7 +102,7 @@ static int iproc_pcie_pltfm_probe(struct platform_device *pdev)
 	}
 
 	/* PHY use is optional */
-	iproc->phy = devm_phy_get(&pdev->dev, "pcie-phy");
+	iproc->phy = devm_phy_get(dev, "pcie-phy");
 	if (IS_ERR(iproc->phy)) {
 		if (PTR_ERR(iproc->phy) == -EPROBE_DEFER)
 			return -EPROBE_DEFER;
@@ -110,7 +111,7 @@ static int iproc_pcie_pltfm_probe(struct platform_device *pdev)
 
 	ret = of_pci_get_host_bridge_resources(np, 0, 0xff, &res, &iobase);
 	if (ret) {
-		dev_err(iproc->dev,
+		dev_err(dev,
 			"unable to get PCI host bridge resources\n");
 		return ret;
 	}
@@ -119,7 +120,7 @@ static int iproc_pcie_pltfm_probe(struct platform_device *pdev)
 
 	ret = iproc_pcie_setup(iproc, &res);
 	if (ret)
-		dev_err(iproc->dev, "PCIe controller setup failed\n");
+		dev_err(dev, "PCIe controller setup failed\n");
 
 	pci_free_resource_list(&res);
 
diff --git a/drivers/pci/host/pcie-iproc.c b/drivers/pci/host/pcie-iproc.c
index 950622d..0a802fc 100644
--- a/drivers/pci/host/pcie-iproc.c
+++ b/drivers/pci/host/pcie-iproc.c
@@ -259,6 +259,7 @@ static void iproc_pcie_reset(struct iproc_pcie *iproc)
 
 static int iproc_pcie_check_link(struct iproc_pcie *iproc, struct pci_bus *bus)
 {
+	struct device *dev = iproc->dev;
 	u8 hdr_type;
 	u32 link_ctrl, class, val;
 	u16 pos = PCI_EXP_CAP, link_status;
@@ -273,14 +274,14 @@ static int iproc_pcie_check_link(struct iproc_pcie *iproc, struct pci_bus *bus)
 
 	val = iproc_readl(iproc, IPROC_PCIE_LINK_STATUS);
 	if (!(val & PCIE_PHYLINKUP) || !(val & PCIE_DL_ACTIVE)) {
-		dev_err(iproc->dev, "PHY or data link is INACTIVE!\n");
+		dev_err(dev, "PHY or data link is INACTIVE!\n");
 		return -ENODEV;
 	}
 
 	/* make sure we are not in EP mode */
 	pci_bus_read_config_byte(bus, 0, PCI_HEADER_TYPE, &hdr_type);
 	if ((hdr_type & 0x7f) != PCI_HEADER_TYPE_BRIDGE) {
-		dev_err(iproc->dev, "in EP mode, hdr=%#02x\n", hdr_type);
+		dev_err(dev, "in EP mode, hdr=%#02x\n", hdr_type);
 		return -EFAULT;
 	}
 
@@ -322,7 +323,7 @@ static int iproc_pcie_check_link(struct iproc_pcie *iproc, struct pci_bus *bus)
 		}
 	}
 
-	dev_info(iproc->dev, "link: %s\n", link_is_active ? "UP" : "DOWN");
+	dev_info(dev, "link: %s\n", link_is_active ? "UP" : "DOWN");
 
 	return link_is_active ? 0 : -ENODEV;
 }
@@ -346,13 +347,14 @@ static void iproc_pcie_enable(struct iproc_pcie *iproc)
 static int iproc_pcie_setup_ob(struct iproc_pcie *iproc, u64 axi_addr,
 			       u64 pci_addr, resource_size_t size)
 {
+	struct device *dev = iproc->dev;
 	struct iproc_pcie_ob *ob = &iproc->ob;
 	unsigned i;
 	u64 max_size = (u64)ob->window_size * MAX_NUM_OB_WINDOWS;
 	u64 remainder;
 
 	if (size > max_size) {
-		dev_err(iproc->dev,
+		dev_err(dev,
 			"res size %pap exceeds max supported size 0x%llx\n",
 			&size, max_size);
 		return -EINVAL;
@@ -360,15 +362,14 @@ static int iproc_pcie_setup_ob(struct iproc_pcie *iproc, u64 axi_addr,
 
 	div64_u64_rem(size, ob->window_size, &remainder);
 	if (remainder) {
-		dev_err(iproc->dev,
+		dev_err(dev,
 			"res size %pap needs to be multiple of window size %pap\n",
 			&size, &ob->window_size);
 		return -EINVAL;
 	}
 
 	if (axi_addr < ob->axi_offset) {
-		dev_err(iproc->dev,
-			"axi address %pap less than offset %pap\n",
+		dev_err(dev, "axi address %pap less than offset %pap\n",
 			&axi_addr, &ob->axi_offset);
 		return -EINVAL;
 	}
@@ -404,6 +405,7 @@ static int iproc_pcie_setup_ob(struct iproc_pcie *iproc, u64 axi_addr,
 static int iproc_pcie_map_ranges(struct iproc_pcie *iproc,
 				 struct list_head *resources)
 {
+	struct device *dev = iproc->dev;
 	struct resource_entry *window;
 	int ret;
 
@@ -423,7 +425,7 @@ static int iproc_pcie_map_ranges(struct iproc_pcie *iproc,
 				return ret;
 			break;
 		default:
-			dev_err(iproc->dev, "invalid resource %pR\n", res);
+			dev_err(dev, "invalid resource %pR\n", res);
 			return -EINVAL;
 		}
 	}
@@ -453,23 +455,24 @@ static void iproc_pcie_msi_disable(struct iproc_pcie *iproc)
 
 int iproc_pcie_setup(struct iproc_pcie *iproc, struct list_head *res)
 {
+	struct device *dev = iproc->dev;
 	int ret;
 	void *sysdata;
 	struct pci_bus *bus;
 
-	ret = devm_request_pci_bus_resources(iproc->dev, res);
+	ret = devm_request_pci_bus_resources(dev, res);
 	if (ret)
 		return ret;
 
 	ret = phy_init(iproc->phy);
 	if (ret) {
-		dev_err(iproc->dev, "unable to initialize PCIe PHY\n");
+		dev_err(dev, "unable to initialize PCIe PHY\n");
 		return ret;
 	}
 
 	ret = phy_power_on(iproc->phy);
 	if (ret) {
-		dev_err(iproc->dev, "unable to power on PCIe PHY\n");
+		dev_err(dev, "unable to power on PCIe PHY\n");
 		goto err_exit_phy;
 	}
 
@@ -481,7 +484,7 @@ int iproc_pcie_setup(struct iproc_pcie *iproc, struct list_head *res)
 		iproc->reg_offsets = iproc_pcie_reg_paxc;
 		break;
 	default:
-		dev_err(iproc->dev, "incompatible iProc PCIe interface\n");
+		dev_err(dev, "incompatible iProc PCIe interface\n");
 		ret = -EINVAL;
 		goto err_power_off_phy;
 	}
@@ -491,7 +494,7 @@ int iproc_pcie_setup(struct iproc_pcie *iproc, struct list_head *res)
 	if (iproc->need_ob_cfg) {
 		ret = iproc_pcie_map_ranges(iproc, res);
 		if (ret) {
-			dev_err(iproc->dev, "map failed\n");
+			dev_err(dev, "map failed\n");
 			goto err_power_off_phy;
 		}
 	}
@@ -503,9 +506,9 @@ int iproc_pcie_setup(struct iproc_pcie *iproc, struct list_head *res)
 	sysdata = iproc;
 #endif
 
-	bus = pci_create_root_bus(iproc->dev, 0, &iproc_pcie_ops, sysdata, res);
+	bus = pci_create_root_bus(dev, 0, &iproc_pcie_ops, sysdata, res);
 	if (!bus) {
-		dev_err(iproc->dev, "unable to create PCI root bus\n");
+		dev_err(dev, "unable to create PCI root bus\n");
 		ret = -ENOMEM;
 		goto err_power_off_phy;
 	}
@@ -513,7 +516,7 @@ int iproc_pcie_setup(struct iproc_pcie *iproc, struct list_head *res)
 
 	ret = iproc_pcie_check_link(iproc, bus);
 	if (ret) {
-		dev_err(iproc->dev, "no PCIe EP device detected\n");
+		dev_err(dev, "no PCIe EP device detected\n");
 		goto err_rm_root_bus;
 	}
 
@@ -521,7 +524,7 @@ int iproc_pcie_setup(struct iproc_pcie *iproc, struct list_head *res)
 
 	if (IS_ENABLED(CONFIG_PCI_MSI))
 		if (iproc_pcie_msi_enable(iproc))
-			dev_info(iproc->dev, "not using iProc MSI\n");
+			dev_info(dev, "not using iProc MSI\n");
 
 	pci_scan_child_bus(bus);
 	pci_assign_unassigned_bus_resources(bus);

[PATCH 7/7] PCI: iproc: Set drvdata at end of probe function

[Bjorn Helgaas]

Set the drvdata pointer at the end of probe function for consistency with
other drivers.  We don't need the drvdata until after the probe completes,
and we don't need it at all if the probe fails.  No functional change
intended.

Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
 drivers/pci/host/pcie-iproc-bcma.c     |    2 +-
 drivers/pci/host/pcie-iproc-platform.c |    2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/drivers/pci/host/pcie-iproc-bcma.c b/drivers/pci/host/pcie-iproc-bcma.c
index bc364a7..800bc84 100644
--- a/drivers/pci/host/pcie-iproc-bcma.c
+++ b/drivers/pci/host/pcie-iproc-bcma.c
@@ -53,7 +53,6 @@ static int iproc_pcie_bcma_probe(struct bcma_device *bdev)
 		return -ENOMEM;
 
 	iproc->dev = dev;
-	bcma_set_drvdata(bdev, iproc);
 
 	iproc->base = bdev->io_addr;
 	if (!iproc->base) {
@@ -77,6 +76,7 @@ static int iproc_pcie_bcma_probe(struct bcma_device *bdev)
 
 	pci_free_resource_list(&res);
 
+	bcma_set_drvdata(bdev, iproc);
 	return ret;
 }
 
diff --git a/drivers/pci/host/pcie-iproc-platform.c b/drivers/pci/host/pcie-iproc-platform.c
index 6baaae1..31c0fb9 100644
--- a/drivers/pci/host/pcie-iproc-platform.c
+++ b/drivers/pci/host/pcie-iproc-platform.c
@@ -59,7 +59,6 @@ static int iproc_pcie_pltfm_probe(struct platform_device *pdev)
 
 	iproc->dev = dev;
 	iproc->type = (enum iproc_pcie_type)of_id->data;
-	platform_set_drvdata(pdev, iproc);
 
 	ret = of_address_to_resource(np, 0, &reg);
 	if (ret < 0) {
@@ -124,6 +123,7 @@ static int iproc_pcie_pltfm_probe(struct platform_device *pdev)
 
 	pci_free_resource_list(&res);
 
+	platform_set_drvdata(pdev, iproc);
 	return ret;
 }