dm: core: Introduce xxx_translate_dma_address()

Add the following functions to translate DMA address to CPU address:
- dev_translate_dma_address()
- ofnode_translate_dma_address()
- of_translate_dma_address()
- fdt_translate_dma_address()
These functions work the same way as xxx_translate_address(), with the
difference that the translation relies on the "dma-ranges" property
instead of the "ranges" property.

Add related test. Test report:
=> ut dm fdt_translation
Test: dm_test_fdt_translation: test-fdt.c
Test: dm_test_fdt_translation: test-fdt.c (flat tree)
Failures: 0

Signed-off-by: Fabien Dessenne <fabien.dessenne@st.com>

diff --git a/arch/sandbox/dts/test.dts b/arch/sandbox/dts/test.dts
index 531c1afc973e123b4e497d2be162a31938f6198b..ac985ecb32c6ec1b34a7fe68d9fdc86cef98b232 100644 (file)
--- a/arch/sandbox/dts/test.dts
+++ b/arch/sandbox/dts/test.dts
@@ -756,6 +756,10 @@
                          3 0x300 0xB000 0x1000
                         >;
 
+               dma-ranges = <0 0x000 0x10000000 0x1000
+                             1 0x100 0x20000000 0x1000
+                            >;
+
                dev@0,0 {
                        compatible = "denx,u-boot-fdt-dummy";
                        reg = <0 0x0 0x1000>;

diff --git a/common/fdt_support.c b/common/fdt_support.c
index f31e9b0cc5a899ade8f400d1af83fe08e5c593cd..a23367b54a497df065f1bfad63f484d978163930 100644 (file)
--- a/common/fdt_support.c
+++ b/common/fdt_support.c
@@ -1292,6 +1292,12 @@ u64 fdt_translate_address(const void *blob, int node_offset,
        return __of_translate_address(blob, node_offset, in_addr, "ranges");
 }
 
+u64 fdt_translate_dma_address(const void *blob, int node_offset,
+                             const fdt32_t *in_addr)
+{
+       return __of_translate_address(blob, node_offset, in_addr, "dma-ranges");
+}
+
 /**
  * fdt_node_offset_by_compat_reg: Find a node that matches compatiable and
  * who's reg property matches a physical cpu address

diff --git a/drivers/core/of_addr.c b/drivers/core/of_addr.c
index 1bfaaeec00ac546f2e349b9dfcd9efe108cf4eea..4e256d992600dfc1f783dbd50746f94b18090b5c 100644 (file)
--- a/drivers/core/of_addr.c
+++ b/drivers/core/of_addr.c
@@ -318,6 +318,10 @@ u64 of_translate_address(const struct device_node *dev, const __be32 *in_addr)
        return __of_translate_address(dev, in_addr, "ranges");
 }
 
+u64 of_translate_dma_address(const struct device_node *dev, const __be32 *in_addr)
+{
+       return __of_translate_address(dev, in_addr, "dma-ranges");
+}
 
 static int __of_address_to_resource(const struct device_node *dev,
                const __be32 *addrp, u64 size, unsigned int flags,

diff --git a/drivers/core/ofnode.c b/drivers/core/ofnode.c
index c72c6e26737b610b52eaedd5e6d4fbc3ecdc9035..179a6447dc6731661321e08295d2f91c5f7b9da9 100644 (file)
--- a/drivers/core/ofnode.c
+++ b/drivers/core/ofnode.c
@@ -770,6 +770,14 @@ u64 ofnode_translate_address(ofnode node, const fdt32_t *in_addr)
                return fdt_translate_address(gd->fdt_blob, ofnode_to_offset(node), in_addr);
 }
 
+u64 ofnode_translate_dma_address(ofnode node, const fdt32_t *in_addr)
+{
+       if (ofnode_is_np(node))
+               return of_translate_dma_address(ofnode_to_np(node), in_addr);
+       else
+               return fdt_translate_dma_address(gd->fdt_blob, ofnode_to_offset(node), in_addr);
+}
+
 int ofnode_device_is_compatible(ofnode node, const char *compat)
 {
        if (ofnode_is_np(node))

diff --git a/drivers/core/read.c b/drivers/core/read.c
index 6bda077a34b9ce46e5b2456bd14762f950d60f62..1a044b05e88410abbadab1fa1fe9ba6089983105 100644 (file)
--- a/drivers/core/read.c
+++ b/drivers/core/read.c
@@ -265,6 +265,11 @@ u64 dev_translate_address(struct udevice *dev, const fdt32_t *in_addr)
        return ofnode_translate_address(dev_ofnode(dev), in_addr);
 }
 
+u64 dev_translate_dma_address(struct udevice *dev, const fdt32_t *in_addr)
+{
+       return ofnode_translate_dma_address(dev_ofnode(dev), in_addr);
+}
+
 int dev_read_alias_highest_id(const char *stem)
 {
        if (of_live_active())

diff --git a/include/dm/of_addr.h b/include/dm/of_addr.h
index 12b1a99a80ef964958fbf1051046769938119f6a..3fa1ffce81a69587893e1af0f0547bc52ef51b4e 100644 (file)
--- a/include/dm/of_addr.h
+++ b/include/dm/of_addr.h
@@ -26,6 +26,24 @@
  */
 u64 of_translate_address(const struct device_node *no, const __be32 *in_addr);
 
+/**
+ * of_translate_dma_address() - translate a device-tree DMA address to a CPU
+ *                             address
+ *
+ * Translate a DMA address from the device-tree into a CPU physical address,
+ * this walks up the tree and applies the various bus mappings on the way.
+ *
+ * Note: We consider that crossing any level with #size-cells == 0 to mean
+ * that translation is impossible (that is we are not dealing with a value
+ * that can be mapped to a cpu physical address). This is not really specified
+ * that way, but this is traditionally the way IBM at least do things
+ *
+ * @np: node to check
+ * @in_addr: pointer to input DMA address
+ * @return translated DMA address or OF_BAD_ADDR on error
+ */
+u64 of_translate_dma_address(const struct device_node *no, const __be32 *in_addr);
+
 /**
  * of_get_address() - obtain an address from a node
  *

diff --git a/include/dm/ofnode.h b/include/dm/ofnode.h
index 704f91589a5c89e0edaaa127739e470ef9647905..4f89db44c19e5a17ec6b885d9c793850bfde8ab8 100644 (file)
--- a/include/dm/ofnode.h
+++ b/include/dm/ofnode.h
@@ -767,7 +767,7 @@ ofnode ofnode_by_prop_value(ofnode from, const char *propname,
             node = ofnode_next_subnode(node))
 
 /**
- * ofnode_translate_address() - Tranlate a device-tree address
+ * ofnode_translate_address() - Translate a device-tree address
  *
  * Translate an address from the device-tree into a CPU physical address. This
  * function walks up the tree and applies the various bus mappings along the
@@ -780,6 +780,20 @@ ofnode ofnode_by_prop_value(ofnode from, const char *propname,
  */
 u64 ofnode_translate_address(ofnode node, const fdt32_t *in_addr);
 
+/**
+ * ofnode_translate_dma_address() - Translate a device-tree DMA address
+ *
+ * Translate a DMA address from the device-tree into a CPU physical address.
+ * This function walks up the tree and applies the various bus mappings along
+ * the way.
+ *
+ * @ofnode: Device tree node giving the context in which to translate the
+ *          DMA address
+ * @in_addr: pointer to the DMA address to translate
+ * @return the translated DMA address; OF_BAD_ADDR on error
+ */
+u64 ofnode_translate_dma_address(ofnode node, const fdt32_t *in_addr);
+
 /**
  * ofnode_device_is_compatible() - check if the node is compatible with compat
  *

diff --git a/include/dm/read.h b/include/dm/read.h
index 60b727cbd82153637230b40cbc709724de83ba8f..62d4be603827909dc6b02f9841a36739ce9957b2 100644 (file)
--- a/include/dm/read.h
+++ b/include/dm/read.h
@@ -499,7 +499,7 @@ int dev_read_resource_byname(struct udevice *dev, const char *name,
                             struct resource *res);
 
 /**
- * dev_translate_address() - Tranlate a device-tree address
+ * dev_translate_address() - Translate a device-tree address
  *
  * Translate an address from the device-tree into a CPU physical address.  This
  * function walks up the tree and applies the various bus mappings along the
@@ -511,6 +511,19 @@ int dev_read_resource_byname(struct udevice *dev, const char *name,
  */
 u64 dev_translate_address(struct udevice *dev, const fdt32_t *in_addr);
 
+/**
+ * dev_translate_dma_address() - Translate a device-tree DMA address
+ *
+ * Translate a DMA address from the device-tree into a CPU physical address.
+ * This function walks up the tree and applies the various bus mappings along
+ * the way.
+ *
+ * @dev: device giving the context in which to translate the DMA address
+ * @in_addr: pointer to the DMA address to translate
+ * @return the translated DMA address; OF_BAD_ADDR on error
+ */
+u64 dev_translate_dma_address(struct udevice *dev, const fdt32_t *in_addr);
+
 /**
  * dev_read_alias_highest_id - Get highest alias id for the given stem
  * @stem:      Alias stem to be examined
@@ -751,6 +764,11 @@ static inline u64 dev_translate_address(struct udevice *dev, const fdt32_t *in_a
        return ofnode_translate_address(dev_ofnode(dev), in_addr);
 }
 
+static inline u64 dev_translate_dma_address(struct udevice *dev, const fdt32_t *in_addr)
+{
+       return ofnode_translate_dma_address(dev_ofnode(dev), in_addr);
+}
+
 static inline int dev_read_alias_highest_id(const char *stem)
 {
        return fdtdec_get_alias_highest_id(gd->fdt_blob, stem);

diff --git a/include/fdt_support.h b/include/fdt_support.h
index 27fe564f0b6b497c21b4e628ecf155454014dac2..cefb2b2cce2396efa390a8e0f2c84b1a35b4e19e 100644 (file)
--- a/include/fdt_support.h
+++ b/include/fdt_support.h
@@ -218,8 +218,32 @@ static inline void fdt_fixup_mtdparts(void *fdt,
 #endif
 
 void fdt_del_node_and_alias(void *blob, const char *alias);
+
+/**
+ * Translate an address from the DT into a CPU physical address
+ *
+ * The translation relies on the "ranges" property.
+ *
+ * @param blob         Pointer to device tree blob
+ * @param node_offset  Node DT offset
+ * @param in_addr      Pointer to the address to translate
+ * @return translated address or OF_BAD_ADDR on error
+ */
 u64 fdt_translate_address(const void *blob, int node_offset,
                          const __be32 *in_addr);
+/**
+ * Translate a DMA address from the DT into a CPU physical address
+ *
+ * The translation relies on the "dma-ranges" property.
+ *
+ * @param blob         Pointer to device tree blob
+ * @param node_offset  Node DT offset
+ * @param in_addr      Pointer to the DMA address to translate
+ * @return translated DMA address or OF_BAD_ADDR on error
+ */
+u64 fdt_translate_dma_address(const void *blob, int node_offset,
+                             const __be32 *in_addr);
+
 int fdt_node_offset_by_compat_reg(void *blob, const char *compat,
                                        phys_addr_t compat_off);
 int fdt_alloc_phandle(void *blob);

diff --git a/test/dm/test-fdt.c b/test/dm/test-fdt.c
index be16c99e170eb6e1783ec5cd4b42a2d623a747ae..ad8591639da5731b84b28e7eaaf2aadfe2702d7c 100644 (file)
--- a/test/dm/test-fdt.c
+++ b/test/dm/test-fdt.c
@@ -490,6 +490,7 @@ U_BOOT_DRIVER(fdt_dummy_drv) = {
 static int dm_test_fdt_translation(struct unit_test_state *uts)
 {
        struct udevice *dev;
+       fdt32_t dma_addr[2];
 
        /* Some simple translations */
        ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
@@ -509,6 +510,17 @@ static int dm_test_fdt_translation(struct unit_test_state *uts)
        ut_asserteq_str("dev@42", dev->name);
        ut_asserteq(0x42, dev_read_addr(dev));
 
+       /* dma address translation */
+       ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
+       dma_addr[0] = cpu_to_be32(0);
+       dma_addr[1] = cpu_to_be32(0);
+       ut_asserteq(0x10000000, dev_translate_dma_address(dev, dma_addr));
+
+       ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 1, true, &dev));
+       dma_addr[0] = cpu_to_be32(1);
+       dma_addr[1] = cpu_to_be32(0x100);
+       ut_asserteq(0x20000000, dev_translate_dma_address(dev, dma_addr));
+
        return 0;
 }
 DM_TEST(dm_test_fdt_translation, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);