wip

6 files changed, 415 insertions, 31 deletions

diff --git a/cmd/sbc_harness/hw/w5500.c b/cmd/sbc_harness/hw/w5500.c
index 993c2b5..b4000f4 100644
--- a/cmd/sbc_harness/hw/w5500.c
+++ b/cmd/sbc_harness/hw/w5500.c
@@ -1,4 +1,53 @@
+/*
+ * 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/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 <ORGANIZATION> 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.
+ */
+
+#include <pico/time.h> /* for sleep_ms() */
+
 #include "hw/w5500.h"
+#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
+
+/* Low-level protocol built on SPI frames.  ***********************************/
 
 /* A u8 control byte has 3 parts: block-ID, R/W, and
  * operating-mode.  */
@@ -56,7 +105,7 @@ void w5500_spiframe_write(struct spi *spidev, uint16_t addr, uint8_t block, void
 	spidev->vtable->readwritev(spidev, iov, 2);
 }
 
-void w5500_spiframe_read(uint16_t addr, uint8_t ctl, void *data, size_t data_len) {
+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);
@@ -74,10 +123,7 @@ void w5500_spiframe_read(uint16_t addr, uint8_t ctl, void *data, size_t data_len
 	spidev->vtable->readwritev(spidev, iov, 2);
 }
 
-void _w5500_init(struct w5500 *self, struct spi* spi, uint pin_intr) {
-	self->spidev = spi;
-	gpio_set_irq_enabled_with_callback(pin_intr, GPIO_IRQ_EDGE_FALL, true, cbfn);
-}
+/* Offsets and sizes for use with that protocol.  *****************************/
 
 struct w5500_block_common_reg {
 	uint8_t mode;                   /* MR */
@@ -103,7 +149,7 @@ struct w5500_block_common_reg {
 	uint8_t ppp_max_seg_size[2];    /* PMRU0 ... PMRU1 */
 
 	uint8_t unreachable_ip_addr[4]; /* UIPR0 ... UIPR3 */
-	uint8_t unreachable_port[2];    /* UPORTR0, UPROTR1 */
+	uint8_t unreachable_port[2];    /* UPORTR0, UPORTR1 */
 
 	uint8_t phy_cfg;                /* PHYCFGR */
 
@@ -114,14 +160,14 @@ struct w5500_block_common_reg {
 static_assert(sizeof(struct w5500_block_common_reg) == 0x3A);
 
 struct w5500_block_sock_reg {
-	uint8_t mode;                /* Sn_MR */
-	uint8_t command;             /* Sn_CR */
+	uint8_t mode;                /* Sn_MR; see MODE_{x} below */
+	uint8_t command;             /* Sn_CR; see CMD_{x} below */
 	uint8_t interrupt;           /* Sn_IR */
-	uint8_t status;              /* Sn_SR */
-	uint8_t src_port[2];         /* Sn_PORT0, Sn_PORT1 */
-	uint8_t dst_eth_addr[6];     /* Sn_DHAR0 ... SnDHAR5 */
-	uint8_t dst_ip_addr[4];      /* Sn_DIPR0 ... Sn_DIP3 */
-	uint8_t dst_port[2];         /* Sn_DPORT0 ... Sn_DPORT1 */
+	uint8_t status;              /* Sn_SR; see STATUS_{x} below */
+	uint8_t local_port[2];         /* Sn_PORT0, Sn_PORT1 */
+	uint8_t remote_eth_addr[6];     /* Sn_DHAR0 ... SnDHAR5 */
+	uint8_t remote_ip_addr[4];      /* Sn_DIPR0 ... Sn_DIP3 */
+	uint8_t remote_port[2];         /* Sn_DPORT0 ... Sn_DPORT1 */
 
 	uint8_t max_seg_size[2];     /* Sn_MSSR0, Sn_MSSR1 */
 	uint8_t _reserved0[1];
@@ -144,8 +190,282 @@ struct w5500_block_sock_reg {
 };
 static_assert(sizeof(struct w5500_block_sock_reg) == 0x30);
 
+/* low 4 bits are the main enum, high 4 bits are flags */
+#define MODE_CLOSED ((uint8_t)0b0000)
+#define MODE_TCP    ((uint8_t)0b0001)
+#define MODE_UDP    ((uint8_t)0b0010)
+#define MODE_MACRAW ((uint8_t)0b0100)
+
+#define MODE_FLAG_TCP_NODELAY_ACK         ((uint8_t)(1<<5))
+
+#define MODE_FLAG_UDP_ENABLE_MULTICAST    ((uint8_t)(1<<7))
+#define MODE_FLAG_UDP_BLOCK_BROADCAST     ((uint8_t)(1<<6))
+#define MODE_FLAG_UDP_MULTICAST_DOWNGRADE ((uint8_t)(1<<5))
+#define MODE_FLAG_UDP_BLOCK_UNICAST       ((uint8_t)(1<<4))
+
+#define MODE_FLAG_MACRAW_MAC_FILTERING    ((uint8_t)(1<<7))
+#define MODE_FLAG_MACRAW_BLOCK_BROADCAST  ((uint8_t)(1<<6))
+#define MODE_FLAG_MACRAW_BLOCK_MULTICAST  ((uint8_t)(1<<5))
+#define MODE_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 STATUS_CLOSED          ((uint8_t)0x00)
+
+/* The status modes starting with an underscore are expected to be
+ * very short-lived.  */
 
-struct w5500_socket {
-	struct spi *spidev;
-	uint8_t     socknum; /* 0-7 */
+#define STATUS_TCP_INIT        ((uint8_t)0x13)
+#define STATUS_TCP_LISTEN      ((uint8_t)0x14)
+#define _STATUS_TCP_SYNSENT    ((uint8_t)0x15) /* in the CMD_CONNECT INIT->SYNSENT->ESTABLISHED transition */
+#define _STATUS_TCP_SYNRECV    ((uint8_t)0x16) /* in the CMD_LISTEN LISTEN->SYNRECV->ESTABLISHED transition */
+#define STATUS_TCP_ESTABLISHED ((uint8_t)0x17)
+/* The "graceful shutdown" state diagram (with the exception that
+ * reading the W5500's "status" register does not distinguish between
+ * FIN_WAIT_1 and FIN_WAIT_2; it just has a single FIN_WAIT):
+ *
+ *                                                ║
+ *                                                V
+ *                                         ┌─────────────┐
+ *                          "active close" │ ESTABLISHED │  "passive close"
+ *                     (we send FIN first) └─────────────┘  (we send FIN second)
+ *                                             V     V
+ *                                 ╔═══════════╝     ╚═════════╗
+ *                            (CMD_DISCON)                     ║
+ *                        ┌┈┈┈<(send FIN)>┈┈┈┈┈┈┈┈┐            ║
+ *                        ┊        ║              └┈┈┈┈┈┈┈>(recv FIN)
+ *                        ┊        V              ┌┈┈┈┈┈┈┈<(send ACK)
+ *    "double active"     ┊  ┌────────────┐       ┊            ║
+ *   (both sides think    ┊  │ FIN_WAIT_1 │       ┊            V
+ *  they sent FIN first)  ┊  └────────────┘       ┊     ┌────────────┐
+ *                        ┊     V     V           ┊     │ CLOSE_WAIT │
+ *            ╔═════════════════╝  ╔══╝           ┊     └────────────┘
+ *        (recv FIN)<┈┈┈┈┈┤        ║              ┊            V
+ *    ┌┈┈<(send ACK)>┈┈┈┐ ┊        ║              ┊            ║
+ *    ┊       ║         └┈┈┈┈┈>(recv ACK)<┈┈┈┈┈┈┈┈┘            ║
+ *    ┊       ║           ┊        ║                           ║
+ *    ┊       V           ┊        V                           ║
+ *    ┊  ┌─────────┐      ┊  ┌────────────┐                    ║
+ *    ┊  │ CLOSING │      ┊  │ FIN_WAIT_2 │                    ║
+ *    ┊  └─────────┘      ┊  └────────────┘                    ║
+ *    ┊       V           ┊        V                      (CMD_DISCON)
+ *    ┊       ║           ┊        ║              ┌┈┈┈┈┈┈┈<(send FIN)
+ *    ┊       ║           └┈┈┈>(recv FIN)<┈┈┈┈┈┈┈┈┘            ║
+ *    ┊       ║         ┌┈┈┈┈┈<(send ACK)>┈┈┈┈┈┈┈┈┐            V
+ *    └┈┈>(recv ACK)<┈┈┈┘          ║              ┊       ┌──────────┐
+ *            ╚═════════════════╗  ╚═╗            ┊       │ LAST_ACK │
+ *                              V    V            ┊       └──────────┘
+ *                           ┌───────────┐        ┊            V
+ *                           │ TIME_WAIT │        ┊            ║
+ *                           └───────────┘        └┈┈┈┈┈┈┈>(recv ACK)
+ *                                 V                           ║
+ *                                 ║                           ║
+ *                         (2*MSL has elapsed)                 ║
+ *                                 ╚═══════════╗    ╔══════════╝
+ *                                             V    V
+ *                                           ┌────────┐
+ *                                           │ CLOSED │
+ *                                           └────────┘
+ *
+ * One can still write in CLOSE_WAIT, and can still read in FIN_WAIT.
+ */
+#define _STATUS_TCP_FIN_WAIT   ((uint8_t)0x18) /* during active close */
+#define _STATUS_TCP_CLOSING    ((uint8_t)0x1a) /* during active close */
+#define _STATUS_TCP_TIME_WAIT  ((uint8_t)0x1b) /* during active close */
+#define STATUS_TCP_CLOSE_WAIT  ((uint8_t)0x1c) /* during passive close */
+#define _STATUS_TCP_LAST_ACK   ((uint8_t)0x1d) /* during passive close */
+
+#define STATUS_UDP             ((uint8_t)0x22)
+
+#define STATUS_MACRAW          ((uint8_t)0x42)
+
+#define REGWRITE_COMMON(spidev, field, val) do {                                      \
+		assert(sizeof(val) == sizeof((struct w5500_block_common_reg).field)); \
+		w5500_spiframe_write(spidev,                                          \
+		                     offsetof(struct w5500_block_common_reg, field),  \
+		                     CTL_BLOCK_COMMON_REG,                            \
+		                     &(val),                                          \
+		                     sizeof(struct w5500_block_common_reg, field));   \
+	} while (0)
+
+#define REGREAD_COMMON(spidev, field, typ) ({                                               \
+			typ val;                                                            \
+			assert(sizeof(val) == sizeof((struct w5500_block_sock_reg).field)); \
+			w5500_spiframe_read(spidev,                                         \
+			                    offsetof(struct w5500_block_sock_reg, field),   \
+			                    CTL_BLOCK_COMMON,                               \
+			                    &(val),                                         \
+			                    sizeof(struct w5500_block_sock_reg, field));    \
+			val;                                                                \
+		})
+
+#define REGWRITE_SOCK(spidev, socknum, field, val) do {                             \
+		assert(sizeof(val) == sizeof((struct w5500_block_sock_reg).field)); \
+		w5500_spiframe_write(spidev,                                        \
+		                     offsetof(struct w5500_block_sock_reg, field),  \
+		                     CTL_BLOCK_SOCK(socknum, REG),                  \
+		                     &(val),                                        \
+		                     sizeof(struct w5500_block_sock_reg, field));   \
+	} while (0)
+
+#define REGREAD_SOCK(spidev, socknum, field, typ) ({                                        \
+			typ val;                                                            \
+			assert(sizeof(val) == sizeof((struct w5500_block_sock_reg).field)); \
+			w5500_spiframe_read(spidev,                                         \
+			                     offsetof(struct w5500_block_sock_reg, field),  \
+			                     CTL_BLOCK_SOCK(socknum, REG),                  \
+			                     &(val),                                        \
+			                     sizeof(struct w5500_block_sock_reg, field));   \
+			val;                                                                \
+		})
+
+/* init() *********************************************************************/
+
+static struct libnet_conn *w5500_accept(struct libnet_listener *_listener);
+static ssize_t w5500_read(struct libnet_conn *conn, void *buf, size_t count);
+static ssize_t w5500_write(struct libnet_conn *conn, void *buf, size_t count);
+static int w5500_close(struct libnet_conn *conn, bool rd, bool wr);
+
+static struct libnet_listener_vtable w5500_listener_vtable = {
+	.accept = w5500_accept,
 };
+
+static struct libnet_conn_vtable w5500_conn_vtable = {
+	.read  = w5500_read,
+	.write = w5500_write,
+	.close = w5500_close,
+};
+
+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_init(struct w5500 *chip,
+                 struct spi* spi, uint pin_intr, uint pin_reset,
+                 struct eth_addr addr) {
+	chip->spidev = spi;
+	chip->pin_reset = pin_reset;
+	for (uint8_t i = 0; i < 8; i++) {
+		chip->_listeners[i].vtable = &w5500_listener_vtable;
+		chip->_listeners[i].chip = chip;
+		chip->_listeners[i].socknum = i;
+		chip->_listeners[i].active_conn.vtable = &w5500_conn_vtable;
+		chip->_listeners[i].active_conn.parent_listener = &chip->_listeners[i];
+	}
+	chip->_next_local_port = CONFIG_W5500_LOCAL_PORT_MIN;
+
+	gpio_set_irq_enabled_with_callback(pin_intr, GPIO_IRQ_EDGE_FALL, true, cbfn);
+	gpio_set_dir(chip->pin_reset, GPIO_OUT);
+
+	w5500_reset(chip);
+
+	REGWRITE_COMMON(spi, eth_addr, addr);
+}
+
+
+void w5500_reset(struct w5500 *chip) {
+	/* 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 */
+}
+
+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);
+}
+
+/* listen() *******************************************************************/
+
+struct libnet_listener *w5500_listen(struct w5500 *chip, uint8_t socknum, uint16_t port) {
+	assert(chip);
+	assert(socknum < 8);
+	assert(port);
+
+	w5500_close(&chip->_listeners[socknum].active_socket, true, true);
+	REGWRITE_SOCK(chip->spidev, socknum, mode, MODE_TCP);
+	REGWRITE_SOCK(chip->spidev, socknum, local_port, (uint8_t[2]){port>>8, port});
+	REGWRITE_SOCK(chip->spidev, socknum, command, CMD_OPEN);
+	while (REGREAD_SOCK(chip->spidev, socknum, command, uint8_t) != 0x00)
+		cr_yield();
+	while (REGREAD_SOCK(spidev, socknum, status, uint8_t) != STATUS_TCP_INIT)
+		cr_yield();
+
+	return (struct libnet_listener *)&chip->_listeners[socknum];
+}
+
+/* accept() *******************************************************************/
+
+#define ASSERT_LISTENER()                                             \
+	struct w5500_listener *self = (struct w5500_listener *)_self; \
+	assert(self);                                                 \
+	                                                              \
+	struct w5500 *chip = self->chip;                              \
+	uint8_t socknum = self->socknum;                              \
+	assert(chip);                                                 \
+	assert(socknum < 8)                                           \
+
+static struct libnet_conn *w5500_accept(struct libnet_listener *_self) {
+	ASSERT_LISTENER();
+
+	REGWRITE_SOCK(chip->spidev, socknum, command, CMD_LISTEN);
+	while (REGREAD_SOCK(chip->spidev, socknum, command, uint8_t) != 0x00)
+		cr_yield();
+	for (;;) {
+		uint8_t mode = REGREAD_SOCK(spidev, socknum, status, uint8_t);
+		switch (mode) {
+		case STATUS_TCP_LISTEN:
+		case _STATUS_TCP_SYNRECV:
+			cr_yield();
+			break;
+		default:
+			return &self->active_conn;
+		}
+	}
+}
+
+/* write() ********************************************************************/
+
+#define ASSERT_CONN() \
+	struct w5500_conn *self = (struct w5500_conn *)_self; \
+	assert(self);                                         \
+	                                                      \
+	struct w5500 *chip = self->parent_listener->chip;     \
+	uint8_t socknum = self->parent_listener->socknum;     \
+	assert(chip);                                         \
+	assert(socknum < 8)
+
+
+static ssize_t w5500_write(struct libnet_conn *_self, void *buf, size_t count) {
+	ASSERT_CONN();
+	assert(buf);
+	assert(count);
+
+
+}
+
+static int w5500_close(struct libnet_conn *_self, bool rd, bool wr) {
+	ASSERT_CONN();
+
+	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, status, uint8_t) != STATUS_CLOSED)
+		cr_yield();
+
+	return 0;
+}
diff --git a/cmd/sbc_harness/hw/w5500.h b/cmd/sbc_harness/hw/w5500.h
index 0f37797..90d4130 100644
--- a/cmd/sbc_harness/hw/w5500.h
+++ b/cmd/sbc_harness/hw/w5500.h
@@ -1,16 +1,38 @@
 #ifndef _HW_W5500_H_
 #define _HW_W5500_H_
 
+#include <libnet/libnet.h>
+
 #include "hw/spi.h"
 
+struct _w5500_listener;
+
+struct _w5500_conn {
+	struct libnet_conn_vtable       *vtable;
+
+	struct _w5500_listener          *parent_listener;
+};
+
+struct _w5500_listener {
+	struct libnet_listener_vtable   *vtable;
+
+	struct w5500                    *chip;
+	uint8_t                          socknum;
+	struct _w5500_conn               active_conn;
+};
+
 struct w5500 {
-	struct spi *spidev;
+	struct spi                      *spidev;
+	uint                             pin_reset;
+
+	struct _w5500_listener           _listeners[8];
+	uint16_t                         _next_local_port;
 };
 
 /**
- * Initialize a WIZnet W5500 Ethernet and TCP/IP-offload chip.
+ * Initialize a WIZnet W5500 Ethernet-and-TCP/IP-offload chip.
  *
- * The W5500 has 2 channels of communication with the MCU:
+ * The W5500 has 3 channels of communication with the MCU:
  *
  *  - An SPI-based RPC protocol:
  *    + mode: mode 0 or mode 3
@@ -19,11 +41,33 @@ struct w5500 {
  *  - 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.)
+ *  - A reset pin that the MCU can pull low to reset the W5500.
  */
-#define w5500_init(self, name, spi, pin_intr) do {                       \
-		bi_decl(bi_1_pin_with_name(pin_intr, name" interrupt")); \
-		_w5500_init(self, spi, pin_intr);                        \
+#define w5500_init(self, name, spi, pin_intr, pin_reset, eth_addr) do {   \
+		bi_decl(bi_2_pins_with_names(pin_intr, name" interrupt"), \
+		                             pin_reset, name" reset");    \
+		_w5500_init(self, spi, pin_intr, pin_reset, eth_addr);    \
 	} while (0)
-void _w5500_init(struct w5500 *self, struct spi* spi, uint pin_intr);
+void _w5500_init(struct w5500 *self,
+                 struct spi* spi, uint pin_intr,
+                 struct eth_addr addr);
+
+/**
+ * TODO.
+ */
+void w5500_reset(struct w5500 *self);
+
+struct w5500_netcfg {
+	struct ip4_addr gateway_addr;
+	struct ip4_addr subnet_mask;
+	struct ip4_addr addr;
+};
+
+/**
+ * TODO.
+ */
+void w5500_netcfg(struct w5500 *self, struct w5500_netcfg cfg);
+
+struct libnet_listener *w5500_listen(struct w5500 *self, uint8_t socknum, uint16_t port);
 
 #endif /* _HW_W5500_H_ */
diff --git a/cmd/sbc_harness/main.c b/cmd/sbc_harness/main.c
index 9f32037..1200608 100644
--- a/cmd/sbc_harness/main.c
+++ b/cmd/sbc_harness/main.c
@@ -12,6 +12,7 @@
 #include <libusb/usb_common.h>
 
 #include "hw/rp2040_hwspi.h"
+#include "hw/w5500.h"
 #include "usb_keyboard.h"
 
 COROUTINE hello_world_cr(void *_chan) {
@@ -34,6 +35,19 @@ int main() {
 	/* initialization */
 	stdio_uart_init();
 
+	struct rp2040_hwspi dev_spi;
+	struct w5500 dev_w5500;
+	rp2040_hwspi_init(&dev_spi, "W5500", RP2040_HWSPI_0,
+	                  SPI_MODE_0, /* the W5500 supports mode 0 or mode 3 */
+	                  80*1000*1000, /* run at the W5500's max rate of 80MHz */
+	                  16,  /* PIN_MISO */
+	                  19,  /* PIN_MOSI */
+	                  18,  /* PIN_CLK */
+	                  17); /* PIN_CS */
+	w5500_init(&dev_w5500, "W5500", &dev_spi,
+	           21,  /* PIN_INTR */
+	           20); /* PIN_RESET */
+
 	usb_common_earlyinit();
 	usb_keyboard_init();
 	usb_common_lateinit();
diff --git a/cmd/srv9p/gnet.c b/cmd/srv9p/gnet.c
index 5072428..2bed355 100644
--- a/cmd/srv9p/gnet.c
+++ b/cmd/srv9p/gnet.c
@@ -69,7 +69,7 @@ static inline bool RUN_PTHREAD(void *(*fn)(void *), void *args) {
 	return false;
 }
 
-/* vtables ********************************************************************/
+/* init() ( AKA socket(3) + listen(3) )****************************************/
 
 static struct libnet_conn *gnet_accept(struct libnet_listener *_listener);
 static ssize_t gnet_read(struct libnet_conn *conn, void *buf, size_t count);
@@ -86,8 +86,6 @@ static struct libnet_conn_vtable gnet_conn_vtable = {
 	.close = gnet_close,
 };
 
-/* listen() *******************************************************************/
-
 void gnet_listener_init(struct gnet_listener *self, uint16_t port) {
 	int listenerfd;
 	union {
@@ -175,7 +173,7 @@ static void *_pthread_read(void *_args) {
 };
 
 static ssize_t gnet_read(struct libnet_conn *_conn, void *buf, size_t count) {
-	struct gnet_conn *conn = (struct gnet_conn *)_conn;
+	struct _gnet_conn *conn = (struct _gnet_conn *)_conn;
 	assert(conn);
 
 	ssize_t ret;
@@ -225,7 +223,7 @@ static void *_pthread_write(void *_args) {
 };
 
 static ssize_t gnet_write(struct libnet_conn *_conn, void *buf, size_t count) {
-	struct gnet_conn *conn = (struct gnet_conn *)_conn;
+	struct _gnet_conn *conn = (struct _gnet_conn *)_conn;
 	assert(conn);
 
 	ssize_t ret;
@@ -247,7 +245,7 @@ static ssize_t gnet_write(struct libnet_conn *_conn, void *buf, size_t count) {
 /* close() ********************************************************************/
 
 static int gnet_close(struct libnet_conn *_conn, bool rd, bool wr) {
-	struct gnet_conn *conn = (struct gnet_conn *)_conn;
+	struct _gnet_conn *conn = (struct _gnet_conn *)_conn;
 	assert(conn);
 
 	int how;
diff --git a/cmd/srv9p/gnet.h b/cmd/srv9p/gnet.h
index a724128..549dd7b 100644
--- a/cmd/srv9p/gnet.h
+++ b/cmd/srv9p/gnet.h
@@ -11,7 +11,7 @@
 
 #include <libnet/libnet.h>
 
-struct gnet_conn {
+struct _gnet_conn {
 	struct libnet_conn_vtable       *vtable;
 
 	int                              fd;
@@ -21,7 +21,7 @@ struct gnet_listener {
 	struct libnet_listener_vtable   *vtable;
 
 	int                              fd;
-	struct gnet_conn                 active_conn;
+	struct _gnet_conn                active_conn;
 };
 
 void gnet_listener_init(struct gnet_listener *self, uint16_t port);
diff --git a/libnet/include/libnet/libnet.h b/libnet/include/libnet/libnet.h
index cef13d9..c56b61d 100644
--- a/libnet/include/libnet/libnet.h
+++ b/libnet/include/libnet/libnet.h
@@ -5,6 +5,14 @@
 #include <stddef.h>    /* for size_t */
 #include <sys/types.h> /* for ssize_t */
 
+struct ip4_addr {
+	unsigned char   bytes[4];
+}
+
+struct eth_addr {
+	unsigned char   bytes[6];
+}
+
 struct libnet_conn;
 struct libnet_listener;