DMA "blink"

[k057]

Hi,

A bit of a silly question.

To learn about how to implement DMA in upython. I want to make a code that would switch On a GPIO using DMA. Then activate another DMA channel to switch it Off, to kind of blink, once.

I read and followed tutorial on uctypes (https://www.youtube.com/watch?v=WWby6nWORaQ) and on DMA (https://people.ece.cornell.edu/land/courses/ece4760/RP2040/index_rp2040_Micropython.html , plus some example found here and on the past forum).

This is what I did and where I reached so far (at the end, I will add the full code to simplify copy-paste).

import array, uctypes 
from machine import Pin, mem32

# First define the structure of the control register of gpio0 using uctypes.
GPIO_CTRL_LAYOUT = {
    "FUNCSEL" : 0 << uctypes.BF_POS | 5 << uctypes.BF_LEN | uctypes.BFUINT32,
    "RES1" :    5 << uctypes.BF_POS | 3 << uctypes.BF_LEN | uctypes.BFUINT32,
    "OUTOVER" : 8 << uctypes.BF_POS | 2 << uctypes.BF_LEN | uctypes.BFUINT32,
    "RES2" :   10 << uctypes.BF_POS | 2 << uctypes.BF_LEN | uctypes.BFUINT32,
    "OEOVER" : 12 << uctypes.BF_POS | 2 << uctypes.BF_LEN | uctypes.BFUINT32
    } # p.246 datasheet RP2040
gpio0_ctrl = uctypes.struct(0x4001_4004, GPIO_CTRL_LAYOUT)
gpio0_ctrl.FUNCSEL = 0x05 # select SIO function, F6 PIO0, p.236
gpio0_ctrl.OEOVER = 0x03 # Enable output
# Blink the gpio to check if all is okay
gpio0_ctrl.OUTOVER = 0x3 # Set High
time.sleep(0.1)
gpio0_ctrl.OUTOVER = 0x2 # Set Low

So far so good, then to check if the addresses and the value that I am writing to the gpio0 control register are correct I did:

mem32[1073823748]=13061 # Switch ON gpio0
time.sleep(0.1)
mem32[1073823748]=12805 # Switch OFF gpio0

Now I would like to create and activate a DMA channels that writes to the gpio0 control register (located at mem32[1073823748]) the value 13061.

src = array.array("I",[13061]) # The value to be writen by the DMA
src_addr = uctypes.addressof(src)
dst = array.array("I",[1073823748]) # An array containing the address where the DMA should write to, that's where I think things goes wrong
dst_addr = uctypes.addressof(dst)

I define the DMA channel using the following code, I found this code online, but I could have re-write it using uctypes.

DMA_base = 0x50000000 # DMA regs
DMA_RD_ADDR0 = DMA_base + 0x000 # starting read address
DMA_WR_ADDR0 = DMA_base + 0x004 # starting write address
DMA_TR_CNT0 =  DMA_base + 0x008 # number off ITEMS (not bytes to transfer)
DMA_CTRL0 = DMA_base + 0x00c # Channel control -- many fields 
DMA_Ch_ABORT = DMA_base + 0x444 # kill the channels by writing one to the bit number of thh channel
DMA_EN = 1 # bits 0
DMA_IRQ_QUIET = (1<<21) # bit 21 turn off interrupt
DMA_WR_INC = (1<<5) # bits 5
DMA_RD_INC = (1<<4) # bits 4
def DMA_TREQ(trigger_source):
    return (trigger_source & 0x3f)<<15
def DMA_DATA_WIDTH(data_width):
    return (data_width & 0x03)<<2 # bits 2:3
perm_trig = 0x3f # Always go
data_32 = 0x02 # 32 bit

Then I set the DMA write and read register and the transfer counter. Then I start the DMA.

mem32[DMA_RD_ADDR0] = src_addr
mem32[DMA_WR_ADDR0] = dst_addr
mem32[DMA_TR_CNT0] = len(src)
machine.mem32[DMA_CTRL0] = (DMA_IRQ_QUIET | DMA_TREQ(perm_trig) |
                    DMA_WR_INC | DMA_RD_INC |
                    DMA_DATA_WIDTH(data_32) |
                    DMA_EN )

I was expecting the gpio0 to turn ON but nothing happens.

I think the error might lays on how I tell the DMA to which address to write to. I might need to define it in another way (maybe using uctypes pointer?).

Cheers,
Martino

import array, uctypes, time 
from machine import Pin, mem32

# First define the structure of the control register of gpio0 using uctypes.
GPIO_CTRL_LAYOUT = {
    "FUNCSEL" : 0 << uctypes.BF_POS | 5 << uctypes.BF_LEN | uctypes.BFUINT32,
    "RES1" :    5 << uctypes.BF_POS | 3 << uctypes.BF_LEN | uctypes.BFUINT32,
    "OUTOVER" : 8 << uctypes.BF_POS | 2 << uctypes.BF_LEN | uctypes.BFUINT32,
    "RES2" :   10 << uctypes.BF_POS | 2 << uctypes.BF_LEN | uctypes.BFUINT32,
    "OEOVER" : 12 << uctypes.BF_POS | 2 << uctypes.BF_LEN | uctypes.BFUINT32
    } # p.246 datasheet RP2040
gpio0_ctrl = uctypes.struct(0x4001_4004, GPIO_CTRL_LAYOUT)
gpio0_ctrl.FUNCSEL = 0x05 # select SIO function, F6 PIO0, p.236
gpio0_ctrl.OEOVER = 0x03 # Enable output
# Blink the gpio to check if all is okay
gpio0_ctrl.OUTOVER = 0x3 # Set High
time.sleep(0.1)
gpio0_ctrl.OUTOVER = 0x2 # Set Low
time.sleep(0.1)
mem32[1073823748]=13061 # Switch ON gpio0
time.sleep(0.1)
mem32[1073823748]=12805 # Switch OFF gpio0

src = array.array("I",[13061]) # The value to be writen by the DMA
src_addr = uctypes.addressof(src)
dst = array.array("I",[1073823748]) # An array containing the address where the DMA should write to, that's where I think things goes wrong
dst_addr = uctypes.addressof(dst)

DMA_base = 0x50000000 # DMA regs
DMA_RD_ADDR0 = DMA_base + 0x000 # starting read address
DMA_WR_ADDR0 = DMA_base + 0x004 # starting write address
DMA_TR_CNT0 =  DMA_base + 0x008 # number off ITEMS (not bytes to transfer)
DMA_CTRL0 = DMA_base + 0x00c # Channel control -- many fields 
DMA_Ch_ABORT = DMA_base + 0x444 # kill the channels by writing one to the bit number of thh channel
DMA_EN = 1 # bits 0
DMA_IRQ_QUIET = (1<<21) # bit 21 turn off interrupt
DMA_WR_INC = (1<<5) # bits 5
DMA_RD_INC = (1<<4) # bits 4
def DMA_TREQ(trigger_source):
    return (trigger_source & 0x3f)<<15
def DMA_DATA_WIDTH(data_width):
    return (data_width & 0x03)<<2 # bits 2:3
perm_trig = 0x3f # Always go
data_32 = 0x02 # 32 bit

mem32[DMA_RD_ADDR0] = src_addr
mem32[DMA_WR_ADDR0] = dst_addr
mem32[DMA_TR_CNT0] = len(src)


machine.mem32[DMA_CTRL0] = (DMA_IRQ_QUIET | DMA_TREQ(perm_trig) |
                    DMA_WR_INC | DMA_RD_INC |
                    DMA_DATA_WIDTH(data_32) |
                    DMA_EN )

[rkompass]

You might want to have a look at my unfinished DMA class, as it seems you are programming for the RP2040.
It should be easy to set it up for that task. You can check the LED switching and compare the DMA registers with your settings afterwards.
Or see the simpler code by robert-hh which is mentioned there.

As far as I can see the src and dst addresses are correct. In principle your example should work.
Note that you cannot DMA to the SIO register as that is only connected directly to the CPUs, not to the main bus.
As you write to a GPIO register it should be fine.

[rkompass]

I have to correct myself:

src = array.array("I",[13061]) # The value to be writen by the DMA
src_addr = uctypes.addressof(src)

seems correct, but

dst = array.array("I",[1073823748]) # An array containing the address where the DMA should write to, that's where I think things goes wrong
dst_addr = uctypes.addressof(dst)

indeed is wrong, as you setup the DMA to write into that array then. so that it becomes array("I",[13061]).
Instead
dst = 1073823748 would be correct here.

[k057]

Hello,

Thank you for the lead! I re-wrote the code (using also uctypes for the DMA) and now it works like a charm.

I attach the full code here below:

import array, uctypes, time
from machine import mem32

# GPIO register addresses
IO_BANK0_BASE = const(0x40014000)
GPIO0_CTRL = const(0x004)


# DMA register addresses
DMA_base = const(0x50000000) # DMA regs
DMA0_offset = const(0x00c)
DMA_RD_ADDR0 = const(DMA_base + 0x000) # read address
DMA_WR_ADDR0 = const(DMA_base + 0x004) # write address
DMA_TR_CNT0 =  const(DMA_base + 0x008) # number off ITEMS (not bytes to transfer)

# Set the uctypes structure for GPI0 Control - p.246 datasheet
GPIO_CTRL_LAYOUT = {
    "FUNCSEL" : 0 << uctypes.BF_POS | 5 << uctypes.BF_LEN | uctypes.BFUINT32,
    "RES1" :    5 << uctypes.BF_POS | 3 << uctypes.BF_LEN | uctypes.BFUINT32,
    "OUTOVER" : 8 << uctypes.BF_POS | 2 << uctypes.BF_LEN | uctypes.BFUINT32,
    "RES2" :   10 << uctypes.BF_POS | 2 << uctypes.BF_LEN | uctypes.BFUINT32,
    "OEOVER" : 12 << uctypes.BF_POS | 2 << uctypes.BF_LEN | uctypes.BFUINT32
    }

# Set the uctypes structure for DMA channel
DMA_CTRL_TRIG = {
    "EN" :              0 << uctypes.BF_POS | 1 << uctypes.BF_LEN | uctypes.BFUINT32,
    "HIGH_PRIORITY" :   1 << uctypes.BF_POS | 1 << uctypes.BF_LEN | uctypes.BFUINT32,
    "DATA_SIZE" :       2 << uctypes.BF_POS | 2 << uctypes.BF_LEN | uctypes.BFUINT32,
    "INCR_READ" :       4 << uctypes.BF_POS | 1 << uctypes.BF_LEN | uctypes.BFUINT32,
    "INCR_WRITE" :      5 << uctypes.BF_POS | 1 << uctypes.BF_LEN | uctypes.BFUINT32,
    "RING_SIZE" :       6 << uctypes.BF_POS | 4 << uctypes.BF_LEN | uctypes.BFUINT32,
    "RING_SEL" :       10 << uctypes.BF_POS | 1 << uctypes.BF_LEN | uctypes.BFUINT32,
    "CHAIN_TO" :       11 << uctypes.BF_POS | 4 << uctypes.BF_LEN | uctypes.BFUINT32,
    "TREQ_SEL" :       15 << uctypes.BF_POS | 6 << uctypes.BF_LEN | uctypes.BFUINT32,
    "IRQ_QUIET" :      21 << uctypes.BF_POS | 1 << uctypes.BF_LEN | uctypes.BFUINT32,
    "BSWAP" :          22 << uctypes.BF_POS | 1 << uctypes.BF_LEN | uctypes.BFUINT32,
    "SNIFF_EN" :       23 << uctypes.BF_POS | 1 << uctypes.BF_LEN | uctypes.BFUINT32,
    "BUSY" :           24 << uctypes.BF_POS | 1 << uctypes.BF_LEN | uctypes.BFUINT32,
    "WRITE_ERROR" :    29 << uctypes.BF_POS | 1 << uctypes.BF_LEN | uctypes.BFUINT32,
    "READ_ERROR" :     30 << uctypes.BF_POS | 1 << uctypes.BF_LEN | uctypes.BFUINT32,
    "AHB_ERROR" :      31 << uctypes.BF_POS | 1 << uctypes.BF_LEN | uctypes.BFUINT32
    }

# Enable structures gpio0 control and dma0 control
gpio0_ctrl = uctypes.struct(IO_BANK0_BASE+GPIO0_CTRL, GPIO_CTRL_LAYOUT) 
dma0_ctrl = uctypes.struct(DMA_base+DMA0_offset,DMA_CTRL_TRIG)

gpio0_ctrl.FUNCSEL = 0x06 # select, F6 PIO0, p.236
gpio0_ctrl.OEOVER = 0x03 # Enable output
gpio0_ctrl.OUTOVER = 0x2 # Set Low

# Blink the gpio to check if all is okay
gpio0_ctrl.OUTOVER = 0x3
time.sleep(0.2)
gpio0_ctrl.OUTOVER = 0x2

# wait a bit, just to eyeball 
time.sleep(1)

print("gpio0 OUTOVER register value: ",gpio0_ctrl.OUTOVER, "(3=High, 2=Low)") # should be 2, LOW

# Create source and destination.
dst_addr = IO_BANK0_BASE + GPIO0_CTRL # where to write
src = array.array("I",[(mem32[IO_BANK0_BASE + GPIO0_CTRL] | 1<<8)]) # The value to be writen by the DMA, set 8th bit to high
src_addr = uctypes.addressof(src)

print("Src array:",src)

# Set the DMA read and write addresses.
mem32[DMA_RD_ADDR0] = src_addr
mem32[DMA_WR_ADDR0] = dst_addr
mem32[DMA_TR_CNT0] = 1

print("Src address: ",src_addr)
print("Dst address: ",dst_addr)
print("DMA register read", mem32[DMA_RD_ADDR0])
print("DMA register write", mem32[DMA_WR_ADDR0])

# Set the DMA
dma0_ctrl.INCR_READ = 1
dma0_ctrl.DATA_SIZE = 0x02
dma0_ctrl.IRQ_QUIET = 1
dma0_ctrl.TREQ_SEL = 0x3f # unpaced
dma0_ctrl.INCR_WRITE = 1
dma0_ctrl.EN = 1

time.sleep(0.1)

print("DMAed src array:",src)
print("DMAed gpio0 OUTOVER register value: ",gpio0_ctrl.OUTOVER, "(3=High, 2=Low)") # should be 2, LOW

[Josverl]

I found this rp2040 DMA library and samples to be very helpful

https://github.com/drtimcollins/RP2040-DMA