Testing DMA on T4.1

ochsenkopf · Jan 13, 2023

Hey,

I've tried to get the DMA running on my Teensy4.1. Until now unsuccessful. Im using Arduino2.0.3 on Windows. I've read through this post by miciwan trying to write from a single uint32_t to the GPIO1_DR to light up a LED connected to pin 23 (GPIO1_IO25 when i understood correctly).

I'm using

Code:

<DMAChannel.h>

and first tried to set it up with source() and destination() and trigger it by triggerManual() as well as triggerContinously().

I then looked into output_pwm.cpp in the Audio Library to set the DMA TCD up manually, but it didn't work as well.

I tested my GPIO configuration by just writing to GPIO1_DR directly and it worked fine.

Here's my full test code:

Code:

#include <DMAChannel.h>

DMAChannel dma;

// The content of this should be written to GPIO1_DR
uint32_t DMAMEM dmasource = 1 <<25;

void setup() {

  // Setup Pin23 / GPIO1_IO25 as Output on the low speed GPIO port

  IOMUXC_SW_MUX_CTL_PAD_GPIO_AD_B1_09 = 5;
  IOMUXC_GPR_GPR26 &= ~(0x0FCC0000u);

  GPIO1_GDIR |= 1 << 25;

  //GPIO1_DR = 1 <<25; // Tested the LED and wether my pin config is right. It worked

  dma.begin(true);
  dma.TCD->SADDR = &dmasource;       // getting data from the variable above
  dma.TCD->SOFF = 0;                         // dont change the adress afterwards
  dma.TCD->NBYTES = 4;                     // uint32_t is 4 bytes in size
  dma.TCD->DOFF = 0;                        // dont make changes to the destination adress
  dma.TCD->CITER = 1;                       // One minor loop of getting the 4 bytes
  dma.TCD->BITER = 1;
  dma.TCD->DADDR = &GPIO1_DR;     // Destination adress
  dma.enable(); // enabling the DMA 
  dma.triggerContinously();                 // triggering the DMA
  
}

void loop() {
  
}

Did I miss something obvious? Im kind of stuck at this point. Or does this even make sense? I just wanted to test the DMA functionality so I can use it later if needed

KurtE · Jan 13, 2023

Sorry, each time I do DMA it takes a bit to get it working. And I have never tried triggerContinously. I typically would want it driven at some specific speed or the like.

Most of my usages have been with SPI and some with ADC pins.

Some example code in the system, to look at:

Paul has DMA output to pins in the OctoWS2811 library (part of Teensyduino release). Look at the OctoWS2811_imxrt.cpp file. - Note it uses timer and XBAR to connect up the timer.

The ADC library has code to do DMA inputs from ADC pins. It has examples of triggering it by completion of ADC operation, likewise it has example of triggering by timer.

Note: when I am working with DMA, whenever possible I try to avoid doing the direct mucking of the TCD registers, like SOFF, NBYTES...

Instead, I prefer to use the helper code/classes, that are port of the core code. Look at DMAChannel.h and .cpp which you are partially using.

But a lot of your code could be setup like:

Code:

  dma.begin(true);
  dma.source(&dmasource);
  dma.destination(&GPIO1_DR);
  dma.enable(); // enabling the DMA 
  dma.triggerContinously();                 // triggering the DMA

But again, would probably try to setup to do something, like timer

ochsenkopf · Jan 13, 2023

Thanks for your reply,

I actually tried it with the setup functions from the library at first. They didn't work neither.

I also looked into the WS2811_imxrt.cpp, but Paul mostly sets the DMAs up by writing to the TCD directly
I also tried attaching an interrupt on completion to test wether the DMA does anything and finishes. The interrupt did not execute once. So it really might has something to do with triggering.

I'll try setting up a timer and also will take a look into the reference manual later.

KurtE · Jan 13, 2023

Here is one that blinks the LED...

Code:

// Quick and dirty sketch to see if I can blink the LED on T4.x using DMA.
//Which is pin GPIO 2 pin 3 
#define PIN_NUMBER 13
#include <DMAChannel.h>
DMAChannel dma1;
extern "C" {
  extern void xbar_connect(unsigned int input, unsigned int output);
  extern void quadtimer_init(IMXRT_TMR_t *p);
  extern void quadtimerWrite(IMXRT_TMR_t *p, unsigned int submodule, uint16_t val);
  extern void quadtimerFrequency(IMXRT_TMR_t *p, unsigned int submodule, float frequency);
}

uint32_t g_out_mask = 0;
uint8_t  g_pin_bit;
uint8_t  g_low_port_number; // 0 biased.


volatile uint32_t *standard_gpio_addr(volatile uint32_t *fastgpio)
{
	return (volatile uint32_t *)((uint32_t)fastgpio - 0x01E48000);
}

void initPin(uint8_t pin) 
{
  pinMode(pin, OUTPUT);  // make sure we start off as output.
  uint8_t bit = digitalPinToBit(pin);
  uint8_t offset = ((uint32_t)portOutputRegister(pin) - (uint32_t)&GPIO6_DR) >> 14;
  Serial.printf("pin %d, offset=%d, bit=%d\n", pin, offset, bit);
  g_pin_bit = bit;
  g_low_port_number = offset;
  g_out_mask = 1 << bit;
  Serial.printf("Mask: %x\n", g_out_mask);
  //bitmask[offset] |= g_out_mask;
  *(&IOMUXC_GPR_GPR26 + offset) &= ~g_out_mask;
  *standard_gpio_addr(portModeRegister(pin)) |= g_out_mask;
} 


void  qtimer_init(float freq)  // try at 20 hz for test...
{
  Serial.println("Try to init QTimer"); Serial.flush();
  quadtimer_init(&IMXRT_TMR4);
  quadtimerFrequency(&IMXRT_TMR4, 0, freq);
  quadtimerWrite(&IMXRT_TMR4, 0, 5);

  Serial.println("After Qtimer init"); Serial.flush();
}
void xbar_init() {
  CCM_CCGR2 |= CCM_CCGR2_XBAR1(CCM_CCGR_ON);   //turn clock on for xbara1
  xbar_connect(XBARA1_IN_QTIMER4_TIMER0, XBARA1_OUT_DMA_CH_MUX_REQ30);   // QTimer to adc_etc
	XBARA1_CTRL0 = 	XBARA_CTRL_STS0 | XBARA_CTRL_EDGE0(3) | XBARA_CTRL_DEN0;

  Serial.println("After xbar_init");
}

void dumpDMA(DMABaseClass *dmabc)
{
  typedef struct  __attribute__((packed, aligned(4))) {
  uint32_t SADDR;
  int16_t SOFF;
  uint16_t ATTR;
  uint32_t NBYTES;
  int32_t SLAST;
  uint32_t DADDR;
  int16_t DOFF;
  uint16_t CITER;
  int32_t DLASTSGA;
  uint16_t CSR;
  uint16_t BITER;
} TCD_DEBUG;
TCD_DEBUG *tcd = (TCD_DEBUG*)dmabc->TCD;
  Serial.printf("%08x %04x %04x %08x %08x ", tcd->SADDR, tcd->SOFF, tcd->ATTR, tcd->NBYTES, tcd->SLAST);
  Serial.printf("%08x %04x %04x %08x %04x %04x\n", tcd->DADDR, tcd->DOFF, tcd->CITER, tcd->DLASTSGA,
                tcd->CSR, tcd->BITER);
}


void dma_init() {
	dma1.begin();
  dma1.source(g_out_mask); 
  switch (g_low_port_number) {
    case 0: dma1.destination(GPIO1_DR_TOGGLE); break;
    case 1: dma1.destination(GPIO2_DR_TOGGLE); break;
    case 2: dma1.destination(GPIO3_DR_TOGGLE); break;
    case 3: dma1.destination(GPIO4_DR_TOGGLE); break;
  }
	dma1.triggerAtHardwareEvent(DMAMUX_SOURCE_XBAR1_0);
  dma1.transferCount(100);
	dma1.disableOnCompletion();

  dumpDMA(&dma1);
}

void setup() {
  // let pinMode setup pin 13 for us:
  while (!Serial && millis() < 4000) ; // don't need it but for debug
  initPin(PIN_NUMBER);
  qtimer_init(10.0);
  xbar_init();
  dma_init();
  dma1.clearComplete();
  dma1.enable();
  
  // Lets see if it completes
  Serial.println("Setup complete");
  elapsedMillis em;
  while (!dma1.complete()) {
    if (em > 1000) {
      Serial.printf("\tCITER:%u BITER:%u\n", dma1.TCD->CITER, dma1.TCD->BITER);
      em = 0;
    }
  }
  Serial.println("Completed DMA operation");
}

void loop() {
  // put your main code here, to run repeatedly:
  

}

Note: I probably cannot go as slow as I would like here, but could with some additional stuff, like maybe instead of fixed one value output,
Could be an array of N elements set up as a Circular buffer, with only one value that is not zero...

KurtE · Jan 13, 2023

Quick update, here it is slightly extended.

Code:

// Quick and dirty sketch to see if I can blink the LED on T4.x using DMA.
//Which is pin GPIO 2 pin 3 
#define PIN_NUMBER 13
#include <DMAChannel.h>
DMAChannel dma1;
extern "C" {
  extern void xbar_connect(unsigned int input, unsigned int output);
  extern void quadtimer_init(IMXRT_TMR_t *p);
  extern void quadtimerWrite(IMXRT_TMR_t *p, unsigned int submodule, uint16_t val);
  extern void quadtimerFrequency(IMXRT_TMR_t *p, unsigned int submodule, float frequency);
}

uint32_t g_output_array[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint8_t  g_pin_bit;
uint8_t  g_low_port_number; // 0 biased.


volatile uint32_t *standard_gpio_addr(volatile uint32_t *fastgpio)
{
	return (volatile uint32_t *)((uint32_t)fastgpio - 0x01E48000);
}

void initPin(uint8_t pin) 
{
  pinMode(pin, OUTPUT);  // make sure we start off as output.
  uint8_t bit = digitalPinToBit(pin);
  uint8_t offset = ((uint32_t)portOutputRegister(pin) - (uint32_t)&GPIO6_DR) >> 14;
  Serial.printf("pin %d, offset=%d, bit=%d\n", pin, offset, bit);
  g_pin_bit = bit;
  g_low_port_number = offset;
  g_output_array[0] = 1 << bit;
  Serial.printf("Mask: %x\n", g_output_array[0]);
  //bitmask[offset] |= g_output_array;
  *(&IOMUXC_GPR_GPR26 + offset) &= ~g_output_array[0];
  *standard_gpio_addr(portModeRegister(pin)) |= g_output_array[0];
} 


void  qtimer_init(float freq)  // try at 20 hz for test...
{
  Serial.println("Try to init QTimer"); Serial.flush();
  quadtimer_init(&IMXRT_TMR4);
  quadtimerFrequency(&IMXRT_TMR4, 0, freq);
  quadtimerWrite(&IMXRT_TMR4, 0, 5);

  uint32_t high = IMXRT_TMR4.CH[0].CMPLD1;
  uint32_t low = 65537 - IMXRT_TMR4.CH[0].LOAD;
  uint32_t highPlusLow = high + low; //
  uint8_t pcs = (IMXRT_TMR4.CH[0].CTRL >> 9) & 0x7;
  float actual_freq = (float)(F_BUS_ACTUAL >> pcs) / (float)highPlusLow;
  Serial.printf("Qtimer freq:%f, actual:%f low:%u, high:%u, hpl:%u\n", freq, actual_freq, low, high, highPlusLow);


  Serial.println("After Qtimer init"); Serial.flush();
}
void xbar_init() {
  CCM_CCGR2 |= CCM_CCGR2_XBAR1(CCM_CCGR_ON);   //turn clock on for xbara1
  xbar_connect(XBARA1_IN_QTIMER4_TIMER0, XBARA1_OUT_DMA_CH_MUX_REQ30);   // QTimer to adc_etc
	XBARA1_CTRL0 = 	XBARA_CTRL_STS0 | XBARA_CTRL_EDGE0(3) | XBARA_CTRL_DEN0;

  Serial.println("After xbar_init");
}

void dumpDMA(DMABaseClass *dmabc)
{
  typedef struct  __attribute__((packed, aligned(4))) {
  uint32_t SADDR;
  int16_t SOFF;
  uint16_t ATTR;
  uint32_t NBYTES;
  int32_t SLAST;
  uint32_t DADDR;
  int16_t DOFF;
  uint16_t CITER;
  int32_t DLASTSGA;
  uint16_t CSR;
  uint16_t BITER;
} TCD_DEBUG;
TCD_DEBUG *tcd = (TCD_DEBUG*)dmabc->TCD;
  Serial.printf("%08x %04x %04x %08x %08x ", tcd->SADDR, tcd->SOFF, tcd->ATTR, tcd->NBYTES, tcd->SLAST);
  Serial.printf("%08x %04x %04x %08x %04x %04x\n", tcd->DADDR, tcd->DOFF, tcd->CITER, tcd->DLASTSGA,
                tcd->CSR, tcd->BITER);
}


void dma_init() {
	dma1.begin();
  dma1.sourceCircular(g_output_array, sizeof(g_output_array)); 
  switch (g_low_port_number) {
    case 0: dma1.destination(GPIO1_DR_TOGGLE); break;
    case 1: dma1.destination(GPIO2_DR_TOGGLE); break;
    case 2: dma1.destination(GPIO3_DR_TOGGLE); break;
    case 3: dma1.destination(GPIO4_DR_TOGGLE); break;
  }
	dma1.triggerAtHardwareEvent(DMAMUX_SOURCE_XBAR1_0);
  
  dma1.transferCount(2000);
	dma1.disableOnCompletion();

  dumpDMA(&dma1);
}

void setup() {
  // let pinMode setup pin 13 for us:
  while (!Serial && millis() < 4000) ; // don't need it but for debug
  initPin(PIN_NUMBER);
  qtimer_init(50.0);
  xbar_init();
  dma_init();
  dma1.clearComplete();
  dma1.enable();
  
  // Lets see if it completes
  Serial.println("Setup complete");
  elapsedMillis em;
  elapsedMillis emTotal;
  while (!dma1.complete()) {
    if (em > 1000) {
      Serial.printf("\tCITER:%u BITER:%u Source:%x\n", dma1.TCD->CITER, dma1.TCD->BITER, dma1.sourceAddress());
      em = 0;
    }
  }
  Serial.printf("Completed DMA operation %u\n", (uint32_t)emTotal);
}

void loop() {
  // put your main code here, to run repeatedly:
  

}

ochsenkopf · Jan 14, 2023

Thanks for the quick reply!

I meanwhile found another solution using the PIT timers. They dont need setup through XBAR and only need DMAMUX to be enabled. (I guess they are hardwired, since the PIT number and DMA Channel number have to be the same).

On the other side, your XBAR setup and "auto detection" of the pin setup is more flexible and probably a better foundation for other triggers aside from PIT.

I really like both approaches. Maybe also these examples could provide a good starting point for getting into DMA stuff.

Code:

#include <DMAChannel.h>

DMAChannel dmaChannel0;
uint32_t DMAMEM buffer = 1<<25; // the buffer we want to write to


void dmaInterrupt(){
  dmaChannel0.clearInterrupt();	// tell system we processed it. 
  asm volatile("dsb"); // Got this from another thread, wait until the change to the register has been made, only works with this line

  buffer ^= 1 << 25; // modify data, in this case toggle bit 25, this could happen in otther places in code async
  arm_dcache_flush(&buffer, 1); // flush from cache directly to physical memory, otherwise it stays in cache.
}

void setup()
{

  // Setting up pin 23
  IOMUXC_SW_MUX_CTL_PAD_GPIO_AD_B1_09 = 5;
  IOMUXC_GPR_GPR26 &= ~(0x0FCC0000u);
  GPIO1_GDIR |= 1 << 25;

  dmaChannel0.channel = 0; // Ensure this is DMA channel 0 (Must be same as PIT)

  //Setting the source and destination
  dmaChannel0.source(buffer);
  dmaChannel0.destination(GPIO1_DR);
	
  // transferring 1 uint32 (= 4 bytes) once
  dmaChannel0.transferSize(4);
  dmaChannel0.transferCount(1);

  // attach Interrupt on completion
  dmaChannel0.interruptAtCompletion();  
  dmaChannel0.attachInterrupt( dmaInterrupt );
	
  DMAMUX_CHCFG0 = DMAMUX_CHCFG_ENBL | DMAMUX_CHCFG_TRIG | DMAMUX_CHCFG_A_ON ; //0xE0000000; Always On, Trigger On and DMAMUX enable
  dmaChannel0.enable();

  // Turn on PIT
  PIT_MCR = 0x00;
  PIT_LDVAL0 = 12000000 - 1; // 1/2 seconds
  PIT_TCTRL0 = PIT_TCTRL_TEN |  PIT_TCTRL_TIE; // 0x00000003; timer 0 enable and interrupt enable
    
}

void loop(){

}

timseverance77 · Dec 20, 2023

Where is it documented that Teensy 4.1 pin 23 (AD_B1_09) is IO25 of GPIO1?
Is it in the processor reference manual?
Reference Manual
I am in the early stages of figuring out how to do DMA sourcing.
Thank you.
Tim

KurtE · Dec 20, 2023

timseverance77 said:
Where is it documented that Teensy 4.1 pin 23 (AD_B1_09) is IO25 of GPIO1?
Is it in the processor reference manual?
Reference Manual

Yes, it is in the reference manual... It takes a little work to find all of the information.
So once Paul starts a Beta of a new board I will typically generate something like an excel document with information.
For example on the T4.1 I have a few pages including:

Name

GPIO

Serial

I2C

SPI

PWM

CAN

Audio

XBAR

FlexIO

Analog

SD/CSI/LCD

0

AD_B0_03

1.3

Serial1(6) RX

SPI1(3) CS0

PWM1_X1

2_RX

IO-17

1

AD_B0_02

1.2

Serial1(6) TX

SPI1(3) MISO

PWM1_X0

2_TX

IO-16

2

EMC_04

4.4

PWM4_A2

2:TX_DATA

IO-06

1:4

3

EMC_05

4.5

PWM4_B2

2:TX_SYNC

IO-07

1:5

4

EMC_06

4.6

PWM2_A0

2:TX_BCLK

IO-08

1:6

5

EMC_08

4.8

PWM2_A1

2:RX_DATA

IO-17

1:8

6

B0_10

2.10

PWM2_A2, QT4_1

1:TX3_RX1

2:10

7

B1_01

2.17

Serial2(4) RX

PWM1_B3

1:TX_DATA

IO-15

2:17, 3:17

8

B1_00

2.16

Serial2(4) TX

PWM1_A3

1:RX_DATA

IO-14

2:16, 3:16

9

B0_11

2.11

PWM2_B2,QT4_2

1:TX2_RX2

2:11

10

B0_00

2.0

SPI(4) CS0

QT1_0

MQS_RIGHT

2:0

11

B0_02

2.2

SPI(4) MOSI

QT1_2

1_TX

2:2

12

B0_01

2.1

SPI(4) MISO

QT1_1

MQS_LEFT

2:1

13

B0_03

2.3

SPI(4) SCK

QT2_0

1_RX

2:3

14/A0

AD_B1_02

1.18

Serial3(2) TX

QT3_2

SPDIF_OUT

3:2

A1:7, A2:7

15/A1

AD_B1_03

1.19

Serial3(2) RX

QT3_3

SPDIF_IN

3:3

A1:8, A2:8

16/A2

AD_B1_07

1.23

Serial4(3) RX

Wire1(3) SCL

SPDIF_EXTCLK

3:7

A1:12, A2:12

CSI_HSYNC

17/A3

AD_B1_06

1.22

Serial4(3) TX

Wire1(3) SDA

SPDIF_LOCK

3:6

A1:11, A2:11

CSI_VSYNC

18/A4

AD_B1_01

1.17

Serial3(2) RTS

Wire(1) SDA

QT3_1

3:1

A1:6, A2:6

19/A5

AD_B1_00

1.16

Serial3(2) CTS

Wire(1) SCL

QT3_0

3:0

A1:5, A2:5

20/A6

AD_B1_10

1.26

Serial5(8) TX

1:RX_SYNC

3:10

A1:15, A2:15

CSI_D7

21/A7

AD_B1_11

1.27

Serial5(8) RX

1:RX_BCLK

3:11

A1:0, A2:0

CSI_D6

22/A8

AD_B1_08

1.24

PWM4_A0

1_TX

3:8

A1:13, A2:13

CSI_D9

23/A9

AD_B1_09

1.25

PWM4_A1

1_RX

1:MCLK

3:9

A1:14, A2:14

CSI_D8

---

----

------

---

----

-----

------

24/A10

AD_B0_12

1.12

Serial6(1) TX

Wire2(4) SCL

PWM1_X2

A1:1

25/A11

AD_B0_13

1.13

Serial6(1) RX

Wire2(4) SDA

PWM1_X3

GPT1_CLK

A1:2

26/A12

AD_B1_14

1.30

SPI1(3) MOSI

1:TX_BCLK

3:14

A2:3

CSI_D3

27/A13

AD_B1_15

1.31

SPI1(3) SCK

1:TX_SYNC

3:15

A2:4

CSI_D2

28

EMC_32

3.18

Serial7(7) RX

PWM3_B1

29

EMC_31

4.31

Serial7(7) TX

SPI2(1) CS1

PWM3_A1

30

EMC_37

3.23

GPT1_3

3_RX

3:MCLK

IO-23

31

EMC_36

3.22

GPT1_2

3_TX

3:TX_DATA

IO-22

32

B0_12

2.12

1:TX1_RX3

IO-10

2:12

33

EMC_07

4.7

PWM2_B0

2:MCLK

IO-09

1:7

34

B1_13

2.29

Serial8(5) RX

2:29,3:29

35

B1_12

2.28

Serial8(5) TX

2:28,3:28

36

B1_02

2.18

SPI(4) CS2

PWM2_A3

1:TX_BCLK

IO-16

2:18,3:18

37

B1_03

2.19

SPI(4) CS1

PWM2_B3

1:TX_SYNC

IO-17

2:19,3:19

38/A14

AD_B1_12

1.28

SPI1(3) CS0

1:rx_data

3:12

A2:1

CSI_D5

39/A5

AD_B1_13

1.29

SPI1(3) MISO

1:tx_data

3:13

A2:2

CSI_D4

40/A16

AD_B1_04

1.20

3:4

A1:9,A2:9

CSI_PIXCLK

41/A17

AD_B1_05

1.21

GPT2_1

3:5

A1:10,A2:10

CSI_MCLK

SD Pins - Cable connector(T4 34-39)

42

SD_B0_03

3.15

Serial5(8) RTS

SPI2(1) MISO

PWM1_B1

IO-07

DATA1

43

SD_B0_02

3.14

Serial5(8) CTS

SPI2(1) MOSI

PWM1_A1

IO-06

DATA0

44

SD_B0_01

3.13

Wire1(3) SDA

SPI2(1) CS0

PWM1_B0

IO-05

CLK

45

SD_B0_00

3.12

Wire1(3) SCL

SPI2(1) SCK

PWM1_A0

IO-04

CMD

46

SD_B0_05

3.17

Serial5(8) RX

FLEXSPI B_DQS

PWM1_B2

IO-09

DATA3

47

SD_B0_04

3.16

Serial5(8) TX

FLEXSPI B_SSO_B

PWM1_A2

IO-08

DATA2

Bottom Memory Connectors

48

EMC_24

4:24

Serial8(5) RX

FLEXSPI2_A_SS0_B

PWM1_B0

49

EMC_27