/* libhw/w5500.c - implementation for the WIZnet W5500 chip * * Copyright (C) 2024 Luke T. Shumaker * SPDX-License-Identifier: AGPL-3.0-or-later * * ----------------------------------------------------------------------------- * https://github.com/Wiznet/ioLibrary_Driver/blob/b981401e7f3d07015619adf44c13998e13e777f9/Ethernet/wizchip_conf.c * https://github.com/Wiznet/ioLibrary_Driver/blob/b981401e7f3d07015619adf44c13998e13e777f9/Ethernet/W5500/w5500.h * https://github.com/Wiznet/ioLibrary_Driver/blob/b981401e7f3d07015619adf44c13998e13e777f9/Ethernet/W5500/w5500.c * https://github.com/Wiznet/ioLibrary_Driver/blob/b981401e7f3d07015619adf44c13998e13e777f9/Ethernet/socket.c * * Copyright (c) 2013, WIZnet Co., LTD. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. * * SPDX-License-Identifier: BSD-3-Clause * * ----------------------------------------------------------------------------- * https://github.com/Wiznet/ioLibrary_Driver/blob/b981401e7f3d07015619adf44c13998e13e777f9/license.txt * * Copyright (c) 2014 WIZnet Co.,Ltd. * Copyright (c) WIZnet ioLibrary Project. * All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. * * SPDX-License-Identifier: MIT */ /* TODO: Write a to avoid w5500.c being * pico-sdk-specific. */ #include /* pico-sdk:hardware_gpio */ #include /* for cr_yield() */ #include /* for VCALL_SELF() */ #include /* for sleep_*() */ #define IMPLEMENTATION_FOR_LIBHW_W5500_H YES #include #include "w5500_ll.h" /* Config *********************************************************************/ #include "config.h" /* These are the default values of the Linux kernel's * net.ipv4.ip_local_port_range, so I figure they're probably good * values to use. */ #ifndef CONFIG_W5500_LOCAL_PORT_MIN #define CONFIG_W5500_LOCAL_PORT_MIN 32768 #endif #ifndef CONFIG_W5500_LOCAL_PORT_MAX #define CONFIG_W5500_LOCAL_PORT_MAX 60999 #endif #ifndef CONFIG_W5500_NUM #error config.h must define CONFIG_W5500_NUM #endif /* C language *****************************************************************/ #define UNUSED(name) #define ARRAY_LEN(ary) (sizeof(ary)/sizeof((ary)[0])) /* vtables ********************************************************************/ static implements_net_stream_conn *w5500_tcp_accept(implements_net_stream_listener *); static void w5500_tcp_set_read_deadline(implements_net_stream_conn *, uint64_t ns); static ssize_t w5500_tcp_read( implements_net_stream_conn *, void *, size_t); static ssize_t w5500_tcp_write( implements_net_stream_conn *, void *, size_t); static int w5500_tcp_close( implements_net_stream_conn *, bool rd, bool wr); static void w5500_udp_set_read_deadline(implements_net_packet_conn *, uint64_t ns); static ssize_t w5500_udp_recvfrom( implements_net_packet_conn *, void *, size_t, struct net_ip4_addr *, uint16_t *); static ssize_t w5500_udp_sendto( implements_net_packet_conn *, void *, size_t, struct net_ip4_addr, uint16_t); static int w5500_udp_close( implements_net_packet_conn *); static struct net_stream_listener_vtable w5500_tcp_listener_vtable = { .accept = w5500_tcp_accept, }; static struct net_stream_conn_vtable w5500_tcp_conn_vtable = { .set_read_deadline = w5500_tcp_set_read_deadline, .read = w5500_tcp_read, .write = w5500_tcp_write, .close = w5500_tcp_close, }; static struct net_packet_conn_vtable w5500_udp_conn_vtable = { .set_read_deadline = w5500_udp_set_read_deadline, .recvfrom = w5500_udp_recvfrom, .sendto = w5500_udp_sendto, .close = w5500_udp_close, }; /* mid-level utilities ********************************************************/ #if 0 static uint16_t w5500_get_local_port(struct w5500 *self) { uint16_t ret = self->next_local_port++; if (self->next_local_port > CONFIG_W5500_LOCAL_PORT_MAX) self->next_local_port = CONFIG_W5500_LOCAL_PORT_MIN; return ret; } #endif static COROUTINE w5500_irq_cr(void *_chip) { struct w5500 *chip = _chip; cr_begin(); for (;;) { cr_sema_wait(&chip->intr); if (w5500ll_read_common_reg(chip->spidev, chip_interrupt)) w5500ll_write_common_reg(chip->spidev, chip_interrupt, 0xFF); uint8_t sockmask = w5500ll_read_common_reg(chip->spidev, sock_interrupt); for (uint8_t socknum = 0; socknum < 8; socknum++) { if (!(sockmask & (1<sockets[socknum]; uint8_t sockintr = w5500ll_read_sock_reg(chip->spidev, socknum, interrupt); switch (socket->mode) { case W5500_MODE_NONE: break; case W5500_MODE_TCP: /* SOCKINTR_SEND_OK is useless; just count on the write methods to * poll instead of waiting on notification from here. */ uint8_t listen_bits = sockintr & (SOCKINTR_TIMEOUT|SOCKINTR_CONN), read_bits = sockintr & (SOCKINTR_TIMEOUT|SOCKINTR_RECV|SOCKINTR_FIN); if (listen_bits) cr_sema_signal(&socket->listen_sema); /* fallthrough */ case W5500_MODE_UDP: if (read_bits) cr_sema_signal(&socket->read_sema); } w5500ll_write_sock_reg(chip->spidev, socknum, interrupt, sockintr); } } cr_end(); } static struct w5500 *w5500_socket_chip(struct _w5500_socket *socket) { assert(socket); assert(socket->socknum < 8); struct _w5500_socket *sock0 = &socket[-(socket->socknum)]; assert(sock0); struct w5500 *chip = ((void *)sock0) - offsetof(struct w5500, sockets); assert(chip); return chip; } static inline void w5500_socket_cmd(struct _w5500_socket *socket, uint8_t cmd) { assert(socket); struct w5500 *chip = w5500_socket_chip(socket); uint8_t socknum = socket->socknum; cr_mutex_lock(&socket->cmd_mu); w5500ll_write_sock_reg(chip->spidev, socknum, command, cmd); while (w5500ll_read_sock_reg(chip->spidev, socknum, command) != 0x00) cr_yield(); cr_mutex_unlock(&socket->cmd_mu); } static inline void w5500_socket_close(struct _w5500_socket *socket) { assert(socket); struct w5500 *chip = w5500_socket_chip(socket); uint8_t socknum = socket->socknum; /* Send CMD_CLOSE. */ w5500_socket_cmd(socket, CMD_CLOSE); /* Wait for it to transition to STATE_CLOSED. */ while (w5500ll_read_sock_reg(chip->spidev, socknum, state) != STATE_CLOSED) cr_yield(); /* Update our MCU-side bookkeeping. */ socket->mode = W5500_MODE_NONE; socket->port = 0; socket->read_deadline_ns = 0; socket->read_open = socket->write_open = false; } #define ASSERT_SELF(_iface, _mode) \ struct _w5500_socket *socket = \ VCALL_SELF(struct _w5500_socket, \ implements_net_##_iface, _socket); \ assert(socket); \ uint8_t socknum = socket->socknum; \ assert(socknum < 8); \ assert(socket->mode == W5500_MODE_##_mode); \ struct w5500 *chip = w5500_socket_chip(socket); \ assert(chip); /* init() *********************************************************************/ static struct w5500 *w5500_chips[CONFIG_W5500_NUM] = {0}; static void w5500_intrhandler(uint gpio, uint32_t UNUSED(event_mask)) { for (size_t i = 0; i < ARRAY_LEN(w5500_chips); i++) if (w5500_chips[i] && w5500_chips[i]->pin_intr == gpio) cr_sema_signal_from_intrhandler(&w5500_chips[i]->intr); } void _w5500_init(struct w5500 *chip, implements_spi *spi, uint pin_intr, uint pin_reset, struct net_eth_addr addr) { assert(chip); assert(spi); /* Initialize the data structures. */ *chip = (struct w5500){ /* const-after-init */ .spidev = spi, .pin_intr = pin_intr, .pin_reset = pin_reset, .hwaddr = addr, /* mutable */ .next_local_port = CONFIG_W5500_LOCAL_PORT_MIN, }; for (uint8_t i = 0; i < 8; i++) { chip->sockets[i] = (struct _w5500_socket){ /* const-after-init */ .implements_net_stream_listener = { .vtable = &w5500_tcp_listener_vtable }, .implements_net_stream_conn = { .vtable = &w5500_tcp_conn_vtable }, .implements_net_packet_conn = { .vtable = &w5500_udp_conn_vtable }, .socknum = i, /* mutable */ /* these all get initialized to the zero values */ }; } /* Initialize the hardware. */ gpio_set_irq_enabled_with_callback(pin_intr, GPIO_IRQ_EDGE_FALL, true, w5500_intrhandler); gpio_set_dir(chip->pin_reset, GPIO_OUT); w5500_hard_reset(chip); /* Finally, wire in the interrupt handler. */ cr_disable_interrupts(); for (size_t i = 0; i < ARRAY_LEN(w5500_chips); i++) { if (w5500_chips[i] == NULL) { w5500_chips[i] = chip; break; } } cr_enable_interrupts(); coroutine_add(w5500_irq_cr, chip); } /* chip methods ***************************************************************/ static inline void w5500_post_reset(struct w5500 *chip) { /* The W5500 does not have a built-in MAC address, we must * provide one. */ w5500ll_write_common_reg(chip->spidev, eth_addr, chip->hwaddr); /* The RP2040 needs a 1/sys_clk hysteresis between interrupts * for us to notice them. At the maximum-rated clock-rate of * 133MHz, that means 7.5ns (but the sbc-harness overclocks * the RP2040, so we could get away with even shorter). * * If intlevel is non-zero, then the hysteresis is * (intlevel+1)*4/(150MHz), or (intlevel+1)*26.7ns; so even * the shortest-possible hysteresis much larger than necessary * for us. */ w5500ll_write_common_reg(chip->spidev, intlevel, uint16be_marshal(1)); /* This implementation does not care about any of the * chip-level interrupts. */ w5500ll_write_common_reg(chip->spidev, chip_interrupt_mask, 0); /* This implementation cares about interrupts for each * socket. */ w5500ll_write_common_reg(chip->spidev, sock_interrupt_mask, 0xFF); /* Configure retry/timeout. * * timeout_arp = 0.1ms * retry_time * (retry_count+1) * * retry_count * timeout_tcp = 0.1ms * retry_time * Σ 2^min(n, floor(1+log_2(65535/retry_time))) * n=0 * * For retry_time=2000, retry_count=3, this means * * timeout_arp = 0.8s * timeout_tcp = 3.0s */ w5500ll_write_common_reg(chip->spidev, retry_time, uint16be_marshal(2000)); w5500ll_write_common_reg(chip->spidev, retry_count, 3); } void w5500_hard_reset(struct w5500 *chip) { gpio_put(chip->pin_reset, 0); sleep_for_ms(1); /* minimum of 500us */ gpio_put(chip->pin_reset, 1); sleep_for_ms(2); /* minimum of 1ms */ w5500_post_reset(chip); } void w5500_soft_reset(struct w5500 *chip) { w5500ll_write_common_reg(chip->spidev, mode, CHIPMODE_RST); while (w5500ll_read_common_reg(chip->spidev, mode) & CHIPMODE_RST) cr_yield(); w5500_post_reset(chip); } void w5500_netcfg(struct w5500 *chip, struct w5500_netcfg cfg) { w5500ll_write_common_reg(chip->spidev, ip_gateway_addr, cfg.gateway_addr); w5500ll_write_common_reg(chip->spidev, ip_subnet_mask, cfg.subnet_mask); w5500ll_write_common_reg(chip->spidev, ip_addr, cfg.addr); } implements_net_stream_listener *w5500_tcp_listen(struct w5500 *chip, uint8_t socknum, uint16_t port) { assert(chip); assert(socknum < 8); assert(port); assert(chip->sockets[socknum].mode == W5500_MODE_NONE); chip->sockets[socknum].mode = W5500_MODE_TCP; chip->sockets[socknum].port = port; chip->sockets[socknum].read_deadline_ns = 0; return &chip->sockets[socknum].implements_net_stream_listener; } implements_net_packet_conn *w5500_udp_conn(struct w5500 *chip, uint8_t socknum, uint16_t port) { assert(chip); assert(socknum < 8); assert(port); assert(chip->sockets[socknum].mode == W5500_MODE_NONE); chip->sockets[socknum].mode = W5500_MODE_UDP; chip->sockets[socknum].port = port; chip->sockets[socknum].read_deadline_ns = 0; return &chip->sockets[socknum].implements_net_packet_conn; } /* tcp_listener methods *******************************************************/ static implements_net_stream_conn *w5500_tcp_accept(implements_net_stream_listener *_socket) { ASSERT_SELF(stream_listener, TCP); restart: /* Mimics socket.c:socket(). */ w5500_socket_close(socket); w5500ll_write_sock_reg(chip->spidev, socknum, mode, SOCKMODE_TCP); w5500ll_write_sock_reg(chip->spidev, socknum, local_port, uint16be_marshal(socket->port)); w5500_socket_cmd(socket, CMD_OPEN); while (w5500ll_read_sock_reg(chip->spidev, socknum, state) != STATE_TCP_INIT) cr_yield(); /* Mimics socket.c:listen(). */ w5500_socket_cmd(socket, CMD_LISTEN); for (;;) { uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state); switch (state) { case STATE_TCP_LISTEN: case STATE_TCP_SYNRECV: cr_sema_wait(&socket->listen_sema); break; case STATE_TCP_ESTABLISHED: socket->read_open = true; /* fall-through */ case STATE_TCP_CLOSE_WAIT: socket->write_open = true; return &socket->implements_net_stream_conn; default: goto restart; } } } /* tcp_conn methods ***********************************************************/ static ssize_t w5500_tcp_write(implements_net_stream_conn *_socket, void *buf, size_t count) { ASSERT_SELF(stream_conn, TCP); assert(buf); assert(count); /* What we really want is to pause until we receive an ACK for * some data we just queued, so that we can line up some new * data to keep the buffer full. But that's not what * SEND_FINISHED does AIUI, the SEND_FINISHED interrupt * doesn't fire until we receive the *last* ACK for the data, * when the buffer is entirely empty. * * Which means we basically have to busy-poll for space in the * buffer becoming available. * * We'll add more data to the buffer whenever there is * `min_free_space` in the buffer (or the rest of the data * fits in the buffer). * * This `min_free_space` can probably stand to be tuned; must * be >0, <=bufsize. `1500-58` is the 100BaseT MTU minus the * Ethernet+IP+TCP overhead. */ uint16_t bufsize = ((uint16_t)w5500ll_read_sock_reg(chip->spidev, socknum, tx_buf_size))*1024; uint16_t min_free_space = MIN(1500-58, bufsize/4); size_t done = 0; while (done < count) { if (!socket->write_open) return -NET_ECLOSED; uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state); if (state != STATE_TCP_ESTABLISHED && state != STATE_TCP_CLOSE_WAIT) return -NET_ECLOSED; uint16_t freesize = uint16be_unmarshal(w5500ll_read_sock_reg(chip->spidev, socknum, tx_free_size)); if (freesize < count-done && freesize < min_free_space) { /* Wait for more buffer space. */ cr_yield(); continue; } /* Queue data to be sent. */ if ((size_t)freesize > count-done) freesize = count-done; uint16_t ptr = uint16be_unmarshal(w5500ll_read_sock_reg(chip->spidev, socknum, tx_write_pointer)); w5500ll_write(chip->spidev, ptr, CTL_BLOCK_SOCK(socknum, TX), &((char *)buf)[done], freesize); w5500ll_write_sock_reg(chip->spidev, socknum, tx_write_pointer, uint16be_marshal(ptr+freesize)); /* Submit the queue. */ w5500_socket_cmd(socket, CMD_SEND); done += freesize; } return done; } static void w5500_tcp_set_read_deadline(implements_net_stream_conn *_socket, uint64_t ns) { ASSERT_SELF(stream_conn, TCP); socket->read_deadline_ns = ns; } static void w5500_tcp_alarm_handler(void *_arg) { struct _w5500_socket *socket = _arg; cr_sema_signal(&socket->read_sema); } static ssize_t w5500_tcp_read(implements_net_stream_conn *_socket, void *buf, size_t count) { ASSERT_SELF(stream_conn, TCP); assert(buf); assert(count); struct alarmclock_trigger trigger = {0}; if (socket->read_deadline_ns) VCALL(bootclock, add_trigger, &trigger, socket->read_deadline_ns, w5500_tcp_alarm_handler, socket); /* Wait until there is data to read. */ uint16_t avail = 0; for (;;) { if (!socket->read_open) { VCALL(bootclock, del_trigger, &trigger); return -NET_ECLOSED; } if (socket->read_deadline_ns && socket->read_deadline_ns >= VCALL(bootclock, get_time_ns)) { VCALL(bootclock, del_trigger, &trigger); return -NET_ETIMEDOUT; } uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state); switch (state) { case STATE_TCP_CLOSE_WAIT: case STATE_TCP_ESTABLISHED: case STATE_TCP_FIN_WAIT: break; /* OK */ default: VCALL(bootclock, del_trigger, &trigger); return -NET_ECLOSED; } avail = uint16be_unmarshal(w5500ll_read_sock_reg(chip->spidev, socknum, rx_size)); if (avail) /* We have data to read. */ break; if (state == STATE_TCP_CLOSE_WAIT) { VCALL(bootclock, del_trigger, &trigger); return 0; /* EOF */ } cr_sema_wait(&socket->read_sema); } assert(avail); uint16_t ptr = uint16be_unmarshal(w5500ll_read_sock_reg(chip->spidev, socknum, rx_read_pointer)); /* Read the data. */ if ((size_t)avail > count) avail = count; w5500ll_read(chip->spidev, ptr, CTL_BLOCK_SOCK(socknum, RX), buf, avail); /* Tell the chip that we read the data. */ w5500ll_write_sock_reg(chip->spidev, socknum, rx_read_pointer, uint16be_marshal(ptr+avail)); w5500_socket_cmd(socket, CMD_RECV); /* Return. */ VCALL(bootclock, del_trigger, &trigger); return avail; } static int w5500_tcp_close(implements_net_stream_conn *_socket, bool rd, bool wr) { ASSERT_SELF(stream_conn, TCP); if (rd) socket->read_open = false; if (wr && socket->write_open) { w5500_socket_cmd(socket, CMD_DISCON); while (socket->write_open) { uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state); switch (state) { case STATE_TCP_FIN_WAIT: socket->write_open = false; /* Can still read */ if (!socket->read_open) w5500_socket_close(socket); break; case STATE_CLOSED: socket->write_open = false; break; } } } return 0; } /* udp_conn methods ***********************************************************/ static ssize_t w5500_udp_sendto(implements_net_packet_conn *_socket, void *buf, size_t count, struct net_ip4_addr node, uint16_t port) { ASSERT_SELF(packet_conn, UDP); assert(buf); assert(count); uint16_t bufsize = ((uint16_t)w5500ll_read_sock_reg(chip->spidev, socknum, tx_buf_size))*1024; if (count < bufsize) return -NET_EMSGSIZE; for (;;) { uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state); if (state != STATE_UDP) return -NET_ECLOSED; uint16_t freesize = uint16be_unmarshal(w5500ll_read_sock_reg(chip->spidev, socknum, tx_free_size)); if (freesize >= count) /* We can send. */ break; /* Wait for more buffer space. */ cr_yield(); } /* Where we're sending it. */ w5500ll_write_sock_reg(chip->spidev, socknum, remote_ip_addr, node); w5500ll_write_sock_reg(chip->spidev, socknum, remote_port, uint16be_marshal(port)); /* Queue data to be sent. */ uint16_t ptr = uint16be_unmarshal(w5500ll_read_sock_reg(chip->spidev, socknum, tx_write_pointer)); w5500ll_write(chip->spidev, ptr, CTL_BLOCK_SOCK(socknum, TX), buf, count); w5500ll_write_sock_reg(chip->spidev, socknum, tx_write_pointer, uint16be_marshal(ptr+count)); /* Submit the queue. */ w5500_socket_cmd(socket, CMD_SEND); return count; } static void w5500_udp_set_read_deadline(implements_net_packet_conn *_socket, uint64_t ns) { ASSERT_SELF(packet_conn, UDP); socket->read_deadline_ns = ns; } static void w5500_udp_alarm_handler(void *_arg) { struct _w5500_socket *socket = _arg; cr_sema_signal(&socket->read_sema); } static ssize_t w5500_udp_recvfrom(implements_net_packet_conn *_socket, void *buf, size_t count, struct net_ip4_addr *node, uint16_t *port) { ASSERT_SELF(packet_conn, UDP); assert(buf); assert(count); struct alarmclock_trigger trigger = {0}; if (socket->read_deadline_ns) VCALL(bootclock, add_trigger, &trigger, socket->read_deadline_ns, w5500_udp_alarm_handler, socket); /* Wait until there is data to read. */ uint16_t avail = 0; for (;;) { if (socket->read_deadline_ns && socket->read_deadline_ns >= VCALL(bootclock, get_time_ns)) { VCALL(bootclock, del_trigger, &trigger); return -NET_ETIMEDOUT; } uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state); if (state != STATE_UDP) { VCALL(bootclock, del_trigger, &trigger); return -NET_ECLOSED; } uint16_t avail = uint16be_unmarshal(w5500ll_read_sock_reg(chip->spidev, socknum, rx_size)); if (avail) /* We have data to read. */ break; cr_sema_wait(&socket->read_sema); } assert(avail >= 8); uint16_t ptr = uint16be_unmarshal(w5500ll_read_sock_reg(chip->spidev, socknum, rx_read_pointer)); /* Read a munged form of the UDP packet header. I * can't find in the datasheet where it describes * this; this is based off of socket.c:recvfrom(). */ uint8_t hdr[8]; w5500ll_read(chip->spidev, ptr, CTL_BLOCK_SOCK(socknum, RX), hdr, sizeof(hdr)); node->octets[0] = hdr[0]; node->octets[1] = hdr[1]; node->octets[2] = hdr[2]; node->octets[3] = hdr[3]; *port = uint16be_decode(&hdr[4]); uint16_t len = uint16be_decode(&hdr[6]); /* Now read the actual data. */ if (count > len) count = len; w5500ll_read(chip->spidev, ptr+8, CTL_BLOCK_SOCK(socknum, RX), buf, len); /* Tell the chip that we read the data. */ w5500ll_write_sock_reg(chip->spidev, socknum, rx_read_pointer, uint16be_marshal(ptr+8+len)); w5500_socket_cmd(socket, CMD_RECV); /* Return. */ VCALL(bootclock, del_trigger, &trigger); return len; } static int w5500_udp_close(implements_net_packet_conn *_socket) { ASSERT_SELF(packet_conn, UDP); w5500_socket_close(socket); return 0; }