All of lore.kernel.org
 help / color / mirror / Atom feed
* [U-Boot] [PATCH v3 0/7] Add PCIe root complex support for AM654x SoC
@ 2019-08-01 13:42 Sekhar Nori
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 1/7] clk: add support for clk_is_match() Sekhar Nori
                   ` (6 more replies)
  0 siblings, 7 replies; 21+ messages in thread
From: Sekhar Nori @ 2019-08-01 13:42 UTC (permalink / raw)
  To: u-boot

Hi,

This patch series adds PCIe root complex support for AM654x SoC.

The device-tree files are based on bindings accepted in linux.
See files Documentation/devicetree/bindings/phy/ti,phy-am654-serdes.txt
and Documentation/devicetree/bindings/pci/pci-keystone.txt in latest
mainline master.

I have not posted the actual board-specific device-tree bits yet.
The reason is that PCIe slot is on a daughter card on the AM65x EVM.
I want to see how we can support that as an overlay in U-Boot. That
needs some more attention. Meanwhile I have tested this using a patch
that simply enables PCIe in the baseboard device-tree file itself.

v3:
- fix unit test for clk_is_match()

v2:
- add unit tests for new clock and dm APIs introduced
- add Lokesh's Reviewed-by: for patches #1 and #2

Sekhar Nori (7):
  clk: add support for clk_is_match()
  dm: core: add support for getting register address and size
  pcie: ti: add driver for AM65x PCIe RC
  phy: add support for AM654x SERDES
  configs: am65x_evm_a53: enable PCIe support
  arm: dts: k3-am65: add support for PCIe and SERDES
  configs: am65x_evm_a53: enable support for PCIe ethernet cards

 arch/arm/dts/k3-am65-main.dtsi             | 108 +++++
 arch/arm/dts/k3-am65.dtsi                  |   1 +
 configs/am65x_evm_a53_defconfig            |   8 +
 drivers/clk/clk-uclass.c                   |  13 +
 drivers/core/fdtaddr.c                     |  17 +
 drivers/core/read.c                        |  20 +
 drivers/pci/Kconfig                        |   6 +
 drivers/pci/Makefile                       |   1 +
 drivers/pci/pcie_dw_ti.c                   | 725 +++++++++++++++++++++++++++++
 drivers/phy/Kconfig                        |   9 +
 drivers/phy/Makefile                       |   1 +
 drivers/phy/phy-ti-am654.c                 | 411 ++++++++++++++++
 include/clk.h                              |  12 +
 include/dm/fdtaddr.h                       |  18 +
 include/dm/read.h                          |  41 ++
 include/dt-bindings/phy/phy-am654-serdes.h |  13 +
 test/dm/clk.c                              |   1 +
 test/dm/test-fdt.c                         |  16 +-
 18 files changed, 1417 insertions(+), 4 deletions(-)
 create mode 100644 drivers/pci/pcie_dw_ti.c
 create mode 100644 drivers/phy/phy-ti-am654.c
 create mode 100644 include/dt-bindings/phy/phy-am654-serdes.h

-- 
2.16.2

^ permalink raw reply	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 1/7] clk: add support for clk_is_match()
  2019-08-01 13:42 [U-Boot] [PATCH v3 0/7] Add PCIe root complex support for AM654x SoC Sekhar Nori
@ 2019-08-01 13:42 ` Sekhar Nori
  2019-08-01 13:47   ` Fabio Estevam
  2019-08-13 16:51   ` Tom Rini
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 2/7] dm: core: add support for getting register address and size Sekhar Nori
                   ` (5 subsequent siblings)
  6 siblings, 2 replies; 21+ messages in thread
From: Sekhar Nori @ 2019-08-01 13:42 UTC (permalink / raw)
  To: u-boot

Add support for clk_is_match() which is required to
know if two clock pointers point to the same exact
physical clock.

Also add a unit test for the new API.

Reviewed-by: Lokesh Vutla <lokeshvutla@ti.com>
Signed-off-by: Sekhar Nori <nsekhar@ti.com>
---
 drivers/clk/clk-uclass.c | 13 +++++++++++++
 include/clk.h            | 12 ++++++++++++
 test/dm/clk.c            |  1 +
 3 files changed, 26 insertions(+)

diff --git a/drivers/clk/clk-uclass.c b/drivers/clk/clk-uclass.c
index 85dfe712f5ac..1409c03ea174 100644
--- a/drivers/clk/clk-uclass.c
+++ b/drivers/clk/clk-uclass.c
@@ -515,6 +515,19 @@ int clk_get_by_id(ulong id, struct clk **clkp)
 	return -ENOENT;
 }
 
+bool clk_is_match(const struct clk *p, const struct clk *q)
+{
+	/* trivial case: identical struct clk's or both NULL */
+	if (p == q)
+		return true;
+
+	/* same device, id and data */
+	if (p->dev == q->dev && p->id == q->id && p->data == q->data)
+		return true;
+
+	return false;
+}
+
 UCLASS_DRIVER(clk) = {
 	.id		= UCLASS_CLK,
 	.name		= "clk",
diff --git a/include/clk.h b/include/clk.h
index f8f56d9cf01d..f50e5caa2206 100644
--- a/include/clk.h
+++ b/include/clk.h
@@ -333,6 +333,18 @@ int clk_disable(struct clk *clk);
  */
 int clk_disable_bulk(struct clk_bulk *bulk);
 
+/**
+ * clk_is_match - check if two clk's point to the same hardware clock
+ * @p: clk compared against q
+ * @q: clk compared against p
+ *
+ * Returns true if the two struct clk pointers both point to the same hardware
+ * clock node.
+ *
+ * Returns false otherwise. Note that two NULL clks are treated as matching.
+ */
+bool clk_is_match(const struct clk *p, const struct clk *q);
+
 int soc_clk_dump(void);
 
 /**
diff --git a/test/dm/clk.c b/test/dm/clk.c
index f301ecbb459d..676ef217f093 100644
--- a/test/dm/clk.c
+++ b/test/dm/clk.c
@@ -24,6 +24,7 @@ static int dm_test_clk_base(struct unit_test_state *uts)
 	/* Get the same clk port in 2 different ways and compare */
 	ut_assertok(clk_get_by_index(dev, 1, &clk_method1));
 	ut_assertok(clk_get_by_index_nodev(dev_ofnode(dev), 1, &clk_method2));
+	ut_asserteq(clk_is_match(&clk_method1, &clk_method2), true);
 	ut_asserteq(clk_method1.id, clk_method2.id);
 
 	return 0;
-- 
2.16.2

^ permalink raw reply related	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 2/7] dm: core: add support for getting register address and size
  2019-08-01 13:42 [U-Boot] [PATCH v3 0/7] Add PCIe root complex support for AM654x SoC Sekhar Nori
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 1/7] clk: add support for clk_is_match() Sekhar Nori
@ 2019-08-01 13:42 ` Sekhar Nori
  2019-08-01 16:21   ` Daniel Schwierzeck
  2019-08-13 16:51   ` Tom Rini
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 3/7] pcie: ti: add driver for AM65x PCIe RC Sekhar Nori
                   ` (4 subsequent siblings)
  6 siblings, 2 replies; 21+ messages in thread
From: Sekhar Nori @ 2019-08-01 13:42 UTC (permalink / raw)
  To: u-boot

Current dev_read_*() API lacks support to get address and size
of a "reg" property by name or index. Add support for the same.

Livetree support has been added but not tested on real hardware.

The existing unit tests testing reading address from device-tree
have been updated to test address as well as size.

Reviewed-by: Lokesh Vutla <lokeshvutla@ti.com>
Signed-off-by: Sekhar Nori <nsekhar@ti.com>
---
 drivers/core/fdtaddr.c | 17 +++++++++++++++++
 drivers/core/read.c    | 20 ++++++++++++++++++++
 include/dm/fdtaddr.h   | 18 ++++++++++++++++++
 include/dm/read.h      | 41 +++++++++++++++++++++++++++++++++++++++++
 test/dm/test-fdt.c     | 16 ++++++++++++----
 5 files changed, 108 insertions(+), 4 deletions(-)

diff --git a/drivers/core/fdtaddr.c b/drivers/core/fdtaddr.c
index c2873861dacd..6850003a287b 100644
--- a/drivers/core/fdtaddr.c
+++ b/drivers/core/fdtaddr.c
@@ -129,6 +129,23 @@ fdt_addr_t devfdt_get_addr_name(struct udevice *dev, const char *name)
 #endif
 }
 
+fdt_addr_t devfdt_get_addr_size_name(struct udevice *dev, const char *name,
+				     fdt_size_t *size)
+{
+#if CONFIG_IS_ENABLED(OF_CONTROL)
+	int index;
+
+	index = fdt_stringlist_search(gd->fdt_blob, dev_of_offset(dev),
+				      "reg-names", name);
+	if (index < 0)
+		return index;
+
+	return devfdt_get_addr_size_index(dev, index, size);
+#else
+	return FDT_ADDR_T_NONE;
+#endif
+}
+
 fdt_addr_t devfdt_get_addr(struct udevice *dev)
 {
 	return devfdt_get_addr_index(dev, 0);
diff --git a/drivers/core/read.c b/drivers/core/read.c
index 1a044b05e884..8b5502de1159 100644
--- a/drivers/core/read.c
+++ b/drivers/core/read.c
@@ -82,6 +82,15 @@ fdt_addr_t dev_read_addr_index(struct udevice *dev, int index)
 		return devfdt_get_addr_index(dev, index);
 }
 
+fdt_addr_t dev_read_addr_size_index(struct udevice *dev, int index,
+				    fdt_size_t *size)
+{
+	if (ofnode_is_np(dev_ofnode(dev)))
+		return ofnode_get_addr_size_index(dev_ofnode(dev), index, size);
+	else
+		return devfdt_get_addr_size_index(dev, index, size);
+}
+
 void *dev_remap_addr_index(struct udevice *dev, int index)
 {
 	fdt_addr_t addr = dev_read_addr_index(dev, index);
@@ -102,6 +111,17 @@ fdt_addr_t dev_read_addr_name(struct udevice *dev, const char *name)
 		return dev_read_addr_index(dev, index);
 }
 
+fdt_addr_t dev_read_addr_size_name(struct udevice *dev, const char *name,
+				   fdt_size_t *size)
+{
+	int index = dev_read_stringlist_search(dev, "reg-names", name);
+
+	if (index < 0)
+		return FDT_ADDR_T_NONE;
+	else
+		return dev_read_addr_size_index(dev, index, size);
+}
+
 void *dev_remap_addr_name(struct udevice *dev, const char *name)
 {
 	fdt_addr_t addr = dev_read_addr_name(dev, name);
diff --git a/include/dm/fdtaddr.h b/include/dm/fdtaddr.h
index 3bc2599b6cbd..57b326cb3362 100644
--- a/include/dm/fdtaddr.h
+++ b/include/dm/fdtaddr.h
@@ -120,4 +120,22 @@ fdt_addr_t devfdt_get_addr_size_index(struct udevice *dev, int index,
  */
 fdt_addr_t devfdt_get_addr_name(struct udevice *dev, const char *name);
 
+/**
+ * devfdt_get_addr_size_name() - Get the reg property and its size for a device,
+ *				 indexed by name
+ *
+ * Returns the address and size specified in the 'reg' property of a device.
+ *
+ * @dev: Pointer to a device
+ * @name: the 'reg' property can hold a list of <addr, size> pairs, with the
+ *	  'reg-names' property providing named-based identification. @index
+ *	  indicates the value to search for in 'reg-names'.
+ * @size: Pointer to size variable - this function returns the size
+ *        specified in the 'reg' property here
+ *
+ * @return addr
+ */
+fdt_addr_t devfdt_get_addr_size_name(struct udevice *dev, const char *name,
+				     fdt_size_t *size);
+
 #endif
diff --git a/include/dm/read.h b/include/dm/read.h
index 6ecd062e200c..0c62d62f1148 100644
--- a/include/dm/read.h
+++ b/include/dm/read.h
@@ -144,6 +144,19 @@ int dev_read_size(struct udevice *dev, const char *propname);
  */
 fdt_addr_t dev_read_addr_index(struct udevice *dev, int index);
 
+/**
+ * dev_read_addr_size_index() - Get the indexed reg property of a device
+ *
+ * @dev: Device to read from
+ * @index: the 'reg' property can hold a list of <addr, size> pairs
+ *	   and @index is used to select which one is required
+ * @size: place to put size value (on success)
+ *
+ * @return address or FDT_ADDR_T_NONE if not found
+ */
+fdt_addr_t dev_read_addr_size_index(struct udevice *dev, int index,
+				    fdt_size_t *size);
+
 /**
  * dev_remap_addr_index() - Get the indexed reg property of a device
  *                               as a memory-mapped I/O pointer
@@ -168,6 +181,20 @@ void *dev_remap_addr_index(struct udevice *dev, int index);
  */
 fdt_addr_t dev_read_addr_name(struct udevice *dev, const char* name);
 
+/**
+ * dev_read_addr_size_name() - Get the reg property of a device, indexed by name
+ *
+ * @dev: Device to read from
+ * @name: the 'reg' property can hold a list of <addr, size> pairs, with the
+ *	  'reg-names' property providing named-based identification. @index
+ *	  indicates the value to search for in 'reg-names'.
+ *  @size: place to put size value (on success)
+ *
+ * @return address or FDT_ADDR_T_NONE if not found
+ */
+fdt_addr_t dev_read_addr_size_name(struct udevice *dev, const char *name,
+				   fdt_size_t *size);
+
 /**
  * dev_remap_addr_name() - Get the reg property of a device, indexed by name,
  *                         as a memory-mapped I/O pointer
@@ -601,12 +628,26 @@ static inline fdt_addr_t dev_read_addr_index(struct udevice *dev, int index)
 	return devfdt_get_addr_index(dev, index);
 }
 
+static inline fdt_addr_t dev_read_addr_size_index(struct udevice *dev,
+						  int index,
+						  fdt_size_t *size)
+{
+	return devfdt_get_addr_size_index(dev, index, size);
+}
+
 static inline fdt_addr_t dev_read_addr_name(struct udevice *dev,
 					    const char *name)
 {
 	return devfdt_get_addr_name(dev, name);
 }
 
+static inline fdt_addr_t dev_read_addr_size_name(struct udevice *dev,
+						 const char *name,
+						 fdt_size_t *size)
+{
+	return devfdt_get_addr_size_name(dev, name, size);
+}
+
 static inline fdt_addr_t dev_read_addr(struct udevice *dev)
 {
 	return devfdt_get_addr(dev);
diff --git a/test/dm/test-fdt.c b/test/dm/test-fdt.c
index ad8591639da5..1fb8b5c248d3 100644
--- a/test/dm/test-fdt.c
+++ b/test/dm/test-fdt.c
@@ -549,12 +549,14 @@ static int dm_test_fdt_remap_addr_index_flat(struct unit_test_state *uts)
 {
 	struct udevice *dev;
 	fdt_addr_t addr;
+	fdt_size_t size;
 	void *paddr;
 
 	ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 
-	addr = devfdt_get_addr_index(dev, 0);
+	addr = devfdt_get_addr_size_index(dev, 0, &size);
 	ut_asserteq(0x8000, addr);
+	ut_asserteq(0x1000, size);
 
 	paddr = map_physmem(addr, 0, MAP_NOCACHE);
 	ut_assertnonnull(paddr);
@@ -569,12 +571,14 @@ static int dm_test_fdt_remap_addr_name_flat(struct unit_test_state *uts)
 {
 	struct udevice *dev;
 	fdt_addr_t addr;
+	fdt_size_t size;
 	void *paddr;
 
 	ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 
-	addr = devfdt_get_addr_name(dev, "sandbox-dummy-0");
+	addr = devfdt_get_addr_size_name(dev, "sandbox-dummy-0", &size);
 	ut_asserteq(0x8000, addr);
+	ut_asserteq(0x1000, size);
 
 	paddr = map_physmem(addr, 0, MAP_NOCACHE);
 	ut_assertnonnull(paddr);
@@ -609,12 +613,14 @@ static int dm_test_fdt_remap_addr_index_live(struct unit_test_state *uts)
 {
 	struct udevice *dev;
 	fdt_addr_t addr;
+	fdt_size_t size;
 	void *paddr;
 
 	ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 
-	addr = dev_read_addr_index(dev, 0);
+	addr = dev_read_addr_size_index(dev, 0, &size);
 	ut_asserteq(0x8000, addr);
+	ut_asserteq(0x1000, size);
 
 	paddr = map_physmem(addr, 0, MAP_NOCACHE);
 	ut_assertnonnull(paddr);
@@ -629,12 +635,14 @@ static int dm_test_fdt_remap_addr_name_live(struct unit_test_state *uts)
 {
 	struct udevice *dev;
 	fdt_addr_t addr;
+	fdt_size_t size;
 	void *paddr;
 
 	ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 
-	addr = dev_read_addr_name(dev, "sandbox-dummy-0");
+	addr = dev_read_addr_size_name(dev, "sandbox-dummy-0", &size);
 	ut_asserteq(0x8000, addr);
+	ut_asserteq(0x1000, size);
 
 	paddr = map_physmem(addr, 0, MAP_NOCACHE);
 	ut_assertnonnull(paddr);
-- 
2.16.2

^ permalink raw reply related	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 3/7] pcie: ti: add driver for AM65x PCIe RC
  2019-08-01 13:42 [U-Boot] [PATCH v3 0/7] Add PCIe root complex support for AM654x SoC Sekhar Nori
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 1/7] clk: add support for clk_is_match() Sekhar Nori
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 2/7] dm: core: add support for getting register address and size Sekhar Nori
@ 2019-08-01 13:42 ` Sekhar Nori
  2019-08-13 16:51   ` Tom Rini
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 4/7] phy: add support for AM654x SERDES Sekhar Nori
                   ` (3 subsequent siblings)
  6 siblings, 1 reply; 21+ messages in thread
From: Sekhar Nori @ 2019-08-01 13:42 UTC (permalink / raw)
  To: u-boot

Add driver supporting PCIe root-complex available
on TI's AM65x SoC.

Signed-off-by: Sekhar Nori <nsekhar@ti.com>
---
 drivers/pci/Kconfig      |   6 +
 drivers/pci/Makefile     |   1 +
 drivers/pci/pcie_dw_ti.c | 725 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 732 insertions(+)
 create mode 100644 drivers/pci/pcie_dw_ti.c

diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index 3fe38f7315ed..bdfc0c17963f 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -145,4 +145,10 @@ config PCI_MVEBU
 	  Say Y here if you want to enable PCIe controller support on
 	  Armada XP/38x SoCs.
 
+config PCI_KEYSTONE
+	bool "TI Keystone PCIe controller"
+	depends on DM_PCI
+	help
+	  Say Y here if you want to enable PCI controller support on AM654 SoC.
+
 endif
diff --git a/drivers/pci/Makefile b/drivers/pci/Makefile
index b5ebd50c855f..e54a98b8c9c5 100644
--- a/drivers/pci/Makefile
+++ b/drivers/pci/Makefile
@@ -38,3 +38,4 @@ obj-$(CONFIG_PCIE_LAYERSCAPE_GEN4) += pcie_layerscape_gen4.o \
 				pcie_layerscape_gen4_fixup.o
 obj-$(CONFIG_PCI_XILINX) += pcie_xilinx.o
 obj-$(CONFIG_PCIE_INTEL_FPGA) += pcie_intel_fpga.o
+obj-$(CONFIG_PCI_KEYSTONE) += pcie_dw_ti.o
diff --git a/drivers/pci/pcie_dw_ti.c b/drivers/pci/pcie_dw_ti.c
new file mode 100644
index 000000000000..b37fc2de7fb8
--- /dev/null
+++ b/drivers/pci/pcie_dw_ti.c
@@ -0,0 +1,725 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2018 Texas Instruments, Inc
+ */
+
+#include <common.h>
+#include <dm.h>
+#include <pci.h>
+#include <generic-phy.h>
+#include <power-domain.h>
+#include <regmap.h>
+#include <syscon.h>
+#include <asm/io.h>
+#include <asm-generic/gpio.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+#define PCIE_VENDORID_MASK	GENMASK(15, 0)
+#define PCIE_DEVICEID_SHIFT	16
+
+/* PCI DBICS registers */
+#define PCIE_CONFIG_BAR0		0x10
+#define PCIE_LINK_STATUS_REG		0x80
+#define PCIE_LINK_STATUS_SPEED_OFF	16
+#define PCIE_LINK_STATUS_SPEED_MASK	(0xf << PCIE_LINK_STATUS_SPEED_OFF)
+#define PCIE_LINK_STATUS_WIDTH_OFF	20
+#define PCIE_LINK_STATUS_WIDTH_MASK	(0xf << PCIE_LINK_STATUS_WIDTH_OFF)
+
+#define PCIE_LINK_CAPABILITY		0x7c
+#define PCIE_LINK_CTL_2			0xa0
+#define TARGET_LINK_SPEED_MASK		0xf
+#define LINK_SPEED_GEN_1		0x1
+#define LINK_SPEED_GEN_2		0x2
+#define LINK_SPEED_GEN_3		0x3
+
+#define PCIE_MISC_CONTROL_1_OFF		0x8bc
+#define PCIE_DBI_RO_WR_EN		BIT(0)
+
+#define PLR_OFFSET			0x700
+#define PCIE_PORT_DEBUG0		(PLR_OFFSET + 0x28)
+#define PORT_LOGIC_LTSSM_STATE_MASK	0x1f
+#define PORT_LOGIC_LTSSM_STATE_L0	0x11
+
+#define PCIE_LINK_WIDTH_SPEED_CONTROL	0x80c
+#define PORT_LOGIC_SPEED_CHANGE		(0x1 << 17)
+
+#define PCIE_LINK_UP_TIMEOUT_MS		100
+
+/*
+ * iATU Unroll-specific register definitions
+ * From 4.80 core version the address translation will be made by unroll.
+ * The registers are offset from atu_base
+ */
+#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_LIMIT		0x10
+#define PCIE_ATU_UNR_LOWER_TARGET	0x14
+#define PCIE_ATU_UNR_UPPER_TARGET	0x18
+
+#define PCIE_ATU_REGION_INDEX1		(0x1 << 0)
+#define PCIE_ATU_REGION_INDEX0		(0x0 << 0)
+#define PCIE_ATU_TYPE_MEM		(0x0 << 0)
+#define PCIE_ATU_TYPE_IO		(0x2 << 0)
+#define PCIE_ATU_TYPE_CFG0		(0x4 << 0)
+#define PCIE_ATU_TYPE_CFG1		(0x5 << 0)
+#define PCIE_ATU_ENABLE			(0x1 << 31)
+#define PCIE_ATU_BAR_MODE_ENABLE	(0x1 << 30)
+#define PCIE_ATU_BUS(x)			(((x) & 0xff) << 24)
+#define PCIE_ATU_DEV(x)			(((x) & 0x1f) << 19)
+#define PCIE_ATU_FUNC(x)		(((x) & 0x7) << 16)
+
+/* Register address builder */
+#define PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(region)	((region) << 9)
+
+/* Offsets from App base */
+#define PCIE_CMD_STATUS			0x04
+#define LTSSM_EN_VAL			BIT(0)
+
+/* Parameters for the waiting for iATU enabled routine */
+#define LINK_WAIT_MAX_IATU_RETRIES	5
+#define LINK_WAIT_IATU			10000
+
+#define AM654_PCIE_DEV_TYPE_MASK	0x3
+#define EP				0x0
+#define LEG_EP				0x1
+#define RC				0x2
+
+/**
+ * struct pcie_dw_ti - TI DW PCIe controller state
+ *
+ * @app_base: The base address of application register space
+ * @dbics_base: The base address of dbics register space
+ * @cfg_base: The base address of configuration space
+ * @atu_base: The base address of ATU space
+ * @cfg_size: The size of the configuration space which is needed
+ *            as it gets written into the PCIE_ATU_LIMIT register
+ * @first_busno: This driver supports multiple PCIe controllers.
+ *               first_busno stores the bus number of the PCIe root-port
+ *               number which may vary depending on the PCIe setup
+ *               (PEX switches etc).
+ */
+struct pcie_dw_ti {
+	void *app_base;
+	void *dbi_base;
+	void *cfg_base;
+	void *atu_base;
+	fdt_size_t cfg_size;
+	int first_busno;
+	struct udevice *dev;
+
+	/* IO and MEM PCI regions */
+	struct pci_region io;
+	struct pci_region mem;
+};
+
+enum dw_pcie_device_mode {
+	DW_PCIE_UNKNOWN_TYPE,
+	DW_PCIE_EP_TYPE,
+	DW_PCIE_LEG_EP_TYPE,
+	DW_PCIE_RC_TYPE,
+};
+
+static int pcie_dw_get_link_speed(struct pcie_dw_ti *pci)
+{
+	return (readl(pci->dbi_base + PCIE_LINK_STATUS_REG) &
+		PCIE_LINK_STATUS_SPEED_MASK) >> PCIE_LINK_STATUS_SPEED_OFF;
+}
+
+static int pcie_dw_get_link_width(struct pcie_dw_ti *pci)
+{
+	return (readl(pci->dbi_base + PCIE_LINK_STATUS_REG) &
+		PCIE_LINK_STATUS_WIDTH_MASK) >> PCIE_LINK_STATUS_WIDTH_OFF;
+}
+
+static void dw_pcie_writel_ob_unroll(struct pcie_dw_ti *pci, u32 index, u32 reg,
+				     u32 val)
+{
+	u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index);
+	void __iomem *base = pci->atu_base;
+
+	writel(val, base + offset + reg);
+}
+
+static u32 dw_pcie_readl_ob_unroll(struct pcie_dw_ti *pci, u32 index, u32 reg)
+{
+	u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index);
+	void __iomem *base = pci->atu_base;
+
+	return readl(base + offset + reg);
+}
+
+/**
+ * pcie_dw_prog_outbound_atu_unroll() - Configure ATU for outbound accesses
+ *
+ * @pcie: Pointer to the PCI controller state
+ * @index: ATU region index
+ * @type: ATU accsess type
+ * @cpu_addr: the physical address for the translation entry
+ * @pci_addr: the pcie bus address for the translation entry
+ * @size: the size of the translation entry
+ */
+static void pcie_dw_prog_outbound_atu_unroll(struct pcie_dw_ti *pci, int index,
+					     int type, u64 cpu_addr,
+					     u64 pci_addr, u32 size)
+{
+	u32 retries, val;
+
+	debug("ATU programmed with: index: %d, type: %d, cpu addr: %8llx, pci addr: %8llx, size: %8x\n",
+	      index, type, cpu_addr, pci_addr, size);
+
+	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_LIMIT,
+				 lower_32_bits(cpu_addr + size - 1));
+	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));
+	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL1,
+				 type);
+	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;
+
+		udelay(LINK_WAIT_IATU);
+	}
+	dev_err(pci->dev, "outbound iATU is not being enabled\n");
+}
+
+/**
+ * set_cfg_address() - Configure the PCIe controller config space access
+ *
+ * @pcie: Pointer to the PCI controller state
+ * @d: PCI device to access
+ * @where: Offset in the configuration space
+ *
+ * Configures the PCIe controller to access the configuration space of
+ * a specific PCIe device and returns the address to use for this
+ * access.
+ *
+ * Return: Address that can be used to access the configation space
+ *         of the requested device / offset
+ */
+static uintptr_t set_cfg_address(struct pcie_dw_ti *pcie,
+				 pci_dev_t d, uint where)
+{
+	int bus = PCI_BUS(d) - pcie->first_busno;
+	uintptr_t va_address;
+	u32 atu_type;
+
+	/* Use dbi_base for own configuration read and write */
+	if (!bus) {
+		va_address = (uintptr_t)pcie->dbi_base;
+		goto out;
+	}
+
+	if (bus == 1)
+		/* For local bus, change TLP Type field to 4. */
+		atu_type = PCIE_ATU_TYPE_CFG0;
+	else
+		/* Otherwise, change TLP Type field to 5. */
+		atu_type = PCIE_ATU_TYPE_CFG1;
+
+	/*
+	 * Not accessing root port configuration space?
+	 * Region #0 is used for Outbound CFG space access.
+	 * Direction = Outbound
+	 * Region Index = 0
+	 */
+	d = PCI_MASK_BUS(d);
+	d = PCI_ADD_BUS(bus, d);
+	pcie_dw_prog_outbound_atu_unroll(pcie, PCIE_ATU_REGION_INDEX1,
+					 atu_type, (u64)pcie->cfg_base,
+					 d << 8, pcie->cfg_size);
+
+	va_address = (uintptr_t)pcie->cfg_base;
+
+out:
+	va_address += where & ~0x3;
+
+	return va_address;
+}
+
+/**
+ * pcie_dw_addr_valid() - Check for valid bus address
+ *
+ * @d: The PCI device to access
+ * @first_busno: Bus number of the PCIe controller root complex
+ *
+ * Return 1 (true) if the PCI device can be accessed by this controller.
+ *
+ * Return: 1 on valid, 0 on invalid
+ */
+static int pcie_dw_addr_valid(pci_dev_t d, int first_busno)
+{
+	if ((PCI_BUS(d) == first_busno) && (PCI_DEV(d) > 0))
+		return 0;
+	if ((PCI_BUS(d) == first_busno + 1) && (PCI_DEV(d) > 0))
+		return 0;
+
+	return 1;
+}
+
+/**
+ * pcie_dw_ti_read_config() - Read from configuration space
+ *
+ * @bus: Pointer to the PCI bus
+ * @bdf: Identifies the PCIe device to access
+ * @offset: The offset into the device's configuration space
+ * @valuep: A pointer at which to store the read value
+ * @size: Indicates the size of access to perform
+ *
+ * Read a value of size @size from offset @offset within the configuration
+ * space of the device identified by the bus, device & function numbers in @bdf
+ * on the PCI bus @bus.
+ *
+ * Return: 0 on success
+ */
+static int pcie_dw_ti_read_config(struct udevice *bus, pci_dev_t bdf,
+				  uint offset, ulong *valuep,
+				  enum pci_size_t size)
+{
+	struct pcie_dw_ti *pcie = dev_get_priv(bus);
+	uintptr_t va_address;
+	ulong value;
+
+	debug("PCIE CFG read: bdf=%2x:%2x:%2x ",
+	      PCI_BUS(bdf), PCI_DEV(bdf), PCI_FUNC(bdf));
+
+	if (!pcie_dw_addr_valid(bdf, pcie->first_busno)) {
+		debug("- out of range\n");
+		*valuep = pci_get_ff(size);
+		return 0;
+	}
+
+	va_address = set_cfg_address(pcie, bdf, offset);
+
+	value = readl(va_address);
+
+	debug("(addr,val)=(0x%04x, 0x%08lx)\n", offset, value);
+	*valuep = pci_conv_32_to_size(value, offset, size);
+
+	pcie_dw_prog_outbound_atu_unroll(pcie, PCIE_ATU_REGION_INDEX1,
+					 PCIE_ATU_TYPE_IO, pcie->io.phys_start,
+					 pcie->io.bus_start, pcie->io.size);
+
+	return 0;
+}
+
+/**
+ * pcie_dw_ti_write_config() - Write to configuration space
+ *
+ * @bus: Pointer to the PCI bus
+ * @bdf: Identifies the PCIe device to access
+ * @offset: The offset into the device's configuration space
+ * @value: The value to write
+ * @size: Indicates the size of access to perform
+ *
+ * Write the value @value of size @size from offset @offset within the
+ * configuration space of the device identified by the bus, device & function
+ * numbers in @bdf on the PCI bus @bus.
+ *
+ * Return: 0 on success
+ */
+static int pcie_dw_ti_write_config(struct udevice *bus, pci_dev_t bdf,
+				   uint offset, ulong value,
+				   enum pci_size_t size)
+{
+	struct pcie_dw_ti *pcie = dev_get_priv(bus);
+	uintptr_t va_address;
+	ulong old;
+
+	debug("PCIE CFG write: (b,d,f)=(%2d,%2d,%2d) ",
+	      PCI_BUS(bdf), PCI_DEV(bdf), PCI_FUNC(bdf));
+	debug("(addr,val)=(0x%04x, 0x%08lx)\n", offset, value);
+
+	if (!pcie_dw_addr_valid(bdf, pcie->first_busno)) {
+		debug("- out of range\n");
+		return 0;
+	}
+
+	va_address = set_cfg_address(pcie, bdf, offset);
+
+	old = readl(va_address);
+	value = pci_conv_size_to_32(old, value, offset, size);
+	writel(value, va_address);
+
+	pcie_dw_prog_outbound_atu_unroll(pcie, PCIE_ATU_REGION_INDEX1,
+					 PCIE_ATU_TYPE_IO, pcie->io.phys_start,
+					 pcie->io.bus_start, pcie->io.size);
+
+	return 0;
+}
+
+static inline void dw_pcie_dbi_write_enable(struct pcie_dw_ti *pci, bool en)
+{
+	u32 val;
+
+	val = readl(pci->dbi_base + PCIE_MISC_CONTROL_1_OFF);
+	if (en)
+		val |= PCIE_DBI_RO_WR_EN;
+	else
+		val &= ~PCIE_DBI_RO_WR_EN;
+	writel(val, pci->dbi_base + PCIE_MISC_CONTROL_1_OFF);
+}
+
+/**
+ * pcie_dw_configure() - Configure link capabilities and speed
+ *
+ * @regs_base: A pointer to the PCIe controller registers
+ * @cap_speed: The capabilities and speed to configure
+ *
+ * Configure the link capabilities and speed in the PCIe root complex.
+ */
+static void pcie_dw_configure(struct pcie_dw_ti *pci, u32 cap_speed)
+{
+	u32 val;
+
+	dw_pcie_dbi_write_enable(pci, true);
+
+	val = readl(pci->dbi_base + PCIE_LINK_CAPABILITY);
+	val &= ~TARGET_LINK_SPEED_MASK;
+	val |= cap_speed;
+	writel(val, pci->dbi_base + PCIE_LINK_CAPABILITY);
+
+	val = readl(pci->dbi_base + PCIE_LINK_CTL_2);
+	val &= ~TARGET_LINK_SPEED_MASK;
+	val |= cap_speed;
+	writel(val, pci->dbi_base + PCIE_LINK_CTL_2);
+
+	dw_pcie_dbi_write_enable(pci, false);
+}
+
+/**
+ * is_link_up() - Return the link state
+ *
+ * @regs_base: A pointer to the PCIe DBICS registers
+ *
+ * Return: 1 (true) for active line and 0 (false) for no link
+ */
+static int is_link_up(struct pcie_dw_ti *pci)
+{
+	u32 val;
+
+	val = readl(pci->dbi_base + PCIE_PORT_DEBUG0);
+	val &= PORT_LOGIC_LTSSM_STATE_MASK;
+
+	return (val == PORT_LOGIC_LTSSM_STATE_L0);
+}
+
+/**
+ * wait_link_up() - Wait for the link to come up
+ *
+ * @regs_base: A pointer to the PCIe controller registers
+ *
+ * Return: 1 (true) for active line and 0 (false) for no link (timeout)
+ */
+static int wait_link_up(struct pcie_dw_ti *pci)
+{
+	unsigned long timeout;
+
+	timeout = get_timer(0) + PCIE_LINK_UP_TIMEOUT_MS;
+	while (!is_link_up(pci)) {
+		if (get_timer(0) > timeout)
+			return 0;
+	};
+
+	return 1;
+}
+
+static int pcie_dw_ti_pcie_link_up(struct pcie_dw_ti *pci, u32 cap_speed)
+{
+	u32 val;
+
+	if (is_link_up(pci)) {
+		printf("PCI Link already up before configuration!\n");
+		return 1;
+	}
+
+	/* DW pre link configurations */
+	pcie_dw_configure(pci, cap_speed);
+
+	/* Initiate link training */
+	val = readl(pci->app_base + PCIE_CMD_STATUS);
+	val |= LTSSM_EN_VAL;
+	writel(val, pci->app_base + PCIE_CMD_STATUS);
+
+	/* Check that link was established */
+	if (!wait_link_up(pci))
+		return 0;
+
+	/*
+	 * Link can be established in Gen 1. still need to wait
+	 * till MAC nagaotiation is completed
+	 */
+	udelay(100);
+
+	return 1;
+}
+
+/**
+ * pcie_dw_setup_host() - Setup the PCIe controller for RC opertaion
+ *
+ * @pcie: Pointer to the PCI controller state
+ *
+ * Configure the host BARs of the PCIe controller root port so that
+ * PCI(e) devices may access the system memory.
+ */
+static void pcie_dw_setup_host(struct pcie_dw_ti *pci)
+{
+	u32 val;
+
+	/* setup RC BARs */
+	writel(PCI_BASE_ADDRESS_MEM_TYPE_64,
+	       pci->dbi_base + PCI_BASE_ADDRESS_0);
+	writel(0x0, pci->dbi_base + PCI_BASE_ADDRESS_1);
+
+	/* setup interrupt pins */
+	dw_pcie_dbi_write_enable(pci, true);
+	val = readl(pci->dbi_base + PCI_INTERRUPT_LINE);
+	val &= 0xffff00ff;
+	val |= 0x00000100;
+	writel(val, pci->dbi_base + PCI_INTERRUPT_LINE);
+	dw_pcie_dbi_write_enable(pci, false);
+
+	/* setup bus numbers */
+	val = readl(pci->dbi_base + PCI_PRIMARY_BUS);
+	val &= 0xff000000;
+	val |= 0x00ff0100;
+	writel(val, pci->dbi_base + PCI_PRIMARY_BUS);
+
+	/* setup command register */
+	val = readl(pci->dbi_base + PCI_COMMAND);
+	val &= 0xffff0000;
+	val |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY |
+		PCI_COMMAND_MASTER | PCI_COMMAND_SERR;
+	writel(val, pci->dbi_base + PCI_COMMAND);
+
+	/* Enable write permission for the DBI read-only register */
+	dw_pcie_dbi_write_enable(pci, true);
+	/* program correct class for RC */
+	writew(PCI_CLASS_BRIDGE_PCI, pci->dbi_base + PCI_CLASS_DEVICE);
+	/* Better disable write permission right after the update */
+	dw_pcie_dbi_write_enable(pci, false);
+
+	val = readl(pci->dbi_base + PCIE_LINK_WIDTH_SPEED_CONTROL);
+	val |= PORT_LOGIC_SPEED_CHANGE;
+	writel(val, pci->dbi_base + PCIE_LINK_WIDTH_SPEED_CONTROL);
+}
+
+static int pcie_am654_set_mode(struct pcie_dw_ti *pci,
+			       enum dw_pcie_device_mode mode)
+{
+	struct regmap *syscon;
+	u32 val;
+	u32 mask;
+	int ret;
+
+	syscon = syscon_regmap_lookup_by_phandle(pci->dev,
+						 "ti,syscon-pcie-mode");
+	if (IS_ERR(syscon))
+		return 0;
+
+	mask = AM654_PCIE_DEV_TYPE_MASK;
+
+	switch (mode) {
+	case DW_PCIE_RC_TYPE:
+		val = RC;
+		break;
+	case DW_PCIE_EP_TYPE:
+		val = EP;
+		break;
+	default:
+		dev_err(pci->dev, "INVALID device type %d\n", mode);
+		return -EINVAL;
+	}
+
+	ret = regmap_update_bits(syscon, 0, mask, val);
+	if (ret) {
+		dev_err(pci->dev, "failed to set pcie mode\n");
+		return ret;
+	}
+
+	return 0;
+}
+
+static int pcie_dw_init_id(struct pcie_dw_ti *pci)
+{
+	struct regmap *devctrl_regs;
+	unsigned int id;
+	int ret;
+
+	devctrl_regs = syscon_regmap_lookup_by_phandle(pci->dev,
+						       "ti,syscon-pcie-id");
+	if (IS_ERR(devctrl_regs))
+		return PTR_ERR(devctrl_regs);
+
+	ret = regmap_read(devctrl_regs, 0, &id);
+	if (ret)
+		return ret;
+
+	dw_pcie_dbi_write_enable(pci, true);
+	writew(id & PCIE_VENDORID_MASK, pci->dbi_base + PCI_VENDOR_ID);
+	writew(id >> PCIE_DEVICEID_SHIFT, pci->dbi_base + PCI_DEVICE_ID);
+	dw_pcie_dbi_write_enable(pci, false);
+
+	return 0;
+}
+
+/**
+ * pcie_dw_ti_probe() - Probe the PCIe bus for active link
+ *
+ * @dev: A pointer to the device being operated on
+ *
+ * Probe for an active link on the PCIe bus and configure the controller
+ * to enable this port.
+ *
+ * Return: 0 on success, else -ENODEV
+ */
+static int pcie_dw_ti_probe(struct udevice *dev)
+{
+	struct pcie_dw_ti *pci = dev_get_priv(dev);
+	struct udevice *ctlr = pci_get_controller(dev);
+	struct pci_controller *hose = dev_get_uclass_priv(ctlr);
+	struct power_domain pci_pwrdmn;
+	struct phy phy0, phy1;
+	int ret;
+
+	ret = power_domain_get_by_index(dev, &pci_pwrdmn, 0);
+	if (ret) {
+		dev_err(dev, "failed to get power domain\n");
+		return ret;
+	}
+
+	ret = power_domain_on(&pci_pwrdmn);
+	if (ret) {
+		dev_err(dev, "Power domain on failed\n");
+		return ret;
+	}
+
+	ret = generic_phy_get_by_name(dev,  "pcie-phy0", &phy0);
+	if (ret) {
+		dev_err(dev, "Unable to get phy0");
+		return ret;
+	}
+	generic_phy_reset(&phy0);
+	generic_phy_init(&phy0);
+	generic_phy_power_on(&phy0);
+
+	ret = generic_phy_get_by_name(dev,  "pcie-phy1", &phy1);
+	if (ret) {
+		dev_err(dev, "Unable to get phy1");
+		return ret;
+	}
+	generic_phy_reset(&phy1);
+	generic_phy_init(&phy1);
+	generic_phy_power_on(&phy1);
+
+	pci->first_busno = dev->seq;
+	pci->dev = dev;
+
+	pcie_dw_setup_host(pci);
+	pcie_dw_init_id(pci);
+
+	if (device_is_compatible(dev, "ti,am654-pcie-rc"))
+		pcie_am654_set_mode(pci, DW_PCIE_RC_TYPE);
+
+	if (!pcie_dw_ti_pcie_link_up(pci, LINK_SPEED_GEN_2)) {
+		printf("PCIE-%d: Link down\n", dev->seq);
+		return -ENODEV;
+	}
+
+	printf("PCIE-%d: Link up (Gen%d-x%d, Bus%d)\n", dev->seq,
+	       pcie_dw_get_link_speed(pci),
+	       pcie_dw_get_link_width(pci),
+	       hose->first_busno);
+
+	/* Store the IO and MEM windows settings for future use by the ATU */
+	pci->io.phys_start = hose->regions[0].phys_start; /* IO base */
+	pci->io.bus_start  = hose->regions[0].bus_start;  /* IO_bus_addr */
+	pci->io.size	    = hose->regions[0].size;	   /* IO size */
+
+	pci->mem.phys_start = hose->regions[1].phys_start; /* MEM base */
+	pci->mem.bus_start  = hose->regions[1].bus_start;  /* MEM_bus_addr */
+	pci->mem.size	     = hose->regions[1].size;	    /* MEM size */
+
+	pcie_dw_prog_outbound_atu_unroll(pci, PCIE_ATU_REGION_INDEX0,
+					 PCIE_ATU_TYPE_MEM,
+					 pci->mem.phys_start,
+					 pci->mem.bus_start, pci->mem.size);
+
+	return 0;
+}
+
+/**
+ * pcie_dw_ti_ofdata_to_platdata() - Translate from DT to device state
+ *
+ * @dev: A pointer to the device being operated on
+ *
+ * Translate relevant data from the device tree pertaining to device @dev into
+ * state that the driver will later make use of. This state is stored in the
+ * device's private data structure.
+ *
+ * Return: 0 on success, else -EINVAL
+ */
+static int pcie_dw_ti_ofdata_to_platdata(struct udevice *dev)
+{
+	struct pcie_dw_ti *pcie = dev_get_priv(dev);
+
+	/* Get the controller base address */
+	pcie->dbi_base = (void *)dev_read_addr_name(dev, "dbics");
+	if ((fdt_addr_t)pcie->dbi_base == FDT_ADDR_T_NONE)
+		return -EINVAL;
+
+	/* Get the config space base address and size */
+	pcie->cfg_base = (void *)dev_read_addr_size_name(dev, "config",
+							 &pcie->cfg_size);
+	if ((fdt_addr_t)pcie->cfg_base == FDT_ADDR_T_NONE)
+		return -EINVAL;
+
+	/* Get the iATU base address and size */
+	pcie->atu_base = (void *)dev_read_addr_name(dev, "atu");
+	if ((fdt_addr_t)pcie->atu_base == FDT_ADDR_T_NONE)
+		return -EINVAL;
+
+	/* Get the app base address and size */
+	pcie->app_base = (void *)dev_read_addr_name(dev, "app");
+	if ((fdt_addr_t)pcie->app_base == FDT_ADDR_T_NONE)
+		return -EINVAL;
+
+	return 0;
+}
+
+static const struct dm_pci_ops pcie_dw_ti_ops = {
+	.read_config	= pcie_dw_ti_read_config,
+	.write_config	= pcie_dw_ti_write_config,
+};
+
+static const struct udevice_id pcie_dw_ti_ids[] = {
+	{ .compatible = "ti,am654-pcie-rc" },
+	{ }
+};
+
+U_BOOT_DRIVER(pcie_dw_ti) = {
+	.name			= "pcie_dw_ti",
+	.id			= UCLASS_PCI,
+	.of_match		= pcie_dw_ti_ids,
+	.ops			= &pcie_dw_ti_ops,
+	.ofdata_to_platdata	= pcie_dw_ti_ofdata_to_platdata,
+	.probe			= pcie_dw_ti_probe,
+	.priv_auto_alloc_size	= sizeof(struct pcie_dw_ti),
+};
-- 
2.16.2

^ permalink raw reply related	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 4/7] phy: add support for AM654x SERDES
  2019-08-01 13:42 [U-Boot] [PATCH v3 0/7] Add PCIe root complex support for AM654x SoC Sekhar Nori
                   ` (2 preceding siblings ...)
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 3/7] pcie: ti: add driver for AM65x PCIe RC Sekhar Nori
@ 2019-08-01 13:42 ` Sekhar Nori
  2019-08-13 16:51   ` Tom Rini
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 5/7] configs: am65x_evm_a53: enable PCIe support Sekhar Nori
                   ` (2 subsequent siblings)
  6 siblings, 1 reply; 21+ messages in thread
From: Sekhar Nori @ 2019-08-01 13:42 UTC (permalink / raw)
  To: u-boot

Add a new SERDES driver for TI's AM654x SoC which configures
the SERDES only for PCIe. Support fo USB3 can be added later.

SERDES in am654x has three input clocks (left input, external
reference clock and right input) and two output clocks (left
output and right output) in addition to a PLL mux clock which
the SERDES uses for Clock Multiplier Unit (CMU refclock).

The PLL mux clock can select from one of the three input
clocks. The right output can select between left input and
external reference clock while the left output can select
between the right input and external reference clock.

The driver has support to select PLL mux and left/right output
mux as specified in device tree.

Signed-off-by: Sekhar Nori <nsekhar@ti.com>
---
 drivers/phy/Kconfig        |   9 +
 drivers/phy/Makefile       |   1 +
 drivers/phy/phy-ti-am654.c | 411 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 421 insertions(+)
 create mode 100644 drivers/phy/phy-ti-am654.c

diff --git a/drivers/phy/Kconfig b/drivers/phy/Kconfig
index 957efb3984bf..cce98448a4b5 100644
--- a/drivers/phy/Kconfig
+++ b/drivers/phy/Kconfig
@@ -102,6 +102,15 @@ config SPL_PIPE3_PHY
 	  This PHY is found on omap devices supporting SATA such as dra7, am57x
 	  and omap5
 
+config AM654_PHY
+	tristate "TI AM654 SERDES support"
+	depends on PHY && ARCH_K3
+	select REGMAP
+	select SYSCON
+	help
+	  This option enables support for TI AM654 SerDes PHY used for
+	  PCIe.
+
 config STI_USB_PHY
 	bool "STMicroelectronics USB2 picoPHY driver for STiH407 family"
 	depends on PHY && ARCH_STI
diff --git a/drivers/phy/Makefile b/drivers/phy/Makefile
index 90646ca55b9d..39da13c4c941 100644
--- a/drivers/phy/Makefile
+++ b/drivers/phy/Makefile
@@ -11,6 +11,7 @@ obj-$(CONFIG_BCM6358_USBH_PHY) += bcm6358-usbh-phy.o
 obj-$(CONFIG_BCM6368_USBH_PHY) += bcm6368-usbh-phy.o
 obj-$(CONFIG_PHY_SANDBOX) += sandbox-phy.o
 obj-$(CONFIG_$(SPL_)PIPE3_PHY) += ti-pipe3-phy.o
+obj-$(CONFIG_AM654_PHY) += phy-ti-am654.o
 obj-$(CONFIG_STI_USB_PHY) += sti_usb_phy.o
 obj-$(CONFIG_PHY_RCAR_GEN2) += phy-rcar-gen2.o
 obj-$(CONFIG_PHY_RCAR_GEN3) += phy-rcar-gen3.o
diff --git a/drivers/phy/phy-ti-am654.c b/drivers/phy/phy-ti-am654.c
new file mode 100644
index 000000000000..39490124eabf
--- /dev/null
+++ b/drivers/phy/phy-ti-am654.c
@@ -0,0 +1,411 @@
+// SPDX-License-Identifier: GPL-2.0+
+/**
+ * PCIe SERDES driver for AM654x SoC
+ *
+ * Copyright (C) 2018 Texas Instruments
+ * Author: Kishon Vijay Abraham I <kishon@ti.com>
+ */
+
+#include <common.h>
+#include <clk-uclass.h>
+#include <dm.h>
+#include <dm/device.h>
+#include <dm/lists.h>
+#include <dt-bindings/phy/phy.h>
+#include <generic-phy.h>
+#include <asm/io.h>
+#include <asm/arch/sys_proto.h>
+#include <power-domain.h>
+#include <regmap.h>
+#include <syscon.h>
+
+#define CMU_R07C		0x7c
+#define CMU_MASTER_CDN_O	BIT(24)
+
+#define COMLANE_R138		0xb38
+#define CONFIG_VERSION_REG_MASK	GENMASK(23, 16)
+#define CONFIG_VERSION_REG_SHIFT 16
+#define VERSION			0x70
+
+#define COMLANE_R190		0xb90
+#define L1_MASTER_CDN_O		BIT(9)
+
+#define COMLANE_R194		0xb94
+#define CMU_OK_I_0		BIT(19)
+
+#define SERDES_CTRL		0x1fd0
+#define POR_EN			BIT(29)
+
+#define WIZ_LANEXCTL_STS	0x1fe0
+#define TX0_ENABLE_OVL		BIT(31)
+#define TX0_ENABLE_MASK		GENMASK(30, 29)
+#define TX0_ENABLE_SHIFT	29
+#define TX0_DISABLE_STATE	0x0
+#define TX0_SLEEP_STATE		0x1
+#define TX0_SNOOZE_STATE	0x2
+#define TX0_ENABLE_STATE	0x3
+#define RX0_ENABLE_OVL		BIT(15)
+#define RX0_ENABLE_MASK		GENMASK(14, 13)
+#define RX0_ENABLE_SHIFT	13
+#define RX0_DISABLE_STATE	0x0
+#define RX0_SLEEP_STATE		0x1
+#define RX0_SNOOZE_STATE	0x2
+#define RX0_ENABLE_STATE	0x3
+
+#define WIZ_PLL_CTRL		0x1ff4
+#define PLL_ENABLE_OVL		BIT(31)
+#define PLL_ENABLE_MASK		GENMASK(30, 29)
+#define PLL_ENABLE_SHIFT	29
+#define PLL_DISABLE_STATE	0x0
+#define PLL_SLEEP_STATE		0x1
+#define PLL_SNOOZE_STATE	0x2
+#define PLL_ENABLE_STATE	0x3
+#define PLL_OK			BIT(28)
+
+#define PLL_LOCK_TIME		1000	/* in milliseconds */
+#define SLEEP_TIME		100	/* in microseconds */
+
+#define LANE_USB3		0x0
+#define LANE_PCIE0_LANE0	0x1
+
+#define LANE_PCIE1_LANE0	0x0
+#define LANE_PCIE0_LANE1	0x1
+
+#define SERDES_NUM_CLOCKS	3
+
+/* SERDES control MMR bit offsets */
+#define SERDES_CTL_LANE_FUNC_SEL_SHIFT	0
+#define SERDES_CTL_LANE_FUNC_SEL_MASK	GENMASK(1, 0)
+#define SERDES_CTL_CLK_SEL_SHIFT	4
+#define SERDES_CTL_CLK_SEL_MASK		GENMASK(7, 4)
+
+/**
+ * struct serdes_am654_mux_clk_data - clock controller information structure
+ */
+struct serdes_am654_mux_clk_data {
+	struct regmap *regmap;
+	struct clk_bulk parents;
+};
+
+static int serdes_am654_mux_clk_probe(struct udevice *dev)
+{
+	struct serdes_am654_mux_clk_data *data = dev_get_priv(dev);
+	struct udevice *syscon;
+	struct regmap *regmap;
+	int ret;
+
+	debug("%s(dev=%s)\n", __func__, dev->name);
+
+	if (!data)
+		return -ENOMEM;
+
+	ret = uclass_get_device_by_phandle(UCLASS_SYSCON, dev,
+					   "ti,serdes-clk", &syscon);
+	if (ret) {
+		dev_err(dev, "unable to find syscon device\n");
+		return ret;
+	}
+
+	regmap = syscon_get_regmap(syscon);
+	if (IS_ERR(regmap)) {
+		dev_err(dev, "Fail to get Syscon regmap\n");
+		return PTR_ERR(regmap);
+	}
+
+	data->regmap = regmap;
+
+	ret = clk_get_bulk(dev, &data->parents);
+	if (ret) {
+		dev_err(dev, "Failed to obtain parent clocks\n");
+		return ret;
+	}
+
+	return 0;
+}
+
+static int mux_table[SERDES_NUM_CLOCKS][3] = {
+	/*
+	 * The entries represent values for selecting between
+	 * {left input, external reference clock, right input}
+	 * Only one of Left Output or Right Output should be used since
+	 * both left and right output clock uses the same bits and modifying
+	 * one clock will impact the other.
+	 */
+	{ BIT(2),               0, BIT(0) }, /* Mux of CMU refclk */
+	{     -1,          BIT(3), BIT(1) }, /* Mux of Left Output */
+	{ BIT(1), BIT(3) | BIT(1),     -1 }, /* Mux of Right Output */
+};
+
+static int serdes_am654_mux_clk_set_parent(struct clk *clk, struct clk *parent)
+{
+	struct serdes_am654_mux_clk_data *data = dev_get_priv(clk->dev);
+	u32 val;
+	int i;
+
+	debug("%s(clk=%s, parent=%s)\n", __func__, clk->dev->name,
+	      parent->dev->name);
+
+	/*
+	 * Since we have the same device-tree node represent both the
+	 * clock and serdes device, we have two devices associated with
+	 * the serdes node. assigned-clocks for this node is processed twice,
+	 * once for the clock device and another time for the serdes
+	 * device. When it is processed for the clock device, it is before
+	 * the probe for clock device has been called. We ignore this case
+	 * and rely on assigned-clocks to be processed correctly for the
+	 * serdes case.
+	 */
+	if (!data->regmap)
+		return 0;
+
+	for (i = 0; i < data->parents.count; i++) {
+		if (clk_is_match(&data->parents.clks[i], parent))
+			break;
+	}
+
+	if (i >= data->parents.count)
+		return -EINVAL;
+
+	val = mux_table[clk->id][i];
+	val <<= SERDES_CTL_CLK_SEL_SHIFT;
+
+	regmap_update_bits(data->regmap, 0, SERDES_CTL_CLK_SEL_MASK, val);
+
+	return 0;
+}
+
+static struct clk_ops serdes_am654_mux_clk_ops = {
+	.set_parent = serdes_am654_mux_clk_set_parent,
+};
+
+U_BOOT_DRIVER(serdes_am654_mux_clk) = {
+	.name = "ti-serdes-am654-mux-clk",
+	.id = UCLASS_CLK,
+	.probe = serdes_am654_mux_clk_probe,
+	.priv_auto_alloc_size = sizeof(struct serdes_am654_mux_clk_data),
+	.ops = &serdes_am654_mux_clk_ops,
+};
+
+struct serdes_am654 {
+	struct regmap *regmap;
+	struct regmap *serdes_ctl;
+};
+
+static int serdes_am654_enable_pll(struct serdes_am654 *phy)
+{
+	u32 mask = PLL_ENABLE_OVL | PLL_ENABLE_MASK;
+	u32 val = PLL_ENABLE_OVL | (PLL_ENABLE_STATE << PLL_ENABLE_SHIFT);
+
+	regmap_update_bits(phy->regmap, WIZ_PLL_CTRL, mask, val);
+
+	return regmap_read_poll_timeout(phy->regmap, WIZ_PLL_CTRL, val,
+					val & PLL_OK, 1000, PLL_LOCK_TIME);
+}
+
+static void serdes_am654_disable_pll(struct serdes_am654 *phy)
+{
+	u32 mask = PLL_ENABLE_OVL | PLL_ENABLE_MASK;
+
+	regmap_update_bits(phy->regmap, WIZ_PLL_CTRL, mask, 0);
+}
+
+static int serdes_am654_enable_txrx(struct serdes_am654 *phy)
+{
+	u32 mask;
+	u32 val;
+
+	/* Enable TX */
+	mask = TX0_ENABLE_OVL | TX0_ENABLE_MASK;
+	val = TX0_ENABLE_OVL | (TX0_ENABLE_STATE << TX0_ENABLE_SHIFT);
+	regmap_update_bits(phy->regmap, WIZ_LANEXCTL_STS, mask, val);
+
+	/* Enable RX */
+	mask = RX0_ENABLE_OVL | RX0_ENABLE_MASK;
+	val = RX0_ENABLE_OVL | (RX0_ENABLE_STATE << RX0_ENABLE_SHIFT);
+	regmap_update_bits(phy->regmap, WIZ_LANEXCTL_STS, mask, val);
+
+	return 0;
+}
+
+static int serdes_am654_disable_txrx(struct serdes_am654 *phy)
+{
+	u32 mask;
+
+	/* Disable TX */
+	mask = TX0_ENABLE_OVL | TX0_ENABLE_MASK;
+	regmap_update_bits(phy->regmap, WIZ_LANEXCTL_STS, mask, 0);
+
+	/* Disable RX */
+	mask = RX0_ENABLE_OVL | RX0_ENABLE_MASK;
+	regmap_update_bits(phy->regmap, WIZ_LANEXCTL_STS, mask, 0);
+
+	return 0;
+}
+
+static int serdes_am654_power_on(struct phy *x)
+{
+	struct serdes_am654 *phy = dev_get_priv(x->dev);
+	int ret;
+	u32 val;
+
+	ret = serdes_am654_enable_pll(phy);
+	if (ret) {
+		dev_err(x->dev, "Failed to enable PLL\n");
+		return ret;
+	}
+
+	ret = serdes_am654_enable_txrx(phy);
+	if (ret) {
+		dev_err(x->dev, "Failed to enable TX RX\n");
+		return ret;
+	}
+
+	return regmap_read_poll_timeout(phy->regmap, COMLANE_R194, val,
+					val & CMU_OK_I_0, SLEEP_TIME,
+					PLL_LOCK_TIME);
+}
+
+static int serdes_am654_power_off(struct phy *x)
+{
+	struct serdes_am654 *phy = dev_get_priv(x->dev);
+
+	serdes_am654_disable_txrx(phy);
+	serdes_am654_disable_pll(phy);
+
+	return 0;
+}
+
+static int serdes_am654_init(struct phy *x)
+{
+	struct serdes_am654 *phy = dev_get_priv(x->dev);
+	u32 mask;
+	u32 val;
+
+	mask = CONFIG_VERSION_REG_MASK;
+	val = VERSION << CONFIG_VERSION_REG_SHIFT;
+	regmap_update_bits(phy->regmap, COMLANE_R138, mask, val);
+
+	val = CMU_MASTER_CDN_O;
+	regmap_update_bits(phy->regmap, CMU_R07C, val, val);
+
+	val = L1_MASTER_CDN_O;
+	regmap_update_bits(phy->regmap, COMLANE_R190, val, val);
+
+	return 0;
+}
+
+static int serdes_am654_reset(struct phy *x)
+{
+	struct serdes_am654 *phy = dev_get_priv(x->dev);
+	u32 val;
+
+	val = POR_EN;
+	regmap_update_bits(phy->regmap, SERDES_CTRL, val, val);
+	mdelay(1);
+	regmap_update_bits(phy->regmap, SERDES_CTRL, val, 0);
+
+	return 0;
+}
+
+static int serdes_am654_of_xlate(struct phy *x,
+				 struct ofnode_phandle_args *args)
+{
+	struct serdes_am654 *phy = dev_get_priv(x->dev);
+
+	if (args->args_count != 2) {
+		dev_err(phy->dev, "Invalid DT PHY argument count: %d\n",
+			args->args_count);
+		return -EINVAL;
+	}
+
+	if (args->args[0] != PHY_TYPE_PCIE) {
+		dev_err(phy->dev, "Unrecognized PHY type: %d\n",
+			args->args[0]);
+		return -EINVAL;
+	}
+
+	x->id = args->args[0] | (args->args[1] << 16);
+
+	/* Setup mux mode using second argument */
+	regmap_update_bits(phy->serdes_ctl, 0, SERDES_CTL_LANE_FUNC_SEL_MASK,
+			   args->args[1]);
+
+	return 0;
+}
+
+static int serdes_am654_bind(struct udevice *dev)
+{
+	int ret;
+
+	ret = device_bind_driver_to_node(dev->parent,
+					 "ti-serdes-am654-mux-clk",
+					 dev_read_name(dev), dev->node,
+					 NULL);
+	if (ret) {
+		dev_err(dev, "%s: not able to bind clock driver\n", __func__);
+		return ret;
+	}
+
+	return 0;
+}
+
+static int serdes_am654_probe(struct udevice *dev)
+{
+	struct serdes_am654 *phy = dev_get_priv(dev);
+	struct power_domain serdes_pwrdmn;
+	struct regmap *serdes_ctl;
+	struct regmap *map;
+	int ret;
+
+	ret = regmap_init_mem(dev_ofnode(dev), &map);
+	if (ret)
+		return ret;
+
+	phy->regmap = map;
+
+	serdes_ctl = syscon_regmap_lookup_by_phandle(dev, "ti,serdes-clk");
+	if (IS_ERR(serdes_ctl)) {
+		dev_err(dev, "unable to find syscon device\n");
+		return PTR_ERR(serdes_ctl);
+	}
+
+	phy->serdes_ctl = serdes_ctl;
+
+	ret = power_domain_get_by_index(dev, &serdes_pwrdmn, 0);
+	if (ret) {
+		dev_err(dev, "failed to get power domain\n");
+		return ret;
+	}
+
+	ret = power_domain_on(&serdes_pwrdmn);
+	if (ret) {
+		dev_err(dev, "Power domain on failed\n");
+		return ret;
+	}
+
+	return 0;
+}
+
+static const struct udevice_id serdes_am654_phy_ids[] = {
+	{
+		.compatible = "ti,phy-am654-serdes",
+	},
+};
+
+static const struct phy_ops serdes_am654_phy_ops = {
+	.reset		= serdes_am654_reset,
+	.init		= serdes_am654_init,
+	.power_on	= serdes_am654_power_on,
+	.power_off	= serdes_am654_power_off,
+	.of_xlate	= serdes_am654_of_xlate,
+};
+
+U_BOOT_DRIVER(am654_serdes_phy) = {
+	.name	= "am654_serdes_phy",
+	.id	= UCLASS_PHY,
+	.of_match = serdes_am654_phy_ids,
+	.bind = serdes_am654_bind,
+	.ops = &serdes_am654_phy_ops,
+	.probe = serdes_am654_probe,
+	.priv_auto_alloc_size = sizeof(struct serdes_am654),
+};
-- 
2.16.2

^ permalink raw reply related	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 5/7] configs: am65x_evm_a53: enable PCIe support
  2019-08-01 13:42 [U-Boot] [PATCH v3 0/7] Add PCIe root complex support for AM654x SoC Sekhar Nori
                   ` (3 preceding siblings ...)
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 4/7] phy: add support for AM654x SERDES Sekhar Nori
@ 2019-08-01 13:42 ` Sekhar Nori
  2019-08-13 16:51   ` Tom Rini
  2019-08-01 13:43 ` [U-Boot] [PATCH v3 6/7] arm: dts: k3-am65: add support for PCIe and SERDES Sekhar Nori
  2019-08-01 13:43 ` [U-Boot] [PATCH v3 7/7] configs: am65x_evm_a53: enable support for PCIe ethernet cards Sekhar Nori
  6 siblings, 1 reply; 21+ messages in thread
From: Sekhar Nori @ 2019-08-01 13:42 UTC (permalink / raw)
  To: u-boot

Enable support for PCIe and related configurations
on AM654 EVM platform.

Signed-off-by: Sekhar Nori <nsekhar@ti.com>
---
 configs/am65x_evm_a53_defconfig | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/configs/am65x_evm_a53_defconfig b/configs/am65x_evm_a53_defconfig
index 2cf3a693fc70..efb030549218 100644
--- a/configs/am65x_evm_a53_defconfig
+++ b/configs/am65x_evm_a53_defconfig
@@ -35,6 +35,7 @@ CONFIG_CMD_ASKENV=y
 CONFIG_CMD_GPT=y
 CONFIG_CMD_I2C=y
 CONFIG_CMD_MMC=y
+CONFIG_CMD_PCI=y
 CONFIG_CMD_REMOTEPROC=y
 # CONFIG_CMD_SETEXPR is not set
 CONFIG_CMD_TIME=y
@@ -72,6 +73,10 @@ CONFIG_PHY_FIXED=y
 CONFIG_DM_ETH=y
 CONFIG_TI_AM65_CPSW_NUSS=y
 CONFIG_PHY=y
+CONFIG_PCI=y
+CONFIG_DM_PCI=y
+CONFIG_PCI_KEYSTONE=y
+CONFIG_AM654_PHY=y
 CONFIG_PINCTRL=y
 # CONFIG_PINCTRL_GENERIC is not set
 CONFIG_SPL_PINCTRL=y
-- 
2.16.2

^ permalink raw reply related	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 6/7] arm: dts: k3-am65: add support for PCIe and SERDES
  2019-08-01 13:42 [U-Boot] [PATCH v3 0/7] Add PCIe root complex support for AM654x SoC Sekhar Nori
                   ` (4 preceding siblings ...)
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 5/7] configs: am65x_evm_a53: enable PCIe support Sekhar Nori
@ 2019-08-01 13:43 ` Sekhar Nori
  2019-08-13 16:51   ` Tom Rini
  2019-08-01 13:43 ` [U-Boot] [PATCH v3 7/7] configs: am65x_evm_a53: enable support for PCIe ethernet cards Sekhar Nori
  6 siblings, 1 reply; 21+ messages in thread
From: Sekhar Nori @ 2019-08-01 13:43 UTC (permalink / raw)
  To: u-boot

Add needed device-tree nodes to support PCIe 0
and SERDES on AM65x SoC. The nodes are kept
disabled by default.

Signed-off-by: Sekhar Nori <nsekhar@ti.com>
---
 arch/arm/dts/k3-am65-main.dtsi             | 108 +++++++++++++++++++++++++++++
 arch/arm/dts/k3-am65.dtsi                  |   1 +
 include/dt-bindings/phy/phy-am654-serdes.h |  13 ++++
 3 files changed, 122 insertions(+)
 create mode 100644 include/dt-bindings/phy/phy-am654-serdes.h

diff --git a/arch/arm/dts/k3-am65-main.dtsi b/arch/arm/dts/k3-am65-main.dtsi
index 7d0370605769..0f5da9a563d3 100644
--- a/arch/arm/dts/k3-am65-main.dtsi
+++ b/arch/arm/dts/k3-am65-main.dtsi
@@ -5,6 +5,9 @@
  * Copyright (C) 2016-2018 Texas Instruments Incorporated - http://www.ti.com/
  */
 
+#include <dt-bindings/phy/phy-am654-serdes.h>
+#include <dt-bindings/phy/phy.h>
+
 &cbass_main {
 	gic500: interrupt-controller at 1800000 {
 		compatible = "arm,gic-v3";
@@ -143,4 +146,109 @@
 		clocks = <&k3_clks 113 1>;
 		power-domains = <&k3_pds 113 TI_SCI_PD_EXCLUSIVE>;
 	};
+
+	scm_conf: scm_conf at 100000 {
+		compatible = "syscon", "simple-mfd";
+		reg = <0 0x00100000 0 0x1c000>;
+		#address-cells = <1>;
+		#size-cells = <1>;
+		ranges = <0x0 0x0 0x00100000 0x1c000>;
+
+		serdes_mux: mux-controller {
+			compatible = "mmio-mux";
+			#mux-control-cells = <1>;
+			mux-reg-masks = <0x4080 0x3>, /* SERDES0 lane select */
+					<0x4090 0x3>; /* SERDES1 lane select */
+		};
+
+		pcie0_mode: pcie-mode at 4060 {
+			compatible = "syscon";
+			reg = <0x00004060 0x4>;
+		};
+
+		pcie1_mode: pcie-mode at 4070 {
+			compatible = "syscon";
+			reg = <0x00004070 0x4>;
+		};
+
+		serdes0_clk: serdes_clk at 4080 {
+			compatible = "syscon";
+			reg = <0x00004080 0x4>;
+		};
+
+		serdes1_clk: serdes_clk at 4090 {
+			compatible = "syscon";
+			reg = <0x00004090 0x4>;
+		};
+
+		pcie_devid: pcie-devid at 210 {
+			compatible = "syscon";
+			reg = <0x00000210 0x4>;
+		};
+	};
+
+	serdes0: serdes at 900000 {
+		compatible = "ti,phy-am654-serdes";
+		reg = <0x0 0x900000 0x0 0x2000>;
+		reg-names = "serdes";
+		#phy-cells = <2>;
+		power-domains = <&k3_pds 153 TI_SCI_PD_EXCLUSIVE>;
+		clocks = <&k3_clks 153 4>, <&k3_clks 153 1>, <&serdes1 AM654_SERDES_LO_REFCLK>;
+		clock-output-names = "serdes0_cmu_refclk", "serdes0_lo_refclk", "serdes0_ro_refclk";
+		assigned-clocks = <&k3_clks 153 4>, <&serdes0 AM654_SERDES_CMU_REFCLK>;
+		assigned-clock-parents = <&k3_clks 153 8>, <&k3_clks 153 4>;
+		ti,serdes-clk = <&serdes0_clk>;
+		mux-controls = <&serdes_mux 0>;
+		#clock-cells = <1>;
+	};
+
+	serdes1: serdes at 910000 {
+		compatible = "ti,phy-am654-serdes";
+		reg = <0x0 0x910000 0x0 0x2000>;
+		reg-names = "serdes";
+		#phy-cells = <2>;
+		power-domains = <&k3_pds 154 TI_SCI_PD_EXCLUSIVE>;
+		clocks = <&serdes0 AM654_SERDES_RO_REFCLK>, <&k3_clks 154 1>, <&k3_clks 154 5>;
+		clock-output-names = "serdes1_cmu_refclk", "serdes1_lo_refclk", "serdes1_ro_refclk";
+		assigned-clocks = <&k3_clks 154 5>, <&serdes1 AM654_SERDES_CMU_REFCLK>;
+		assigned-clock-parents = <&k3_clks 154 9>, <&k3_clks 154 5>;
+		ti,serdes-clk = <&serdes1_clk>;
+		mux-controls = <&serdes_mux 1>;
+		#clock-cells = <1>;
+	};
+
+	pcie0_rc: pcie at 5500000 {
+		compatible = "ti,am654-pcie-rc";
+		reg =  <0x0 0x5500000 0x0 0x1000>, <0x0 0x5501000 0x0 0x1000>, <0x0 0x10000000 0x0 0x2000>, <0x0 0x5506000 0x0 0x1000>;
+		reg-names = "app", "dbics", "config", "atu";
+		power-domains = <&k3_pds 120 TI_SCI_PD_EXCLUSIVE>;
+		#address-cells = <3>;
+		#size-cells = <2>;
+		ranges = <0x81000000 0 0          0x0   0x10020000 0 0x00010000
+			  0x82000000 0 0x10030000 0x0   0x10030000 0 0x07FD0000>;
+		ti,syscon-pcie-id = <&pcie_devid>;
+		ti,syscon-pcie-mode = <&pcie0_mode>;
+		bus-range = <0x0 0xff>;
+		status = "disabled";
+		device_type = "pci";
+		num-lanes = <1>;
+		num-ob-windows = <16>;
+		num-viewport = <16>;
+		max-link-speed = <3>;
+		interrupts = <GIC_SPI 340 IRQ_TYPE_EDGE_RISING>;
+		#interrupt-cells = <1>;
+		interrupt-map-mask = <0 0 0 7>;
+		interrupt-map = <0 0 0 1 &pcie0_intc 0>, /* INT A */
+				<0 0 0 2 &pcie0_intc 0>, /* INT B */
+				<0 0 0 3 &pcie0_intc 0>, /* INT C */
+				<0 0 0 4 &pcie0_intc 0>; /* INT D */
+		msi-map = <0x0 &gic_its 0x0 0x10000>;
+
+		pcie0_intc: legacy-interrupt-controller at 1 {
+			interrupt-controller;
+			#interrupt-cells = <1>;
+			interrupt-parent = <&gic500>;
+			interrupts = <GIC_SPI 328 IRQ_TYPE_EDGE_RISING>;
+		};
+	};
 };
diff --git a/arch/arm/dts/k3-am65.dtsi b/arch/arm/dts/k3-am65.dtsi
index a3abd146d104..a1467a4dd4d4 100644
--- a/arch/arm/dts/k3-am65.dtsi
+++ b/arch/arm/dts/k3-am65.dtsi
@@ -69,6 +69,7 @@
 			 <0x00 0x00900000 0x00 0x00900000 0x00 0x00012000>, /* serdes */
 			 <0x00 0x01000000 0x00 0x01000000 0x00 0x0af02400>, /* Most peripherals */
 			 <0x00 0x30800000 0x00 0x30800000 0x00 0x0bc00000>, /* MAIN NAVSS */
+			 <0x00 0x10000000 0x00 0x10000000 0x00 0x10000000>, /* PCIe DAT */
 			 /* MCUSS Range */
 			 <0x00 0x28380000 0x00 0x28380000 0x00 0x03880000>,
 			 <0x00 0x40200000 0x00 0x40200000 0x00 0x00900100>,
diff --git a/include/dt-bindings/phy/phy-am654-serdes.h b/include/dt-bindings/phy/phy-am654-serdes.h
new file mode 100644
index 000000000000..e8d901729ed9
--- /dev/null
+++ b/include/dt-bindings/phy/phy-am654-serdes.h
@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * This header provides constants for AM654 SERDES.
+ */
+
+#ifndef _DT_BINDINGS_AM654_SERDES
+#define _DT_BINDINGS_AM654_SERDES
+
+#define AM654_SERDES_CMU_REFCLK	0
+#define AM654_SERDES_LO_REFCLK	1
+#define AM654_SERDES_RO_REFCLK	2
+
+#endif /* _DT_BINDINGS_AM654_SERDES */
-- 
2.16.2

^ permalink raw reply related	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 7/7] configs: am65x_evm_a53: enable support for PCIe ethernet cards
  2019-08-01 13:42 [U-Boot] [PATCH v3 0/7] Add PCIe root complex support for AM654x SoC Sekhar Nori
                   ` (5 preceding siblings ...)
  2019-08-01 13:43 ` [U-Boot] [PATCH v3 6/7] arm: dts: k3-am65: add support for PCIe and SERDES Sekhar Nori
@ 2019-08-01 13:43 ` Sekhar Nori
  2019-08-13 16:51   ` Tom Rini
  6 siblings, 1 reply; 21+ messages in thread
From: Sekhar Nori @ 2019-08-01 13:43 UTC (permalink / raw)
  To: u-boot

Enable support for Intel E1000 based PCIe ethernet cards that
can be used to test PCIe RC functionality on AM65x EVM.

Signed-off-by: Sekhar Nori <nsekhar@ti.com>
---
 configs/am65x_evm_a53_defconfig | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/configs/am65x_evm_a53_defconfig b/configs/am65x_evm_a53_defconfig
index efb030549218..edc83675d8ae 100644
--- a/configs/am65x_evm_a53_defconfig
+++ b/configs/am65x_evm_a53_defconfig
@@ -73,6 +73,9 @@ CONFIG_PHY_FIXED=y
 CONFIG_DM_ETH=y
 CONFIG_TI_AM65_CPSW_NUSS=y
 CONFIG_PHY=y
+CONFIG_DM_ETH=y
+CONFIG_E1000=y
+CONFIG_CMD_E1000=y
 CONFIG_PCI=y
 CONFIG_DM_PCI=y
 CONFIG_PCI_KEYSTONE=y
-- 
2.16.2

^ permalink raw reply related	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 1/7] clk: add support for clk_is_match()
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 1/7] clk: add support for clk_is_match() Sekhar Nori
@ 2019-08-01 13:47   ` Fabio Estevam
  2019-08-01 13:54     ` Sekhar Nori
  2019-08-13 16:51   ` Tom Rini
  1 sibling, 1 reply; 21+ messages in thread
From: Fabio Estevam @ 2019-08-01 13:47 UTC (permalink / raw)
  To: u-boot

Hi Sekhar,

On Thu, Aug 1, 2019 at 10:44 AM Sekhar Nori <nsekhar@ti.com> wrote:
>
> Add support for clk_is_match() which is required to
> know if two clock pointers point to the same exact
> physical clock.

I would suggest adding a note that this is inspired from the
clk_is_match() implementation from the Linux kernel.

Thanks

^ permalink raw reply	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 1/7] clk: add support for clk_is_match()
  2019-08-01 13:47   ` Fabio Estevam
@ 2019-08-01 13:54     ` Sekhar Nori
  2019-08-01 13:55       ` Fabio Estevam
  2019-08-01 15:50       ` Tom Rini
  0 siblings, 2 replies; 21+ messages in thread
From: Sekhar Nori @ 2019-08-01 13:54 UTC (permalink / raw)
  To: u-boot

Hi Fabio,

On 01/08/19 7:17 PM, Fabio Estevam wrote:
> Hi Sekhar,
> 
> On Thu, Aug 1, 2019 at 10:44 AM Sekhar Nori <nsekhar@ti.com> wrote:
>>
>> Add support for clk_is_match() which is required to
>> know if two clock pointers point to the same exact
>> physical clock.
> 
> I would suggest adding a note that this is inspired from the
> clk_is_match() implementation from the Linux kernel.

Sure. I assume this goes into the commit description?

Tom, should I resend or this is something that you can fix while applying?

Thanks,
Sekhar

^ permalink raw reply	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 1/7] clk: add support for clk_is_match()
  2019-08-01 13:54     ` Sekhar Nori
@ 2019-08-01 13:55       ` Fabio Estevam
  2019-08-01 15:50       ` Tom Rini
  1 sibling, 0 replies; 21+ messages in thread
From: Fabio Estevam @ 2019-08-01 13:55 UTC (permalink / raw)
  To: u-boot

Hi Sekhar,

On Thu, Aug 1, 2019 at 10:54 AM Sekhar Nori <nsekhar@ti.com> wrote:

> Sure. I assume this goes into the commit description?

Yes, correct. Thanks

^ permalink raw reply	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 1/7] clk: add support for clk_is_match()
  2019-08-01 13:54     ` Sekhar Nori
  2019-08-01 13:55       ` Fabio Estevam
@ 2019-08-01 15:50       ` Tom Rini
  1 sibling, 0 replies; 21+ messages in thread
From: Tom Rini @ 2019-08-01 15:50 UTC (permalink / raw)
  To: u-boot

On Thu, Aug 01, 2019 at 07:24:27PM +0530, Sekhar Nori wrote:
> Hi Fabio,
> 
> On 01/08/19 7:17 PM, Fabio Estevam wrote:
> > Hi Sekhar,
> > 
> > On Thu, Aug 1, 2019 at 10:44 AM Sekhar Nori <nsekhar@ti.com> wrote:
> >>
> >> Add support for clk_is_match() which is required to
> >> know if two clock pointers point to the same exact
> >> physical clock.
> > 
> > I would suggest adding a note that this is inspired from the
> > clk_is_match() implementation from the Linux kernel.
> 
> Sure. I assume this goes into the commit description?
> 
> Tom, should I resend or this is something that you can fix while applying?

Please v4 this part as I'm sure I'll otherwise forget, thanks!

-- 
Tom
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: not available
URL: <http://lists.denx.de/pipermail/u-boot/attachments/20190801/c115fd6e/attachment.sig>

^ permalink raw reply	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 2/7] dm: core: add support for getting register address and size
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 2/7] dm: core: add support for getting register address and size Sekhar Nori
@ 2019-08-01 16:21   ` Daniel Schwierzeck
  2019-08-02  6:09     ` Sekhar Nori
  2019-08-13 16:51   ` Tom Rini
  1 sibling, 1 reply; 21+ messages in thread
From: Daniel Schwierzeck @ 2019-08-01 16:21 UTC (permalink / raw)
  To: u-boot

On Thu, Aug 1, 2019 at 3:46 PM Sekhar Nori <nsekhar@ti.com> wrote:
>
> Current dev_read_*() API lacks support to get address and size
> of a "reg" property by name or index. Add support for the same.
>
> Livetree support has been added but not tested on real hardware.
>
> The existing unit tests testing reading address from device-tree
> have been updated to test address as well as size.
>
> Reviewed-by: Lokesh Vutla <lokeshvutla@ti.com>
> Signed-off-by: Sekhar Nori <nsekhar@ti.com>
> ---
>  drivers/core/fdtaddr.c | 17 +++++++++++++++++
>  drivers/core/read.c    | 20 ++++++++++++++++++++
>  include/dm/fdtaddr.h   | 18 ++++++++++++++++++
>  include/dm/read.h      | 41 +++++++++++++++++++++++++++++++++++++++++
>  test/dm/test-fdt.c     | 16 ++++++++++++----
>  5 files changed, 108 insertions(+), 4 deletions(-)
>
> diff --git a/drivers/core/fdtaddr.c b/drivers/core/fdtaddr.c
> index c2873861dacd..6850003a287b 100644
> --- a/drivers/core/fdtaddr.c
> +++ b/drivers/core/fdtaddr.c
> @@ -129,6 +129,23 @@ fdt_addr_t devfdt_get_addr_name(struct udevice *dev, const char *name)
>  #endif
>  }
>
> +fdt_addr_t devfdt_get_addr_size_name(struct udevice *dev, const char *name,
> +                                    fdt_size_t *size)
> +{
> +#if CONFIG_IS_ENABLED(OF_CONTROL)
> +       int index;
> +
> +       index = fdt_stringlist_search(gd->fdt_blob, dev_of_offset(dev),
> +                                     "reg-names", name);
> +       if (index < 0)
> +               return index;
> +
> +       return devfdt_get_addr_size_index(dev, index, size);
> +#else
> +       return FDT_ADDR_T_NONE;
> +#endif
> +}
> +
>  fdt_addr_t devfdt_get_addr(struct udevice *dev)
>  {
>         return devfdt_get_addr_index(dev, 0);
> diff --git a/drivers/core/read.c b/drivers/core/read.c
> index 1a044b05e884..8b5502de1159 100644
> --- a/drivers/core/read.c
> +++ b/drivers/core/read.c
> @@ -82,6 +82,15 @@ fdt_addr_t dev_read_addr_index(struct udevice *dev, int index)
>                 return devfdt_get_addr_index(dev, index);
>  }
>
> +fdt_addr_t dev_read_addr_size_index(struct udevice *dev, int index,
> +                                   fdt_size_t *size)
> +{
> +       if (ofnode_is_np(dev_ofnode(dev)))
> +               return ofnode_get_addr_size_index(dev_ofnode(dev), index, size);
> +       else
> +               return devfdt_get_addr_size_index(dev, index, size);
> +}
> +
>  void *dev_remap_addr_index(struct udevice *dev, int index)
>  {
>         fdt_addr_t addr = dev_read_addr_index(dev, index);
> @@ -102,6 +111,17 @@ fdt_addr_t dev_read_addr_name(struct udevice *dev, const char *name)
>                 return dev_read_addr_index(dev, index);
>  }

maybe it makes sense to update the dev_remap_* variants to utilise the
new dev_read_addr_* to be able to pass a valid size to map_physmem()?
Currently a size of 0 is passed due to the lack of function which you
are adding now.

>
> +fdt_addr_t dev_read_addr_size_name(struct udevice *dev, const char *name,
> +                                  fdt_size_t *size)
> +{
> +       int index = dev_read_stringlist_search(dev, "reg-names", name);
> +
> +       if (index < 0)
> +               return FDT_ADDR_T_NONE;
> +       else
> +               return dev_read_addr_size_index(dev, index, size);
> +}
> +
>  void *dev_remap_addr_name(struct udevice *dev, const char *name)
>  {
>         fdt_addr_t addr = dev_read_addr_name(dev, name);
> diff --git a/include/dm/fdtaddr.h b/include/dm/fdtaddr.h
> index 3bc2599b6cbd..57b326cb3362 100644
> --- a/include/dm/fdtaddr.h
> +++ b/include/dm/fdtaddr.h
> @@ -120,4 +120,22 @@ fdt_addr_t devfdt_get_addr_size_index(struct udevice *dev, int index,
>   */
>  fdt_addr_t devfdt_get_addr_name(struct udevice *dev, const char *name);
>
> +/**
> + * devfdt_get_addr_size_name() - Get the reg property and its size for a device,
> + *                              indexed by name
> + *
> + * Returns the address and size specified in the 'reg' property of a device.
> + *
> + * @dev: Pointer to a device
> + * @name: the 'reg' property can hold a list of <addr, size> pairs, with the
> + *       'reg-names' property providing named-based identification. @index
> + *       indicates the value to search for in 'reg-names'.
> + * @size: Pointer to size variable - this function returns the size
> + *        specified in the 'reg' property here
> + *
> + * @return addr
> + */
> +fdt_addr_t devfdt_get_addr_size_name(struct udevice *dev, const char *name,
> +                                    fdt_size_t *size);
> +
>  #endif
> diff --git a/include/dm/read.h b/include/dm/read.h
> index 6ecd062e200c..0c62d62f1148 100644
> --- a/include/dm/read.h
> +++ b/include/dm/read.h
> @@ -144,6 +144,19 @@ int dev_read_size(struct udevice *dev, const char *propname);
>   */
>  fdt_addr_t dev_read_addr_index(struct udevice *dev, int index);
>
> +/**
> + * dev_read_addr_size_index() - Get the indexed reg property of a device
> + *
> + * @dev: Device to read from
> + * @index: the 'reg' property can hold a list of <addr, size> pairs
> + *        and @index is used to select which one is required
> + * @size: place to put size value (on success)
> + *
> + * @return address or FDT_ADDR_T_NONE if not found
> + */
> +fdt_addr_t dev_read_addr_size_index(struct udevice *dev, int index,
> +                                   fdt_size_t *size);
> +
>  /**
>   * dev_remap_addr_index() - Get the indexed reg property of a device
>   *                               as a memory-mapped I/O pointer
> @@ -168,6 +181,20 @@ void *dev_remap_addr_index(struct udevice *dev, int index);
>   */
>  fdt_addr_t dev_read_addr_name(struct udevice *dev, const char* name);
>
> +/**
> + * dev_read_addr_size_name() - Get the reg property of a device, indexed by name
> + *
> + * @dev: Device to read from
> + * @name: the 'reg' property can hold a list of <addr, size> pairs, with the
> + *       'reg-names' property providing named-based identification. @index
> + *       indicates the value to search for in 'reg-names'.
> + *  @size: place to put size value (on success)
> + *
> + * @return address or FDT_ADDR_T_NONE if not found
> + */
> +fdt_addr_t dev_read_addr_size_name(struct udevice *dev, const char *name,
> +                                  fdt_size_t *size);
> +
>  /**
>   * dev_remap_addr_name() - Get the reg property of a device, indexed by name,
>   *                         as a memory-mapped I/O pointer
> @@ -601,12 +628,26 @@ static inline fdt_addr_t dev_read_addr_index(struct udevice *dev, int index)
>         return devfdt_get_addr_index(dev, index);
>  }
>
> +static inline fdt_addr_t dev_read_addr_size_index(struct udevice *dev,
> +                                                 int index,
> +                                                 fdt_size_t *size)
> +{
> +       return devfdt_get_addr_size_index(dev, index, size);
> +}
> +
>  static inline fdt_addr_t dev_read_addr_name(struct udevice *dev,
>                                             const char *name)
>  {
>         return devfdt_get_addr_name(dev, name);
>  }
>
> +static inline fdt_addr_t dev_read_addr_size_name(struct udevice *dev,
> +                                                const char *name,
> +                                                fdt_size_t *size)
> +{
> +       return devfdt_get_addr_size_name(dev, name, size);
> +}
> +
>  static inline fdt_addr_t dev_read_addr(struct udevice *dev)
>  {
>         return devfdt_get_addr(dev);
> diff --git a/test/dm/test-fdt.c b/test/dm/test-fdt.c
> index ad8591639da5..1fb8b5c248d3 100644
> --- a/test/dm/test-fdt.c
> +++ b/test/dm/test-fdt.c
> @@ -549,12 +549,14 @@ static int dm_test_fdt_remap_addr_index_flat(struct unit_test_state *uts)
>  {
>         struct udevice *dev;
>         fdt_addr_t addr;
> +       fdt_size_t size;
>         void *paddr;
>
>         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
>
> -       addr = devfdt_get_addr_index(dev, 0);
> +       addr = devfdt_get_addr_size_index(dev, 0, &size);
>         ut_asserteq(0x8000, addr);
> +       ut_asserteq(0x1000, size);
>
>         paddr = map_physmem(addr, 0, MAP_NOCACHE);
>         ut_assertnonnull(paddr);
> @@ -569,12 +571,14 @@ static int dm_test_fdt_remap_addr_name_flat(struct unit_test_state *uts)
>  {
>         struct udevice *dev;
>         fdt_addr_t addr;
> +       fdt_size_t size;
>         void *paddr;
>
>         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
>
> -       addr = devfdt_get_addr_name(dev, "sandbox-dummy-0");
> +       addr = devfdt_get_addr_size_name(dev, "sandbox-dummy-0", &size);
>         ut_asserteq(0x8000, addr);
> +       ut_asserteq(0x1000, size);
>
>         paddr = map_physmem(addr, 0, MAP_NOCACHE);
>         ut_assertnonnull(paddr);
> @@ -609,12 +613,14 @@ static int dm_test_fdt_remap_addr_index_live(struct unit_test_state *uts)
>  {
>         struct udevice *dev;
>         fdt_addr_t addr;
> +       fdt_size_t size;
>         void *paddr;
>
>         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
>
> -       addr = dev_read_addr_index(dev, 0);
> +       addr = dev_read_addr_size_index(dev, 0, &size);
>         ut_asserteq(0x8000, addr);
> +       ut_asserteq(0x1000, size);
>
>         paddr = map_physmem(addr, 0, MAP_NOCACHE);
>         ut_assertnonnull(paddr);
> @@ -629,12 +635,14 @@ static int dm_test_fdt_remap_addr_name_live(struct unit_test_state *uts)
>  {
>         struct udevice *dev;
>         fdt_addr_t addr;
> +       fdt_size_t size;
>         void *paddr;
>
>         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
>
> -       addr = dev_read_addr_name(dev, "sandbox-dummy-0");
> +       addr = dev_read_addr_size_name(dev, "sandbox-dummy-0", &size);
>         ut_asserteq(0x8000, addr);
> +       ut_asserteq(0x1000, size);
>
>         paddr = map_physmem(addr, 0, MAP_NOCACHE);
>         ut_assertnonnull(paddr);
> --
> 2.16.2
>
> _______________________________________________
> U-Boot mailing list
> U-Boot at lists.denx.de
> https://lists.denx.de/listinfo/u-boot



-- 
- Daniel

^ permalink raw reply	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 2/7] dm: core: add support for getting register address and size
  2019-08-01 16:21   ` Daniel Schwierzeck
@ 2019-08-02  6:09     ` Sekhar Nori
  0 siblings, 0 replies; 21+ messages in thread
From: Sekhar Nori @ 2019-08-02  6:09 UTC (permalink / raw)
  To: u-boot

Hi Daniel,

On 01/08/19 9:51 PM, Daniel Schwierzeck wrote:
>> diff --git a/drivers/core/read.c b/drivers/core/read.c
>> index 1a044b05e884..8b5502de1159 100644
>> --- a/drivers/core/read.c
>> +++ b/drivers/core/read.c
>> @@ -82,6 +82,15 @@ fdt_addr_t dev_read_addr_index(struct udevice *dev, int index)
>>                 return devfdt_get_addr_index(dev, index);
>>  }
>>
>> +fdt_addr_t dev_read_addr_size_index(struct udevice *dev, int index,
>> +                                   fdt_size_t *size)
>> +{
>> +       if (ofnode_is_np(dev_ofnode(dev)))
>> +               return ofnode_get_addr_size_index(dev_ofnode(dev), index, size);
>> +       else
>> +               return devfdt_get_addr_size_index(dev, index, size);
>> +}
>> +
>>  void *dev_remap_addr_index(struct udevice *dev, int index)
>>  {
>>         fdt_addr_t addr = dev_read_addr_index(dev, index);
>> @@ -102,6 +111,17 @@ fdt_addr_t dev_read_addr_name(struct udevice *dev, const char *name)
>>                 return dev_read_addr_index(dev, index);
>>  }
> 
> maybe it makes sense to update the dev_remap_* variants to utilise the
> new dev_read_addr_* to be able to pass a valid size to map_physmem()?
> Currently a size of 0 is passed due to the lack of function which you
> are adding now.

Thanks for pointing that out. I think this is something that can come as
a follow-on series. This series itself was supposed to go into 2019.10,
but held up due to a stupid bug I introduced.

I will send a v4 today with a commit message change that was asked with
the hope that it can get into 2019.10 still.

Thanks,
Sekhar

^ permalink raw reply	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 1/7] clk: add support for clk_is_match()
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 1/7] clk: add support for clk_is_match() Sekhar Nori
  2019-08-01 13:47   ` Fabio Estevam
@ 2019-08-13 16:51   ` Tom Rini
  1 sibling, 0 replies; 21+ messages in thread
From: Tom Rini @ 2019-08-13 16:51 UTC (permalink / raw)
  To: u-boot

On Thu, Aug 01, 2019 at 07:12:55PM +0530, Sekhar Nori wrote:

> Add support for clk_is_match() which is required to
> know if two clock pointers point to the same exact
> physical clock.
> 
> Also add a unit test for the new API.
> 
> Reviewed-by: Lokesh Vutla <lokeshvutla@ti.com>
> Signed-off-by: Sekhar Nori <nsekhar@ti.com>

Applied to u-boot/master, thanks!

-- 
Tom
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: not available
URL: <http://lists.denx.de/pipermail/u-boot/attachments/20190813/914dadcb/attachment.sig>

^ permalink raw reply	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 2/7] dm: core: add support for getting register address and size
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 2/7] dm: core: add support for getting register address and size Sekhar Nori
  2019-08-01 16:21   ` Daniel Schwierzeck
@ 2019-08-13 16:51   ` Tom Rini
  1 sibling, 0 replies; 21+ messages in thread
From: Tom Rini @ 2019-08-13 16:51 UTC (permalink / raw)
  To: u-boot

On Thu, Aug 01, 2019 at 07:12:56PM +0530, Sekhar Nori wrote:

> Current dev_read_*() API lacks support to get address and size
> of a "reg" property by name or index. Add support for the same.
> 
> Livetree support has been added but not tested on real hardware.
> 
> The existing unit tests testing reading address from device-tree
> have been updated to test address as well as size.
> 
> Reviewed-by: Lokesh Vutla <lokeshvutla@ti.com>
> Signed-off-by: Sekhar Nori <nsekhar@ti.com>

Applied to u-boot/master, thanks!

-- 
Tom
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: not available
URL: <http://lists.denx.de/pipermail/u-boot/attachments/20190813/bd4f8a4f/attachment.sig>

^ permalink raw reply	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 3/7] pcie: ti: add driver for AM65x PCIe RC
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 3/7] pcie: ti: add driver for AM65x PCIe RC Sekhar Nori
@ 2019-08-13 16:51   ` Tom Rini
  0 siblings, 0 replies; 21+ messages in thread
From: Tom Rini @ 2019-08-13 16:51 UTC (permalink / raw)
  To: u-boot

On Thu, Aug 01, 2019 at 07:12:57PM +0530, Sekhar Nori wrote:

> Add driver supporting PCIe root-complex available
> on TI's AM65x SoC.
> 
> Signed-off-by: Sekhar Nori <nsekhar@ti.com>

Applied to u-boot/master, thanks!

-- 
Tom
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: not available
URL: <http://lists.denx.de/pipermail/u-boot/attachments/20190813/3114939a/attachment.sig>

^ permalink raw reply	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 4/7] phy: add support for AM654x SERDES
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 4/7] phy: add support for AM654x SERDES Sekhar Nori
@ 2019-08-13 16:51   ` Tom Rini
  0 siblings, 0 replies; 21+ messages in thread
From: Tom Rini @ 2019-08-13 16:51 UTC (permalink / raw)
  To: u-boot

On Thu, Aug 01, 2019 at 07:12:58PM +0530, Sekhar Nori wrote:

> Add a new SERDES driver for TI's AM654x SoC which configures
> the SERDES only for PCIe. Support fo USB3 can be added later.
> 
> SERDES in am654x has three input clocks (left input, external
> reference clock and right input) and two output clocks (left
> output and right output) in addition to a PLL mux clock which
> the SERDES uses for Clock Multiplier Unit (CMU refclock).
> 
> The PLL mux clock can select from one of the three input
> clocks. The right output can select between left input and
> external reference clock while the left output can select
> between the right input and external reference clock.
> 
> The driver has support to select PLL mux and left/right output
> mux as specified in device tree.
> 
> Signed-off-by: Sekhar Nori <nsekhar@ti.com>

Applied to u-boot/master, thanks!

-- 
Tom
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: not available
URL: <http://lists.denx.de/pipermail/u-boot/attachments/20190813/7f842ab5/attachment.sig>

^ permalink raw reply	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 5/7] configs: am65x_evm_a53: enable PCIe support
  2019-08-01 13:42 ` [U-Boot] [PATCH v3 5/7] configs: am65x_evm_a53: enable PCIe support Sekhar Nori
@ 2019-08-13 16:51   ` Tom Rini
  0 siblings, 0 replies; 21+ messages in thread
From: Tom Rini @ 2019-08-13 16:51 UTC (permalink / raw)
  To: u-boot

On Thu, Aug 01, 2019 at 07:12:59PM +0530, Sekhar Nori wrote:

> Enable support for PCIe and related configurations
> on AM654 EVM platform.
> 
> Signed-off-by: Sekhar Nori <nsekhar@ti.com>

Applied to u-boot/master, thanks!

-- 
Tom
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: not available
URL: <http://lists.denx.de/pipermail/u-boot/attachments/20190813/0ffed016/attachment.sig>

^ permalink raw reply	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 6/7] arm: dts: k3-am65: add support for PCIe and SERDES
  2019-08-01 13:43 ` [U-Boot] [PATCH v3 6/7] arm: dts: k3-am65: add support for PCIe and SERDES Sekhar Nori
@ 2019-08-13 16:51   ` Tom Rini
  0 siblings, 0 replies; 21+ messages in thread
From: Tom Rini @ 2019-08-13 16:51 UTC (permalink / raw)
  To: u-boot

On Thu, Aug 01, 2019 at 07:13:00PM +0530, Sekhar Nori wrote:

> Add needed device-tree nodes to support PCIe 0
> and SERDES on AM65x SoC. The nodes are kept
> disabled by default.
> 
> Signed-off-by: Sekhar Nori <nsekhar@ti.com>

Applied to u-boot/master, thanks!

-- 
Tom
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: not available
URL: <http://lists.denx.de/pipermail/u-boot/attachments/20190813/d58eefcd/attachment.sig>

^ permalink raw reply	[flat|nested] 21+ messages in thread

* [U-Boot] [PATCH v3 7/7] configs: am65x_evm_a53: enable support for PCIe ethernet cards
  2019-08-01 13:43 ` [U-Boot] [PATCH v3 7/7] configs: am65x_evm_a53: enable support for PCIe ethernet cards Sekhar Nori
@ 2019-08-13 16:51   ` Tom Rini
  0 siblings, 0 replies; 21+ messages in thread
From: Tom Rini @ 2019-08-13 16:51 UTC (permalink / raw)
  To: u-boot

On Thu, Aug 01, 2019 at 07:13:01PM +0530, Sekhar Nori wrote:

> Enable support for Intel E1000 based PCIe ethernet cards that
> can be used to test PCIe RC functionality on AM65x EVM.
> 
> Signed-off-by: Sekhar Nori <nsekhar@ti.com>

Applied to u-boot/master, thanks!

-- 
Tom
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: not available
URL: <http://lists.denx.de/pipermail/u-boot/attachments/20190813/167f03ed/attachment.sig>

^ permalink raw reply	[flat|nested] 21+ messages in thread

end of thread, other threads:[~2019-08-13 16:51 UTC | newest]

Thread overview: 21+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2019-08-01 13:42 [U-Boot] [PATCH v3 0/7] Add PCIe root complex support for AM654x SoC Sekhar Nori
2019-08-01 13:42 ` [U-Boot] [PATCH v3 1/7] clk: add support for clk_is_match() Sekhar Nori
2019-08-01 13:47   ` Fabio Estevam
2019-08-01 13:54     ` Sekhar Nori
2019-08-01 13:55       ` Fabio Estevam
2019-08-01 15:50       ` Tom Rini
2019-08-13 16:51   ` Tom Rini
2019-08-01 13:42 ` [U-Boot] [PATCH v3 2/7] dm: core: add support for getting register address and size Sekhar Nori
2019-08-01 16:21   ` Daniel Schwierzeck
2019-08-02  6:09     ` Sekhar Nori
2019-08-13 16:51   ` Tom Rini
2019-08-01 13:42 ` [U-Boot] [PATCH v3 3/7] pcie: ti: add driver for AM65x PCIe RC Sekhar Nori
2019-08-13 16:51   ` Tom Rini
2019-08-01 13:42 ` [U-Boot] [PATCH v3 4/7] phy: add support for AM654x SERDES Sekhar Nori
2019-08-13 16:51   ` Tom Rini
2019-08-01 13:42 ` [U-Boot] [PATCH v3 5/7] configs: am65x_evm_a53: enable PCIe support Sekhar Nori
2019-08-13 16:51   ` Tom Rini
2019-08-01 13:43 ` [U-Boot] [PATCH v3 6/7] arm: dts: k3-am65: add support for PCIe and SERDES Sekhar Nori
2019-08-13 16:51   ` Tom Rini
2019-08-01 13:43 ` [U-Boot] [PATCH v3 7/7] configs: am65x_evm_a53: enable support for PCIe ethernet cards Sekhar Nori
2019-08-13 16:51   ` Tom Rini

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.