Use DMA in custom C module without breaking Micropython DMA definitions

[eliclement]

Does anybody know how I can use DMA for a SPI peripheral inside a custom C module without interfering with the micropython dma implementation? I am working on a stm32h743 nucleo board and the goal is to have a non-blocking write/send SPI function. Apparently the SPI call in micropython is blocking until the transfer is complete (for that part of the application I really need the speed to update the peripheral very frequently driven by a timer interrupt so micropython for this part is a no-go). Building my own c code for the SPI using DMA (using the ST examples) interferes with the already defined DMA definitions/handles/streams etc in dma.c of the stm32 port. Completely deleting the dma.c here is not what I want, as 80% of the application is running micropython code which works great.
Any ideas?

[andrewleech]

You can configure and use the DMA in a user C module, I've done this recently to work with timer capture units. You do need to choose channels that aren't already in use on the particular chip you're using.

I had to use a mix of the microypthon dma init functions (to ensure the correct handles are configured that the interrupts expect) as well as the HAL functions (to configure settings not exposed by the micropython functions).

Here's some snippets from my C code, hopefully they help

#include "py/runtime.h"
#include "py/mphal.h"

#include "ports/stm32/dma.h"
#include "ports/stm32/pin.h"
#include "ports/stm32/timer.h"

#define SIGGEN_DMA_CHANNEL DMA2_Channel1
#define SIGGEN_DMA_CHANNEL_IRQ DMA2_Channel1_IRQn

// Look at <SIGGEN_DMA_CHANNEL>_IRQHandler in src/micropython/ports/stm32/dma.c
// Set the matching dma_id_x used there here
#define SIGGEN_DMA_CHANNEL_ID dma_id_7

// Start
    // Configure and start the DMA
    __HAL_RCC_DMA2_CLK_ENABLE();

    DMA_InitTypeDef dma_conf = {
        .PeriphInc = DMA_PINC_DISABLE,
        .MemInc = DMA_MINC_ENABLE,
        .PeriphDataAlignment = DMA_PDATAALIGN_WORD,
        .MemDataAlignment = DMA_MDATAALIGN_BYTE,
        .Mode = DMA_CIRCULAR,
        .Priority = DMA_PRIORITY_HIGH
    };

    dma_descr_t dma_descr = {SIGGEN_DMA_CHANNEL, self->dma_trigger, SIGGEN_DMA_CHANNEL_ID, &dma_conf};
    dma_init(&self->dma_handle, &dma_descr, DMA_MEMORY_TO_PERIPH, self);

    // dma_init() above does not support custom IRQ callbacks, re-init them here.
    self->dma_handle.XferCpltCallback = &XferCpltCallback;
    self->dma_handle.XferHalfCpltCallback = &XferHalfCpltCallback;
    if (HAL_DMA_Init(&self->dma_handle) != HAL_OK) {
        mp_raise_ValueError(MP_ERROR_TEXT("Unable to init DMA unit with provided details"));
    }
    // This Parent attribute is passed to irq functions above.
    self->dma_handle.Parent = self;

    // Start the DMA in interrupt mode.
    pyb_timer_obj_t *dma_timer = MP_OBJ_TO_PTR(self->dma_timer);
    HAL_DMA_Start_IT(&self->dma_handle, (uint32_t)dma_buffer, self->dma_dest_address, SIGGEN_DMA_DEPTH);
    __HAL_TIM_ENABLE_DMA(&dma_timer->tim, (TIM_DMA_CC1 << (self->dma_tim_channel_idx - 1)));

    NVIC_SetPriority(SIGGEN_DMA_CHANNEL_IRQ, IRQ_PRI_DMA);
    HAL_NVIC_EnableIRQ(SIGGEN_DMA_CHANNEL_IRQ);

// Stop
    const dma_descr_t dma_descr = {SIGGEN_DMA_CHANNEL, self->dma_trigger, SIGGEN_DMA_CHANNEL_ID, &self->dma_handle.Init};
    dma_deinit(&dma_descr);

    if (self->dma_handle.Instance != NULL) {
        HAL_DMA_DeInit(&self->dma_handle);
    }

[eliclement]

commenting the spi_wait_dma_finished line in the spi_transfer function of spi.c gives me a ETIMEOUT...
Any idea why this happens?

[andrewleech]

There's three different copies of that line in the spi transfer function for send, receive and both. They also potentially get run in a loop depending on the size of len and whether it all gets handed in the first iteration.
To handle bigger transfers some kind of interrupt or asyncio behaviour will need to be added so that each iteration can be continued in the background.

[eliclement]

Yes i know, but my goal is to be able to use multiple SPI busses sending out small packets at regular intervals (triggered by an interrupt) from my C code. When the first SPI does its transfer, it will block until it is finished and after that I can start sending out on the next SPI bus etc. I want to be able to start all transfers rapidly so the transfers (using DMA) can run more or less concurrently instead of sequentially. I moved to a c module as I thought I could omit the blocking spi_transfer call somehow...

[eliclement]

@andrewleech can you elaborate a bit on your snippet where you use:

self->dma_handle.XferCpltCallback = &XferCpltCallback;
self->dma_handle.XferHalfCpltCallback = &XferHalfCpltCallback;

Are those your own custom callback functions or are they already defined elsewhere?
The reason why I ask is that I have a good transfer using HAL_SPI_Transmit_DMA but it hangs after transmit. So there is some callback issue that is not being handled properly after the transmission took place.
Another question: your reference to "self" is this a SPI struct? (i want to understand why self->dma_handle.Parent = self;)

[andrewleech]

They're custom callbacks, I was using this to ping pong between two lookup table buffers which the dma is copying from.

The self here is a custom struct/object holding a bunch of dma and timer related objects