summaryrefslogtreecommitdiff
path: root/cmd/sbc_harness/hw/w5500.c
diff options
context:
space:
mode:
Diffstat (limited to 'cmd/sbc_harness/hw/w5500.c')
-rw-r--r--cmd/sbc_harness/hw/w5500.c614
1 files changed, 224 insertions, 390 deletions
diff --git a/cmd/sbc_harness/hw/w5500.c b/cmd/sbc_harness/hw/w5500.c
index 5e418f1..7bd2fde 100644
--- a/cmd/sbc_harness/hw/w5500.c
+++ b/cmd/sbc_harness/hw/w5500.c
@@ -39,12 +39,16 @@
*/
#include <pico/time.h> /* for sleep_ms() */
-#include <hardware/gpio.h> /* pico-sdk:hardware_gpio5 */
+#include <hardware/gpio.h> /* pico-sdk:hardware_gpio */
#include <libcr/coroutine.h>
#include <libmisc/vcall.h>
+#include "hw/w5500_ll.h"
#include "hw/w5500.h"
+
+/* Config *********************************************************************/
+
#include "config.h"
/* These are the default values of the Linux kernel's
@@ -57,343 +61,94 @@
# define CONFIG_W5500_LOCAL_PORT_MAX 60999
#endif
-#define UNUSED(name)
-
-#define ASSERT_SAMETYPE(a, b) \
- static_assert(_Generic(a, typeof(b): 1, default: 0), \
- "typeof("#a") != typeof("#b")")
-
-
-/* Low-level protocol built on SPI frames. ***********************************/
-
-/* A u8 control byte has 3 parts: block-ID, R/W, and
- * operating-mode. */
+#ifndef CONFIG_W5500_NUM
+# error config.h must define CONFIG_W5500_NUM
+#endif
-/* Part 1: Block ID. */
-#define CTL_MASK_BLOCK 0b11111000
-#define _CTL_BLOCK_RES 0b00000
-#define _CTL_BLOCK_REG 0b01000
-#define _CTL_BLOCK_TX 0b10000
-#define _CTL_BLOCK_RX 0b11000
-#define CTL_BLOCK_SOCK(n,part) (((n)<<5)|(_CTL_BLOCK_##part))
-#define CTL_BLOCK_COMMON_REG CTL_BLOCK_SOCK(0,RES)
+/* C language *****************************************************************/
-/* Part 2: R/W. */
-#define CTL_MASK_RW 0b100
-#define CTL_R 0b000
-#define CTL_W 0b100
+#define UNUSED(name)
+#define ARRAY_LEN(ary) (sizeof(ary)/sizeof((ary)[0]))
-/* Part 3: Operating mode. */
-#define CTL_MASK_OM 0b11
-#define CTL_OM_VDM 0b00
-#define CTL_OM_FDM1 0b01
-#define CTL_OM_FDM2 0b10
-#define CTL_OM_FDM4 0b11
+/* mid-level utilities ********************************************************/
-/* The W5500 has 2 channels of communication with the MCU:
- *
- * - An SPI-based RPC protocol:
- * + mode: mode 0 or mode 3
- * + bit-order: MSB-first
- * + clock frequency: 33.3MHz - 80MHz
- * - An interrupt pin that it pulls low when an event happens (to let
- * the MCU know that it should do an SPI RPC "get" to see what
- * happened.)
- *
- * Even though SPI is a full-duplex protocol, the W5500's RPC protocol
- * on top of it is only half-duplex. Lame.
+/*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;
+ *}
*/
-void w5500_spiframe_write(struct spi *spidev, uint16_t addr, uint8_t block, void *data, size_t data_len) {
- assert(spidev);
- assert((block & ~CTL_MASK_BLOCK) == 0);
- assert(data);
- assert(data_len);
+static struct w5500 *w5500_sock_chip(struct _w5500_listener *listener) {
+ assert(listener);
+ assert(listener->socknum < 8);
- uint8_t header[3] = {
- (uint8_t)((addr >> 8) & 0xFF),
- (uint8_t)(addr & 0xFF),
- (block & CTL_MASK_BLOCK) | CTL_W | CTL_OM_VDM,
- };
- struct bidi_iovec iov[] = {
- {.iov_read_dst = NULL, .iov_write_src = header, .iov_len = sizeof(header)},
- {.iov_read_dst = NULL, .iov_write_src = data, .iov_len = data_len},
- };
- VCALL(spidev, readwritev, iov, 2);
+ struct _w5500_listener *sock0 = &listener[-listener->socknum];
+ assert(sock0);
+ struct w5500 *chip =
+ ((void *)sock0) - offsetof(struct w5500, listeners);
+ assert(chip);
+ return chip;
}
-void w5500_spiframe_read(struct spi *spidev, uint16_t addr, uint8_t block, void *data, size_t data_len) {
- assert(spidev);
- assert((block & ~CTL_MASK_BLOCK) == 0);
- assert(data);
- assert(data_len);
+static inline void w5500_sock_cmd(struct _w5500_listener *listener, uint8_t cmd) {
+ assert(listener);
+ struct w5500 *chip = w5500_sock_chip(listener);
+ uint8_t socknum = listener->socknum;
- uint8_t header[3] = {
- (uint8_t)((addr >> 8) & 0xFF),
- (uint8_t)(addr & 0xFF),
- (block & CTL_MASK_BLOCK) | CTL_R | CTL_OM_VDM,
- };
- struct bidi_iovec iov[] = {
- {.iov_read_dst = NULL, .iov_write_src = header, .iov_len = sizeof(header)},
- {.iov_read_dst = data, .iov_write_src = NULL, .iov_len = data_len},
- };
- VCALL(spidev, readwritev, iov, 2);
+ cr_mutex_lock(&listener->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(&listener->cmd_mu);
}
-/* Offsets and sizes for use with that protocol. *****************************/
+static void w5500_sock_cmd_close(struct _w5500_listener *listener) {
+ assert(listener);
+ struct w5500 *chip = w5500_sock_chip(listener);
+ uint8_t socknum = listener->socknum;
-struct uint16_be {
- uint8_t octets[2];
-};
+ w5500_sock_cmd(listener, CMD_CLOSE);
+ w5500ll_write_sock_reg(chip->spidev, socknum, interrupt, 0xFF);
+ while (w5500ll_read_sock_reg(chip->spidev, socknum, state) != STATE_CLOSED)
+ cr_yield();
-struct w5500_block_common_reg {
- uint8_t mode; /* MR; bitfield, see CHIPMODE_{x} below */
- struct net_ip4_addr ip_gateway_addr; /* GAR0 ... GAR3 */
- struct net_ip4_addr ip_subnet_mask; /* SUBR0 ... SUBR3 */
- struct net_eth_addr eth_addr; /* SHAR0 ... SHAR5 */
- struct net_ip4_addr ip_addr; /* SIPR0 ... SIPR3 */
+ listener->active_conn.read_open = listener->active_conn.write_open = false;
+}
- struct uint16_be intlevel; /* INTLEVEL0, INTLEVEL1; minimum time before pin_intr can be pulled low again (time=(intlevel+1)*4/PLL) */
- uint8_t chip_interrupt; /* IR; bitfield, see CHIPINTR_{x} below */
- uint8_t chip_interrupt_mask; /* IMR; bitfield, see CHIPINTR_{x} below, 0=disable, 1=enable */
- uint8_t sock_interrupt; /* SIR; bitfield of which sockets have their .interrupt set */
- uint8_t sock_interrupt_mask; /* SIMR; bitfield of sockets, 0=disable, 1=enable */
- struct uint16_be retry_time; /* RTR0, RTR0; configures re-transmission period, in units of 100µs */
- uint8_t retry_count; /* RCR; configures max re-transmission count */
+static COROUTINE w5500_irq_cr(void *_chip) {
+ struct w5500 *chip = _chip;
+ cr_begin();
- uint8_t ppp_lcp_request_timer; /* PTIMER */
- uint8_t ppp_lcp_magic_bumber; /* PMAGIC */
- struct net_eth_addr ppp_dst_eth_addr; /* PHAR0 ... PHAR5 */
- struct uint16_be ppp_sess_id; /* PSID0 ... PSID1 */
- struct uint16_be ppp_max_seg_size; /* PMRU0 ... PMRU1 */
+ for (;;) {
+ cr_sema_wait(&chip->intr);
+ if (w5500ll_read_common_reg(chip->spidev, chip_interrupt))
+ w5500ll_write_common_reg(chip->spidev, chip_interrupt, 0xFF);
- struct net_ip4_addr unreachable_ip_addr; /* UIPR0 ... UIPR3 */
- struct uint16_be unreachable_port; /* UPORTR0, UPORTR1 */
+ uint8_t sockmask = w5500ll_read_common_reg(chip->spidev, sock_interrupt);
+ for (uint8_t socknum = 0; socknum < 8; socknum++) {
+ if (!(sockmask & (1<<socknum)))
+ continue;
+ struct _w5500_listener *listener = &chip->listeners[socknum];
- uint8_t phy_cfg; /* PHYCFGR */
+ uint8_t sockintr = w5500ll_read_sock_reg(chip->spidev, socknum, interrupt);
- uint8_t _reserved[10];
+ /* SOCKINTR_SEND_OK is useless. */
+ uint8_t listen_bits = sockintr & (SOCKINTR_TIMEOUT|SOCKINTR_CONN),
+ read_bits = sockintr & (SOCKINTR_TIMEOUT|SOCKINTR_RECV|SOCKINTR_FIN);
- uint8_t chip_version; /* VERSIONR */
-};
-static_assert(sizeof(struct w5500_block_common_reg) == 0x3A);
-
-/* bitfield */
-#define CHIPMODE_RST ((uint8_t)(1<<7)); /* software reset */
-#define _CHIPMODE_UNUSED6 ((uint8_t)(1<<6));
-#define CHIPMODE_WOL ((uint8_t)(1<<5)); /* wake-on-lan */
-#define CHIPMODE_BLOCK_PING ((uint8_t)(1<<4));
-#define CHIPMODE_PPP ((uint8_t)(1<<3));
-#define _CHIPMODE_UNUSED2 ((uint8_t)(1<<2));
-#define CHIPMODE_FORCE_ARP ((uint8_t)(1<<1));
-#define _CHIPMODE_UNUSED0 ((uint8_t)(1<<0));
-
-#define CHIPINTR_CONFLICT ((uint8_t)(1<<7)); /* ARP says remote IP is self */
-#define CHIPINTR_UNREACH ((uint8_t)(1<<6));
-#define CHIPINTR_PPP_CLOSE ((uint8_t)(1<<6));
-#define CHIPINTR_WOL ((uint8_t)(1<<4));
-#define _CHIPINTR_UNUSED3 ((uint8_t)(1<<3));
-#define _CHIPINTR_UNUSED2 ((uint8_t)(1<<2));
-#define _CHIPINTR_UNUSED1 ((uint8_t)(1<<1));
-#define _CHIPINTR_UNUSED0 ((uint8_t)(1<<0));
-
-struct w5500_block_sock_reg {
- uint8_t mode; /* Sn_MR; see SOCKMODE_{x} below */
- uint8_t command; /* Sn_CR; see CMD_{x} below */
- uint8_t interrupt; /* Sn_IR; bitfield, see SOCKINTR_{x} below */
- uint8_t state; /* Sn_SR; see STATE_{x} below */
- struct uint16_be local_port; /* Sn_PORT0, Sn_PORT1 */
- struct net_eth_addr remote_eth_addr; /* Sn_DHAR0 ... SnDHAR5 */
- struct net_ip4_addr remote_ip_addr; /* Sn_DIPR0 ... Sn_DIP3 */
- struct uint16_be remote_port; /* Sn_DPORT0 ... Sn_DPORT1 */
-
- struct uint16_be max_seg_size; /* Sn_MSSR0, Sn_MSSR1 */
- uint8_t _reserved0[1];
- uint8_t ip_tos; /* Sn_TOS */
- uint8_t ip_ttl; /* Sn_TTL */
- uint8_t _reserved1[7];
-
- uint8_t rx_buf_size; /* Sn_RXBUF_SIZE */
- uint8_t tx_buf_size; /* Sn_TXBUF_SIZE */
- struct uint16_be tx_free_size; /* Sn_TX_FSR0, Sn_TX_FSR1 */
- struct uint16_be tx_read_pointer; /* Sn_TX_RD0, Sn_TX_RD1 */
- struct uint16_be tx_write_pointer; /* Sn_TX_WR0, Sn_TX_WR1 */
- struct uint16_be rx_size; /* Sn_RX_RSR0, Sn_RX_RSR1 */
- struct uint16_be rx_read_pointer; /* Sn_RX_RD0, Sn_RX_RD1 */
- struct uint16_be rx_write_pointer; /* Sn_RX_WR0, Sn_RX_WR1 */
-
- uint8_t interrupt_mask; /* Sn_IMR */
- struct uint16_be fragment_offset; /* Sn_FRAG0, Sn_FRAG1 */
- uint8_t keepalive_timer; /* Sn_KPALVTR */
-};
-static_assert(sizeof(struct w5500_block_sock_reg) == 0x30);
-
-/* low 4 bits are the main enum, high 4 bits are flags */
-#define SOCKMODE_CLOSED ((uint8_t)0b0000)
-#define SOCKMODE_TCP ((uint8_t)0b0001)
-#define SOCKMODE_UDP ((uint8_t)0b0010)
-#define SOCKMODE_MACRAW ((uint8_t)0b0100)
-
-#define SOCKMODE_FLAG_TCP_NODELAY_ACK ((uint8_t)(1<<5))
-
-#define SOCKMODE_FLAG_UDP_ENABLE_MULTICAST ((uint8_t)(1<<7))
-#define SOCKMODE_FLAG_UDP_BLOCK_BROADCAST ((uint8_t)(1<<6))
-#define SOCKMODE_FLAG_UDP_MULTICAST_DOWNGRADE ((uint8_t)(1<<5))
-#define SOCKMODE_FLAG_UDP_BLOCK_UNICAST ((uint8_t)(1<<4))
-
-#define SOCKMODE_FLAG_MACRAW_MAC_FILTERING ((uint8_t)(1<<7))
-#define SOCKMODE_FLAG_MACRAW_BLOCK_BROADCAST ((uint8_t)(1<<6))
-#define SOCKMODE_FLAG_MACRAW_BLOCK_MULTICAST ((uint8_t)(1<<5))
-#define SOCKMODE_FLAG_MACRAW_BLOCK_V6 ((uint8_t)(1<<4))
-
-#define CMD_OPEN ((uint8_t)0x01)
-#define CMD_LISTEN ((uint8_t)0x02) /* TCP-only */
-#define CMD_CONNECT ((uint8_t)0x04) /* TCP-only: dial */
-#define CMD_DISCON ((uint8_t)0x08) /* TCP-only: send/reply FIN */
-#define CMD_CLOSE ((uint8_t)0x10)
-#define CMD_SEND ((uint8_t)0x20)
-#define CMD_SEND_MAC ((uint8_t)0x21) /* UDP-only: send to remote_eth_addr without doing ARP on remote_ip_addr */
-#define CMD_SEND_KEEP ((uint8_t)0x22) /* TCP-only: send a keepalive without any data */
-#define CMD_RECV ((uint8_t)0x40)
-
-#define _SOCKINTR_SEND_UNUSED7 ((uint8_t)1<<7)
-#define _SOCKINTR_SEND_UNUSED6 ((uint8_t)1<<6)
-#define _SOCKINTR_SEND_UNUSED5 ((uint8_t)1<<5)
-#define SOCKINTR_SEND_FINISHED ((uint8_t)1<<4)
-#define SOCKINTR_TIMEOUT ((uint8_t)1<<3)
-#define SOCKINTR_RECV ((uint8_t)1<<2)
-#define SOCKINTR_FIN ((uint8_t)1<<1)
-#define SOCKINTR_CON ((uint8_t)1<<1) /* once for SYN, then once when SOCKMODE_ESTABLISHED */
-
-#define STATE_CLOSED ((uint8_t)0x00)
-
-/**
- * The TCP state diagram is as follows.
- * - Reading the W5500's "state" register does not distinguish between FIN_WAIT_1 and FIN_WAIT_2;
- * it just has a single FIN_WAIT.
- * - At any point the state can jump to "CLOSED" either by CMD_CLOSE or by a timeout.
- * - Writing data is valid in ESTABLISHED and CLOSE_WAIT.
- * - Reading data is valid in ESTABLISHED and FIN_WAIT.
- *
- * TCP state diagram, showing the flow of │ CLOSED │ ━━ role separator ┌───────┐
- * SYN, FIN, and their assocaited ACKs. └────────┘ ══ state transition │ state │
- * V ┈┈ packet flow └───────┘
- * (CMD_OPEN) ║
- * V (action/event)
- * ┌────────┐
- * ┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━│ INIT │━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┓
- * ┃ server ┃ └────────┘ ┃ client ┃
- * ┣━━━━━━━━━━━━━━━━┛ V ┃┃ V ┗━━━━━━━━━━━━━━━━┫
- * ┃ ╔═══════════╝ ┃┃ ╚═══════════╗ ┃
- * ┃ (CMD_LISTEN) ┃┃ (CMD_CONNECT) ┃
- * ┃ V ┌┃┃┈┈┈┈┈┈┈┈<(send SYN) ┃
- * ┃ ┌────────┐ ┊┃┃ V ┃
- * ┃ │ LISTEN │ ┊┃┃ ┌─────────┐ ┃
- * ┃ └────────┘ ┊┃┃ │ SYNSENT │ ┃
- * ┃ V ┊┃┃ └─────────┘ ┃
- * ┃ (recv SYN)<┈┈┈┈┈┈┘┃┃ V ┃
- * ┃ (send SYN+ACK)>┈┈┈┈┐┃┃ ║ ┃
- * ┃ V └┃┃┈┈┈┈┈┈>(recv SYN+ACK) ┃
- * ┃ ┌─────────┐ ┌┃┃┈┈┈┈┈┈┈┈<(send ack) ┃
- * ┃ │ SYNRECV │ ┊┃┃ ║ ┃
- * ┃ └─────────┘ ┊┃┃ ║ ┃
- * ┃ V V ┊┃┃ ║ ┃
- * ┃ ║ (recv ACK)<┈┈┈┘┃┃ ║ ┃
- * ┃ ║ ╚═════════╗ ┃┃ ╔═══════════╝ ┃
- * ┃ ╚═══╗ V ┃┃ V ┃
- * ┃ ║ ┌─────────────┐ ┃
- * ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━║━━━━━━━│ ESTABLISHED │━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
- * ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━║━━━━━━━└─────────────┘━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
- * ┃ ║ V ┃┃ V ┃
- * ┃ ╠═══════════╝ ┃┃ ╚═══════════╗ ┃
- * ┃ (CMD_DISCON) ┃┃ ║ ┃
- * ┃ Both sides sent ┌┈┈┈<(send FIN)>┈┈┈┈┈┈┐┃┃ ║ ┃
- * ┃ FIN at the "same" ┊ V └┃┃┈┈┈┈┈┈┈┈>(recv FIN) ┃
- * ┃ time; both are ┊ ┌────────────┐ ┌┃┃┈┈┈┈┈┈┈┈<(send ACK) ┃
- * ┃ active closers ┊ │ FIN_WAIT_1 │ ┊┃┃ V ┃
- * ┃ / \ ┊ └────────────┘ ┊┃┃ ┌────────────┐ ┃
- * ┃ ,-----' '-----, ┊ V V ┊┃┃ │ CLOSE_WAIT │ ┃
- * ┃ ╔════════════════╝ ║ ┊┃┃ └────────────┘ ┃
- * ┃ (recv FIN)<┈┈┈┈┤ ╔══╝ ┊┃┃ V ┃
- * ┃ ┌┈┈<(send ACK)>┈┈┐ ┊ ║ ┊┃┃ ║ ┃
- * ┃ ┊ ║ └┈┈┈┈┈>(recv ACK)<┈┈┈┈┈┈┘┃┃ ║ ┃
- * ┃ ┊ V ┊ V ┃┃ ║ ┃
- * ┃ ┊ ┌─────────┐ ┊ ┌────────────┐ ┃┃ ║ ┃
- * ┃ ┊ │ CLOSING │ ┊ │ FIN_WAIT_2 │ ┃┃ ║ ┃
- * ┃ ┊ └─────────┘ ┊ └────────────┘ ┃┃ (CMD_DISCON) ┃
- * ┃ ┊ V ┊ V ┌┃┃┈┈┈┈┈┈┈┈<(send FIN) ┃
- * ┃ ┊ ║ └┈┈┈>(recv FIN)<┈┈┈┈┈┈┘┃┃ ║ ┃
- * ┃ ┊ ║ ┌┈┈┈┈┈<(send ACK)>┈┈┈┈┈┈┐┃┃ V ┃
- * ┃ └┈┈>(recv ACK)<┈┈┘ ╚═╗ ┊┃┃ ┌──────────┐ ┃
- * ┃ ╚════════════════╗ ║ ┊┃┃ │ LAST_ACK │ ┃
- * ┃ V V ┊┃┃ └──────────┘ ┃
- * ┃ ┌───────────┐ ┊┃┃ V ┃
- * ┃ │ TIME_WAIT │ ┊┃┃ ║ ┃
- * ┃ └───────────┘ └┃┃┈┈┈┈┈┈┈┈>(recv ACK) ┃
- * ┃ V ┃┃ ║ ┃
- * ┣━━━━━━━━━━━━━━━━┓ (2*MSL has elapsed) ┃┃ ║ ┏━━━━━━━━━━━━━━━━┫
- * ┃ active closer ┃ ╚═══════════╗ ┃┃ ╔═══════════╝ ┃ passive closer ┃
- * ┗━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━━━━━V━┛┗━V━━━━━━━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━┛
- * ┌────────┐
- * │ CLOSED │
- */
-#define STATE_TCP_INIT ((uint8_t)0x13)
-#define STATE_TCP_LISTEN ((uint8_t)0x14) /* server */
-#define STATE_TCP_SYNSENT ((uint8_t)0x15) /* client; during dial */
-#define STATE_TCP_SYNRECV ((uint8_t)0x16) /* server; during accept */
-#define STATE_TCP_ESTABLISHED ((uint8_t)0x17)
-#define STATE_TCP_FIN_WAIT ((uint8_t)0x18) /* during active close */
-#define STATE_TCP_CLOSING ((uint8_t)0x1a) /* during active close */
-#define STATE_TCP_TIME_WAIT ((uint8_t)0x1b) /* during active close */
-#define STATE_TCP_CLOSE_WAIT ((uint8_t)0x1c) /* during passive close */
-#define STATE_TCP_LAST_ACK ((uint8_t)0x1d) /* during passive close */
-
-#define STATE_UDP ((uint8_t)0x22)
-
-#define STATE_MACRAW ((uint8_t)0x42)
-
-#define REGWRITE_COMMON(spidev, field, val) do { \
- ASSERT_SAMETYPE(val, (struct w5500_block_common_reg){}.field); \
- typeof(val) lval = val; \
- w5500_spiframe_write(spidev, \
- offsetof(struct w5500_block_common_reg, field), \
- CTL_BLOCK_COMMON_REG, \
- &lval, \
- sizeof(lval)); \
- } while (0)
-
-
-#define REGREAD_COMMON(spidev, field, typ) ({ \
- typ val; \
- ASSERT_SAMETYPE(val, (struct w5500_block_common_reg){}.field); \
- w5500_spiframe_read(spidev, \
- offsetof(struct w5500_block_sock_reg, field), \
- CTL_BLOCK_COMMON, \
- &(val), \
- sizeof(val)); \
- val; \
- })
-
-#define REGWRITE_SOCK(spidev, socknum, field, val) do { \
- ASSERT_SAMETYPE(val, (struct w5500_block_sock_reg){}.field); \
- typeof(val) lval = val; \
- w5500_spiframe_write(spidev, \
- offsetof(struct w5500_block_sock_reg, field), \
- CTL_BLOCK_SOCK(socknum, REG), \
- &lval, \
- sizeof(lval)); \
- } while (0)
-
-#define REGREAD_SOCK(spidev, socknum, field, typ) ({ \
- typ val; \
- ASSERT_SAMETYPE(val, (struct w5500_block_sock_reg){}.field); \
- w5500_spiframe_read(spidev, \
- offsetof(struct w5500_block_sock_reg, field), \
- CTL_BLOCK_SOCK(socknum, REG), \
- &(val), \
- sizeof(val)); \
- val; \
- })
+ if (listen_bits)
+ cr_sema_signal(&listener->listen_sema);
+ if (read_bits)
+ cr_sema_signal(&listener->read_sema);
+
+ w5500ll_write_sock_reg(chip->spidev, socknum, interrupt, sockintr);
+ }
+ }
+
+ cr_end();
+}
/* init() *********************************************************************/
@@ -412,17 +167,13 @@ static struct net_conn_vtable w5500_conn_vtable = {
.close = w5500_close,
};
-/*
- 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;
- }
-*/
-
-static void w5500_intrhandler(uint UNUSED(gpio), uint32_t UNUSED(event_mask)) {
- /* TODO */
+
+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,
@@ -435,6 +186,7 @@ void _w5500_init(struct w5500 *chip,
*chip = (struct w5500){
/* const-after-init */
.spidev = spi,
+ .pin_intr = pin_intr,
.pin_reset = pin_reset,
/* mutable */
.next_local_port = CONFIG_W5500_LOCAL_PORT_MIN,
@@ -459,25 +211,65 @@ void _w5500_init(struct w5500 *chip,
/* 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_reset(chip, addr);
+ w5500_hard_reset(chip, addr);
+
+ /* 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 ***************************************************************/
-void w5500_reset(struct w5500 *chip, struct net_eth_addr addr) {
+static inline void w5500_post_reset(struct w5500 *chip, struct net_eth_addr addr) {
+ w5500ll_write_common_reg(chip->spidev, eth_addr, addr);
+
+ /* 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).
+ *
+ * The hysteresis is (intlevel+1)*4/(150MHz) (if intlevel is
+ * non-zero), or (intlevel+1)*26.7ns; so even the shortest-possible
+ * hysteresis much larger than necessary for us. */
+ w5500ll_write_common_reg(chip->spidev, intlevel, encode_u16be(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);
+}
+
+void w5500_hard_reset(struct w5500 *chip, struct net_eth_addr addr) {
/* TODO: Replace blocking sleep_ms() with something libcr-friendly. */
gpio_put(chip->pin_reset, 0);
sleep_ms(1); /* minimum of 500us */
gpio_put(chip->pin_reset, 1);
sleep_ms(2); /* minimum of 1ms */
- REGWRITE_COMMON(chip->spidev, eth_addr, addr);
+ w5500_post_reset(chip, addr);
+}
+
+void w5500_soft_reset(struct w5500 *chip, struct net_eth_addr addr) {
+ 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, addr);
}
void w5500_netcfg(struct w5500 *chip, struct w5500_netcfg cfg) {
- REGWRITE_COMMON(chip->spidev, ip_gateway_addr, cfg.gateway_addr);
- REGWRITE_COMMON(chip->spidev, ip_subnet_mask, cfg.subnet_mask);
- REGWRITE_COMMON(chip->spidev, ip_addr, cfg.addr);
+ 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_listener *w5500_listen(struct w5500 *chip, uint8_t socknum,
@@ -494,66 +286,42 @@ implements_net_listener *w5500_listen(struct w5500 *chip, uint8_t socknum,
/* listener methods ***********************************************************/
-static struct w5500 *w5500_listener_chip(struct _w5500_listener *listener) {
- assert(listener);
- assert(listener->socknum < 8);
-
- struct _w5500_listener *sock0 = &listener[-listener->socknum];
- assert(sock0);
- struct w5500 *chip =
- ((void *)sock0) - offsetof(struct w5500, listeners);
- assert(chip);
- return chip;
-}
-
-#define ASSERT_LISTENER() \
- struct _w5500_listener *self = \
- VCALL_SELF(struct _w5500_listener, \
+#define ASSERT_LISTENER() \
+ struct _w5500_listener *self = \
+ VCALL_SELF(struct _w5500_listener, \
implements_net_listener, _self); \
- struct w5500 *chip = w5500_listener_chip(self); \
+ struct w5500 *chip = w5500_sock_chip(self); \
uint8_t socknum = self->socknum;
-static void w5500_cmd_close(struct _w5500_listener *listener) {
- struct w5500 *chip = w5500_listener_chip(listener);
- uint8_t socknum = listener->socknum;
-
- REGWRITE_SOCK(chip->spidev, socknum, command, CMD_CLOSE);
- while (REGREAD_SOCK(chip->spidev, socknum, command, uint8_t) != 0x00)
- cr_yield();
- REGWRITE_SOCK(chip->spidev, socknum, interrupt, (uint8_t)0xff);
- while (REGREAD_SOCK(chip->spidev, socknum, state, uint8_t) != STATE_CLOSED)
- cr_yield();
-}
-
static implements_net_conn *w5500_accept(implements_net_listener *_self) {
ASSERT_LISTENER();
+ restart:
/* Mimics socket.c:socket(). */
- w5500_cmd_close(self);
- REGWRITE_SOCK(chip->spidev, socknum, mode, SOCKMODE_TCP);
- struct uint16_be port = {{self->port>>8, self->port}};
- REGWRITE_SOCK(chip->spidev, socknum, local_port, port);
- REGWRITE_SOCK(chip->spidev, socknum, command, CMD_OPEN);
- while (REGREAD_SOCK(chip->spidev, socknum, command, uint8_t) != 0x00)
- cr_yield();
- while (REGREAD_SOCK(chip->spidev, socknum, state, uint8_t) != STATE_TCP_INIT)
+ w5500_sock_cmd_close(self);
+ w5500ll_write_sock_reg(chip->spidev, socknum, mode, SOCKMODE_TCP);
+ w5500ll_write_sock_reg(chip->spidev, socknum, local_port, encode_u16be(self->port));
+ w5500_sock_cmd(self, CMD_OPEN);
+ while (w5500ll_read_sock_reg(chip->spidev, socknum, state) != STATE_TCP_INIT)
cr_yield();
/* Mimics socket.c:listen(). */
- REGWRITE_SOCK(chip->spidev, socknum, command, CMD_LISTEN);
- while (REGREAD_SOCK(chip->spidev, socknum, command, uint8_t) != 0x00)
- cr_yield();
+ w5500_sock_cmd(self, CMD_LISTEN);
for (;;) {
- uint8_t state = REGREAD_SOCK(chip->spidev, socknum, state, uint8_t);
+ uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state);
switch (state) {
case STATE_TCP_LISTEN:
case STATE_TCP_SYNRECV:
- cr_yield();
+ cr_sema_wait(&self->listen_sema);
break;
- default:
+ case STATE_TCP_ESTABLISHED:
self->active_conn.read_open = true;
+ /* fall-through */
+ case STATE_TCP_CLOSE_WAIT:
self->active_conn.write_open = true;
return &self->active_conn;
+ default:
+ goto restart;
}
}
}
@@ -568,11 +336,11 @@ static struct _w5500_listener *w5500_conn_listener(struct _w5500_conn *conn) {
return list;
}
-#define ASSERT_CONN() \
- struct _w5500_conn *self = \
+#define ASSERT_CONN() \
+ struct _w5500_conn *self = \
VCALL_SELF(struct _w5500_conn, implements_net_conn, _self); \
- struct _w5500_listener *listener = w5500_conn_listener(self); \
- struct w5500 *chip = w5500_listener_chip(listener); \
+ struct _w5500_listener *listener = w5500_conn_listener(self); \
+ struct w5500 *chip = w5500_sock_chip(listener); \
uint8_t socknum = listener->socknum;
static ssize_t w5500_write(implements_net_conn *_self, void *buf, size_t count) {
@@ -580,10 +348,50 @@ static ssize_t w5500_write(implements_net_conn *_self, void *buf, size_t count)
assert(buf);
assert(count);
- uint8_t state = REGREAD_SOCK(chip->spidev, socknum, state, uint8_t);
- if (state != STATE_TCP_ESTABLISHED && state != STATE_TCP_CLOSE_WAIT)
- return -1;
+ /* 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_FINIAIUI, 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 (!self->write_open)
+ return -1;
+ uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state);
+ if (state != STATE_TCP_ESTABLISHED && state != STATE_TCP_CLOSE_WAIT)
+ return -1;
+
+ uint16_t freesize = decode_u16be(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. */
+ uint16_t ptr = decode_u16be(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, encode_u16be(ptr+freesize));
+ /* Submit the queue. */
+ w5500_sock_cmd(listener, CMD_SEND);
+ done += freesize;
+ }
+ return done;
}
static ssize_t w5500_read(implements_net_conn *_self, void *buf, size_t count) {
@@ -591,7 +399,35 @@ static ssize_t w5500_read(implements_net_conn *_self, void *buf, size_t count) {
assert(buf);
assert(count);
- // TODO
+ size_t done = 0;
+ while (!done) {
+ if (!self->read_open)
+ return -1;
+ uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state);
+ switch (state) {
+ case STATE_TCP_CLOSE_WAIT:
+ return 0; /* EOF */
+ case STATE_TCP_ESTABLISHED: case STATE_TCP_FIN_WAIT:
+ break; /* OK */
+ default:
+ return -1;
+ }
+
+ uint16_t avail = decode_u16be(w5500ll_read_sock_reg(chip->spidev, socknum, rx_size));
+ if (!avail) {
+ cr_sema_wait(&listener->read_sema);
+ continue;
+ }
+ if ((size_t)avail > count)
+ avail = count;
+ uint16_t ptr = decode_u16be(w5500ll_read_sock_reg(chip->spidev, socknum, rx_read_pointer));
+ w5500ll_read(chip->spidev, ptr, CTL_BLOCK_SOCK(socknum, RX), &((char *)buf)[done], avail);
+ w5500ll_write_sock_reg(chip->spidev, socknum, rx_read_pointer, encode_u16be(ptr+avail));
+
+ w5500_sock_cmd(listener, CMD_RECV);
+ done += avail;
+ }
+ return done;
}
static int w5500_close(implements_net_conn *_self, bool rd, bool wr) {
@@ -601,17 +437,15 @@ static int w5500_close(implements_net_conn *_self, bool rd, bool wr) {
self->read_open = false;
if (wr && self->write_open) {
- REGWRITE_SOCK(chip->spidev, socknum, command, CMD_DISCON);
- while (REGREAD_SOCK(chip->spidev, socknum, command, uint8_t) != 0x00)
- cr_yield();
+ w5500_sock_cmd(listener, CMD_DISCON);
while (self->write_open) {
- uint8_t state = REGREAD_SOCK(chip->spidev, socknum, state, uint8_t);
+ uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state);
switch (state) {
case STATE_TCP_FIN_WAIT:
self->write_open = false;
/* Can still read */
if (!self->read_open)
- w5500_cmd_close(listener);
+ w5500_sock_cmd_close(listener);
break;
case STATE_CLOSED:
self->write_open = false;
generated by cgit v1.2.3-2-g168b (git 2.25.1) at 2024-11-24 05:18:02 +0000