CC3XX: DMA: Remap both addresses just before triggering DMA

So that both DIN and DOUT addresses are remapped in the same
function making it easier to follow DMA operations

Signed-off-by: Antonio de Angelis <antonio.deangelis@arm.com>
Change-Id: Iad6f1d31f952c46a5d8c214cf8b5b5ad1f7bb9ed

Author: adeaarm

platform/ext/target/arm/drivers/cc3xx/low_level_driver/include/cc3xx_dma.h

@@ -152,14 +152,19 @@ void cc3xx_lowlevel_dma_copy_data_from_rng_sram(void* dest,
  *                    cc3xx_dma_flush_buffer must be called to ensure all data
  *                    is processed.
  *
+ * @note              The \p buf pointer can be remapped to a different address
+ *                    before being programmed on the DMA engine in case the system
+ *                    memory map exports different interfaces to the same memory
+ *                    location, in case of the CPU and the DMA engine respectively
+ *
  * @param[in]  buf          The pointer to copy data from.
  * @param[in]  length       The size of the data.
  * @param[in]  write_output Whether the data should be output from the engine.
  *
  * @return            CC3XX_ERR_SUCCESS on success, another cc3xx_err_t on
  *                    error.
  */
-cc3xx_err_t cc3xx_lowlevel_dma_buffered_input_data(const void* buf, size_t length,
+cc3xx_err_t cc3xx_lowlevel_dma_buffered_input_data(const void *buf, size_t length,
                                                    bool write_output);
 
 /**
@@ -186,11 +191,16 @@ void cc3xx_lowlevel_dma_set_buffer_size(size_t size);
  * @brief             Set the DMA output location. This controls where the
  *                    DMA will output to after input is started.
  *
+ * @note              The \p buf pointer can be remapped to a different address
+ *                    before being programmed on the DMA engine in case the system
+ *                    memory map exports different interfaces to the same memory
+ *                    location, in case of the CPU and the DMA engine respectively
+ *
  * @param[out] buf    The pointer to output to.
  * @param[in]  length The size of the output location. The DMA will not copy
  *                    more data than this to the pointer.
  */
-void cc3xx_lowlevel_dma_set_output(void* buf, size_t length);
+void cc3xx_lowlevel_dma_set_output(void *buf, size_t length);
 
 /**
  * @brief                       Uninitialize the DMA.

platform/ext/target/arm/drivers/cc3xx/low_level_driver/src/cc3xx_dma.c

@@ -160,20 +160,20 @@ static void process_data(const void *buf, size_t length)
     P_CC3XX->host_rgf.host_rgf_icr |= 0xFF0U;
 
     if (dma_state.block_buf_needs_output) {
-        uintptr_t output_addr = dma_state.output_addr;
+        const uintptr_t remap_output_addr = remap_addr(dma_state.output_addr);
 #ifdef CC3XX_CONFIG_DMA_BURST_RESTRICTED_ENABLE
         /* Force single transactions for restricted addresses */
-        if (is_addr_burst_restricted(output_addr)) {
+        if (is_addr_burst_restricted(remap_output_addr)) {
             P_CC3XX->ahb.ahbm_singles = 0x1UL;
         } else {
             P_CC3XX->ahb.ahbm_singles = 0x0UL;
         }
 #endif /* CC3XX_CONFIG_DMA_BURST_RESTRICTED_ENABLE */
 
-        assert(!((output_addr == NULL) && (length != 0)));
+        assert(!((remap_output_addr == (uintptr_t)NULL) && (length != 0)));
 
         /* Set the data target */
-        P_CC3XX->dout.dst_lli_word0 = output_addr;
+        P_CC3XX->dout.dst_lli_word0 = remap_output_addr;
         /* And the length */
         P_CC3XX->dout.dst_lli_word1 = length;
 
@@ -185,7 +185,7 @@ static void process_data(const void *buf, size_t length)
          * set up an MPU covering the input and output regions so they can be
          * marked as SHAREABLE (which is not currently implemented).
          */
-        SCB_CleanInvalidateDCache_by_Addr((volatile void *)output_addr, length);
+        SCB_CleanInvalidateDCache_by_Addr((volatile void *)remap_output_addr, length);
 #endif /* CC3XX_CONFIG_DMA_CACHE_FLUSH_ENABLE */
 
         dma_state.output_addr += length;
@@ -194,7 +194,7 @@ static void process_data(const void *buf, size_t length)
 
     if (dma_state.input_src == CC3XX_DMA_INPUT_SRC_CPU_MEM) {
         /* remap the address, particularly for TCMs */
-        const uintptr_t remapped_buf =  remap_addr((uintptr_t)buf);
+        const uintptr_t remapped_buf = remap_addr((uintptr_t)buf);
 #ifdef CC3XX_CONFIG_DMA_CACHE_FLUSH_ENABLE
         /* Flush the input data. Note that this is only enough to avoid cache
          * issues if the CPU is in a busy-wait loop while the access completes.
@@ -351,10 +351,9 @@ void cc3xx_lowlevel_dma_set_buffer_size(size_t size) {
     assert(size <= CC3XX_DMA_BLOCK_BUF_MAX_SIZE);
 }
 
-void cc3xx_lowlevel_dma_set_output(void* buf, size_t length)
+void cc3xx_lowlevel_dma_set_output(void *buf, size_t length)
 {
-    /* remap the address, particularly for TCMs */
-    dma_state.output_addr = remap_addr((uintptr_t)buf);
+    dma_state.output_addr = (uintptr_t)buf;
     dma_state.output_size = length;
 }