dma.h File Reference

This file provides functions to program the Snitch DMA. More...

#include <math.h>

Go to the source code of this file.

Typedefs
typedef uint32_t	snrt_dma_txid_t
	A DMA transfer identifier.

Functions
static uint32_t	snrt_dma_start_1d (uint64_t dst, uint64_t src, size_t size, const uint32_t channel=0)
	Start an asynchronous 1D DMA transfer with 64-bit wide pointers on a specific DMA channel.
static uint32_t	snrt_dma_start_1d (volatile void *dst, volatile void *src, size_t size, const uint32_t channel=0)
	Start an asynchronous 1D DMA transfer using native-size pointers.
void	snrt_dma_enable_mcast (uint32_t mask)
	Enable multicast for successive transfers.
void	snrt_dma_disable_mcast ()
	Disable multicast for successive transfers.
static uint32_t	snrt_dma_start_1d_mcast (uint64_t dst, uint64_t src, size_t size, uint32_t mask, const uint32_t channel=0)
	Start an asynchronous multicast 1D DMA transfer with 64-bit wide pointers.
static uint32_t	snrt_dma_start_1d_mcast (volatile void *dst, volatile void *src, size_t size, uint32_t mask, const uint32_t channel=0)
	Start an asynchronous multicast 1D DMA transfer using native-size pointers.
static snrt_dma_txid_t	snrt_dma_start_2d (uint64_t dst, uint64_t src, size_t size, size_t dst_stride, size_t src_stride, size_t repeat, const uint32_t channel=0)
	Start an asynchronous 2D DMA transfer with 64-bit wide pointers.
static uint32_t	snrt_dma_start_2d (volatile void *dst, volatile void *src, size_t size, size_t dst_stride, size_t src_stride, size_t repeat, const uint32_t channel=0)
	Start an asynchronous 2D DMA transfer using native-size pointers.
static uint32_t	snrt_dma_start_2d_mcast (uint64_t dst, uint64_t src, size_t size, size_t dst_stride, size_t src_stride, size_t repeat, uint32_t mask, const uint32_t channel=0)
	Start an asynchronous, multicast 2D DMA transfer with 64-bit wide pointers.
static uint32_t	snrt_dma_start_2d_mcast (volatile void *dst, volatile void *src, size_t size, size_t dst_stride, size_t src_stride, size_t repeat, uint32_t mask, const uint32_t channel=0)
	Start an asynchronous, multicast 2D DMA transfer using native-size pointers.
static void	snrt_dma_wait (snrt_dma_txid_t txid, const uint32_t channel=0)
	Block until a DMA transfer finishes on a specific DMA channel.
static void	snrt_dma_wait_all (const uint32_t channel=0)
	Block until a specific DMA channel is idle.
void	snrt_dma_wait_all_channels (uint32_t num_channels)
	Block until the first num_channels channels are idle.
void	snrt_dma_start_tracking ()
	Start tracking of dma performance region. Does not have any implications on the HW. Only injects a marker in the DMA traces that can be analyzed.
void	snrt_dma_stop_tracking ()
	Stop tracking of dma performance region. Does not have any implications on the HW. Only injects a marker in the DMA traces that can be analyzed.
void	snrt_dma_memset (void *ptr, uint8_t value, uint32_t len)
	Fast memset function performed by DMA.
snrt_dma_txid_t	snrt_dma_load_1d_tile (volatile void *dst, volatile void *src, size_t tile_idx, size_t tile_size, uint32_t prec)
	Load a tile of a 1D array.
snrt_dma_txid_t	snrt_dma_load_1d_tile_mcast (void *dst, void *src, size_t tile_idx, size_t tile_size, uint32_t prec, uint32_t mcast)
	Load a tile of a 1D array.
snrt_dma_txid_t	snrt_dma_1d_to_2d (volatile void *dst, volatile void *src, size_t size, size_t row_size, size_t stride)
	Transfer and reshape a 1D array into a 2D array.
snrt_dma_txid_t	snrt_dma_2d_to_1d (volatile void *dst, volatile void *src, size_t size, size_t row_size, size_t stride)
	Transfer and reshape a 2D array into a 1D array.
snrt_dma_txid_t	snrt_dma_store_1d_tile (void *dst, void *src, size_t tile_idx, size_t tile_size, uint32_t prec)
	Store a tile to a 1D array.
snrt_dma_txid_t	snrt_dma_load_2d_tile (void *dst, void *src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec, size_t tile_ld)
	Load a 2D tile of a 2D array.
snrt_dma_txid_t	snrt_dma_load_2d_tile (void *dst, void *src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec)
	Load a 2D tile of a 2D array.
snrt_dma_txid_t	snrt_dma_load_2d_tile_mcast (void *dst, void *src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec, size_t tile_ld, uint32_t mask)
	Load a 2D tile of a 2D array using multicast.
snrt_dma_txid_t	snrt_dma_load_2d_tile_mcast (void *dst, void *src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec, uint32_t mask)
	Load a 2D tile of a 2D array.
snrt_dma_txid_t	snrt_dma_load_2d_tile_in_banks (void *dst, void *src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec, size_t num_banks)
	Load a 2D tile of a 2D array and reshape it to occupy a subset of TCDM banks.
snrt_dma_txid_t	snrt_dma_store_2d_tile (void *dst, void *src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec, size_t tile_ld)
	Store a 2D tile to a 2D array.
snrt_dma_txid_t	snrt_dma_store_2d_tile (void *dst, void *src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec)
	Store a 2D tile of a 2D array.
snrt_dma_txid_t	snrt_dma_store_2d_tile_from_banks (void *dst, void *src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec, size_t num_banks)
	Store a 2D tile of a 2D array from a 1D layout occupying a subset of TCDM banks.

Detailed Description

This file provides functions to program the Snitch DMA.

Function Documentation

snrt_dma_1d_to_2d()

snrt_dma_txid_t snrt_dma_1d_to_2d ( volatile void * dst, volatile void * src, size_t size, size_t row_size, size_t stride )

inline

Transfer and reshape a 1D array into a 2D array.

Parameters

dst	Pointer to the destination array.
src	Pointer to the source array.
size	Number of bytes to transfer.
row_size	Size of a row in the 2D array, in bytes.
stride	Stride between successive rows in the 2D array, in bytes.

                                                        {
    return snrt_dma_start_2d(dst, src, row_size, stride, row_size,
                             size / row_size);
}

snrt_dma_2d_to_1d()

snrt_dma_txid_t snrt_dma_2d_to_1d ( volatile void * dst, volatile void * src, size_t size, size_t row_size, size_t stride )

inline

Transfer and reshape a 2D array into a 1D array.

Parameters

dst	Pointer to the destination array.
src	Pointer to the source array.
size	Number of bytes to transfer.
row_size	Size of a row in the 2D array, in bytes.
stride	Stride between successive rows in the 2D array, in bytes.

                                                        {
    return snrt_dma_start_2d(dst, src, row_size, row_size, stride,
                             size / row_size);
}

snrt_dma_disable_mcast()

void snrt_dma_disable_mcast ( )

inline

Disable multicast for successive transfers.

Resets the multicast mask to zero.

{ asm volatile("dmuser zero, zero \n"); }

snrt_dma_enable_mcast()

void snrt_dma_enable_mcast ( uint32_t mask )

inline

Enable multicast for successive transfers.

Parameters

mask	Multicast mask applied to successive transfers.

                                                 {
    asm volatile("dmuser %[mask], zero \n" : : [ mask ] "r"(mask));
}

snrt_dma_load_1d_tile()

snrt_dma_txid_t snrt_dma_load_1d_tile ( volatile void * dst, volatile void * src, size_t tile_idx, size_t tile_size, uint32_t prec )

inline

Load a tile of a 1D array.

Parameters

dst	Pointer to the tile destination.
src	Pointer to the source array.
tile_idx	Index of the tile in the 1D array.
tile_size	Number of elements within a tile of the 1D array.
prec	Number of bytes of each element in the 1D array.

                                                            {
    size_t tile_nbytes = tile_size * prec;
    return snrt_dma_start_1d(
        (uint64_t)dst, (uint64_t)src + tile_idx * tile_nbytes, tile_nbytes);
}

snrt_dma_load_1d_tile_mcast()

snrt_dma_txid_t snrt_dma_load_1d_tile_mcast ( void * dst, void * src, size_t tile_idx, size_t tile_size, uint32_t prec, uint32_t mcast )

inline

Load a tile of a 1D array.

Parameters

dst	Pointer to the tile destination.
src	Pointer to the source array.
tile_idx	Index of the tile in the 1D array.
tile_size	Number of elements within a tile of the 1D array.
prec	Number of bytes of each element in the 1D array.
mcast	Multicast mask applied on the destination address.

                                                                   {
    size_t tile_nbytes = tile_size * prec;
    return snrt_dma_start_1d_mcast((uintptr_t)dst,
                                   (uintptr_t)src + tile_idx * tile_nbytes,
                                   tile_nbytes, mcast);
}

snrt_dma_load_2d_tile() [1/2]

snrt_dma_txid_t snrt_dma_load_2d_tile ( void * dst, void * src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec )

inline

Load a 2D tile of a 2D array.

The stride in the destination tile is assumed to be that of a 1D tile, effectively. In other words, this is the same as snrt_dma_2d_to_1d().

See also

snrt_dma_load_2d_tile(void *, void *, size_t, size_t, size_t, size_t, size_t, uint32_t, size_t) for a detailed description of the parameters.

                   {
    return snrt_dma_load_2d_tile(dst, src, tile_x1_idx, tile_x0_idx,
                                 tile_x1_size, tile_x0_size, full_x0_size, prec,
                                 tile_x0_size * prec);
}

snrt_dma_load_2d_tile() [2/2]

snrt_dma_txid_t snrt_dma_load_2d_tile ( void * dst, void * src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec, size_t tile_ld )

inline

Load a 2D tile of a 2D array.

Parameters

dst	Pointer to the tile destination.
src	Pointer to the source array.
tile_x1_idx	Outermost coordinate of the tile in the 2D array.
tile_x0_idx	Innermost coordinate of the tile in the 2D array.
tile_x1_size	Number of elements in the outermost dimension of the tile.
tile_x0_size	Number of elements in the innermost dimension of the tile.
full_x0_size	Number of elements in the innermost dimension of the array.
prec	Number of bytes of each element in the 2D array.
tile_ld	Leading dimension of the tile, in bytes.

                                   {
    size_t src_offset = 0;
    // Advance src array in x0 and x1 dimensions, and convert to byte offset
    src_offset += tile_x0_idx * tile_x0_size;
    src_offset += tile_x1_idx * tile_x1_size * full_x0_size;
    src_offset *= prec;
    // Initiate transfer
    return snrt_dma_start_2d((uint64_t)dst,               // dst
                             (uint64_t)src + src_offset,  // src
                             tile_x0_size * prec,         // size
                             tile_ld,                     // dst_stride
                             full_x0_size * prec,         // src_stride
                             tile_x1_size                 // repeat
    );
}

snrt_dma_load_2d_tile_in_banks()

snrt_dma_txid_t snrt_dma_load_2d_tile_in_banks ( void * dst, void * src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec, size_t num_banks )

inline

Load a 2D tile of a 2D array and reshape it to occupy a subset of TCDM banks.

Parameters

dst	Pointer to the tile destination.
src	Pointer to the source array.
tile_x1_idx	Outermost coordinate of the tile in the 2D array.
tile_x0_idx	Innermost coordinate of the tile in the 2D array.
tile_x1_size	Number of elements in the outermost dimension of the tile.
tile_x0_size	Number of elements in the innermost dimension of the tile.
full_x0_size	Number of elements in the innermost dimension of the array.
prec	Number of bytes of each element in the 2D array.
num_banks	Number of banks to reshape the tile into.

                                     {
    // Calculate new tile size after reshaping the tile in the selected banks
    size_t tile_x0_size_in_banks = (num_banks * SNRT_TCDM_BANK_WIDTH) / prec;
    size_t tile_x1_size_in_banks =
        ceil((tile_x1_size * tile_x0_size) / (double)tile_x0_size_in_banks);
    size_t tile_ld = SNRT_TCDM_HYPERBANK_WIDTH;
    return snrt_dma_load_2d_tile(dst, src, tile_x1_idx, tile_x0_idx,
                                 tile_x1_size_in_banks, tile_x0_size_in_banks,
                                 full_x0_size, prec, tile_ld);
}

snrt_dma_load_2d_tile_mcast() [1/2]

snrt_dma_txid_t snrt_dma_load_2d_tile_mcast ( void * dst, void * src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec, size_t tile_ld, uint32_t mask )

inline

Load a 2D tile of a 2D array using multicast.

Parameters

mask	Multicast mask.

See also

snrt_dma_load_2d_tile(void *, void *, size_t, size_t, size_t, size_t, size_t, uint32_t, size_t) for a description of the other parameters.

                                                  {
    size_t src_offset = 0;
    // Advance src array in x0 and x1 dimensions, and convert to byte offset
    src_offset += tile_x0_idx * tile_x0_size;
    src_offset += tile_x1_idx * tile_x1_size * full_x0_size;
    src_offset *= prec;
    // Initiate transfer
    return snrt_dma_start_2d_mcast((uint64_t)dst,               // dst
                                   (uint64_t)src + src_offset,  // src
                                   tile_x0_size * prec,         // size
                                   tile_ld,                     // dst_stride
                                   full_x0_size * prec,         // src_stride
                                   tile_x1_size,                // repeat
                                   mask                         // mask
    );
}

snrt_dma_load_2d_tile_mcast() [2/2]

snrt_dma_txid_t snrt_dma_load_2d_tile_mcast ( void * dst, void * src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec, uint32_t mask )

inline

Load a 2D tile of a 2D array.

The stride in the destination tile is assumed to be that of a 1D tile, effectively. In other words, this is similar to snrt_dma_2d_to_1d().

See also

snrt_dma_load_2d_tile_mcast(void *, void *, size_t, size_t, size_t, size_t, size_t, uint32_t, size_t, uint32_t) for a detailed description of the parameters.

                                  {
    return snrt_dma_load_2d_tile_mcast(dst, src, tile_x1_idx, tile_x0_idx,
                                       tile_x1_size, tile_x0_size, full_x0_size,
                                       prec, tile_x0_size * prec, mask);
}

snrt_dma_memset()

void snrt_dma_memset ( void * ptr, uint8_t value, uint32_t len )

inline

Fast memset function performed by DMA.

Parameters

ptr	Pointer to the start of the region.
value	Value to set.
len	Number of bytes, must be a multiple of the DMA bus width to use the DMA.

                                                                    {
    // We set the first 64 bytes to the value, and then we use the DMA to copy
    // these into the remaining memory region. DMA is used only if len is
    // larger than 64 bytes, and an integer multiple of 64 bytes.
    size_t n_1d_transfers = len / 64;
    size_t use_dma = (len % 64) == 0 && len > 64;
    uint8_t *p = (uint8_t *)ptr;
 
    uint32_t nbytes = len < 64 || !use_dma ? len : 64;
    while (nbytes--) {
        *p++ = value;
    }
 
    if (use_dma) {
        snrt_dma_start_2d(ptr, ptr, 64, 64, 0, n_1d_transfers);
        snrt_dma_wait_all();
    }
}

snrt_dma_start_1d() [1/2]

static uint32_t snrt_dma_start_1d ( uint64_t dst, uint64_t src, size_t size, const uint32_t channel = 0 )

inlinestatic

Start an asynchronous 1D DMA transfer with 64-bit wide pointers on a specific DMA channel.

Parameters

dst	The destination address.
src	The source address.
size	The size of the transfer in bytes.
channel	The index of the channel.

Returns

The DMA transfer ID.

Note

The function passes the channel argument as an immediate, thus this must be known at compile time. As a consequence, the function must use internal linkage (static keyword) and must be always inlined. This is true also for all functions invoking this function, and passing down an argument to channel.

                                                                     {
    uint32_t dst_lo = dst & 0xFFFFFFFF;
    uint32_t dst_hi = dst >> 32;
    uint32_t src_lo = src & 0xFFFFFFFF;
    uint32_t src_hi = src >> 32;
    uint32_t txid;
 
    asm volatile(
        "dmsrc %[src_lo], %[src_hi] \n"
        "dmdst %[dst_lo], %[dst_hi] \n"
        "dmcpyi %[txid], %[size], (%[channel] << 2) | 0b00 \n"
        : [ txid ] "=r"(txid)
        : [ src_lo ] "r"(src_lo), [ src_hi ] "r"(src_hi),
          [ dst_lo ] "r"(dst_lo), [ dst_hi ] "r"(dst_hi), [ size ] "r"(size),
          [ channel ] "i"(channel));
 
    return txid;
}

snrt_dma_start_1d() [2/2]

static uint32_t snrt_dma_start_1d ( volatile void * dst, volatile void * src, size_t size, const uint32_t channel = 0 )

inlinestatic

Start an asynchronous 1D DMA transfer using native-size pointers.

This is a convenience overload of snrt_dma_start_1d(uint64_t, uint64_t, size_t, uint32_t) using void* pointers.

                                                                     {
    return snrt_dma_start_1d((uint64_t)dst, (uint64_t)src, size, channel);
}

snrt_dma_start_1d_mcast() [1/2]

static uint32_t snrt_dma_start_1d_mcast ( uint64_t dst, uint64_t src, size_t size, uint32_t mask, const uint32_t channel = 0 )

inlinestatic

Start an asynchronous multicast 1D DMA transfer with 64-bit wide pointers.

Parameters

mask	Multicast mask applied on the destination address.

See also

snrt_dma_start_1d(uint64_t, uint64_t, size_t, uint32_t) for a description of the other parameters.

                                                                           {
    snrt_dma_enable_mcast(mask);
    uint32_t txid = snrt_dma_start_1d(dst, src, size, channel);
    snrt_dma_disable_mcast();
    return txid;
}

snrt_dma_start_1d_mcast() [2/2]

static uint32_t snrt_dma_start_1d_mcast ( volatile void * dst, volatile void * src, size_t size, uint32_t mask, const uint32_t channel = 0 )

inlinestatic

Start an asynchronous multicast 1D DMA transfer using native-size pointers.

This is a convenience overload of snrt_dma_start_1d_mcast(uint64_t, uint64_t, size_t, uint32_t, uint32_t) using void* pointers.

                                                                           {
    return snrt_dma_start_1d_mcast((uint64_t)dst, (uint64_t)src, size, mask,
                                   channel);
}

snrt_dma_start_2d() [1/2]

static snrt_dma_txid_t snrt_dma_start_2d ( uint64_t dst, uint64_t src, size_t size, size_t dst_stride, size_t src_stride, size_t repeat, const uint32_t channel = 0 )

inlinestatic

Start an asynchronous 2D DMA transfer with 64-bit wide pointers.

Parameters

dst	The destination address.
src	The source address.
size	The size of every 1D transfer within the 2D transfer in bytes.
dst_stride	The offset between consecutive 1D transfers at the destination, in bytes.
src_stride	The offset between consecutive 1D transfers at the source, in bytes.
repeat	The number of 1D transfers composing the 2D transfer.
channel	The index of the channel.

Returns

The DMA transfer ID.

Note

The function passes the channel argument as an immediate, thus this must be known at compile time. As a consequence, the function must use internal linkage (static keyword) and must be always inlined. This is true also for all functions invoking this function, and passing down an argument to channel.

                                                                            {
    uint32_t dst_lo = dst & 0xFFFFFFFF;
    uint32_t dst_hi = dst >> 32;
    uint32_t src_lo = src & 0xFFFFFFFF;
    uint32_t src_hi = src >> 32;
    uint32_t txid;
 
    asm volatile(
        "dmsrc %[src_lo], %[src_hi] \n"
        "dmdst %[dst_lo], %[dst_hi] \n"
        "dmstr %[src_stride], %[dst_stride] \n"
        "dmrep %[repeat] \n"
        "dmcpyi %[txid], %[size], (%[channel] << 2) | 0b10 \n"
        : [ txid ] "=r"(txid)
        : [ src_lo ] "r"(src_lo), [ src_hi ] "r"(src_hi),
          [ dst_lo ] "r"(dst_lo), [ dst_hi ] "r"(dst_hi),
          [ dst_stride ] "r"(dst_stride), [ src_stride ] "r"(src_stride),
          [ repeat ] "r"(repeat), [ size ] "r"(size), [ channel ] "i"(channel));
 
    return txid;
}

snrt_dma_start_2d() [2/2]

static uint32_t snrt_dma_start_2d ( volatile void * dst, volatile void * src, size_t size, size_t dst_stride, size_t src_stride, size_t repeat, const uint32_t channel = 0 )

inlinestatic

Start an asynchronous 2D DMA transfer using native-size pointers.

This is a convenience overload of snrt_dma_start_2d(uint64_t, uint64_t, size_t, size_t, size_t, size_t, uint32_t) using void* pointers.

                                                                     {
    return snrt_dma_start_2d((uint64_t)dst, (uint64_t)src, size, dst_stride,
                             src_stride, repeat, channel);
}

snrt_dma_start_2d_mcast() [1/2]

static uint32_t snrt_dma_start_2d_mcast ( uint64_t dst, uint64_t src, size_t size, size_t dst_stride, size_t src_stride, size_t repeat, uint32_t mask, const uint32_t channel = 0 )

inlinestatic

Start an asynchronous, multicast 2D DMA transfer with 64-bit wide pointers.

Parameters

mask	Multicast mask.

See also

snrt_dma_start_2d(uint64_t, uint64_t, size_t, size_t, size_t, size_t, uint32_t) for a description of the other parameters.

                                                                           {
    snrt_dma_enable_mcast(mask);
    uint32_t txid = snrt_dma_start_2d(dst, src, size, dst_stride, src_stride,
                                      repeat, channel);
    snrt_dma_disable_mcast();
    return txid;
}

snrt_dma_start_2d_mcast() [2/2]

static uint32_t snrt_dma_start_2d_mcast ( volatile void * dst, volatile void * src, size_t size, size_t dst_stride, size_t src_stride, size_t repeat, uint32_t mask, const uint32_t channel = 0 )

inlinestatic

Start an asynchronous, multicast 2D DMA transfer using native-size pointers.

This is a convenience overload of snrt_dma_start_2d_mcast(uint64_t, uint64_t, size_t, size_t, size_t, size_t, uint32_t, uint32_t) using void* pointers.

                                                                           {
    return snrt_dma_start_2d_mcast((uint64_t)dst, (uint64_t)src, size,
                                   dst_stride, src_stride, repeat, mask,
                                   channel);
}

snrt_dma_start_tracking()

void snrt_dma_start_tracking ( )

inline

Start tracking of dma performance region. Does not have any implications on the HW. Only injects a marker in the DMA traces that can be analyzed.

Deprecated

{ asm volatile("dmstati zero, 0 \n"); }

snrt_dma_stop_tracking()

void snrt_dma_stop_tracking ( )

inline

Stop tracking of dma performance region. Does not have any implications on the HW. Only injects a marker in the DMA traces that can be analyzed.

Deprecated

{ asm volatile("dmstati zero, 0 \n"); }

snrt_dma_store_1d_tile()

snrt_dma_txid_t snrt_dma_store_1d_tile ( void * dst, void * src, size_t tile_idx, size_t tile_size, uint32_t prec )

inline

Store a tile to a 1D array.

Parameters

dst	Pointer to the destination array.
src	Pointer to the source tile.
tile_idx	Index of the tile in the 1D array.
tile_size	Number of elements within a tile of the 1D array.
prec	Number of bytes of each element in the 1D array.

                                                             {
    size_t tile_nbytes = tile_size * prec;
    return snrt_dma_start_1d((uint64_t)dst + tile_idx * tile_nbytes,
                             (uint64_t)src, tile_nbytes);
}

snrt_dma_store_2d_tile() [1/2]

snrt_dma_txid_t snrt_dma_store_2d_tile ( void * dst, void * src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec )

inline

Store a 2D tile of a 2D array.

The stride in the source tile is assumed to be that of a 1D tile, effectively. In other words, this is the same as snrt_dma_1d_to_2d().

See also

snrt_dma_store_2d_tile(void *, void *, size_t, size_t, size_t, size_t, size_t, uint32_t, size_t) for a detailed description of the parameters.

                   {
    return snrt_dma_store_2d_tile(dst, src, tile_x1_idx, tile_x0_idx,
                                  tile_x1_size, tile_x0_size, full_x0_size,
                                  prec, tile_x0_size * prec);
}

snrt_dma_store_2d_tile() [2/2]

snrt_dma_txid_t snrt_dma_store_2d_tile ( void * dst, void * src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec, size_t tile_ld )

inline

Store a 2D tile to a 2D array.

Parameters

dst	Pointer to the destination array.
src	Pointer to the source tile.
tile_x1_idx	Outermost coordinate of the tile in the 2D array.
tile_x0_idx	Innermost coordinate of the tile in the 2D array.
tile_x1_size	Number of elements in the outermost dimension of the tile.
tile_x0_size	Number of elements in the innermost dimension of the tile.
full_x0_size	Number of elements in the innermost dimension of the array.
prec	Number of bytes of each element in the 2D array.
tile_ld	Leading dimension of the tile, in bytes.

                                   {
    size_t dst_offset = 0;
    // Advance dst array in x0 and x1 dimensions, and convert to byte offset
    dst_offset += tile_x0_idx * tile_x0_size;
    dst_offset += tile_x1_idx * tile_x1_size * full_x0_size;
    dst_offset *= prec;
    // Initiate transfer
    return snrt_dma_start_2d((uint64_t)dst + dst_offset,  // dst
                             (uint64_t)src,               // src
                             tile_x0_size * prec,         // size
                             full_x0_size * prec,         // dst_stride
                             tile_ld,                     // src_stride
                             tile_x1_size                 // repeat
    );
}

snrt_dma_store_2d_tile_from_banks()

snrt_dma_txid_t snrt_dma_store_2d_tile_from_banks ( void * dst, void * src, size_t tile_x1_idx, size_t tile_x0_idx, size_t tile_x1_size, size_t tile_x0_size, size_t full_x0_size, uint32_t prec, size_t num_banks )

inline

Store a 2D tile of a 2D array from a 1D layout occupying a subset of TCDM banks.

Parameters

dst	Pointer to the destination array.
src	Pointer to the source tile.
tile_x1_idx	Outermost coordinate of the tile in the 2D array.
tile_x0_idx	Innermost coordinate of the tile in the 2D array.
tile_x1_size	Number of elements in the outermost dimension of the tile.
tile_x0_size	Number of elements in the innermost dimension of the tile.
full_x0_size	Number of elements in the innermost dimension of the array.
prec	Number of bytes of each element in the 2D array.
num_banks	Number of banks the tile is stored in.

                                     {
    // Calculate new tile size after reshaping the tile in the selected banks
    size_t tile_x0_size_in_banks = (num_banks * SNRT_TCDM_BANK_WIDTH) / prec;
    size_t tile_x1_size_in_banks =
        ceil((tile_x1_size * tile_x0_size) / (double)tile_x0_size_in_banks);
    size_t tile_ld = SNRT_TCDM_HYPERBANK_WIDTH;
    return snrt_dma_store_2d_tile(dst, src, tile_x1_idx, tile_x0_idx,
                                  tile_x1_size_in_banks, tile_x0_size_in_banks,
                                  full_x0_size, prec, tile_ld);
}

snrt_dma_wait()

static void snrt_dma_wait ( snrt_dma_txid_t txid, const uint32_t channel = 0 )

inlinestatic

Block until a DMA transfer finishes on a specific DMA channel.

Parameters

txid	The DMA transfer's ID.
channel	The index of the channel.

Note

The function passes the channel argument as an immediate, thus this must be known at compile time. As a consequence, the function must use internal linkage (static keyword) and must be always inlined. This is true also for all functions invoking this function, and passing down an argument to channel.

                                                             {
    asm volatile(
        "1: \n"
        "dmstati t0, (%[channel] << 2) | 0 \n"
        "bltu t0, %[txid], 1b \n"
        :
        : [ txid ] "r"(txid), [ channel ] "i"(channel)
        : "t0");
}

snrt_dma_wait_all()

static void snrt_dma_wait_all ( const uint32_t channel = 0 )

inlinestatic

Block until a specific DMA channel is idle.

Parameters

channel

The index of the channel.

Note

The function passes the channel argument as an immediate, thus this must be known at compile time. As a consequence, the function must use internal linkage (static keyword) and must be always inlined. This is true also for all functions invoking this function, and passing down an argument to channel.

                                                                 {
    uint32_t busy;
    asm volatile(
        "1: \n"
        "dmstati %[busy], (%[channel] << 2) | 2 \n"
        "bne %[busy], zero, 1b \n"
        : [ busy ] "=r"(busy)
        : [ channel ] "i"(channel));
}

snrt_dma_wait_all_channels()

void snrt_dma_wait_all_channels ( uint32_t num_channels )

inline

Block until the first num_channels channels are idle.

Parameters

num_channels

The number of channels to wait on.

                                                              {
    for (int c = 0; c < num_channels; c++) {
        snrt_dma_wait_all(c);
    }
}