DMA chaining with PIO as output

[wikigough]

Hello everyone!

I'm trying to learn how to use DMAs with PIOs and I think Im missing something with the DMA -> PIO interface, as it looks like the PIO doesnt trigger the DMA that feeds into the PIO TX FIFO.

The python code im running on the Pico W is here.
The PIO that I'm using is here.

There are two ways of running this script:

1. With test=True: transfer_data(input, output, test=True)
2. With test=False: transfer_data(input, output, test=False)

With test=True, the script is run with the buffer_dma -> sm0 link broken to check if the DMA chaining is set up OK and works on its own, and if the StateMachine is able to work with the StateMachine.put() function - ie testing the two components separately. They do work okay separately, but note that the buffer_dma needs to be reconfigured to work with the DREQ from the PIO, which I think is where Ive gone wrong... When I say they work, it means that the output buffer is populated correctly, and the correct thing is displayed on the LED Matrix.

With test=False, the link between the buffer_dma and the StateMachine PIO is established, but it doesnt work, and Im getting the following symptoms:

• before setting gather_dma.active(1), reading gather_dma registers using DMA.registers, shows that the read and write buffer are correctly established. So, to the best of my knowledge, the config has been set up correctly.

Gather DMA registers: 
536955040
1342177528
0
4168953
[..]

• before buffer_dma is activated, the read register is set to 0 on startup, or whatever it was set to on previous test before soft reset. The write register is correctly set as PIO0 TX FIFO as 0x50200010. So, to the best of my knowledge, the config has been set up correctly.

Buffer DMA registers: 
0
1344274448
0
2234377
[..]

• Once the gather_dma is activated, some of the registers are read every two seconds ( I have varied the time of this too). The gather_dma read is stuck at the base read + 8, meaning it has transferred the initial two elements of the list into the buffer_dma registers and is waiting for a re-trigger for the next transfer. The buffer_dma read register is correct, and so it the count, so the initial transfer to the buffer_dma registers using gather_dma was a success. However, the addresses do not increment at all:

Gather DMA read:  536955048
Buffer DMA read:  536951360 , buffer DMA write:  1344274448 , buffer DMA count:  11
False True
Gather DMA read:  536955048
Buffer DMA read:  536951360 , buffer DMA write:  1344274448 , buffer DMA count:  11
False True
[...]

To me it looks like the PIO is failing to request the buffer_dma for data. Is this a correct assumption and how can I improve the DMA / PIO configuration to sort this out? Any points or comments will be greatly appreciated!

Here are the two buffer_dma set ups for both the test case and pio case directly copied from the code linked above.

    #--------------------------------------------- BUFFER DMA -------------------------------------------#
    if test:
        # When copying the data, the transfer size is single bytes, and when completed we need
        # to chain back to the start another gather DMA transaction.
        buffer_ctrl = buffer_dma.pack_ctrl(
            enable=True,
            high_pri=False,
            size=2,
            inc_read=True,   # original = True
            inc_write=True, # original = True
            ring_size=0,
            ring_sel=False,
            treq_sel=63,      # original = 63
            irq_quiet=True,   # original = True
            bswap=False,
            sniff_en=False,
            chain_to=gather_dma.channel
        )
        
        
        # The read and count values will be set by the other DMA channel.
        buffer_dma.config(write=addressof(buf), ctrl=buffer_ctrl, trigger=False)
    
    else:
        # When copying the data, the transfer size is single bytes, and when completed we need
        # to chain back to the start another gather DMA transaction.
        buffer_ctrl = buffer_dma.pack_ctrl(
            enable=True,
            high_pri=False,
            size=2,
            inc_read=True,   # original = True
            inc_write=False,  # original = True
            ring_size=0,
            ring_sel=False,
            treq_sel=4,       # original = 63
            irq_quiet=True,
            bswap=False,
            sniff_en=False,
            chain_to=buffer_dma.channel
        )
        
        
        # The read and count values will be set by the other DMA channel.
        buffer_dma.config(write=TXF0_addr, ctrl=buffer_ctrl, trigger=False)
        
    
        
        # state machine 0 irq - not tested.
        sm0.irq(handler=trigger_gather_dma, trigger=1, hard=True)
        
    #----------------------------------------------------------------------------------------------------#
        

[mendenm]

your treq_sel value of 4 appears to be the correct value for the RX channel of the PIO. zero would be correct for the TX side (which is what you are doing, it appears).

[wikigough]

Thanks so much for your time taking a look at this and your help in identifying that the treq_sel should be set to 0 and not to 4. This change worked, and now there is transfer to the PIO using the buffer_dma.

I did test with 0 before, but I have noticed I did a couple of things wrong while trying out treq_sel = 0 on my journey of trying to understand DMAs (I only list this in case this helps anyone else reading this thread):

• I didn't power cycle after testing buggy DMA code -> I've discovered that trying to re-run code after running buggy DMA code leads to erroneous results after a soft reset, and power cycling is necessary depending on how the code exited.
• I added some safe exits to shut down the DMAs and the StateMachine (DMA.close(), DMA.active(0), StateMachine.active(0)) in case of a KeyboardInterrupt for debugging. This made debugging a lot nicer and led to much less power cycling instances.
• I rolled back at some point to MicroPython v 1.23 --> unsure if this actually made any difference or not, but including this in the list of changes I did for completeness.
• When debugging, I decreased the StateMachine frequency for the PIO -> which showed that i did display a single frame of my image, and then I had to change how I restarted the gather_dma, but that is not relevant to this thread.

My latest test code is here, which includes the treq_sel=0 fix and correct restarting of the gather_dma for continuous updating of the 16x7 pimoroni screen using a DMA interrupt service routine.