DMA and W5500 ethernet chip

[boognevatz]

Hi,

I have a development board that features a W5500 Ethernet chip and communicates with an RP2350 over SPI.

I would like to pass a variable (150 kB fixed memory size, which is continuously updated and always holds the latest data) to the W5500 chip without CPU involvement, using DMA. The W5500 communicates over SPI, and I cannot figure out how to transfer memory to the SPI peripheral using DMA.

This is my current code (reduced to the bare minimum). The memory is filled with random data, and after each HTTP request, a random byte is changed to 0xAF.

By using DMA, I would like to serve at least 30 requests per second.

import machine
import network
import socket
import time
import select
import gc
import random

cs = machine.Pin(17, machine.Pin.OUT)
rst = machine.Pin(20, machine.Pin.OUT)

cs.value(1)
time.sleep_ms(10)

rst.value(0)  
time.sleep_ms(100)  
rst.value(1)  
time.sleep_ms(500)  

spi = machine.SPI(
    0,
    baudrate=2000000,  # 2MHz
    polarity=0,
    phase=0,
    sck=machine.Pin(18),
    mosi=machine.Pin(19),
    miso=machine.Pin(16),
)

time.sleep_ms(100)

nic = network.WIZNET5K(spi, cs, rst)

nic.active(True)
time.sleep_ms(100)

nic.ifconfig(("172.16.1.1", "255.255.255.0", "172.16.1.1", "8.8.8.8"))

time.sleep_ms(500)

if nic.active():
    config_net = nic.ifconfig()
    print(f"Ethernet initialized successfully, IP: {config_net[0]}")
else:
    print("ERROR: Ethernet failed")

demo_buffer = bytearray(153600)
for i in range(len(demo_buffer)):
    demo_buffer[i] = random.randint(0, 255)

mv = memoryview(demo_buffer)

def start_server():
    """Simple server to serve the demo data"""
    addr = socket.getaddrinfo("0.0.0.0", 8080)[0][-1]
    s = socket.socket()
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.bind(addr)
    s.listen(5)
    s.setblocking(False)

    print(f"Demo Server started on http://{config_net[0]}:8080")

    poller = select.poll()
    poller.register(s, select.POLLIN)

    while True:
        try:
            events = poller.poll(100)

            for sock, event in events:
                cl = None
                try:
                    cl, addr = sock.accept()
                    cl.setblocking(True)
                    cl.settimeout(2.0)

                    request = cl.recv(1024).decode("utf-8")
                    request_line = request.split("\r\n")[0]
                    path = request_line.split(" ")[1] if len(request_line.split(" ")) > 1 else "/"

                    if path == "/data":
                        data_len = len(mv)
                        header = f"HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nContent-Length: {data_len}\r\nConnection: close\r\n\r\n"
                        cl.send(header.encode())

                        chunk_size = 8192
                        total_sent = 0

                        while total_sent < data_len:
                            end = min(total_sent + chunk_size, data_len)
                            chunk = mv[total_sent:end]
                            bytes_sent = cl.send(chunk)
                            if bytes_sent == 0:
                                break
                            total_sent += bytes_sent  
                            random_index = random.randint(0, len(demo_buffer) - 1)
                            demo_buffer[random_index] = 0xAF
                    else:
                        response = "HTTP/1.1 404 Not Found\r\nContent-Type: text/plain\r\nConnection: close\r\n\r\n404 Not Found"
                        cl.send(response.encode())

                except Exception as e:
                    print(f"Error: {e}")
                finally:
                    if cl:
                        try:
                            cl.close()
                        except:
                            pass
                    gc.collect()

        except Exception as e:
            print(f"Server error: {e}")
            time.sleep_ms(100)

if nic.active():
    try:
        start_server()
    except KeyboardInterrupt:
        print("\nShutdown")
else:
 

[GitHubsSilverBullet]

As of now you don't have any DMA code at all in your program.
Have you tried to read the documentation? (And the datasheet?)

[boognevatz]

After reading through the w5500 sourcecode, I think it is impossible to send a memory range to the W5500 using DMA.
The best I can achieve, is to get rid of the 8kB chunking, and use the .sendall(memoryview) method, also
set the SPI speed to 40Mhz ( baudrate=40000000 ).

I can not paste DMA based code, since it is impossible imho.

[GitHubsSilverBullet]

Just having a casual look at the WizNet datasheet, it should be possible to send bulk data through the SPI. And that is quite doable with DMA.

[MilhouseVH]

Can't help with the DMA query, but you could get better performance by simply adding the INTerrupt pin.

[nickovs]

I'm not familiar with the W5500, so I can't really comment on the specifics of sending data on a socket that way, but in general trying to use DMA to send data directly into chips that are otherwise managed by device drivers is usually dangerous and error prone, since the state in the device driver will get out of sync with the chip.

You will likely be better off writing a patch to the W5500 driver than trying to drive the DMA code from Python. If you did that then sending data to the hardware RP2 SPI engine using DMA is fairly easy. In fact the existing SPI transfer code already uses DMA for large blocks, it just doesn't offer a "fire and forget" mode and will always idle until the transfer completes.

Why specifically do you want to do this with zero CPU utilisation? If what you want to be doing the rest of the time can be done by just one of the two CPU cores you might find it a great deal easier to use the standard code but run it on the second CPU core using the Micropython _thread library.