Commit 5a163f59 authored by Serge Semin's avatar Serge Semin Committed by Bjorn Helgaas
Browse files

PCI: dwc: Simplify in/outbound iATU setup methods 

Previously __dw_pcie_prog_outbound_atu() duplicated a lot of code between
the iatu_unroll_enabled version and the PCIE_ATU_VIEWPORT version:

  __dw_pcie_prog_outbound_atu
    if (iatu_unroll_enabled)
      dw_pcie_prog_outbound_atu_unroll
        dw_pcie_writel_ob_unroll(PCIE_ATU_UNR_LOWER_BASE, ...)
        dw_pcie_writel_ob_unroll(PCIE_ATU_UNR_UPPER_BASE, ...)
        ...
      return
    dw_pcie_writel_dbi(PCIE_ATU_VIEWPORT, ...)
    dw_pcie_writel_dbi(PCIE_ATU_LOWER_BASE, ...)
    dw_pcie_writel_dbi(PCIE_ATU_UPPER_BASE, ...)
    ...

Unify those by pushing the unroll address computation and viewport
selection down into dw_pcie_writel_atu() so we can use the same
dw_pcie_writel_atu_ob() accessor for both paths:

  __dw_pcie_prog_outbound_atu
    dw_pcie_writel_atu_ob(PCIE_ATU_LOWER_BASE, ...)
      dw_pcie_writel_atu
        dw_pcie_select_atu                      # new
          if (iatu_unroll_enabled)
            return pci->atu_base + PCIE_ATU_UNROLL_BASE(...)
          dw_pcie_writel_dbi(PCIE_ATU_VIEWPORT, ...)
          return pci->atu_base
        dw_pcie_write(base + reg)
      dw_pcie_writel_atu_ob(PCIE_ATU_UPPER_BASE, ...)
      ...

In the non-unroll case, this does involve more MMIO writes to
PCIE_ATU_VIEWPORT, but it's mainly in initialization paths and the code
simplification is significant.

[bhelgaas: commit log, simplify dw_pcie_select_atu()]
Link: https://lore.kernel.org/r/20220624143947.8991-12-Sergey.Semin@baikalelectronics.ru


Signed-off-by: default avatarSerge Semin <Sergey.Semin@baikalelectronics.ru>
Signed-off-by: default avatarBjorn Helgaas <bhelgaas@google.com>
parent 38fe2723

drivers/pci/controller/dwc/pcie-designware.c

+85 −205
Original line number Diff line number Diff line
@@ -205,48 +205,61 @@ void dw_pcie_write_dbi2(struct dw_pcie *pci, u32 reg, size_t size, u32 val) 
		dev_err(pci->dev, "write DBI address failed\n");

}



static u32 dw_pcie_readl_atu(struct dw_pcie *pci, u32 reg)

static inline void __iomem *dw_pcie_select_atu(struct dw_pcie *pci, u32 dir,

					       u32 index)

{

	if (pci->iatu_unroll_enabled)

		return pci->atu_base + PCIE_ATU_UNROLL_BASE(dir, index);



	dw_pcie_writel_dbi(pci, PCIE_ATU_VIEWPORT, dir | index);

	return pci->atu_base;

}



static u32 dw_pcie_readl_atu(struct dw_pcie *pci, u32 dir, u32 index, u32 reg)

{

	void __iomem *base;

	int ret;

	u32 val;



	base = dw_pcie_select_atu(pci, dir, index);



	if (pci->ops && pci->ops->read_dbi)

		return pci->ops->read_dbi(pci, pci->atu_base, reg, 4);

		return pci->ops->read_dbi(pci, base, reg, 4);



	ret = dw_pcie_read(pci->atu_base + reg, 4, &val);

	ret = dw_pcie_read(base + reg, 4, &val);

	if (ret)

		dev_err(pci->dev, "Read ATU address failed\n");



	return val;

}



static void dw_pcie_writel_atu(struct dw_pcie *pci, u32 reg, u32 val)

static void dw_pcie_writel_atu(struct dw_pcie *pci, u32 dir, u32 index,

			       u32 reg, u32 val)

{

	void __iomem *base;

	int ret;



	base = dw_pcie_select_atu(pci, dir, index);



	if (pci->ops && pci->ops->write_dbi) {

		pci->ops->write_dbi(pci, pci->atu_base, reg, 4, val);

		pci->ops->write_dbi(pci, base, reg, 4, val);

		return;

	}



	ret = dw_pcie_write(pci->atu_base + reg, 4, val);

	ret = dw_pcie_write(base + reg, 4, val);

	if (ret)

		dev_err(pci->dev, "Write ATU address failed\n");

}



static u32 dw_pcie_readl_ob_unroll(struct dw_pcie *pci, u32 index, u32 reg)

static inline u32 dw_pcie_readl_atu_ob(struct dw_pcie *pci, u32 index, u32 reg)

{

	u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index);



	return dw_pcie_readl_atu(pci, offset + reg);

	return dw_pcie_readl_atu(pci, PCIE_ATU_REGION_DIR_OB, index, reg);

}



static void dw_pcie_writel_ob_unroll(struct dw_pcie *pci, u32 index, u32 reg,

static inline void dw_pcie_writel_atu_ob(struct dw_pcie *pci, u32 index, u32 reg,

					 u32 val)

{

	u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index);



	dw_pcie_writel_atu(pci, offset + reg, val);

	dw_pcie_writel_atu(pci, PCIE_ATU_REGION_DIR_OB, index, reg, val);

}



static inline u32 dw_pcie_enable_ecrc(u32 val)
@@ -290,50 +303,6 @@ static inline u32 dw_pcie_enable_ecrc(u32 val) 
	return val | PCIE_ATU_TD;

}



static void dw_pcie_prog_outbound_atu_unroll(struct dw_pcie *pci, u8 func_no,

					     int index, int type,

					     u64 cpu_addr, u64 pci_addr,

					     u64 size)

{

	u32 retries, val;

	u64 limit_addr = cpu_addr + size - 1;



	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_LOWER_BASE,

				 lower_32_bits(cpu_addr));

	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_UPPER_BASE,

				 upper_32_bits(cpu_addr));

	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_LOWER_LIMIT,

				 lower_32_bits(limit_addr));

	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_UPPER_LIMIT,

				 upper_32_bits(limit_addr));

	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_LOWER_TARGET,

				 lower_32_bits(pci_addr));

	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_UPPER_TARGET,

				 upper_32_bits(pci_addr));

	val = type | PCIE_ATU_FUNC_NUM(func_no);

	if (upper_32_bits(limit_addr) > upper_32_bits(cpu_addr))

		val |= PCIE_ATU_INCREASE_REGION_SIZE;

	if (dw_pcie_ver_is(pci, 490A))

		val = dw_pcie_enable_ecrc(val);

	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL1, val);

	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL2,

				 PCIE_ATU_ENABLE);



	/*

	 * Make sure ATU enable takes effect before any subsequent config

	 * and I/O accesses.

	 */

	for (retries = 0; retries < LINK_WAIT_MAX_IATU_RETRIES; retries++) {

		val = dw_pcie_readl_ob_unroll(pci, index,

					      PCIE_ATU_UNR_REGION_CTRL2);

		if (val & PCIE_ATU_ENABLE)

			return;



		mdelay(LINK_WAIT_IATU);

	}

	dev_err(pci->dev, "Outbound iATU is not being enabled\n");

}



static void __dw_pcie_prog_outbound_atu(struct dw_pcie *pci, u8 func_no,

					int index, int type, u64 cpu_addr,

					u64 pci_addr, u64 size)
@@ -344,49 +313,46 @@ static void __dw_pcie_prog_outbound_atu(struct dw_pcie *pci, u8 func_no, 
	if (pci->ops && pci->ops->cpu_addr_fixup)

		cpu_addr = pci->ops->cpu_addr_fixup(pci, cpu_addr);



	if (pci->iatu_unroll_enabled) {

		dw_pcie_prog_outbound_atu_unroll(pci, func_no, index, type,

						 cpu_addr, pci_addr, size);

		return;

	}



	limit_addr = cpu_addr + size - 1;



	dw_pcie_writel_dbi(pci, PCIE_ATU_VIEWPORT,

			   PCIE_ATU_REGION_DIR_OB | index);

	dw_pcie_writel_dbi(pci, PCIE_ATU_LOWER_BASE,

	dw_pcie_writel_atu_ob(pci, index, PCIE_ATU_LOWER_BASE,

			      lower_32_bits(cpu_addr));

	dw_pcie_writel_dbi(pci, PCIE_ATU_UPPER_BASE,

	dw_pcie_writel_atu_ob(pci, index, PCIE_ATU_UPPER_BASE,

			      upper_32_bits(cpu_addr));

	dw_pcie_writel_dbi(pci, PCIE_ATU_LIMIT,



	dw_pcie_writel_atu_ob(pci, index, PCIE_ATU_LIMIT,

			      lower_32_bits(limit_addr));

	if (dw_pcie_ver_is_ge(pci, 460A))

		dw_pcie_writel_dbi(pci, PCIE_ATU_UPPER_LIMIT,

		dw_pcie_writel_atu_ob(pci, index, PCIE_ATU_UPPER_LIMIT,

				      upper_32_bits(limit_addr));

	dw_pcie_writel_dbi(pci, PCIE_ATU_LOWER_TARGET,



	dw_pcie_writel_atu_ob(pci, index, PCIE_ATU_LOWER_TARGET,

			      lower_32_bits(pci_addr));

	dw_pcie_writel_dbi(pci, PCIE_ATU_UPPER_TARGET,

	dw_pcie_writel_atu_ob(pci, index, PCIE_ATU_UPPER_TARGET,

			      upper_32_bits(pci_addr));



	val = type | PCIE_ATU_FUNC_NUM(func_no);

	if (upper_32_bits(limit_addr) > upper_32_bits(cpu_addr) &&

	    dw_pcie_ver_is_ge(pci, 460A))

		val |= PCIE_ATU_INCREASE_REGION_SIZE;

	if (dw_pcie_ver_is(pci, 490A))

		val = dw_pcie_enable_ecrc(val);

	dw_pcie_writel_dbi(pci, PCIE_ATU_CR1, val);

	dw_pcie_writel_dbi(pci, PCIE_ATU_CR2, PCIE_ATU_ENABLE);

	dw_pcie_writel_atu_ob(pci, index, PCIE_ATU_REGION_CTRL1, val);



	dw_pcie_writel_atu_ob(pci, index, PCIE_ATU_REGION_CTRL2, PCIE_ATU_ENABLE);



	/*

	 * Make sure ATU enable takes effect before any subsequent config

	 * and I/O accesses.

	 */

	for (retries = 0; retries < LINK_WAIT_MAX_IATU_RETRIES; retries++) {

		val = dw_pcie_readl_dbi(pci, PCIE_ATU_CR2);

		val = dw_pcie_readl_atu_ob(pci, index, PCIE_ATU_REGION_CTRL2);

		if (val & PCIE_ATU_ENABLE)

			return;



		mdelay(LINK_WAIT_IATU);

	}



	dev_err(pci->dev, "Outbound iATU is not being enabled\n");

}
@@ -405,37 +371,31 @@ void dw_pcie_prog_ep_outbound_atu(struct dw_pcie *pci, u8 func_no, int index, 
				    cpu_addr, pci_addr, size);

}



static u32 dw_pcie_readl_ib_unroll(struct dw_pcie *pci, u32 index, u32 reg)

static inline u32 dw_pcie_readl_atu_ib(struct dw_pcie *pci, u32 index, u32 reg)

{

	u32 offset = PCIE_GET_ATU_INB_UNR_REG_OFFSET(index);



	return dw_pcie_readl_atu(pci, offset + reg);

	return dw_pcie_readl_atu(pci, PCIE_ATU_REGION_DIR_IB, index, reg);

}



static void dw_pcie_writel_ib_unroll(struct dw_pcie *pci, u32 index, u32 reg,

static inline void dw_pcie_writel_atu_ib(struct dw_pcie *pci, u32 index, u32 reg,

					 u32 val)

{

	u32 offset = PCIE_GET_ATU_INB_UNR_REG_OFFSET(index);



	dw_pcie_writel_atu(pci, offset + reg, val);

	dw_pcie_writel_atu(pci, PCIE_ATU_REGION_DIR_IB, index, reg, val);

}



static int dw_pcie_prog_inbound_atu_unroll(struct dw_pcie *pci, u8 func_no,

					   int index, int type,

					   u64 cpu_addr, u8 bar)

int dw_pcie_prog_inbound_atu(struct dw_pcie *pci, u8 func_no, int index,

			     int type, u64 cpu_addr, u8 bar)

{

	u32 retries, val;



	dw_pcie_writel_ib_unroll(pci, index, PCIE_ATU_UNR_LOWER_TARGET,

	dw_pcie_writel_atu_ib(pci, index, PCIE_ATU_LOWER_TARGET,

			      lower_32_bits(cpu_addr));

	dw_pcie_writel_ib_unroll(pci, index, PCIE_ATU_UNR_UPPER_TARGET,

	dw_pcie_writel_atu_ib(pci, index, PCIE_ATU_UPPER_TARGET,

			      upper_32_bits(cpu_addr));



	dw_pcie_writel_ib_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL1, type |

	dw_pcie_writel_atu_ib(pci, index, PCIE_ATU_REGION_CTRL1, type |

			      PCIE_ATU_FUNC_NUM(func_no));

	dw_pcie_writel_ib_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL2,

				 PCIE_ATU_FUNC_NUM_MATCH_EN |

				 PCIE_ATU_ENABLE |

	dw_pcie_writel_atu_ib(pci, index, PCIE_ATU_REGION_CTRL2,

			      PCIE_ATU_ENABLE | PCIE_ATU_FUNC_NUM_MATCH_EN |

			      PCIE_ATU_BAR_MODE_ENABLE | (bar << 8));



	/*
@@ -443,68 +403,21 @@ static int dw_pcie_prog_inbound_atu_unroll(struct dw_pcie *pci, u8 func_no, 
	 * and I/O accesses.

	 */

	for (retries = 0; retries < LINK_WAIT_MAX_IATU_RETRIES; retries++) {

		val = dw_pcie_readl_ib_unroll(pci, index,

					      PCIE_ATU_UNR_REGION_CTRL2);

		val = dw_pcie_readl_atu_ib(pci, index, PCIE_ATU_REGION_CTRL2);

		if (val & PCIE_ATU_ENABLE)

			return 0;



		mdelay(LINK_WAIT_IATU);

	}

	dev_err(pci->dev, "Inbound iATU is not being enabled\n");



	return -EBUSY;

}



int dw_pcie_prog_inbound_atu(struct dw_pcie *pci, u8 func_no, int index,

			     int type, u64 cpu_addr, u8 bar)

{

	u32 retries, val;



	if (pci->iatu_unroll_enabled)

		return dw_pcie_prog_inbound_atu_unroll(pci, func_no, index,

						       type, cpu_addr, bar);



	dw_pcie_writel_dbi(pci, PCIE_ATU_VIEWPORT, PCIE_ATU_REGION_DIR_IB |

			   index);

	dw_pcie_writel_dbi(pci, PCIE_ATU_LOWER_TARGET, lower_32_bits(cpu_addr));

	dw_pcie_writel_dbi(pci, PCIE_ATU_UPPER_TARGET, upper_32_bits(cpu_addr));



	dw_pcie_writel_dbi(pci, PCIE_ATU_CR1, type |

			   PCIE_ATU_FUNC_NUM(func_no));

	dw_pcie_writel_dbi(pci, PCIE_ATU_CR2, PCIE_ATU_ENABLE |

			   PCIE_ATU_FUNC_NUM_MATCH_EN |

			   PCIE_ATU_BAR_MODE_ENABLE | (bar << 8));



	/*

	 * Make sure ATU enable takes effect before any subsequent config

	 * and I/O accesses.

	 */

	for (retries = 0; retries < LINK_WAIT_MAX_IATU_RETRIES; retries++) {

		val = dw_pcie_readl_dbi(pci, PCIE_ATU_CR2);

		if (val & PCIE_ATU_ENABLE)

			return 0;



		mdelay(LINK_WAIT_IATU);

	}

	dev_err(pci->dev, "Inbound iATU is not being enabled\n");



	return -EBUSY;

	return -ETIMEDOUT;

}



void dw_pcie_disable_atu(struct dw_pcie *pci, u32 dir, int index)

{

	if (pci->iatu_unroll_enabled) {

		if (dir == PCIE_ATU_REGION_DIR_IB) {

			dw_pcie_writel_ib_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL2,

						 ~(u32)PCIE_ATU_ENABLE);

		} else {

			dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL2,

						 ~(u32)PCIE_ATU_ENABLE);

		}

	} else {

		dw_pcie_writel_dbi(pci, PCIE_ATU_VIEWPORT, dir | index);

		dw_pcie_writel_dbi(pci, PCIE_ATU_CR2, ~(u32)PCIE_ATU_ENABLE);

	}

	dw_pcie_writel_atu(pci, dir, index, PCIE_ATU_REGION_CTRL2, 0);

}



int dw_pcie_wait_for_link(struct dw_pcie *pci)
@@ -606,63 +519,29 @@ static bool dw_pcie_iatu_unroll_enabled(struct dw_pcie *pci) 
	return false;

}



static void dw_pcie_iatu_detect_regions_unroll(struct dw_pcie *pci)

{

	int max_region, i, ob = 0, ib = 0;

	u32 val;



	max_region = min((int)pci->atu_size / 512, 256);



	for (i = 0; i < max_region; i++) {

		dw_pcie_writel_ob_unroll(pci, i, PCIE_ATU_UNR_LOWER_TARGET,

					0x11110000);



		val = dw_pcie_readl_ob_unroll(pci, i, PCIE_ATU_UNR_LOWER_TARGET);

		if (val == 0x11110000)

			ob++;

		else

			break;

	}



	for (i = 0; i < max_region; i++) {

		dw_pcie_writel_ib_unroll(pci, i, PCIE_ATU_UNR_LOWER_TARGET,

					0x11110000);



		val = dw_pcie_readl_ib_unroll(pci, i, PCIE_ATU_UNR_LOWER_TARGET);

		if (val == 0x11110000)

			ib++;

		else

			break;

	}

	pci->num_ib_windows = ib;

	pci->num_ob_windows = ob;

}



static void dw_pcie_iatu_detect_regions(struct dw_pcie *pci)

{

	int max_region, i, ob = 0, ib = 0;

	int max_region, ob, ib;

	u32 val;



	if (pci->iatu_unroll_enabled) {

		max_region = min((int)pci->atu_size / 512, 256);

	} else {

		dw_pcie_writel_dbi(pci, PCIE_ATU_VIEWPORT, 0xFF);

		max_region = dw_pcie_readl_dbi(pci, PCIE_ATU_VIEWPORT) + 1;

	}



	for (i = 0; i < max_region; i++) {

		dw_pcie_writel_dbi(pci, PCIE_ATU_VIEWPORT, PCIE_ATU_REGION_DIR_OB | i);

		dw_pcie_writel_dbi(pci, PCIE_ATU_LOWER_TARGET, 0x11110000);

		val = dw_pcie_readl_dbi(pci, PCIE_ATU_LOWER_TARGET);

		if (val == 0x11110000)

			ob++;

		else

	for (ob = 0; ob < max_region; ob++) {

		dw_pcie_writel_atu_ob(pci, ob, PCIE_ATU_LOWER_TARGET, 0x11110000);

		val = dw_pcie_readl_atu_ob(pci, ob, PCIE_ATU_LOWER_TARGET);

		if (val != 0x11110000)

			break;

	}



	for (i = 0; i < max_region; i++) {

		dw_pcie_writel_dbi(pci, PCIE_ATU_VIEWPORT, PCIE_ATU_REGION_DIR_IB | i);

		dw_pcie_writel_dbi(pci, PCIE_ATU_LOWER_TARGET, 0x11110000);

		val = dw_pcie_readl_dbi(pci, PCIE_ATU_LOWER_TARGET);

		if (val == 0x11110000)

			ib++;

		else

	for (ib = 0; ib < max_region; ib++) {

		dw_pcie_writel_atu_ib(pci, ib, PCIE_ATU_LOWER_TARGET, 0x11110000);

		val = dw_pcie_readl_atu_ib(pci, ib, PCIE_ATU_LOWER_TARGET);

		if (val != 0x11110000)

			break;

	}
@@ -690,12 +569,13 @@ void dw_pcie_iatu_detect(struct dw_pcie *pci) 
		if (!pci->atu_size)

			/* Pick a minimal default, enough for 8 in and 8 out windows */

			pci->atu_size = SZ_4K;



		dw_pcie_iatu_detect_regions_unroll(pci);

	} else {

		dw_pcie_iatu_detect_regions(pci);

		pci->atu_base = pci->dbi_base + PCIE_ATU_VIEWPORT_BASE;

		pci->atu_size = PCIE_ATU_VIEWPORT_SIZE;

	}



	dw_pcie_iatu_detect_regions(pci);



	dev_info(pci->dev, "iATU unroll: %s\n", pci->iatu_unroll_enabled ?

		"enabled" : "disabled");

drivers/pci/controller/dwc/pcie-designware.h

+19 −29
Original line number Diff line number Diff line
@@ -103,10 +103,21 @@ 
#define PCIE_VERSION_NUMBER		0x8F8

#define PCIE_VERSION_TYPE		0x8FC



/*

 * iATU inbound and outbound windows CSRs. Before the IP-core v4.80a each

 * iATU region CSRs had been indirectly accessible by means of the dedicated

 * viewport selector. The iATU/eDMA CSRs space was re-designed in DWC PCIe

 * v4.80a in a way so the viewport was unrolled into the directly accessible

 * iATU/eDMA CSRs space.

 */

#define PCIE_ATU_VIEWPORT		0x900

#define PCIE_ATU_REGION_DIR_IB		BIT(31)

#define PCIE_ATU_REGION_DIR_OB		0

#define PCIE_ATU_CR1			0x904

#define PCIE_ATU_VIEWPORT_BASE		0x904

#define PCIE_ATU_UNROLL_BASE(dir, index) \

	(((index) << 9) | ((dir == PCIE_ATU_REGION_DIR_IB) ? BIT(8) : 0))

#define PCIE_ATU_VIEWPORT_SIZE		0x2C

#define PCIE_ATU_REGION_CTRL1		0x000

#define PCIE_ATU_INCREASE_REGION_SIZE	BIT(13)

#define PCIE_ATU_TYPE_MEM		0x0

#define PCIE_ATU_TYPE_IO		0x2
@@ -114,19 +125,19 @@ 
#define PCIE_ATU_TYPE_CFG1		0x5

#define PCIE_ATU_TD			BIT(8)

#define PCIE_ATU_FUNC_NUM(pf)           ((pf) << 20)

#define PCIE_ATU_CR2			0x908

#define PCIE_ATU_REGION_CTRL2		0x004

#define PCIE_ATU_ENABLE			BIT(31)

#define PCIE_ATU_BAR_MODE_ENABLE	BIT(30)

#define PCIE_ATU_FUNC_NUM_MATCH_EN      BIT(19)

#define PCIE_ATU_LOWER_BASE		0x90C

#define PCIE_ATU_UPPER_BASE		0x910

#define PCIE_ATU_LIMIT			0x914

#define PCIE_ATU_LOWER_TARGET		0x918

#define PCIE_ATU_LOWER_BASE		0x008

#define PCIE_ATU_UPPER_BASE		0x00C

#define PCIE_ATU_LIMIT			0x010

#define PCIE_ATU_LOWER_TARGET		0x014

#define PCIE_ATU_BUS(x)			FIELD_PREP(GENMASK(31, 24), x)

#define PCIE_ATU_DEV(x)			FIELD_PREP(GENMASK(23, 19), x)

#define PCIE_ATU_FUNC(x)		FIELD_PREP(GENMASK(18, 16), x)

#define PCIE_ATU_UPPER_TARGET		0x91C

#define PCIE_ATU_UPPER_LIMIT		0x924

#define PCIE_ATU_UPPER_TARGET		0x018

#define PCIE_ATU_UPPER_LIMIT		0x020



#define PCIE_MISC_CONTROL_1_OFF		0x8BC

#define PCIE_DBI_RO_WR_EN		BIT(0)
@@ -143,19 +154,6 @@ 


#define PCIE_PL_CHK_REG_ERR_ADDR			0xB28



/*

 * iATU Unroll-specific register definitions

 * From 4.80 core version the address translation will be made by unroll

 */

#define PCIE_ATU_UNR_REGION_CTRL1	0x00

#define PCIE_ATU_UNR_REGION_CTRL2	0x04

#define PCIE_ATU_UNR_LOWER_BASE		0x08

#define PCIE_ATU_UNR_UPPER_BASE		0x0C

#define PCIE_ATU_UNR_LOWER_LIMIT	0x10

#define PCIE_ATU_UNR_LOWER_TARGET	0x14

#define PCIE_ATU_UNR_UPPER_TARGET	0x18

#define PCIE_ATU_UNR_UPPER_LIMIT	0x20



/*

 * The default address offset between dbi_base and atu_base. Root controller

 * drivers are not required to initialize atu_base if the offset matches this
@@ -164,13 +162,6 @@ 
 */

#define DEFAULT_DBI_ATU_OFFSET (0x3 << 20)



/* Register address builder */

#define PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(region) \

		((region) << 9)



#define PCIE_GET_ATU_INB_UNR_REG_OFFSET(region) \

		(((region) << 9) | BIT(8))



#define MAX_MSI_IRQS			256

#define MAX_MSI_IRQS_PER_CTRL		32

#define MAX_MSI_CTRLS			(MAX_MSI_IRQS / MAX_MSI_IRQS_PER_CTRL)
@@ -277,7 +268,6 @@ struct dw_pcie { 
	struct device		*dev;

	void __iomem		*dbi_base;

	void __iomem		*dbi_base2;

	/* Used when iatu_unroll_enabled is true */

	void __iomem		*atu_base;

	size_t			atu_size;

	u32			num_ib_windows;

drivers/pci/controller/dwc/pcie-tegra194-acpi.c

+4 −3
Original line number Diff line number Diff line
@@ -39,7 +39,8 @@ static int tegra194_acpi_init(struct pci_config_window *cfg) 
static void atu_reg_write(struct tegra194_pcie_ecam *pcie_ecam, int index,

			  u32 val, u32 reg)

{

	u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index);

	u32 offset = PCIE_ATU_UNROLL_BASE(PCIE_ATU_REGION_DIR_OB, index) +

		     PCIE_ATU_VIEWPORT_BASE;



	writel(val, pcie_ecam->iatu_base + offset + reg);

}
@@ -58,8 +59,8 @@ static void program_outbound_atu(struct tegra194_pcie_ecam *pcie_ecam, 
		      PCIE_ATU_LIMIT);

	atu_reg_write(pcie_ecam, index, upper_32_bits(pci_addr),

		      PCIE_ATU_UPPER_TARGET);

	atu_reg_write(pcie_ecam, index, type, PCIE_ATU_CR1);

	atu_reg_write(pcie_ecam, index, PCIE_ATU_ENABLE, PCIE_ATU_CR2);

	atu_reg_write(pcie_ecam, index, type, PCIE_ATU_REGION_CTRL1);

	atu_reg_write(pcie_ecam, index, PCIE_ATU_ENABLE, PCIE_ATU_REGION_CTRL2);

}



static void __iomem *tegra194_map_bus(struct pci_bus *bus,