/* hw/w5500.c - libmisc/net.h implementation for the WIZnet W5500 chip
 *
 * Copyright (C) 2024  Luke T. Shumaker <lukeshu@lukeshu.com>
 * SPDX-Licence-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/socket.c
 *
 * SPDX-Licence-Identifier: BSD-3-Clause
 *
 * 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 <hardware/gpio.h> /* pico-sdk:hardware_gpio5 */

#include <libcr/coroutine.h>
#include <libmisc/vcall.h>

#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

#define UNUSED(name)

/* Low-level protocol built on SPI frames.  ***********************************/

/* A u8 control byte has 3 parts: block-ID, R/W, and
 * operating-mode.  */

/* 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)

/* Part 2: R/W.  */
#define CTL_MASK_RW 0b100
#define CTL_R       0b000
#define CTL_W       0b100

/* 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

/* 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.
 */

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);

	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);
}

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);

	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);
}

/* Offsets and sizes for use with that protocol.  *****************************/

struct w5500_block_common_reg {
	uint8_t mode;                   /* MR */
	uint8_t ip_gateway_addr[4];     /* GAR0 ... GAR3 */
	uint8_t ip_subnet_mask[4];      /* SUBR0 ... SUBR3 */
	uint8_t eth_addr[6];            /* SHAR0 ... SHAR5 */
	uint8_t ip_addr[4];             /* SIPR0 ... SIPR3 */

	uint8_t intlevel_0;             /* INTLEVEL0 */
	uint8_t intlevel_1;             /* INTLEVEL1 */
	uint8_t interrupt;              /* IR */
	uint8_t interrupt_mask;         /* IMR */
	uint8_t sock_interrupt;         /* SIR */
	uint8_t sock_interrupt_mask;    /* SIMR */
	uint8_t retry_time_0;           /* RTR0 */
	uint8_t retry_time_1;           /* RTR0 */
	uint8_t retry_count;            /* RCR */

	uint8_t ppp_lcp_request_timer;  /* PTIMER */
	uint8_t ppp_lcp_magic_bumber;   /* PMAGIC */
	uint8_t ppp_dst_eth_addr[6];    /* PHAR0 ... PHAR5 */
	uint8_t ppp_sess_id[2];         /* PSID0 ... PSID1 */
	uint8_t ppp_max_seg_size[2];    /* PMRU0 ... PMRU1 */

	uint8_t unreachable_ip_addr[4]; /* UIPR0 ... UIPR3 */
	uint8_t unreachable_port[2];    /* UPORTR0, UPORTR1 */

	uint8_t phy_cfg;                /* PHYCFGR */

	uint8_t _reserved[10];

	uint8_t chip_version;           /* VERSIONR */
};
static_assert(sizeof(struct w5500_block_common_reg) == 0x3A);

struct w5500_block_sock_reg {
	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 state;               /* Sn_SR; see STATE_{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];
	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 */
	uint8_t tx_free_size[2];     /* Sn_TX_FSR0, Sn_TX_FSR1 */
	uint8_t tx_read_pointer[2];  /* Sn_TX_RD0, Sn_TX_RD1 */
	uint8_t tx_write_pointer[2]; /* Sn_TX_WR0, Sn_TX_WR1 */
	uint8_t rx_size[2];          /* Sn_RX_RSR0, Sn_RX_RSR1 */
	uint8_t rx_read_pointer[2];  /* Sn_RX_RD0, Sn_RX_RD1 */
	uint8_t rx_write_pointer[2]; /* Sn_RX_WR0, Sn_RX_WR1 */

	uint8_t interrupt_mask;      /* Sn_IMR */
	uint8_t fragment_offset[2];  /* 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 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 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(sizeof(val) == sizeof(((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(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(val));                                       \
		val;                                                                    \
	})

#define REGWRITE_SOCK(spidev, socknum, field, val) do {                                 \
		assert(sizeof(val) == sizeof(((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(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(val));                                      \
		val;                                                                    \
	})

/* init() *********************************************************************/

static implements_net_conn *w5500_accept(implements_net_listener *_listener);
static ssize_t w5500_read(implements_net_conn *conn, void *buf, size_t count);
static ssize_t w5500_write(implements_net_conn *conn, void *buf, size_t count);
static int w5500_close(implements_net_conn *conn, bool rd, bool wr);

static struct net_listener_vtable w5500_listener_vtable = {
	.accept = w5500_accept,
};

static struct net_conn_vtable w5500_conn_vtable = {
	.read  = w5500_read,
	.write = w5500_write,
	.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 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;
}

static struct _w5500_listener *w5500_conn_listener(struct _w5500_conn *conn) {
	assert(conn);

	struct _w5500_listener *list =
		((void *)conn) - offsetof(struct _w5500_listener, active_conn);
	return list;
}

static void w5500_intrhandler(uint UNUSED(gpio), uint32_t UNUSED(event_mask)) {
	/* TODO */
}

void _w5500_init(struct w5500 *chip,
                 struct 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_reset = pin_reset,
		/* mutable */
		.next_local_port = CONFIG_W5500_LOCAL_PORT_MIN,
	};
	for (uint8_t i = 0; i < 8; i++) {
		chip->listeners[i] = (struct _w5500_listener){
			/* const-after-init */
			.vtable = &w5500_listener_vtable,
			.socknum = i,
			.active_conn = {
				.vtable = &w5500_conn_vtable,
			},
			/* mutable */
			.port = 0,
		};
	}

	/* 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);
}

void w5500_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);
}

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() *******************************************************************/

implements_net_listener *w5500_listen(struct w5500 *chip, uint8_t socknum,
                                      uint16_t port) {
	assert(chip);
	assert(socknum < 8);
	assert(port);

	assert(chip->listeners[socknum].port == 0);
	chip->listeners[socknum].port = port;

	return &chip->listeners[socknum];
}

/* accept() *******************************************************************/

#define ASSERT_LISTENER()                                   \
	struct _w5500_listener *self =                      \
		VCALL_SELF(struct _w5500_listener,          \
		           implements_net_listener, _self); \
	struct w5500 *chip = w5500_listener_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();

	/* Mimics socket.c:socket().  */
	w5500_cmd_close(self);
	REGWRITE_SOCK(chip->spidev, socknum, mode, MODE_TCP);
	struct { uint8_t octets[2]; } port_be = {{self->port>>8, self->port}};
	REGWRITE_SOCK(chip->spidev, socknum, local_port, port_be);
	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)
		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();
	for (;;) {
		uint8_t mode = REGREAD_SOCK(chip->spidev, socknum, state, uint8_t);
		switch (mode) {
		case STATE_TCP_LISTEN:
		case STATE_TCP_SYNRECV:
			cr_yield();
			break;
		default:
			return &self->active_conn;
		}
	}
}

/* write() ********************************************************************/

#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);                 \
	uint8_t socknum = listener->socknum;

static ssize_t w5500_write(implements_net_conn *_self, void *buf, size_t count) {
	ASSERT_CONN();
	assert(buf);
	assert(count);

	// TODO
}

static ssize_t w5500_read(implements_net_conn *_self, void *buf, size_t count) {
	ASSERT_CONN();
	assert(buf);
	assert(count);

	// TODO
}