STM32 feature DMAMUX

[Markus M. (adrock)]

Hi,

ich habe beim Stöbern im STM32G0xx Refmanual den DMAMUX gefunden.

Kann mir jmd. in verständlichen Worten erklären, was man damit genau 
machen kann?

Ich habe mir die englischsprachige Präsentation und die AN5224 
angesehen, aber so ganz verstehe ich es noch nicht.

Gut, man kann über externe Eingänge wie z.B. EXTI0 oder auch über einen 
Timer dann DMA-Transfers triggern.

Aber was noch? Speziell das "Multiplexing" erschließt sich mir noch 
nicht.

Gruß
Markus

[Kevin M. (arduinolover)]

Ohne nachgelesen zu haben meine ich das es darum geht jeden DMA Kanal 
für jede Peripherie nutzen zu können, wenn ich mich richtig erinnere.

Das geht bei den älteren STM32 nicht, da konnten für SPI z.B. nur 
gewisse DMA Kanäle genutzt werden.

[Ben S. (bensch123)]

Beim neuen STM32WB55 nutze ich diesen. Damit kann ich quasi auf einen 
DMA Kanal eine beliebige Peripherie mappen.

Antwort ohne Gewehr (peng). Aber eine Begrenzung ist mir spontan nicht 
bekannt.

[Markus M. (adrock)]

Also es ist offenbar tatsächlich das (freie) Mapping zwischen der 
Peripherie und einem DMA-Kanal, zusätzlich die anderen Zusatzfunktionen 
wie triggern durch externes Event etc.

So wie ich es sehe bzw. ausprobiert habe, MUSS man den sogar benutzen, 
sonst kommt der DMA-Request von der Peripherie garnicht beim DMA-Kanal 
an.

[ES (Gast)]

Hi

Ich versuche aktuell meinen SPI Treiber DMA-gesteuert mit meinem 
STM32G031 zum Laufen zu bringen. Aktuell tut sich da leider noch gar 
nichts und ich habe den Verdacht, dass die Peripheral Request nicht 
wirklich beim DMA Controller ankommt und die einzige Geschichte, die ich 
noch nicht so wirklich verstanden habe ist diejenige des DMAMUX.

Kurz zum Verständnis, wenn ich für SPI1_Rx den Channel 3 vom DMA und für 
SPI1_Tx den Channel 4 vom DMA verwenden will, muss ich dann im DMAMUX 
request line multiplexer channel x configuration register (DMAMUX_CxCR) 
ebenfalls die Channels 3 und 4 nutzen oder fungieren die unabhängig 
voneinander?

SPI1_Rx und SPI1_Tx haben gemäss Reference Manual den DMA request MUX 
input 16 bzw 17. Folglich müsste meiner Meinung nach eine 
Initialisierung des Registers so aussehen:

DMAMUX1_Channel3->CCR |= DMAMUX_CxCR_DMAREQ_ID_4 | DMAMUX_CxCR_EGE;
DMAMUX1_Channel4->CCR |= DMAMUX_CxCR_DMAREQ_ID_4 | DMAMUX_CxCR_DMAREQ_ID_0 | DMAMUX_CxCR_EGE;

Zumindest habe ich aus dem Reference Manual verstanden, dass das so 
genügen dürfte, weiss allerdings auch nicht, ob der Wurm wirklich hier 
begraben ist, ich nehme an es gibt keine Möglichkeit zu überprüfen, ob 
vom SPI eine Request am DMA ankommt

[Markus M. (adrock)]

Okay, hier mal mein Code (ist nur SPI Übertragung, Empfang dürfte dann 
aber entsprechend gehen):

Initialisierung, nicht die Clocks vergessen!

void spi_init(void) {

    SET_BIT(RCC->IOPENR, RCC_IOPENR_GPIOAEN_Msk);   // Enable GPIOA clock
    SET_BIT(RCC->APBENR2, RCC_APBENR2_SPI1EN_Msk);  // Enable SPI1 clock
    SET_BIT(RCC->AHBENR, RCC_AHBENR_DMA1EN_Msk);    // Enable DMA1 clock

    // Initalize GPIO

    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE12_Msk, GPIO_MODER_MODE12_1);  // PA12 == AF
//    SET_BIT(GPIOA->OTYPER, GPIO_OTYPER_OT12_Msk);   // PA12 == OpenDrain
    CLEAR_BIT(GPIOA->AFR[1], GPIO_AFRH_AFSEL12_Msk); // AF0 == SPI1 MOSI

    // Initialize SPI

    WRITE_REG(SPI1->CR1, SPI_CR1_SSM_Msk|SPI_CR1_SSI_Msk|(0b010<<SPI_CR1_BR_Pos)|
        SPI_CR1_SPE_Msk|SPI_CR1_MSTR_Msk);
    MODIFY_REG(SPI1->CR2, SPI_CR2_DS_Msk, (7<<SPI_CR2_DS_Pos));
}

Übetragung:

/** \brief Transmit SPI data block by using DMA
 *
 * \param data    Pointer to data
 * \param size    Size of data to send
 */
void spi_txdma(uint8_t *data, uint16_t size) {

    // Disable DMA first and clear any status flags, just in case

    CLEAR_BIT(SPI1->CR2, SPI_CR2_TXDMAEN_Msk);
    CLEAR_BIT(DMA1_Channel1->CCR, DMA_CCR_EN_Msk);
    SET_BIT(DMA1->IFCR, DMA_IFCR_CGIF1_Msk);

    // Setup DMA channel #1 as mem -> peripheral

    WRITE_REG(DMA1_Channel1->CPAR, ((uint32_t) &(SPI1->DR)) + 1);
    WRITE_REG(DMA1_Channel1->CMAR, (uint32_t) data);
    WRITE_REG(DMA1_Channel1->CNDTR, size);
    WRITE_REG(DMA1_Channel1->CCR, DMA_CCR_MINC_Msk|DMA_CCR_DIR_Msk);
    WRITE_REG(DMAMUX1_Channel0->CCR, 17); // Assign SPI1 TX to DMA1_Channel0 using DMAMUX
    SET_BIT(DMA1_Channel1->CCR, DMA_CCR_EN_Msk);

    // Start new transfer

    SET_BIT(SPI1->CR2, SPI_CR2_TXDMAEN_Msk);
}

Ist also so ähnlich wie bei Dir und funktioniert.

[ES (Gast)]

Hmm vielleicht übernehme ich das mal so und schaue, was passiert. Kann 
ja aktuell nicht mal transmitten.

WRITE_REG(DMA1_Channel1->CPAR, ((uint32_t) &(SPI1->DR)) + 1);

Die Zeile verstehe ich nicht ganz, warum "+1", ich nahm an im CPAR 
Register soll die Adresse des Datenregisters des entsprechenden 
Peripherals (In unserem Fall ja das SPI Datenregister) gespeichert 
werden?

[ES (Gast)]

Der Code funktioniert leider ebenfalls nicht. Bei mir sieht das 
folgendermassen aus:

void spi_init(void)
{
// enable DMA1, SPI1 Clock
    SET_BIT(RCC->IOPENR, RCC_IOPENR_GPIOAEN);     // Enable GPIOA clock
    SET_BIT(RCC->AHBENR, RCC_AHBENR_DMA1EN);      // DMA1 clock enable
    SET_BIT(RCC->APBENR2, RCC_APBENR2_SPI1EN);    // SPI1 clock enable
    
    // Configuration of SPI
    // Configuring GPIO for MOSI, MISO and SCK pins
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE5, GPIO_MODER_MODE5_1);
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE6, GPIO_MODER_MODE6_1); 
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE7, GPIO_MODER_MODE7_1);
    WRITE_REG(GPIOA->AFR[0], 0x0);  // Connecting the I/Os PA5-PA7 to the 
                                       desired alternate function (AF0)

    // Writing to the SPI_CR1 register
    WRITE_REG(SPI1->CR1, SPI_CR1_BR_0 + SPI_CR1_MSTR);

    // Writing to the SPI_CR2 register
    WRITE_REG(SPI1->CR2, SPI_CR2_FRXTH + SPI_CR2_SSOE + SPI_CR2_TXDMAEN +        
              SPI_CR2_RXDMAEN);

    // Write proper DMA registers: Configure DMA streams dedicated for SPI 
    // Tx and Rx in DMA registers
    // Configuration of DMA
    // Set peripheral register address int the DMA_CPARx register
    WRITE_REG(DMA1_Channel3->CPAR, (uint32_t)&SPI1->DR);
    WRITE_REG(DMA1_Channel4->CPAR, (uint32_t)&SPI1->DR);

    // Configure the parameters in the DMA_CCRx register
    // For Receive Channel RX
    WRITE_REG(DMA1_Channel3->CCR, DMA_CCR_PL_1 + DMA_CCR_MINC +  
              DMA_CCR_TCIE);

    // For Transmit Channel TX
    WRITE_REG(DMA1_Channel4->CCR, DMA_CCR_DIR +  DMA_CCR_MINC);

    // DMA Channel Remap
    MODIFY_REG(DMAMUX1_Channel3->CCR, DMAMUX_CxCR_DMAREQ_ID, 16);
    SET_BIT(DMAMUX1_Channel3->CCR, DMAMUX_CxCR_EGE);
    MODIFY_REG(DMAMUX1_Channel4->CCR, DMAMUX_CxCR_DMAREQ_ID, 17);
    SET_BIT(DMAMUX1_Channel4->CCR, DMAMUX_CxCR_EGE);

    NVIC_EnableIRQ(DMA1_Channel2_3_IRQn);   // Enable DMA Interrupt
}

uint32_t spi_transfer(uint8_t* pu8_dataTransmit, uint8_t* pu8_dataReceive, uint16_t u16_count)
{
    SET_BIT(SPI1->CR1,SPI_CR1_SPE);           // SPI enable

    // CMAR --> Channel x memory address register
    // CMAR contains the base address of the memory from/to which the data 
    // will be read/written
    WRITE_REG(DMA1_Channel3->CMAR, (uint32_t)pu8_dataReceive);
    WRITE_REG(DMA1_Channel4->CMAR, (uint32_t)pu8_dataTransmit);

    // Number of data to transfer (0 to 2^16 - 1)
    WRITE_REG(DMA1_Channel3->CNDTR, u16_count);
    WRITE_REG(DMA1_Channel4->CNDTR, u16_count);

    SET_BIT(DMA1_Channel3->CCR, DMA_CCR_EN);  // enable RX DMA
    SET_BIT(DMA1_Channel4->CCR, DMA_CCR_EN);  // enable TX DMA

    CLEAR_BIT(DMA1_Channel3->CCR, DMA_CCR_EN);  // disable RX DMA    
    CLEAR_BIT(DMA1_Channel4->CCR, DMA_CCR_EN);  // disable TX DMA

    CLEAR_BIT(SPI1->CR1,SPI_CR1_SPE);           // SPI disable
}

Ich habe es mir vorerst noch erspart, irgendwelche RXNE/TXE oder BSY 
Bits abzufragen, denn noch findet ohnehin keine Kommunikation statt, die 
Bits sind also so oder so nicht gesetzt. Ich vermute nach wie vor, das 
beim DMA Controller gar keine Request ankommt, da das TXE bit gesetzt 
bleibt, der Buffer also stets empty ist und offenbar keine Daten ins SPI 
Datenregister geschrieben werden.

[Markus M. (adrock)]

ES schrieb:

>

> WRITE_REG(DMA1_Channel1->CPAR, ((uint32_t) &(SPI1->DR)) + 1);
>

>
> Die Zeile verstehe ich nicht ganz, warum "+1", ich nahm an im CPAR
> Register soll die Adresse des Datenregisters des entsprechenden
> Peripherals (In unserem Fall ja das SPI Datenregister) gespeichert
> werden?

Stimmt. Eigentlich ist es tatsächlich falsch bzw. funktioniert wohl 
trotzdem aufgrund der Gutmütigkeit der HW in meinem Projekt (ich benutze 
diesen Code seit vielen Stunden in einem Deko-Projekt mit WS2812-LEDs 
ohne jeglichen Fehler).

Ich glaube mein Gedanke war, dass ich ja nur 8-Bit übertrage, das 
Register aber 16-Bit groß ist. Mir war allerdings entgangen, dass der 
Speicher als little endian organisiert ist, also die Bits 0-7 des 
Registers tatsächlich im ersten Byte liegen.

Muss ich bei Gelegenheit mal testen ob es ohne das "+1" bei mir auch 
noch funktioniert.

[Markus M. (adrock)]

Also ich habe das "+1" tatsächlich aus meinem Code entfernen können und 
er funktioniert nach wie vor problemlos.

Da scheint die Hardware intelligent genug zu sein, je nachdem ob man in 
das High-oder Low-Byte schreibt wird das dann entsprechend in den TX 
FiFo übernommen.

    SET_BIT(DMA1_Channel3->CCR, DMA_CCR_EN);  // enable RX DMA
    SET_BIT(DMA1_Channel4->CCR, DMA_CCR_EN);  // enable TX DMA
    CLEAR_BIT(DMA1_Channel3->CCR, DMA_CCR_EN);  // disable RX DMA    
    CLEAR_BIT(DMA1_Channel4->CCR, DMA_CCR_EN);  // disable TX DMA

Warum löscht Du denn eigentlich die Enable-Bits gleich wieder nachdem Du 
sie gesetzt hast? Da kann es doch eigentlich garnicht funktionieren.

Du müsstest schon warten bis der DMA-Transfer fertig ist.

[RG (Gast)]

Meinen Dank in die Runde, diese Antworten Code-Schnipsel haben auch mir 
geholfen. Da ich ein leicht anderes Problem hatte (und Google mich 
hierher geführt hat), möchte ich dieses explizit betonen:

Bekannt ist, dass je ein Dmamux-Kanal hart verdrahtet ist mit je einem 
Dma-Kanal. Bei älteren Stm32Fxxx gibt es salopp gesagt einen Dma-Kanal, 
der nur Spi kann, und einen weiteren für Uart. Die G-Familie hat einen 
Dmamux, wo jeder Dma-Kanal die zugehörige Peripherie einstellbar hat, 
mittels DMAMUX > CxCR > DMAREQ_ID.

Woran ist es bei mir gescheitert? Hier ein Auszug aus der stm32g031xx.h:

#define DMA1_Channel1       ((DMA_Channel_TypeDef *) DMA1_Channel1_BASE)
#define DMA1_Channel2       ((DMA_Channel_TypeDef *) DMA1_Channel2_BASE)
#define DMA1_Channel3       ((DMA_Channel_TypeDef *) DMA1_Channel3_BASE)
#define DMA1_Channel4       ((DMA_Channel_TypeDef *) DMA1_Channel4_BASE)
#define DMA1_Channel5       ((DMA_Channel_TypeDef *) DMA1_Channel5_BASE)
#define DMAMUX1                ((DMAMUX_Channel_TypeDef *) DMAMUX1_BASE)
#define DMAMUX1_Channel0       ((DMAMUX_Channel_TypeDef *) DMAMUX1_Channel0_BASE)
#define DMAMUX1_Channel1       ((DMAMUX_Channel_TypeDef *) DMAMUX1_Channel1_BASE)
#define DMAMUX1_Channel2       ((DMAMUX_Channel_TypeDef *) DMAMUX1_Channel2_BASE)
#define DMAMUX1_Channel3       ((DMAMUX_Channel_TypeDef *) DMAMUX1_Channel3_BASE)
#define DMAMUX1_Channel4       ((DMAMUX_Channel_TypeDef *) DMAMUX1_Channel4_BASE)

DMA1_Channel1 ist hart verdrahtet mit DMAMUX1_Channel0, DMA1_Channel5 
ist hart verdrahtet mit DMAMUX1_Channel4, allgemein: DMA1_Channel[x+1] 
ist hart verdrahtet mit DMAMUX1_Channel[x]. Umgekehrt: Ich habe 
DMA1_Channel1 und DMAMUX1_Channel1 (sowie jew. 4) konfiguriert, der 
Compiler kann den Fehler nicht sehen und meine Events laufen ins Leere.

In meiner spi.h ist das wie folgt gelöst:

#define DMA_Channel_BP_Rx DMA1_Channel1
#define DMA_Channel_BP_Tx DMA1_Channel4
#define DMA_Channel_BP_Rx_IRQn DMA1_Channel1_IRQn
// Note, that stm32g031xx.h enumerates DMA1_Channel1..5 and DMAMUX1_Channel0..4 so DMAMUX1_Channel(x) applies to DMA1_Channel(x+1)
#define DMAMUX_Channel_BP_Rx DMAMUX1_Channel0
#define DMAMUX_Channel_BP_Tx DMAMUX1_Channel3

#define BP_Rx_IRQHandler DMA1_Channel1_IRQHandler
#define DMA_ISR_BP_Rx DMA_ISR_TCIF1
#define DMA_IFCR_BP_Rx DMA_IFCR_CTCIF1

Notiz am Rande: Die Low-Level-Funktionen von CubeMx haben ja durchaus 
ihre Berechtigung. Geschickt ist, dass die LL_DMA_SetPeriphRequest() auf 
den Dmamux zielt, aber als Parameter den Dma-Kanal nutzt. Damit steht in 
der spi.c steht immer der gleiche Kanal, also niemals ein "+1". Das 
funktioniert, weil die Werte der defines alle beim Offset 0 starten.

Interessant, dass ich auch einen Fehler mit diesem "+1" hatte.

Nochmals Danke in die Runde! Ich hoffe, dass meine Antwort hier 
niemandem hilft und euch mein Ärger erspart blieb.