picomap/firmware/w6300/w6300.h

#pragma once
#include <array>
#include <cstdint>
#include <expected>
#include <optional>
#include <span>

namespace w6300 {

constexpr int sock_count = 8;

enum class socket_id : uint8_t {};
enum class port_num : uint16_t {};

enum class sock_error : int16_t {
    busy           =     0,
    sock_num       =    -1,
    sock_opt       =    -2,
    sock_init      =    -3,
    sock_closed    =    -4,
    sock_mode      =    -5,
    sock_flag      =    -6,
    sock_status    =    -7,
    arg            =   -10,
    port_zero      =   -11,
    ip_invalid     =   -12,
    timeout        =   -13,
    data_len       =   -14,
    buffer         =   -15,
    fatal_packlen  = -1001,
};

enum class protocol : uint8_t {
    tcp       = 0x01,
    udp       = 0x02,
    ipraw     = 0x03,
    macraw    = 0x07,
    tcp6      = 0x09,
    udp6      = 0x0A,
    ipraw6    = 0x0B,
    tcp_dual  = 0x0D,
    udp_dual  = 0x0E,
};

enum class sock_flag : uint8_t {
    none            = 0,
    multi_enable    = 1 << 7,
    ether_own       = 1 << 7,
    broad_block     = 1 << 6,
    tcp_fpsh        = 1 << 6,
    tcp_nodelay     = 1 << 5,
    igmp_ver2       = 1 << 5,
    solicit_block   = 1 << 5,
    ether_multi4b   = 1 << 5,
    uni_block       = 1 << 4,
    ether_multi6b   = 1 << 4,
    force_arp       = 1 << 0,
    dha_manual      = 1 << 1,
    io_nonblock     = 1 << 3,
};
constexpr sock_flag operator|(sock_flag a, sock_flag b) {
    return static_cast<sock_flag>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
}
constexpr uint8_t operator&(sock_flag a, sock_flag b) {
    return static_cast<uint8_t>(a) & static_cast<uint8_t>(b);
}

enum class pack_info : uint8_t {
    none           = 0x00,
    first          = 1 << 1,
    remained       = 1 << 2,
    completed      = 1 << 3,
    ipv6_lla       = (1 << 7) | (1 << 4),
    ipv6_multi     = (1 << 7) | (1 << 5),
    ipv6_allnode   = (1 << 7) | (1 << 6),
    ipv6           = 1 << 7,
};
constexpr pack_info operator|(pack_info a, pack_info b) {
    return static_cast<pack_info>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
}
constexpr uint8_t operator&(pack_info a, pack_info b) {
    return static_cast<uint8_t>(a) & static_cast<uint8_t>(b);
}

enum class srcv6_prefer : uint8_t {
    auto_select = 0x00,
    lla         = 0x02,
    gua         = 0x03,
};

enum class tcp_sock_info : uint8_t {
    mode = 1 << 2,
    op   = 1 << 1,
    sip  = 1 << 0,
};

enum class sock_io_mode : uint8_t {
    block    = 0,
    nonblock = 1,
};

enum intr_kind : uint32_t {
    ik_pppoe_terminated = (1 << 0), ik_dest_unreach = (1 << 1), ik_ip_conflict = (1 << 2),
    ik_dest_unreach6 = (1 << 4), ik_wol = (1 << 7), ik_net_all = 0x97,
    ik_sock_0 = (1 << 8), ik_sock_1 = (1 << 9), ik_sock_2 = (1 << 10), ik_sock_3 = (1 << 11),
    ik_sock_4 = (1 << 12), ik_sock_5 = (1 << 13), ik_sock_6 = (1 << 14), ik_sock_7 = (1 << 15),
    ik_sock_all = (0xFF << 8),
    ik_sockl_tout = (1 << 16), ik_sockl_arp4 = (1 << 17), ik_sockl_ping4 = (1 << 18),
    ik_sockl_arp6 = (1 << 19), ik_sockl_ping6 = (1 << 20), ik_sockl_ns = (1 << 21),
    ik_sockl_rs = (1 << 22), ik_sockl_ra = (1 << 23), ik_sockl_all = (0xFF << 16),
    ik_int_all = 0x00FFFF97
};

struct phy_conf {
    uint8_t by;
    uint8_t mode;
    uint8_t speed;
    uint8_t duplex;
};

enum ipconf_mode : uint8_t {
    ipconf_none = 0x00, ipconf_static_v4 = 0x01, ipconf_static_v6 = 0x02,
    ipconf_static_all = 0x03, ipconf_slaac_v6 = 0x04,
    ipconf_dhcp_v4 = 0x10, ipconf_dhcp_v6 = 0x20, ipconf_dhcp_all = 0x30
};

enum dhcp_mode : uint8_t { dhcp_static = 1, dhcp_dynamic };

struct net_info {
    std::array<uint8_t, 6> mac;
    std::array<uint8_t, 4> ip;
    std::array<uint8_t, 4> sn;
    std::array<uint8_t, 4> gw;
    std::array<uint8_t, 16> lla;
    std::array<uint8_t, 16> gua;
    std::array<uint8_t, 16> sn6;
    std::array<uint8_t, 16> gw6;
    std::array<uint8_t, 4> dns;
    std::array<uint8_t, 16> dns6;
    ipconf_mode ipmode;
    dhcp_mode dhcp;
};

enum netmode_type : uint32_t {
    nm_ipb_v4 = (1 << 0), nm_ipb_v6 = (1 << 1), nm_wol = (1 << 2),
    nm_pb6_multi = (1 << 4), nm_pb6_allnode = (1 << 5), nm_mr_mask = 0x37,
    nm_pppoe = (1 << 8), nm_dha_select = (1 << 15), nm_mr2_mask = (0x09 << 8),
    nm_pb4_all = (1 << 16), nm_trstb_v4 = (1 << 17), nm_parp_v4 = (1 << 18),
    nm_unrb_v4 = (1 << 19), nm_net4_mask = (0x0F << 16),
    nm_pb6_all = (1 << 24), nm_trstb_v6 = (1 << 25), nm_parp_v6 = (1 << 26),
    nm_unrb_v6 = (1 << 27), nm_net6_mask = (0x0F << 24),
    nm_mask_all = 0x0F0F0937
};

struct net_timeout {
    uint8_t  s_retry_cnt;
    uint16_t s_time_100us;
    uint8_t  sl_retry_cnt;
    uint16_t sl_time_100us;
};

struct ip_address {
    std::array<uint8_t, 16> ip;
    uint8_t len;
};

struct prefix {
    uint8_t  len;
    uint8_t  flag;
    uint32_t valid_lifetime;
    uint32_t preferred_lifetime;
    std::array<uint8_t, 16> prefix;
};

struct arp_request {
    ip_address destinfo;
    std::array<uint8_t, 6> dha;
};

struct ping_request {
    uint16_t id;
    uint16_t seq;
    ip_address destinfo;
};

void init_spi();
void init_critical_section();
void reset();
void init();
bool check();
void init_net(const net_info& info);

void soft_reset();
int8_t init_buffers(std::span<const uint8_t> txsize, std::span<const uint8_t> rxsize);
void clear_interrupt(intr_kind intr);
intr_kind get_interrupt();
void set_interrupt_mask(intr_kind intr);
void enable_interrupt_pin();
intr_kind get_interrupt_mask();

int8_t get_phy_link();
int8_t get_phy_power_mode();
void reset_phy();
void set_phy_conf(const phy_conf& conf);
phy_conf get_phy_conf();
phy_conf get_phy_status();
void set_phy_power_mode(uint8_t pmode);

void set_net_info(const net_info& info);
net_info get_net_info();
void set_net_mode(netmode_type mode);
netmode_type get_net_mode();
void set_timeout(const net_timeout& timeout);
net_timeout get_timeout();

int8_t send_arp(arp_request& arp);
int8_t send_ping(const ping_request& ping);
int8_t send_dad(std::span<const uint8_t, 16> ipv6);
int8_t send_slaac(prefix& pfx);
int8_t send_unsolicited();
int8_t get_prefix(prefix& pfx);

std::expected<socket_id, sock_error> open_socket(socket_id sn, protocol proto, port_num port, sock_flag flag);
std::expected<void, sock_error> close(socket_id sn);
std::expected<void, sock_error> listen(socket_id sn);
std::expected<void, sock_error> disconnect(socket_id sn);
std::expected<uint16_t, sock_error> send(socket_id sn, std::span<const uint8_t> buf);
std::expected<uint16_t, sock_error> recv(socket_id sn, std::span<uint8_t> buf);

std::expected<void, sock_error> connect(socket_id sn, const ip_address& addr, port_num port);
std::expected<uint16_t, sock_error> sendto(socket_id sn, std::span<const uint8_t> buf, const ip_address& addr, port_num port);
std::expected<uint16_t, sock_error> recvfrom(socket_id sn, std::span<uint8_t> buf, ip_address& addr, port_num& port);

std::expected<void, sock_error> set_socket_io_mode(socket_id sn, sock_io_mode mode);
sock_io_mode get_socket_io_mode(socket_id sn);
uint16_t get_socket_max_tx(socket_id sn);
uint16_t get_socket_max_rx(socket_id sn);
std::expected<void, sock_error> clear_socket_interrupt(socket_id sn, uint8_t flags);
uint8_t get_socket_interrupt(socket_id sn);
std::expected<void, sock_error> set_socket_interrupt_mask(socket_id sn, uint8_t mask);
uint8_t get_socket_interrupt_mask(socket_id sn);
std::expected<void, sock_error> set_socket_prefer(socket_id sn, srcv6_prefer pref);
srcv6_prefer get_socket_prefer(socket_id sn);

void set_socket_ttl(socket_id sn, uint8_t ttl);
uint8_t get_socket_ttl(socket_id sn);
void set_socket_tos(socket_id sn, uint8_t tos);
uint8_t get_socket_tos(socket_id sn);
void set_socket_mss(socket_id sn, uint16_t mss);
uint16_t get_socket_mss(socket_id sn);
void set_socket_dest_mac(socket_id sn, const std::array<uint8_t, 6>& mac);
void set_socket_dest_ip(socket_id sn, const ip_address& addr);
ip_address get_socket_dest_ip(socket_id sn);
void set_socket_dest_port(socket_id sn, port_num port);
port_num get_socket_dest_port(socket_id sn);
std::expected<void, sock_error> send_keepalive(socket_id sn);
void set_socket_keepalive_auto(socket_id sn, uint8_t interval);
uint8_t get_socket_keepalive_auto(socket_id sn);
uint16_t get_socket_send_buf(socket_id sn);
uint16_t get_socket_recv_buf(socket_id sn);
uint8_t get_socket_status(socket_id sn);
uint8_t get_socket_ext_status(socket_id sn);
uint8_t get_socket_mode(socket_id sn);
uint16_t get_socket_remain_size(socket_id sn);
pack_info get_socket_pack_info(socket_id sn);

std::optional<uint16_t> peek_socket_msg(socket_id sn, std::span<const uint8_t> submsg);

} // namespace w6300