Can't get DMA to SPI to work

[HLammers]

I'm trying to use DMA for writing to an ILI9225 based display from a Raspberry Pi Pico 2, but I can't get it to work. This is my test code:

import machine
import time
import random
import rp2
import framebuf

_USE_DMA = const(False)

_DISPLAY_BAUTRATE            = const (50_000_000)
_DISPLAY_SPI                 = const(0)
_DISPLAY_PIN_DC              = const(20) # RS
_DISPLAY_PIN_RST             = const(21)
_DISPLAY_PIN_BACKLIGHT       = const(17) # LED

_DISPLAY_WIDTH        = const(220)
_DISPLAY_HEIGHT       = const(176)

_BUFFER_SIZE          = const(77440) # _DISPLAY_WIDTH * _DISPLAY_HEIGHT * 2

# ILI9225 LCD Registers
_DRIVER_OUTPUT_CTRL   = const(0x01)  # Driver Output Control
_LCD_AC_DRIVING_CTRL  = const(0x02)  # LCD AC Driving Control
_ENTRY_MODE           = const(0x03)  # Entry Mode
_DISP_CTRL1           = const(0x07)  # Display Control 1
_BLANK_PERIOD_CTRL1   = const(0x08)  # Blank Period Control
_FRAME_CYCLE_CTRL     = const(0x0B)  # Frame Cycle Control
_INTERFACE_CTRL       = const(0x0C)  # Interface Control
_OSC_CTRL             = const(0x0F)  # Osc Control
_POWER_CTRL1          = const(0x10)  # Power Control 1
_POWER_CTRL2          = const(0x11)  # Power Control 2
_POWER_CTRL3          = const(0x12)  # Power Control 3
_POWER_CTRL4          = const(0x13)  # Power Control 4
_POWER_CTRL5          = const(0x14)  # Power Control 5
_VCI_RECYCLING        = const(0x15)  # VCI Recycling
_RAM_ADDR_SET1        = const(0x20)  # Horizontal GRAM Address Set
_RAM_ADDR_SET2        = const(0x21)  # Vertical GRAM Address Set
_GRAM_DATA_REG        = const(0x22)  # GRAM Data Register
_GATE_SCAN_CTRL       = const(0x30)  # Gate Scan Control Register
_VER_SCROLL_CTRL1     = const(0x31)  # Vertical Scroll Control 1 Register
_VER_SCROLL_CTRL2     = const(0x32)  # Vertical Scroll Control 2 Register
_VER_SCROLL_CTRL3     = const(0x33)  # Vertical Scroll Control 3 Register
_PARTIAL_DRIVING_POS1 = const(0x34)  # Partial Driving Position 1 Register
_PARTIAL_DRIVING_POS2 = const(0x35)  # Partial Driving Position 2 Register
_HOR_WINDOW_ADDR1     = const(0x36)  # Horizontal Address Start Position
_HOR_WINDOW_ADDR2     = const(0x37)  # Horizontal Address End Position
_VER_WINDOW_ADDR1     = const(0x38)  # Vertical Address Start Position
_VER_WINDOW_ADDR2     = const(0x39)  # Vertical Address End Position
_GAMMA_CTRL1          = const(0x50)  # Gamma Control 1
_GAMMA_CTRL2          = const(0x51)  # Gamma Control 2
_GAMMA_CTRL3          = const(0x52)  # Gamma Control 3
_GAMMA_CTRL4          = const(0x53)  # Gamma Control 4
_GAMMA_CTRL5          = const(0x54)  # Gamma Control 5
_GAMMA_CTRL6          = const(0x55)  # Gamma Control 6
_GAMMA_CTRL7          = const(0x56)  # Gamma Control 7
_GAMMA_CTRL8          = const(0x57)  # Gamma Control 8
_GAMMA_CTRL9          = const(0x58)  # Gamma Control 9
_GAMMA_CTRL10         = const(0x59)  # Gamma Control 10

class Display(framebuf.FrameBuffer):
    '''class providing diplay buffer and draw functions; initiated once by ui.__init__'''

    def __init__(self, spi_id: int, baudrate: int, dc_pin: machine.Pin, rst_pin: machine.Pin, backlight_pin: machine.Pin) -> None:
        self.spi = machine.SPI(spi_id, baudrate=baudrate)
        self.dc = dc_pin
        self.rst = rst_pin
        self.backlight = backlight_pin
        backlight_pin.off()
        self.dma = (_dma := rp2.DMA())
        _dma.irq(self._cb_dma, True)
        if spi_id == 0:
            self.treq_sel = 29 # TX DREQ number
            self.tx_fifo_addr = 0x4003C00C
        else:
            self.treq_sel = 31 # TX DREQ number
            self.tx_fifo_addr = 0x4004000C
        self.dma_done = True
        rst_pin.init(rst_pin.OUT, value=0)
        dc_pin.init(dc_pin.OUT, value=0)
        self.byte_buffer = (byte_buffer := memoryview(bytearray(_BUFFER_SIZE)))
        super().__init__(byte_buffer, _DISPLAY_WIDTH, _DISPLAY_HEIGHT, (RGB565 := framebuf.RGB565))
        self._reset()
        self._setup()
        self._palette = framebuf.FrameBuffer(bytearray(4), 2, 1, RGB565)
        backlight_pin.on()

    def set_display(self, flag: bool) -> None:
        '''turn display on or off (excluding backlight); called by ui.check_sleep_time_out and ui._wake_up'''
        _write = self.spi.write
        _dc_low = self.dc.low
        _dc_high = self.dc.high
        _sleep_ms = time.sleep_ms
        reg_buf = bytearray(2)
        data_buf = bytearray(2)

        def write_reg(cmd: int, value: int) -> None:
            reg_buf[1] = cmd; data_buf[0] = value >> 8; data_buf[1] = value & 0xFF
            _dc_low(); _write(reg_buf); _dc_high(); _write(data_buf)

        def write_reg_zero(cmd: int) -> None:
            reg_buf[1] = cmd; data_buf[0] = 0; data_buf[1] = 0
            _dc_low(); _write(reg_buf); _dc_high(); _write(data_buf)

        write_reg_zero(0xFF)
        if flag:
            write_reg_zero(_POWER_CTRL1)
            _sleep_ms(50)
            write_reg(_DISP_CTRL1, 0x1017)
            _sleep_ms(200)
            self.backlight.on()
        else:
            self.backlight.off()
            write_reg_zero(_DISP_CTRL1)
            _sleep_ms(50)
            write_reg(_POWER_CTRL1, 0x0003)
            _sleep_ms(200)

    def draw_screen(self) -> bool:
        '''draw display buffer to screen; called by main'''
        if _USE_DMA and not self.dma_done:
            print('dma not done')
            return False
        print('dma done')
        self._set_window(0, 0, _DISPLAY_WIDTH - 1, _DISPLAY_HEIGHT - 1)
        self.dc.high()
        _dma = self.dma
        print('dma.pack_ctrl, treq_sel', self.treq_sel)
        ctrl = _dma.pack_ctrl(size=1, inc_read=True, inc_write=False, treq_sel=self.treq_sel, irq_quiet=False)
        print('ctrl', ctrl)
        self.dma_done = False
        if _USE_DMA:
            print('dma.config, write buffer addres', self.tx_fifo_addr, 'len(self.byte_buffer)', len(self.byte_buffer), 'count', _DISPLAY_WIDTH * _DISPLAY_HEIGHT * 2)
            _dma.config(read=self.byte_buffer, write=self.tx_fifo_addr, count=_DISPLAY_WIDTH * _DISPLAY_HEIGHT * 2, ctrl=ctrl, trigger=True)
            now = time.ticks_ms()
            while _dma.active():
                if time.ticks_diff(time.ticks_ms(), now) > 10000:
                    print('timeout')
                    break
            print('return from draw_screen')
        else:
            self.spi.write(self.byte_buffer)
        return True

    def _setup(self) -> None:
        '''screen set up routine; called by self.__init__'''
        _write = self.spi.write
        _dc_low = self.dc.low
        _dc_high = self.dc.high
        _sleep_ms = time.sleep_ms
        reg_buf = bytearray(2)
        data_buf = bytearray(2)

        def write_reg(cmd: int, data: tuple[int, int], sleep: int) -> None:
            reg_buf[1] = cmd; data_buf[0], data_buf[1] = data
            _dc_low(); _write(reg_buf); _dc_high(); _write(data_buf)
            if sleep > 0:
                _sleep_ms(sleep)

        commands = ( # (register, data, sleep_ms)
            (_POWER_CTRL1, (0x00, 0x00), 0),          (_POWER_CTRL2, (0x00, 0x00), 0),       (_POWER_CTRL3, (0x00, 0x00), 0),
            (_POWER_CTRL4, (0x00, 0x00), 0),          (_POWER_CTRL5, (0x00, 0x00), 0),       (_POWER_CTRL2, (0x00, 0x18), 0),
            (_POWER_CTRL3, (0x11, 0x21), 0),          (_POWER_CTRL4, (0x00, 0x66), 0),       (_POWER_CTRL5, (0x5F, 0x60), 0),
            (_POWER_CTRL1, (0x0A, 0x00), 0),          (_POWER_CTRL2, (0x10, 0x38), 50),      (_DRIVER_OUTPUT_CTRL, (0x03, 0x1C), 10),
            (_LCD_AC_DRIVING_CTRL, (0x01, 0x00), 10), (_ENTRY_MODE, (0x10, 0x30), 10),       (_DISP_CTRL1, (0x00, 0x00), 10),
            (_BLANK_PERIOD_CTRL1, (0x08, 0x08), 10),  (_FRAME_CYCLE_CTRL, (0x11, 0x00), 10), (_INTERFACE_CTRL, (0x00, 0x00), 10),
            (_OSC_CTRL, (0x0D, 0x01), 10),            (_VCI_RECYCLING, (0x00, 0x20), 10),    (_RAM_ADDR_SET1, (0x00, 0x00), 0),
            (_RAM_ADDR_SET2, (0x00, 0x00), 0),        (_GATE_SCAN_CTRL, (0x00, 0x00), 0),    (_VER_SCROLL_CTRL1, (0x00, 0xDB), 0),
            (_VER_SCROLL_CTRL2, (0x00, 0x00), 0),     (_VER_SCROLL_CTRL3, (0x00, 0x00), 0),  (_PART_DRIVING_POS1, (0x00, 0xDB), 0),
            (_PART_DRIVING_POS2, (0x00, 0x00), 0),    (_HOR_WINDOW_ADDR1, (0x00, 0xAF), 0),  (_HOR_WINDOW_ADDR2, (0x00, 0x00), 0),
            (_VER_WINDOW_ADDR1, (0x00, 0xDB), 0),     (_VER_WINDOW_ADDR2, (0x00, 0x20), 0),  (_GAMMA_CTRL1, (0x00, 0x00), 0),
            (_GAMMA_CTRL2, (0x08, 0x08), 0),          (_GAMMA_CTRL3, (0x08, 0x0A), 0),       (_GAMMA_CTRL4, (0x00, 0x0A), 0),
            (_GAMMA_CTRL5, (0x0A, 0x08), 0),          (_GAMMA_CTRL6, (0x08, 0x08), 0),       (_GAMMA_CTRL7, (0x00, 0x00), 0),
            (_GAMMA_CTRL8, (0x0A, 0x00), 0),          (_GAMMA_CTRL9, (0x07, 0x10), 0),       (_GAMMA_CTRL10, (0x07, 0x10), 0),
            (_DISP_CTRL1, (0x00, 0x12), 50),          (_DISP_CTRL1, (0x10, 0x17), 0))

        for cmd, data, sleep in commands:
            write_reg(cmd, data, sleep)

    def _reset(self) -> None:
        '''reset screen; called by self.__init__'''
        _rst = self.rst; _sleep_ms = time.sleep_ms
        _rst.high()  # pull reset pin high to release from reset status
        _sleep_ms(1)
        _rst.low()   # pull reset pin low to reset
        _sleep_ms(10)
        _rst.high()  # pull reset pin high to release from reset status
        _sleep_ms(50)

    def _set_window(self, x0: int, y0: int, x1: int, y1: int) -> None:
        '''set draw window; called by self.draw_screen'''
        _write = self.spi.write
        _dc_low = self.dc.low
        _dc_high = self.dc.high
        reg_buf = bytearray(2)
        data_buf = bytearray(2)

        def write_reg(cmd, data):
            reg_buf[1] = cmd; data_buf[0] = data >> 8; data_buf[1] = data & 0xFF
            _dc_low(); _write(reg_buf); _dc_high(); _write(data_buf)

        write_reg(_ENTRY_MODE, 0x1038)   # ENTRY_MODE: set GRAM write direction and other mode bits (0x1000 | (_TOP_DOWN_L2R << 3))
        write_reg(_HOR_WINDOW_ADDR1, y1) # horizontal window: Y range
        write_reg(_HOR_WINDOW_ADDR2, y0)
        write_reg(_VER_WINDOW_ADDR1, x1) # vertical window: X range
        write_reg(_VER_WINDOW_ADDR2, x0)
        write_reg(_RAM_ADDR_SET1, y0)    # set RAM address (start point)
        write_reg(_RAM_ADDR_SET2, x0)
        reg_buf[1] = _GRAM_DATA_REG      # final GRAM register select
        _dc_low()
        _write(reg_buf)

    def _cb_dma(self, *_) -> None:
        print('_cb_dma')
        self.dma_done = True

display = Display(_DISPLAY_SPI, _DISPLAY_BAUTRATE, machine.Pin(_DISPLAY_PIN_DC), machine.Pin(_DISPLAY_PIN_RST), machine.Pin(_DISPLAY_PIN_BACKLIGHT, mode=machine.Pin.OUT))
redraw = False
i = 0
while i < 5:
    if not redraw:
        time.sleep(1)
        print('fill display')
        display.fill(random.randint(0, 0xFFFF))
        redraw = True
    else:
        time.sleep(0.5)
    if redraw:
        redraw = not display.draw_screen()
        print('redraw', redraw, i)
    i += 1

If I set _USE_DMA to False it works (using spi.write) suggesting that my SPI setup is correct and the display driver works, but if set to True it doesn't, so the problem must be with the DMA setup. If I run it I get the following output:

fill display
dma done
dma.pack_ctrl, treq_sel 29
ctrl 3801109
dma.config, write buffer addres 1073987596 len(self.byte_buffer) 77440 count 77440
timeout
return from draw_screen
redraw False 0
fill display
dma not done
redraw True 1
dma not done
redraw True 2
dma not done
redraw True 3
dma not done
redraw True 4

This suggests that DMA writing never finishes (timeout) and that the DMA callback never fires (probably also because it never finishes).

What could be the issue?

Added just to be complete: CS (chip select) isn't set anywhere in the code because it is hardwired to ground.

[GitHubsSilverBullet]

Looks like you've got your DMA requests wrong.
PICO2 uses 24:DREQ_SPI0_TX and 26:DREQ_SPI1_TX
Edit:
Oh, and the SPI bases as well. (copied from PICO?)

[HLammers]

@GitHubsSilverBullet Thanks for your hint. I found in the RP2350 datasheet, section 12.3.5 (pages 1057-1058) that the base addresses for SPI are 0x40080000/0x40088000, but I don't really understand which offset to use (what to add to that) to get the tx fifo address. Do you know how that works?

[robert-hh]

There is the data register at offset 8, and the DMA control register at offset 24. The latter controls, whether DMA is enabled for RX and TX. The former has the data.

[HLammers]

@robert-hh thank you for your answer. I've adjusted my code as follows:

        if spi_id == 0:
            self.treq_sel = 24 # TX DREQ number (rp2040: 16, rp2350: 24)
            self.tx_fifo_addr = 0x40080000 + 8 # rp2040: 0x4003C000, rp2350: 0x40080000
        else:
            self.treq_sel = 26 # TX DREQ number (rp2040: 18, rp2350: 26)
            self.tx_fifo_addr = 0x40088000 + 8 # rp2040: 0x40040000, rp2350: 0x40088000

Now the screen gets half filled, but my code throws an 'Uncaught exception in IRQ callback handler' error followed by an unspecified MemoryError, as seen in the output:

fill display
dma done
dma.pack_ctrl, treq_sel 24
ctrl 3145749
dma.config, write buffer addres 1074266120 len(self.byte_buffer) 77440 count 77440
Uncaught exception in IRQ callback handler
MemoryError: 
return from draw_screen
redraw False 0
fill display
dma not done
redraw True 1
dma not done
redraw True 2
dma not done
redraw True 3
dma not done
redraw True 4

It looks like my callback (Display._cb_dma) never get's called, because I don't see the output of the print statement in that function. Could it be a problem with that callback function? What arguments should it take (not specified in the documentation? The fact that only half my screen gets filled suggests that the problem might also occur earlier in the DMA transfer itself. Is there perhaps anything I need to do with the DMA control register at offset 24?

[robert-hh]

The error is typically thrown in a callback if it tries to allocate memory. The callback typically only has a single argument, so try to write def _cb_dma(self, arg). You seem to ignore the argument anyhow. print() does not allocate.

[HLammers]

@robert-hh Thank you for your answer. Now it works, but I'm running into a different problem: if I use DMA it displays on half the resolution:

If set _USE_DMA to False it looks correct (colours are random):

What could cause this?

I've tried changing size to 2 in pack_ctrl, but that makes the output even smaller (half the size), so that's not the solution.

Latest version of my test code:

import machine
import time
import random
import rp2
import framebuf

_USE_DMA = const(False)
_ENABLE_IRQ = const(True)
_HARD_IRQ = const(True)

_DISPLAY_BAUTRATE            = const(50_000_000)
_DISPLAY_SPI                 = const(0)
_DISPLAY_PIN_DC              = const(20) # RS
_DISPLAY_PIN_RST             = const(21)
_DISPLAY_PIN_BACKLIGHT       = const(17) # LED

_DISPLAY_WIDTH        = const(220)
_DISPLAY_HEIGHT       = const(176)

_BUFFER_SIZE          = const(77440) # _DISPLAY_WIDTH * _DISPLAY_HEIGHT * 2

# ILI9225 LCD Registers
_DRIVER_OUTPUT_CTRL  = const(0x01)  # Driver Output Control
_LCD_AC_DRIVING_CTRL = const(0x02)  # LCD AC Driving Control
_ENTRY_MODE          = const(0x03)  # Entry Mode
_DISP_CTRL1          = const(0x07)  # Display Control 1
_BLANK_PERIOD_CTRL1  = const(0x08)  # Blank Period Control
_FRAME_CYCLE_CTRL    = const(0x0B)  # Frame Cycle Control
_INTERFACE_CTRL      = const(0x0C)  # Interface Control
_OSC_CTRL            = const(0x0F)  # Osc Control
_POWER_CTRL1         = const(0x10)  # Power Control 1
_POWER_CTRL2         = const(0x11)  # Power Control 2
_POWER_CTRL3         = const(0x12)  # Power Control 3
_POWER_CTRL4         = const(0x13)  # Power Control 4
_POWER_CTRL5         = const(0x14)  # Power Control 5
_VCI_RECYCLING       = const(0x15)  # VCI Recycling
_RAM_ADDR_SET1       = const(0x20)  # Horizontal GRAM Address Set
_RAM_ADDR_SET2       = const(0x21)  # Vertical GRAM Address Set
_GRAM_DATA_REG       = const(0x22)  # GRAM Data Register
_GATE_SCAN_CTRL      = const(0x30)  # Gate Scan Control Register
_VER_SCROLL_CTRL1    = const(0x31)  # Vertical Scroll Control 1 Register
_VER_SCROLL_CTRL2    = const(0x32)  # Vertical Scroll Control 2 Register
_VER_SCROLL_CTRL3    = const(0x33)  # Vertical Scroll Control 3 Register
_PART_DRIVING_POS1   = const(0x34)  # Partial Driving Position 1 Register
_PART_DRIVING_POS2   = const(0x35)  # Partial Driving Position 2 Register
_HOR_WINDOW_ADDR1    = const(0x36)  # Horizontal Address Start Position
_HOR_WINDOW_ADDR2    = const(0x37)  # Horizontal Address End Position
_VER_WINDOW_ADDR1    = const(0x38)  # Vertical Address Start Position
_VER_WINDOW_ADDR2    = const(0x39)  # Vertical Address End Position
_GAMMA_CTRL1         = const(0x50)  # Gamma Control 1
_GAMMA_CTRL2         = const(0x51)  # Gamma Control 2
_GAMMA_CTRL3         = const(0x52)  # Gamma Control 3
_GAMMA_CTRL4         = const(0x53)  # Gamma Control 4
_GAMMA_CTRL5         = const(0x54)  # Gamma Control 5
_GAMMA_CTRL6         = const(0x55)  # Gamma Control 6
_GAMMA_CTRL7         = const(0x56)  # Gamma Control 7
_GAMMA_CTRL8         = const(0x57)  # Gamma Control 8
_GAMMA_CTRL9         = const(0x58)  # Gamma Control 9
_GAMMA_CTRL10        = const(0x59)  # Gamma Control 10

_SET_UP_SEQUENCE = ( # (register, data, sleep_ms)
    (_POWER_CTRL1, (0x00, 0x00), 0),          (_POWER_CTRL2, (0x00, 0x00), 0),       (_POWER_CTRL3, (0x00, 0x00), 0),
    (_POWER_CTRL4, (0x00, 0x00), 0),          (_POWER_CTRL5, (0x00, 0x00), 0),       (_POWER_CTRL2, (0x00, 0x18), 0),
    (_POWER_CTRL3, (0x11, 0x21), 0),          (_POWER_CTRL4, (0x00, 0x66), 0),       (_POWER_CTRL5, (0x5F, 0x60), 0),
    (_POWER_CTRL1, (0x0A, 0x00), 0),          (_POWER_CTRL2, (0x10, 0x38), 50),      (_DRIVER_OUTPUT_CTRL, (0x03, 0x1C), 10),
    (_LCD_AC_DRIVING_CTRL, (0x01, 0x00), 10), (_ENTRY_MODE, (0x10, 0x30), 10),       (_DISP_CTRL1, (0x00, 0x00), 10),
    (_BLANK_PERIOD_CTRL1, (0x08, 0x08), 10),  (_FRAME_CYCLE_CTRL, (0x11, 0x00), 10), (_INTERFACE_CTRL, (0x00, 0x00), 10),
    (_OSC_CTRL, (0x0D, 0x01), 10),            (_VCI_RECYCLING, (0x00, 0x20), 10),    (_RAM_ADDR_SET1, (0x00, 0x00), 0),
    (_RAM_ADDR_SET2, (0x00, 0x00), 0),        (_GATE_SCAN_CTRL, (0x00, 0x00), 0),    (_VER_SCROLL_CTRL1, (0x00, 0xDB), 0),
    (_VER_SCROLL_CTRL2, (0x00, 0x00), 0),     (_VER_SCROLL_CTRL3, (0x00, 0x00), 0),  (_PART_DRIVING_POS1, (0x00, 0xDB), 0),
    (_PART_DRIVING_POS2, (0x00, 0x00), 0),    (_HOR_WINDOW_ADDR1, (0x00, 0xAF), 0),  (_HOR_WINDOW_ADDR2, (0x00, 0x00), 0),
    (_VER_WINDOW_ADDR1, (0x00, 0xDB), 0),     (_VER_WINDOW_ADDR2, (0x00, 0x20), 0),  (_GAMMA_CTRL1, (0x00, 0x00), 0),
    (_GAMMA_CTRL2, (0x08, 0x08), 0),          (_GAMMA_CTRL3, (0x08, 0x0A), 0),       (_GAMMA_CTRL4, (0x00, 0x0A), 0),
    (_GAMMA_CTRL5, (0x0A, 0x08), 0),          (_GAMMA_CTRL6, (0x08, 0x08), 0),       (_GAMMA_CTRL7, (0x00, 0x00), 0),
    (_GAMMA_CTRL8, (0x0A, 0x00), 0),          (_GAMMA_CTRL9, (0x07, 0x10), 0),       (_GAMMA_CTRL10, (0x07, 0x10), 0),
    (_DISP_CTRL1, (0x00, 0x12), 50),          (_DISP_CTRL1, (0x10, 0x17), 0))

class Display(framebuf.FrameBuffer):

    def __init__(self, spi_id: int, baudrate: int, dc_pin: machine.Pin, rst_pin: machine.Pin, backlight_pin: machine.Pin) -> None:
        self.spi = machine.SPI(spi_id, baudrate=baudrate)
        self.dc = dc_pin
        self.rst = rst_pin
        self.backlight = backlight_pin
        backlight_pin.off()
        self.dma = (_dma := rp2.DMA())
        if _ENABLE_IRQ:
            _dma.irq(self._cb_dma, bool(_HARD_IRQ))
        if spi_id == 0:
            self.treq_sel = 24 # TX DREQ number (rp2040: 16, rp2350: 24)
            self.tx_fifo_addr = 0x40080000 + 8 # rp2040: 0x4003C000, rp2350: 0x40080000
        else:
            self.treq_sel = 26 # TX DREQ number (rp2040: 18, rp2350: 26)
            self.tx_fifo_addr = 0x40088000 + 8 # rp2040: 0x40040000, rp2350: 0x40088000
        self.dma_done = True
        rst_pin.init(rst_pin.OUT, value=0)
        dc_pin.init(dc_pin.OUT, value=0)
        self.byte_buffer = (byte_buffer := memoryview(bytearray(_BUFFER_SIZE)))
        super().__init__(byte_buffer, _DISPLAY_WIDTH, _DISPLAY_HEIGHT, (RGB565 := framebuf.RGB565))
        self._reset()
        self._setup()
        self._palette = framebuf.FrameBuffer(bytearray(4), 2, 1, RGB565)
        backlight_pin.on()

    def set_display(self, flag: bool) -> None:
        '''turn display on or off (excluding backlight); called by ui.check_sleep_time_out and ui._wake_up'''
        _write = self.spi.write
        _dc_low = self.dc.low
        _dc_high = self.dc.high
        _sleep_ms = time.sleep_ms
        reg_buf = bytearray(2)
        data_buf = bytearray(2)

        def write_reg(cmd: int, value: int) -> None:
            reg_buf[1] = cmd; data_buf[0] = value >> 8; data_buf[1] = value & 0xFF
            _dc_low(); _write(reg_buf); _dc_high(); _write(data_buf)

        def write_reg_zero(cmd: int) -> None:
            reg_buf[1] = cmd; data_buf[0] = 0; data_buf[1] = 0
            _dc_low(); _write(reg_buf); _dc_high(); _write(data_buf)

        write_reg_zero(0xFF)
        if flag:
            write_reg_zero(_POWER_CTRL1)
            _sleep_ms(50)
            write_reg(_DISP_CTRL1, 0x1017)
            _sleep_ms(200)
            self.backlight.on()
        else:
            self.backlight.off()
            write_reg_zero(_DISP_CTRL1)
            _sleep_ms(50)
            write_reg(_POWER_CTRL1, 0x0003)
            _sleep_ms(200)

    def draw_screen(self) -> bool:
        '''draw display buffer to screen; called by main'''
        if _USE_DMA and _ENABLE_IRQ and not self.dma_done:
            print('dma not done')
            return False
        print('dma done')
        _dma = self.dma
        print('dma.pack_ctrl, treq_sel', self.treq_sel)
        ctrl = _dma.pack_ctrl(size=1, inc_read=True, inc_write=False, treq_sel=self.treq_sel, irq_quiet=not _ENABLE_IRQ)
        print('ctrl', ctrl)
        self.dma_done = False
        self._set_window(0, 0, _DISPLAY_WIDTH - 1, _DISPLAY_HEIGHT - 1)
        self.dc.high()
        if _USE_DMA:
            print('dma.config, write buffer addres', self.tx_fifo_addr, 'len(self.byte_buffer)', len(self.byte_buffer), 'count', _DISPLAY_WIDTH * _DISPLAY_HEIGHT * 2)
            _dma.config(read=self.byte_buffer, write=self.tx_fifo_addr, count=_DISPLAY_WIDTH * _DISPLAY_HEIGHT * 2, ctrl=ctrl, trigger=True)
            now = time.ticks_ms()
            while _dma.active():
                if time.ticks_diff(time.ticks_ms(), now) > 10000:
                    print('timeout')
                    break
            print('return from draw_screen')
        else:
            self.spi.write(self.byte_buffer)
        return True

    def _setup(self) -> None:
        '''screen set up routine; called by self.__init__'''
        _write = self.spi.write
        _dc_low = self.dc.low
        _dc_high = self.dc.high
        _sleep_ms = time.sleep_ms
        reg_buf = bytearray(2)
        data_buf = bytearray(2)

        def write_reg(cmd: int, data: tuple[int, int], sleep: int) -> None:
            reg_buf[1] = cmd; data_buf[0], data_buf[1] = data
            _dc_low(); _write(reg_buf); _dc_high(); _write(data_buf)
            if sleep > 0:
                _sleep_ms(sleep)

        for cmd, data, sleep in _SET_UP_SEQUENCE:
            write_reg(cmd, data, sleep)

    def _reset(self) -> None:
        '''reset screen; called by self.__init__'''
        _rst = self.rst; _sleep_ms = time.sleep_ms
        _rst.high()  # pull reset pin high to release from reset status
        _sleep_ms(1)
        _rst.low()   # pull reset pin low to reset
        _sleep_ms(10)
        _rst.high()  # pull reset pin high to release from reset status
        _sleep_ms(50)

    def _set_window(self, x0: int, y0: int, x1: int, y1: int) -> None:
        '''set draw window; called by self.draw_screen'''
        _write = self.spi.write
        _dc_low = self.dc.low
        _dc_high = self.dc.high
        reg_buf = bytearray(2)
        data_buf = bytearray(2)

        def write_reg(cmd, data):
            reg_buf[1] = cmd; data_buf[0] = data >> 8; data_buf[1] = data & 0xFF
            _dc_low(); _write(reg_buf); _dc_high(); _write(data_buf)

        write_reg(_ENTRY_MODE, 0x1038)   # ENTRY_MODE: set GRAM write direction and other mode bits (0x1000 | (_TOP_DOWN_L2R << 3))
        write_reg(_HOR_WINDOW_ADDR1, y1) # horizontal window: Y range
        write_reg(_HOR_WINDOW_ADDR2, y0)
        write_reg(_VER_WINDOW_ADDR1, x1) # vertical window: X range
        write_reg(_VER_WINDOW_ADDR2, x0)
        write_reg(_RAM_ADDR_SET1, y0)    # set RAM address (start point)
        write_reg(_RAM_ADDR_SET2, x0)
        reg_buf[1] = _GRAM_DATA_REG      # final GRAM register select
        _dc_low()
        _write(reg_buf)

    def _cb_dma(self, _) -> None:
        print('_cb_dma')
        self.dma_done = True

display = Display(_DISPLAY_SPI, _DISPLAY_BAUTRATE, machine.Pin(_DISPLAY_PIN_DC), machine.Pin(_DISPLAY_PIN_RST), machine.Pin(_DISPLAY_PIN_BACKLIGHT, mode=machine.Pin.OUT))
redraw = False
i = 0
while i < 5:
    if not redraw:
        time.sleep(1)
        print('fill display')
        display.fill(random.randint(0, 0xFFFF))
        display.text('TL', 0, 0, (c := random.randint(0, 0xFFFF)))
        display.text('TR', _DISPLAY_WIDTH - 16, 0, c)
        display.text('BL', 0, _DISPLAY_HEIGHT - 8, c)
        display.text('BR', _DISPLAY_WIDTH - 16, _DISPLAY_HEIGHT - 8, c)
        redraw = True
    else:
        time.sleep(0.5)
    if redraw:
        redraw = not display.draw_screen()
        print('redraw', redraw, i)
    i += 1

[GitHubsSilverBullet]

Your DMA routine sends HALFWORDS (16bit) to the SPI. Check whether that's OK.
In case it is, do you need BIG endian or little endian? DMA can swap if needed.

[HLammers]

Thanks @GitHubsSilverBullet and @robert-hh, now it works.

For if anybody find this in search of a solution, this is my working test code:

import machine
import time
import random
import rp2
import framebuf

_DISPLAY_BAUTRATE            = const(50_000_000)
_DISPLAY_SPI                 = const(0)
_DISPLAY_PIN_DC              = const(20) # RS
_DISPLAY_PIN_RST             = const(21)
_DISPLAY_PIN_BACKLIGHT       = const(17) # LED

_DISPLAY_WIDTH        = const(220)
_DISPLAY_HEIGHT       = const(176)

_BUFFER_SIZE          = const(77440) # _DISPLAY_WIDTH * _DISPLAY_HEIGHT * 2

# ILI9225 LCD Registers
_DRIVER_OUTPUT_CTRL  = const(0x01)  # Driver Output Control
_LCD_AC_DRIVING_CTRL = const(0x02)  # LCD AC Driving Control
_ENTRY_MODE          = const(0x03)  # Entry Mode
_DISP_CTRL1          = const(0x07)  # Display Control 1
_BLANK_PERIOD_CTRL1  = const(0x08)  # Blank Period Control
_FRAME_CYCLE_CTRL    = const(0x0B)  # Frame Cycle Control
_INTERFACE_CTRL      = const(0x0C)  # Interface Control
_OSC_CTRL            = const(0x0F)  # Osc Control
_POWER_CTRL1         = const(0x10)  # Power Control 1
_POWER_CTRL2         = const(0x11)  # Power Control 2
_POWER_CTRL3         = const(0x12)  # Power Control 3
_POWER_CTRL4         = const(0x13)  # Power Control 4
_POWER_CTRL5         = const(0x14)  # Power Control 5
_VCI_RECYCLING       = const(0x15)  # VCI Recycling
_RAM_ADDR_SET1       = const(0x20)  # Horizontal GRAM Address Set
_RAM_ADDR_SET2       = const(0x21)  # Vertical GRAM Address Set
_GRAM_DATA_REG       = const(0x22)  # GRAM Data Register
_GATE_SCAN_CTRL      = const(0x30)  # Gate Scan Control Register
_VER_SCROLL_CTRL1    = const(0x31)  # Vertical Scroll Control 1 Register
_VER_SCROLL_CTRL2    = const(0x32)  # Vertical Scroll Control 2 Register
_VER_SCROLL_CTRL3    = const(0x33)  # Vertical Scroll Control 3 Register
_PART_DRIVING_POS1   = const(0x34)  # Partial Driving Position 1 Register
_PART_DRIVING_POS2   = const(0x35)  # Partial Driving Position 2 Register
_HOR_WINDOW_ADDR1    = const(0x36)  # Horizontal Address Start Position
_HOR_WINDOW_ADDR2    = const(0x37)  # Horizontal Address End Position
_VER_WINDOW_ADDR1    = const(0x38)  # Vertical Address Start Position
_VER_WINDOW_ADDR2    = const(0x39)  # Vertical Address End Position
_GAMMA_CTRL1         = const(0x50)  # Gamma Control 1
_GAMMA_CTRL2         = const(0x51)  # Gamma Control 2
_GAMMA_CTRL3         = const(0x52)  # Gamma Control 3
_GAMMA_CTRL4         = const(0x53)  # Gamma Control 4
_GAMMA_CTRL5         = const(0x54)  # Gamma Control 5
_GAMMA_CTRL6         = const(0x55)  # Gamma Control 6
_GAMMA_CTRL7         = const(0x56)  # Gamma Control 7
_GAMMA_CTRL8         = const(0x57)  # Gamma Control 8
_GAMMA_CTRL9         = const(0x58)  # Gamma Control 9
_GAMMA_CTRL10        = const(0x59)  # Gamma Control 10

_SET_UP_SEQUENCE = ( # (register, data, sleep_ms)
    (_POWER_CTRL1, (0x00, 0x00), 0),          (_POWER_CTRL2, (0x00, 0x00), 0),       (_POWER_CTRL3, (0x00, 0x00), 0),
    (_POWER_CTRL4, (0x00, 0x00), 0),          (_POWER_CTRL5, (0x00, 0x00), 0),       (_POWER_CTRL2, (0x00, 0x18), 0),
    (_POWER_CTRL3, (0x11, 0x21), 0),          (_POWER_CTRL4, (0x00, 0x66), 0),       (_POWER_CTRL5, (0x5F, 0x60), 0),
    (_POWER_CTRL1, (0x0A, 0x00), 0),          (_POWER_CTRL2, (0x10, 0x38), 50),      (_DRIVER_OUTPUT_CTRL, (0x03, 0x1C), 10),
    (_LCD_AC_DRIVING_CTRL, (0x01, 0x00), 10), (_ENTRY_MODE, (0x10, 0x30), 10),       (_DISP_CTRL1, (0x00, 0x00), 10),
    (_BLANK_PERIOD_CTRL1, (0x08, 0x08), 10),  (_FRAME_CYCLE_CTRL, (0x11, 0x00), 10), (_INTERFACE_CTRL, (0x00, 0x00), 10),
    (_OSC_CTRL, (0x0D, 0x01), 10),            (_VCI_RECYCLING, (0x00, 0x20), 10),    (_RAM_ADDR_SET1, (0x00, 0x00), 0),
    (_RAM_ADDR_SET2, (0x00, 0x00), 0),        (_GATE_SCAN_CTRL, (0x00, 0x00), 0),    (_VER_SCROLL_CTRL1, (0x00, 0xDB), 0),
    (_VER_SCROLL_CTRL2, (0x00, 0x00), 0),     (_VER_SCROLL_CTRL3, (0x00, 0x00), 0),  (_PART_DRIVING_POS1, (0x00, 0xDB), 0),
    (_PART_DRIVING_POS2, (0x00, 0x00), 0),    (_HOR_WINDOW_ADDR1, (0x00, 0xAF), 0),  (_HOR_WINDOW_ADDR2, (0x00, 0x00), 0),
    (_VER_WINDOW_ADDR1, (0x00, 0xDB), 0),     (_VER_WINDOW_ADDR2, (0x00, 0x20), 0),  (_GAMMA_CTRL1, (0x00, 0x00), 0),
    (_GAMMA_CTRL2, (0x08, 0x08), 0),          (_GAMMA_CTRL3, (0x08, 0x0A), 0),       (_GAMMA_CTRL4, (0x00, 0x0A), 0),
    (_GAMMA_CTRL5, (0x0A, 0x08), 0),          (_GAMMA_CTRL6, (0x08, 0x08), 0),       (_GAMMA_CTRL7, (0x00, 0x00), 0),
    (_GAMMA_CTRL8, (0x0A, 0x00), 0),          (_GAMMA_CTRL9, (0x07, 0x10), 0),       (_GAMMA_CTRL10, (0x07, 0x10), 0),
    (_DISP_CTRL1, (0x00, 0x12), 50),          (_DISP_CTRL1, (0x10, 0x17), 0))

class Display(framebuf.FrameBuffer):

    def __init__(self, spi_id: int, baudrate: int, dc_pin: machine.Pin, rst_pin: machine.Pin, backlight_pin: machine.Pin) -> None:
        self.spi = machine.SPI(spi_id, baudrate=baudrate)
        self.dc = dc_pin
        self.rst = rst_pin
        self.backlight = backlight_pin
        backlight_pin.off()
        self.dma = (_dma := rp2.DMA())
        _dma.irq(self._cb_dma, True)
        if spi_id == 0:
            self.treq_sel = 24 # TX DREQ number (rp2040: 16, rp2350: 24)
            self.tx_fifo_addr = 0x40080000 + 8 # rp2040: 0x4003C000, rp2350: 0x40080000
        else:
            self.treq_sel = 26 # TX DREQ number (rp2040: 18, rp2350: 26)
            self.tx_fifo_addr = 0x40088000 + 8 # rp2040: 0x40040000, rp2350: 0x40088000
        self.dma_done = True
        rst_pin.init(rst_pin.OUT, value=0)
        dc_pin.init(dc_pin.OUT, value=0)
        self.byte_buffer = (byte_buffer := memoryview(bytearray(_BUFFER_SIZE)))
        super().__init__(byte_buffer, _DISPLAY_WIDTH, _DISPLAY_HEIGHT, (RGB565 := framebuf.RGB565))
        self._reset()
        self._setup()
        self._palette = framebuf.FrameBuffer(bytearray(4), 2, 1, RGB565)
        backlight_pin.on()

    def set_display(self, flag: bool) -> None:
        '''turn display on or off (excluding backlight); called by ui.check_sleep_time_out and ui._wake_up'''
        _write = self.spi.write
        _dc_low = self.dc.low
        _dc_high = self.dc.high
        _sleep_ms = time.sleep_ms
        reg_buf = bytearray(2)
        data_buf = bytearray(2)

        def write_reg(cmd: int, value: int) -> None:
            reg_buf[1] = cmd; data_buf[0] = value >> 8; data_buf[1] = value & 0xFF
            _dc_low(); _write(reg_buf); _dc_high(); _write(data_buf)

        def write_reg_zero(cmd: int) -> None:
            reg_buf[1] = cmd; data_buf[0] = 0; data_buf[1] = 0
            _dc_low(); _write(reg_buf); _dc_high(); _write(data_buf)

        write_reg_zero(0xFF)
        if flag:
            write_reg_zero(_POWER_CTRL1)
            _sleep_ms(50)
            write_reg(_DISP_CTRL1, 0x1017)
            _sleep_ms(200)
            self.backlight.on()
        else:
            self.backlight.off()
            write_reg_zero(_DISP_CTRL1)
            _sleep_ms(50)
            write_reg(_POWER_CTRL1, 0x0003)
            _sleep_ms(200)

    def draw_screen(self) -> bool:
        '''draw display buffer to screen; called by main'''
        if not self.dma_done:
            print('dma not done')
            return False
        print('dma done')
        _dma = self.dma
        print('dma.pack_ctrl, treq_sel', self.treq_sel)
        ctrl = _dma.pack_ctrl(size=0, inc_read=True, inc_write=False, treq_sel=self.treq_sel, irq_quiet=False)
        print('ctrl', ctrl)
        self.dma_done = False
        self._set_window(0, 0, _DISPLAY_WIDTH - 1, _DISPLAY_HEIGHT - 1)
        self.dc.high()
        print('dma.config, write buffer addres', self.tx_fifo_addr, 'len(self.byte_buffer)', len(self.byte_buffer), 'count', _DISPLAY_WIDTH * _DISPLAY_HEIGHT * 2)
        _dma.config(read=self.byte_buffer, write=self.tx_fifo_addr, count=_DISPLAY_WIDTH * _DISPLAY_HEIGHT * 2, ctrl=ctrl, trigger=True)
        print('return from draw_screen')
        return True

    def _setup(self) -> None:
        '''screen set up routine; called by self.__init__'''
        _write = self.spi.write
        _dc_low = self.dc.low
        _dc_high = self.dc.high
        _sleep_ms = time.sleep_ms
        reg_buf = bytearray(2)
        data_buf = bytearray(2)

        def write_reg(cmd: int, data: tuple[int, int], sleep: int) -> None:
            reg_buf[1] = cmd; data_buf[0], data_buf[1] = data
            _dc_low(); _write(reg_buf); _dc_high(); _write(data_buf)
            if sleep > 0:
                _sleep_ms(sleep)

        for cmd, data, sleep in _SET_UP_SEQUENCE:
            write_reg(cmd, data, sleep)

    def _reset(self) -> None:
        '''reset screen; called by self.__init__'''
        _rst = self.rst; _sleep_ms = time.sleep_ms
        _rst.high()  # pull reset pin high to release from reset status
        _sleep_ms(1)
        _rst.low()   # pull reset pin low to reset
        _sleep_ms(10)
        _rst.high()  # pull reset pin high to release from reset status
        _sleep_ms(50)

    def _set_window(self, x0: int, y0: int, x1: int, y1: int) -> None:
        '''set draw window; called by self.draw_screen'''
        _write = self.spi.write
        _dc_low = self.dc.low
        _dc_high = self.dc.high
        reg_buf = bytearray(2)
        data_buf = bytearray(2)

        def write_reg(cmd, data):
            reg_buf[1] = cmd; data_buf[0] = data >> 8; data_buf[1] = data & 0xFF
            _dc_low(); _write(reg_buf); _dc_high(); _write(data_buf)

        write_reg(_ENTRY_MODE, 0x1038)   # ENTRY_MODE: set GRAM write direction and other mode bits (0x1000 | (_TOP_DOWN_L2R << 3))
        write_reg(_HOR_WINDOW_ADDR1, y1) # horizontal window: Y range
        write_reg(_HOR_WINDOW_ADDR2, y0)
        write_reg(_VER_WINDOW_ADDR1, x1) # vertical window: X range
        write_reg(_VER_WINDOW_ADDR2, x0)
        write_reg(_RAM_ADDR_SET1, y0)    # set RAM address (start point)
        write_reg(_RAM_ADDR_SET2, x0)
        reg_buf[1] = _GRAM_DATA_REG      # final GRAM register select
        _dc_low()
        _write(reg_buf)

    def _cb_dma(self, _) -> None:
        print('_cb_dma')
        self.dma_done = True

display = Display(_DISPLAY_SPI, _DISPLAY_BAUTRATE, machine.Pin(_DISPLAY_PIN_DC), machine.Pin(_DISPLAY_PIN_RST), machine.Pin(_DISPLAY_PIN_BACKLIGHT, mode=machine.Pin.OUT))
redraw = False
i = 0
while i < 5:
    if not redraw:
        time.sleep(1)
        print('fill display')
        display.fill(random.randint(0, 0xFFFF))
        display.text('TL', 0, 0, (c := random.randint(0, 0xFFFF)))
        display.text('TR', _DISPLAY_WIDTH - 16, 0, c)
        display.text('BL', 0, _DISPLAY_HEIGHT - 8, c)
        display.text('BR', _DISPLAY_WIDTH - 16, _DISPLAY_HEIGHT - 8, c)
        redraw = True
    else:
        time.sleep(0.5)
    if redraw:
        redraw = not display.draw_screen()
        print('redraw', redraw, i)
    i += 1