Commit 22c7e1d4 authored by Bjorn Helgaas's avatar Bjorn Helgaas
Browse files

Merge branch 'pci/host-designware' into next 

* pci/host-designware:
  PCI: designware-plat: Remove unused platform data
  PCI: designware-plat: Add local struct device pointers
  PCI: designware-plat: Remove redundant dw_plat_pcie.mem_base
  PCI: designware: Swap order of dw_pcie_writel_unroll() reg/val arguments
  PCI: designware: Uninline register accessors
  PCI: designware: Export dw_pcie_readl_rc(), dw_pcie_writel_rc()
  PCI: designware: Swap order of dw_pcie_writel_rc() reg/val arguments
  PCI: designware: Simplify pcie_host_ops.readl_rc() and .writel_rc() interfaces
  PCI: designware: Simplify dw_pcie_readl_unroll(), dw_pcie_writel_unroll()
  PCI: designware: Rename dw_pcie_valid_config() to dw_pcie_valid_device()
parents dd5bba52 4c9441d1

drivers/pci/host/pci-exynos.c

+4 −6
Original line number Diff line number Diff line
@@ -425,22 +425,20 @@ static void exynos_pcie_enable_interrupts(struct pcie_port *pp) 
		exynos_pcie_msi_init(pp);

}



static inline u32 exynos_pcie_readl_rc(struct pcie_port *pp,

				       void __iomem *dbi_base)

static inline u32 exynos_pcie_readl_rc(struct pcie_port *pp, u32 reg)

{

	u32 val;



	exynos_pcie_sideband_dbi_r_mode(pp, true);

	val = readl(dbi_base);

	val = readl(pp->dbi_base + reg);

	exynos_pcie_sideband_dbi_r_mode(pp, false);

	return val;

}



static inline void exynos_pcie_writel_rc(struct pcie_port *pp,

					u32 val, void __iomem *dbi_base)

static inline void exynos_pcie_writel_rc(struct pcie_port *pp, u32 reg, u32 val)

{

	exynos_pcie_sideband_dbi_w_mode(pp, true);

	writel(val, dbi_base);

	writel(val, pp->dbi_base + reg);

	exynos_pcie_sideband_dbi_w_mode(pp, false);

}

drivers/pci/host/pcie-designware-plat.c

+11 −14
Original line number Diff line number Diff line
@@ -25,8 +25,7 @@ 
#include "pcie-designware.h"



struct dw_plat_pcie {

	void __iomem		*mem_base;

	struct pcie_port	pp;

	struct pcie_port	pp;	/* pp.dbi_base is DT 0th resource */

};



static irqreturn_t dw_plat_pcie_msi_irq_handler(int irq, void *arg)
@@ -52,6 +51,7 @@ static struct pcie_host_ops dw_plat_pcie_host_ops = { 
static int dw_plat_add_pcie_port(struct pcie_port *pp,

				 struct platform_device *pdev)

{

	struct device *dev = pp->dev;

	int ret;



	pp->irq = platform_get_irq(pdev, 1);
@@ -63,11 +63,11 @@ static int dw_plat_add_pcie_port(struct pcie_port *pp, 
		if (pp->msi_irq < 0)

			return pp->msi_irq;



		ret = devm_request_irq(&pdev->dev, pp->msi_irq,

		ret = devm_request_irq(dev, pp->msi_irq,

					dw_plat_pcie_msi_irq_handler,

					IRQF_SHARED, "dw-plat-pcie-msi", pp);

		if (ret) {

			dev_err(&pdev->dev, "failed to request MSI IRQ\n");

			dev_err(dev, "failed to request MSI IRQ\n");

			return ret;

		}

	}
@@ -77,7 +77,7 @@ static int dw_plat_add_pcie_port(struct pcie_port *pp, 


	ret = dw_pcie_host_init(pp);

	if (ret) {

		dev_err(&pdev->dev, "failed to initialize host\n");

		dev_err(dev, "failed to initialize host\n");

		return ret;

	}
@@ -86,31 +86,28 @@ static int dw_plat_add_pcie_port(struct pcie_port *pp, 


static int dw_plat_pcie_probe(struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	struct dw_plat_pcie *dw_plat_pcie;

	struct pcie_port *pp;

	struct resource *res;  /* Resource from DT */

	int ret;



	dw_plat_pcie = devm_kzalloc(&pdev->dev, sizeof(*dw_plat_pcie),

					GFP_KERNEL);

	dw_plat_pcie = devm_kzalloc(dev, sizeof(*dw_plat_pcie), GFP_KERNEL);

	if (!dw_plat_pcie)

		return -ENOMEM;



	pp = &dw_plat_pcie->pp;

	pp->dev = &pdev->dev;

	pp->dev = dev;



	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	dw_plat_pcie->mem_base = devm_ioremap_resource(&pdev->dev, res);

	if (IS_ERR(dw_plat_pcie->mem_base))

		return PTR_ERR(dw_plat_pcie->mem_base);



	pp->dbi_base = dw_plat_pcie->mem_base;

	pp->dbi_base = devm_ioremap_resource(dev, res);

	if (IS_ERR(pp->dbi_base))

		return PTR_ERR(pp->dbi_base);



	ret = dw_plat_add_pcie_port(pp, pdev);

	if (ret < 0)

		return ret;



	platform_set_drvdata(pdev, dw_plat_pcie);

	return 0;

}

drivers/pci/host/pcie-designware.c

+48 −54
Original line number Diff line number Diff line
@@ -141,41 +141,35 @@ int dw_pcie_cfg_write(void __iomem *addr, int size, u32 val) 
	return PCIBIOS_SUCCESSFUL;

}



static inline u32 dw_pcie_readl_rc(struct pcie_port *pp, u32 reg)

u32 dw_pcie_readl_rc(struct pcie_port *pp, u32 reg)

{

	if (pp->ops->readl_rc)

		return pp->ops->readl_rc(pp, pp->dbi_base + reg);

		return pp->ops->readl_rc(pp, reg);



	return readl(pp->dbi_base + reg);

}



static inline void dw_pcie_writel_rc(struct pcie_port *pp, u32 val, u32 reg)

void dw_pcie_writel_rc(struct pcie_port *pp, u32 reg, u32 val)

{

	if (pp->ops->writel_rc)

		pp->ops->writel_rc(pp, val, pp->dbi_base + reg);

		pp->ops->writel_rc(pp, reg, val);

	else

		writel(val, pp->dbi_base + reg);

}



static inline u32 dw_pcie_readl_unroll(struct pcie_port *pp, u32 index, u32 reg)

static u32 dw_pcie_readl_unroll(struct pcie_port *pp, u32 index, u32 reg)

{

	u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index);



	if (pp->ops->readl_rc)

		return pp->ops->readl_rc(pp, pp->dbi_base + offset + reg);



	return readl(pp->dbi_base + offset + reg);

	return dw_pcie_readl_rc(pp, offset + reg);

}



static inline void dw_pcie_writel_unroll(struct pcie_port *pp, u32 index,

					 u32 val, u32 reg)

static void dw_pcie_writel_unroll(struct pcie_port *pp, u32 index, u32 reg,

				  u32 val)

{

	u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index);



	if (pp->ops->writel_rc)

		pp->ops->writel_rc(pp, val, pp->dbi_base + offset + reg);

	else

		writel(val, pp->dbi_base + offset + reg);

	dw_pcie_writel_rc(pp, offset + reg, val);

}



static int dw_pcie_rd_own_conf(struct pcie_port *pp, int where, int size,
@@ -202,35 +196,35 @@ static void dw_pcie_prog_outbound_atu(struct pcie_port *pp, int index, 
	u32 retries, val;



	if (pp->iatu_unroll_enabled) {

		dw_pcie_writel_unroll(pp, index,

			lower_32_bits(cpu_addr), PCIE_ATU_UNR_LOWER_BASE);

		dw_pcie_writel_unroll(pp, index,

			upper_32_bits(cpu_addr), PCIE_ATU_UNR_UPPER_BASE);

		dw_pcie_writel_unroll(pp, index,

			lower_32_bits(cpu_addr + size - 1), PCIE_ATU_UNR_LIMIT);

		dw_pcie_writel_unroll(pp, index,

			lower_32_bits(pci_addr), PCIE_ATU_UNR_LOWER_TARGET);

		dw_pcie_writel_unroll(pp, index,

			upper_32_bits(pci_addr), PCIE_ATU_UNR_UPPER_TARGET);

		dw_pcie_writel_unroll(pp, index,

			type, PCIE_ATU_UNR_REGION_CTRL1);

		dw_pcie_writel_unroll(pp, index,

			PCIE_ATU_ENABLE, PCIE_ATU_UNR_REGION_CTRL2);

		dw_pcie_writel_unroll(pp, index, PCIE_ATU_UNR_LOWER_BASE,

			lower_32_bits(cpu_addr));

		dw_pcie_writel_unroll(pp, index, PCIE_ATU_UNR_UPPER_BASE,

			upper_32_bits(cpu_addr));

		dw_pcie_writel_unroll(pp, index, PCIE_ATU_UNR_LIMIT,

			lower_32_bits(cpu_addr + size - 1));

		dw_pcie_writel_unroll(pp, index, PCIE_ATU_UNR_LOWER_TARGET,

			lower_32_bits(pci_addr));

		dw_pcie_writel_unroll(pp, index, PCIE_ATU_UNR_UPPER_TARGET,

			upper_32_bits(pci_addr));

		dw_pcie_writel_unroll(pp, index, PCIE_ATU_UNR_REGION_CTRL1,

			type);

		dw_pcie_writel_unroll(pp, index, PCIE_ATU_UNR_REGION_CTRL2,

			PCIE_ATU_ENABLE);

	} else {

		dw_pcie_writel_rc(pp, PCIE_ATU_REGION_OUTBOUND | index,

						PCIE_ATU_VIEWPORT);

		dw_pcie_writel_rc(pp, lower_32_bits(cpu_addr),

						PCIE_ATU_LOWER_BASE);

		dw_pcie_writel_rc(pp, upper_32_bits(cpu_addr),

						PCIE_ATU_UPPER_BASE);

		dw_pcie_writel_rc(pp, lower_32_bits(cpu_addr + size - 1),

						PCIE_ATU_LIMIT);

		dw_pcie_writel_rc(pp, lower_32_bits(pci_addr),

						PCIE_ATU_LOWER_TARGET);

		dw_pcie_writel_rc(pp, upper_32_bits(pci_addr),

						PCIE_ATU_UPPER_TARGET);

		dw_pcie_writel_rc(pp, type, PCIE_ATU_CR1);

		dw_pcie_writel_rc(pp, PCIE_ATU_ENABLE, PCIE_ATU_CR2);

		dw_pcie_writel_rc(pp, PCIE_ATU_VIEWPORT,

				  PCIE_ATU_REGION_OUTBOUND | index);

		dw_pcie_writel_rc(pp, PCIE_ATU_LOWER_BASE,

				  lower_32_bits(cpu_addr));

		dw_pcie_writel_rc(pp, PCIE_ATU_UPPER_BASE,

				  upper_32_bits(cpu_addr));

		dw_pcie_writel_rc(pp, PCIE_ATU_LIMIT,

				  lower_32_bits(cpu_addr + size - 1));

		dw_pcie_writel_rc(pp, PCIE_ATU_LOWER_TARGET,

				  lower_32_bits(pci_addr));

		dw_pcie_writel_rc(pp, PCIE_ATU_UPPER_TARGET,

				  upper_32_bits(pci_addr));

		dw_pcie_writel_rc(pp, PCIE_ATU_CR1, type);

		dw_pcie_writel_rc(pp, PCIE_ATU_CR2, PCIE_ATU_ENABLE);

	}



	/*
@@ -760,8 +754,8 @@ static int dw_pcie_wr_other_conf(struct pcie_port *pp, struct pci_bus *bus, 
	return ret;

}



static int dw_pcie_valid_config(struct pcie_port *pp,

				struct pci_bus *bus, int dev)

static int dw_pcie_valid_device(struct pcie_port *pp, struct pci_bus *bus,

				int dev)

{

	/* If there is no link, then there is no device */

	if (bus->number != pp->root_bus_nr) {
@@ -781,7 +775,7 @@ static int dw_pcie_rd_conf(struct pci_bus *bus, u32 devfn, int where, 
{

	struct pcie_port *pp = bus->sysdata;



	if (dw_pcie_valid_config(pp, bus, PCI_SLOT(devfn)) == 0) {

	if (!dw_pcie_valid_device(pp, bus, PCI_SLOT(devfn))) {

		*val = 0xffffffff;

		return PCIBIOS_DEVICE_NOT_FOUND;

	}
@@ -797,7 +791,7 @@ static int dw_pcie_wr_conf(struct pci_bus *bus, u32 devfn, 
{

	struct pcie_port *pp = bus->sysdata;



	if (dw_pcie_valid_config(pp, bus, PCI_SLOT(devfn)) == 0)

	if (!dw_pcie_valid_device(pp, bus, PCI_SLOT(devfn)))

		return PCIBIOS_DEVICE_NOT_FOUND;



	if (bus->number == pp->root_bus_nr)
@@ -835,7 +829,7 @@ void dw_pcie_setup_rc(struct pcie_port *pp) 
		dev_err(pp->dev, "num-lanes %u: invalid value\n", pp->lanes);

		return;

	}

	dw_pcie_writel_rc(pp, val, PCIE_PORT_LINK_CONTROL);

	dw_pcie_writel_rc(pp, PCIE_PORT_LINK_CONTROL, val);



	/* set link width speed control register */

	val = dw_pcie_readl_rc(pp, PCIE_LINK_WIDTH_SPEED_CONTROL);
@@ -854,30 +848,30 @@ void dw_pcie_setup_rc(struct pcie_port *pp) 
		val |= PORT_LOGIC_LINK_WIDTH_8_LANES;

		break;

	}

	dw_pcie_writel_rc(pp, val, PCIE_LINK_WIDTH_SPEED_CONTROL);

	dw_pcie_writel_rc(pp, PCIE_LINK_WIDTH_SPEED_CONTROL, val);



	/* setup RC BARs */

	dw_pcie_writel_rc(pp, 0x00000004, PCI_BASE_ADDRESS_0);

	dw_pcie_writel_rc(pp, 0x00000000, PCI_BASE_ADDRESS_1);

	dw_pcie_writel_rc(pp, PCI_BASE_ADDRESS_0, 0x00000004);

	dw_pcie_writel_rc(pp, PCI_BASE_ADDRESS_1, 0x00000000);



	/* setup interrupt pins */

	val = dw_pcie_readl_rc(pp, PCI_INTERRUPT_LINE);

	val &= 0xffff00ff;

	val |= 0x00000100;

	dw_pcie_writel_rc(pp, val, PCI_INTERRUPT_LINE);

	dw_pcie_writel_rc(pp, PCI_INTERRUPT_LINE, val);



	/* setup bus numbers */

	val = dw_pcie_readl_rc(pp, PCI_PRIMARY_BUS);

	val &= 0xff000000;

	val |= 0x00010100;

	dw_pcie_writel_rc(pp, val, PCI_PRIMARY_BUS);

	dw_pcie_writel_rc(pp, PCI_PRIMARY_BUS, val);



	/* setup command register */

	val = dw_pcie_readl_rc(pp, PCI_COMMAND);

	val &= 0xffff0000;

	val |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY |

		PCI_COMMAND_MASTER | PCI_COMMAND_SERR;

	dw_pcie_writel_rc(pp, val, PCI_COMMAND);

	dw_pcie_writel_rc(pp, PCI_COMMAND, val);



	/*

	 * If the platform provides ->rd_other_conf, it means the platform

drivers/pci/host/pcie-designware.h

+4 −3
Original line number Diff line number Diff line
@@ -54,9 +54,8 @@ struct pcie_port { 
};



struct pcie_host_ops {

	u32 (*readl_rc)(struct pcie_port *pp, void __iomem *dbi_base);

	void (*writel_rc)(struct pcie_port *pp,

			u32 val, void __iomem *dbi_base);

	u32 (*readl_rc)(struct pcie_port *pp, u32 reg);

	void (*writel_rc)(struct pcie_port *pp, u32 reg, u32 val);

	int (*rd_own_conf)(struct pcie_port *pp, int where, int size, u32 *val);

	int (*wr_own_conf)(struct pcie_port *pp, int where, int size, u32 val);

	int (*rd_other_conf)(struct pcie_port *pp, struct pci_bus *bus,
@@ -73,6 +72,8 @@ struct pcie_host_ops { 
	int (*msi_host_init)(struct pcie_port *pp, struct msi_controller *chip);

};



u32 dw_pcie_readl_rc(struct pcie_port *pp, u32 reg);

void dw_pcie_writel_rc(struct pcie_port *pp, u32 reg, u32 val);

int dw_pcie_cfg_read(void __iomem *addr, int size, u32 *val);

int dw_pcie_cfg_write(void __iomem *addr, int size, u32 val);

irqreturn_t dw_handle_msi_irq(struct pcie_port *pp);

CRA Git | Maintained and supported by SUSTech CRA and CCSE