theater/picomap
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use std::array, std::span, split void* ctl functions into typed API

Browse Source
This commit is contained in:
Ian Gulliver
2026-04-05 08:55:51 +09:00
parent 7f7055cec5
commit fd9e85c970
3 changed files with 405 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

287
w6300/w6300.cpp
View File

@@ -260,6 +260,40 @@ constexpr uint8_t PACK_REMAINED = static_cast<uint8_t>(pack_info::remained);
constexpr uint8_t PACK_COMPLETED = static_cast<uint8_t>(pack_info::completed);
constexpr uint8_t PACK_IPv6 = static_cast<uint8_t>(pack_info::ipv6);
enum chip_ctl {
CW_SYS_LOCK, CW_SYS_UNLOCK, CW_GET_SYSLOCK,
CW_RESET_WIZCHIP, CW_INIT_WIZCHIP,
CW_GET_INTERRUPT, CW_CLR_INTERRUPT, CW_SET_INTRMASK, CW_GET_INTRMASK,
CW_SET_INTRTIME, CW_GET_INTRTIME, CW_SET_IEN, CW_GET_IEN,
CW_GET_ID, CW_GET_VER, CW_SET_SYSCLK, CW_GET_SYSCLK,
CW_RESET_PHY, CW_SET_PHYCONF, CW_GET_PHYCONF, CW_GET_PHYSTATUS,
CW_SET_PHYPOWMODE, CW_GET_PHYPOWMODE, CW_GET_PHYLINK
};
enum net_ctl {
CN_SET_NETINFO, CN_GET_NETINFO, CN_SET_NETMODE, CN_GET_NETMODE,
CN_SET_TIMEOUT, CN_GET_TIMEOUT, CN_SET_PREFER, CN_GET_PREFER,
};
enum net_service_ctl {
CNS_ARP, CNS_PING, CNS_DAD, CNS_SLAAC, CNS_UNSOL_NA, CNS_GET_PREFIX
};
enum sock_ctl {
CS_SET_IOMODE, CS_GET_IOMODE, CS_GET_MAXTXBUF, CS_GET_MAXRXBUF,
CS_CLR_INTERRUPT, CS_GET_INTERRUPT, CS_SET_PREFER, CS_GET_PREFER,
CS_SET_INTMASK, CS_GET_INTMASK
};
enum sockopt_type {
SO_FLAG, SO_TTL, SO_TOS, SO_MSS, SO_DESTIP, SO_DESTPORT,
SO_KEEPALIVESEND, SO_KEEPALIVEAUTO, SO_SENDBUF, SO_RECVBUF,
SO_STATUS, SO_EXTSTATUS, SO_MODE, SO_REMAINSIZE, SO_PACKINFO
};
enum sockint_kind { SIK_CONNECTED = 1, SIK_DISCONNECTED = 2, SIK_RECEIVED = 4, SIK_TIMEOUT = 8, SIK_SENT = 16, SIK_ALL = 0x1F };
constexpr uint8_t SOCK_IO_BLOCK = static_cast<uint8_t>(sock_io_mode::block);
constexpr uint8_t SOCK_IO_NONBLOCK = static_cast<uint8_t>(sock_io_mode::nonblock);
@@ -1169,18 +1203,18 @@ void set_phy_power_mode(uint8_t pmode) {
}
void set_net_info(net_info* p) {
setSHAR(p->mac); setGAR(p->gw); setSUBR(p->sn); setSIPR(p->ip);
setGA6R(p->gw6); setSUB6R(p->sn6); setLLAR(p->lla); setGUAR(p->gua);
memcpy(dns_, p->dns, 4);
memcpy(dns6_, p->dns6, 16);
setSHAR(p->mac.data()); setGAR(p->gw.data()); setSUBR(p->sn.data()); setSIPR(p->ip.data());
setGA6R(p->gw6.data()); setSUB6R(p->sn6.data()); setLLAR(p->lla.data()); setGUAR(p->gua.data());
memcpy(dns_, p->dns.data(), 4);
memcpy(dns6_, p->dns6.data(), 16);
ipmode_ = p->ipmode;
}
void get_net_info(net_info* p) {
getSHAR(p->mac); getGAR(p->gw); getSUBR(p->sn); getSIPR(p->ip);
getGA6R(p->gw6); getSUB6R(p->sn6); getLLAR(p->lla); getGUAR(p->gua);
memcpy(p->dns, dns_, 4);
memcpy(p->dns6, dns6_, 16);
getSHAR(p->mac.data()); getGAR(p->gw.data()); getSUBR(p->sn.data()); getSIPR(p->ip.data());
getGA6R(p->gw6.data()); getSUB6R(p->sn6.data()); getLLAR(p->lla.data()); getGUAR(p->gua.data());
memcpy(p->dns.data(), dns_, 4);
memcpy(p->dns6.data(), dns6_, 16);
p->ipmode = ipmode_;
}
@@ -1212,20 +1246,20 @@ void get_timeout(net_timeout* t) {
int8_t send_arp(arp_request* arp) {
uint8_t tmp;
if (arp->destinfo.len == 16) { setSLDIP6R(arp->destinfo.ip); setSLCR(SLCR_ARP6); }
else { setSLDIP4R(arp->destinfo.ip); setSLCR(SLCR_ARP4); }
if (arp->destinfo.len == 16) { setSLDIP6R(arp->destinfo.ip.data()); setSLCR(SLCR_ARP6); }
else { setSLDIP4R(arp->destinfo.ip.data()); setSLCR(SLCR_ARP4); }
while (getSLCR());
while ((tmp = getSLIR()) == 0x00);
setSLIRCLR(~SLIR_RA);
if (tmp & (SLIR_ARP4 | SLIR_ARP6)) { getSLDHAR(arp->dha); return 0; }
if (tmp & (SLIR_ARP4 | SLIR_ARP6)) { getSLDHAR(arp->dha.data()); return 0; }
return -1;
}
int8_t send_ping(ping_request* ping) {
uint8_t tmp;
setPINGIDR(ping->id); setPINGSEQR(ping->seq);
if (ping->destinfo.len == 16) { setSLDIP6R(ping->destinfo.ip); setSLCR(SLCR_PING6); }
else { setSLDIP4R(ping->destinfo.ip); setSLCR(SLCR_PING4); }
if (ping->destinfo.len == 16) { setSLDIP6R(ping->destinfo.ip.data()); setSLCR(SLCR_PING6); }
else { setSLDIP4R(ping->destinfo.ip.data()); setSLCR(SLCR_PING4); }
while (getSLCR());
while ((tmp = getSLIR()) == 0x00);
setSLIRCLR(~SLIR_RA);
@@ -1252,7 +1286,7 @@ int8_t send_slaac(prefix* prefix) {
if (tmp & SLIR_RS) {
prefix->len = getPLR(); prefix->flag = getPFR();
prefix->valid_lifetime = getVLTR(); prefix->preferred_lifetime = getPLTR();
getPAR(prefix->prefix);
getPAR(prefix->prefix.data());
return 0;
}
return -1;
@@ -1272,7 +1306,7 @@ int8_t get_prefix(prefix* prefix) {
if (getSLIR() & SLIR_RA) {
prefix->len = getPLR(); prefix->flag = getPFR();
prefix->valid_lifetime = getVLTR(); prefix->preferred_lifetime = getPLTR();
getPAR(prefix->prefix);
getPAR(prefix->prefix.data());
setSLIRCLR(SLIR_RA);
}
return -1;
@@ -1280,7 +1314,7 @@ int8_t get_prefix(prefix* prefix) {
constexpr uint16_t SOCK_ANY_PORT_NUM = 0xC000;
static uint16_t sock_any_port = SOCK_ANY_PORT_NUM;
static uint16_t sock_io_mode = 0;
static uint16_t sock_io_mode_bits = 0;
static uint16_t sock_is_sending = 0;
static uint16_t sock_remained_size[_SOCK_COUNT_] = {0,};
uint8_t sock_pack_info[_SOCK_COUNT_] = {0,};
@@ -1358,8 +1392,8 @@ std::expected<socket_id, sock_error> open_socket(socket_id sid, protocol proto,
setSn_PORTR(sn, p);
setSn_CR(sn, Sn_CR_OPEN);
while (getSn_CR(sn));
sock_io_mode &= ~(1 << sn);
sock_io_mode |= ((fl & (static_cast<uint8_t>(sock_flag::io_nonblock) >> 3)) << sn);
sock_io_mode_bits &= ~(1 << sn);
sock_io_mode_bits |= ((fl & (static_cast<uint8_t>(sock_flag::io_nonblock) >> 3)) << sn);
sock_is_sending &= ~(1 << sn);
sock_remained_size[sn] = 0;
sock_pack_info[sn] = static_cast<uint8_t>(pack_info::completed);
@@ -1373,7 +1407,7 @@ std::expected<void, sock_error> close(socket_id sid) {
setSn_CR(sn, Sn_CR_CLOSE);
while (getSn_CR(sn));
setSn_IR(sn, 0xFF);
sock_io_mode &= ~(1 << sn);
sock_io_mode_bits &= ~(1 << sn);
sock_is_sending &= ~(1 << sn);
sock_remained_size[sn] = 0;
sock_pack_info[sn] = PACK_NONE;
@@ -1418,7 +1452,7 @@ std::expected<void, sock_error> connect(socket_id sid, uint8_t * addr, port_num
setSn_CR(sn, Sn_CR_CONNECT);
}
while (getSn_CR(sn));
if (sock_io_mode & (1 << sn)) FAIL(busy);
if (sock_io_mode_bits & (1 << sn)) FAIL(busy);
while (getSn_SR(sn) != SOCK_ESTABLISHED) {
if (getSn_IR(sn) & Sn_IR_TIMEOUT) {
setSn_IR(sn, Sn_IR_TIMEOUT);
@@ -1437,7 +1471,7 @@ std::expected<void, sock_error> disconnect(socket_id sid) {
setSn_CR(sn, Sn_CR_DISCON);
while (getSn_CR(sn));
sock_is_sending &= ~(1 << sn);
if (sock_io_mode & (1 << sn)) FAIL(busy);
if (sock_io_mode_bits & (1 << sn)) FAIL(busy);
while (getSn_SR(sn) != SOCK_CLOSED) {
if (getSn_IR(sn) & Sn_IR_TIMEOUT) {
close(sid);
@@ -1448,10 +1482,11 @@ std::expected<void, sock_error> disconnect(socket_id sid) {
return {};
}
std::expected<uint16_t, sock_error> send(socket_id sid, uint8_t * buf, uint16_t len) {
std::expected<uint16_t, sock_error> send(socket_id sid, std::span<const uint8_t> buf) {
uint8_t sn = static_cast<uint8_t>(sid);
uint8_t tmp = 0;
uint16_t freesize = 0;
uint16_t len = buf.size();
freesize = getSn_TxMAX(sn);
if (len > freesize) len = freesize;
@@ -1462,10 +1497,10 @@ std::expected<uint16_t, sock_error> send(socket_id sid, uint8_t * buf, uint16_t
if (tmp == SOCK_CLOSED) close(sid);
FAIL(sock_status);
}
if ((sock_io_mode & (1 << sn)) && (len > freesize)) FAIL(busy);
if ((sock_io_mode_bits & (1 << sn)) && (len > freesize)) FAIL(busy);
if (len <= freesize) break;
}
wiz_send_data(sn, buf, len);
wiz_send_data(sn, const_cast<uint8_t*>(buf.data()), len);
if (sock_is_sending & (1 << sn)) {
while (!(getSn_IR(sn) & Sn_IR_SENDOK)) {
tmp = getSn_SR(sn);
@@ -1473,7 +1508,7 @@ std::expected<uint16_t, sock_error> send(socket_id sid, uint8_t * buf, uint16_t
if ((tmp == SOCK_CLOSED) || (getSn_IR(sn) & Sn_IR_TIMEOUT)) close(sid);
FAIL(sock_status);
}
if (sock_io_mode & (1 << sn)) FAIL(busy);
if (sock_io_mode_bits & (1 << sn)) FAIL(busy);
}
setSn_IR(sn, Sn_IR_SENDOK);
}
@@ -1483,8 +1518,9 @@ std::expected<uint16_t, sock_error> send(socket_id sid, uint8_t * buf, uint16_t
return len;
}
std::expected<uint16_t, sock_error> recv(socket_id sid, uint8_t * buf, uint16_t len) {
std::expected<uint16_t, sock_error> recv(socket_id sid, std::span<uint8_t> buf) {
uint8_t sn = static_cast<uint8_t>(sid);
uint16_t len = buf.size();
uint8_t tmp = 0;
uint16_t recvsize = 0;
@@ -1511,19 +1547,20 @@ std::expected<uint16_t, sock_error> recv(socket_id sid, uint8_t * buf, uint16_t
}
}
if (recvsize != 0) break;
if (sock_io_mode & (1 << sn)) FAIL(busy);
if (sock_io_mode_bits & (1 << sn)) FAIL(busy);
};
if (recvsize < len) len = recvsize;
wiz_recv_data(sn, buf, len);
wiz_recv_data(sn, buf.data(), len);
setSn_CR(sn, Sn_CR_RECV);
while (getSn_CR(sn));
return len;
}
std::expected<uint16_t, sock_error> sendto(socket_id sid, uint8_t * buf, uint16_t len, uint8_t * addr, port_num port, uint8_t addrlen) {
std::expected<uint16_t, sock_error> sendto(socket_id sid, std::span<const uint8_t> buf, uint8_t * addr, port_num port, uint8_t addrlen) {
uint8_t sn = static_cast<uint8_t>(sid);
uint16_t p = static_cast<uint16_t>(port);
uint16_t len = buf.size();
uint8_t tmp = 0;
uint8_t tcmd = Sn_CR_SEND;
uint16_t freesize = 0;
@@ -1568,10 +1605,10 @@ std::expected<uint16_t, sock_error> sendto(socket_id sid, uint8_t * buf, uint16_
while (1) {
freesize = getSn_TX_FSR(sn);
if (getSn_SR(sn) == SOCK_CLOSED) FAIL(sock_closed);
if ((sock_io_mode & (1 << sn)) && (len > freesize)) FAIL(busy);
if ((sock_io_mode_bits & (1 << sn)) && (len > freesize)) FAIL(busy);
if (len <= freesize) break;
};
wiz_send_data(sn, buf, len);
wiz_send_data(sn, const_cast<uint8_t*>(buf.data()), len);
setSn_CR(sn, tcmd);
while (getSn_CR(sn));
while (1) {
@@ -1587,8 +1624,9 @@ std::expected<uint16_t, sock_error> sendto(socket_id sid, uint8_t * buf, uint16_
return len;
}
std::expected<uint16_t, sock_error> recvfrom(socket_id sid, uint8_t * buf, uint16_t len, uint8_t * addr, port_num *port, uint8_t *addrlen) {
std::expected<uint16_t, sock_error> recvfrom(socket_id sid, std::span<uint8_t> buf, uint8_t * addr, port_num *port, uint8_t *addrlen) {
uint8_t sn = static_cast<uint8_t>(sid);
uint16_t len = buf.size();
uint8_t mr;
uint8_t head[8];
uint16_t pack_len = 0;
@@ -1614,7 +1652,7 @@ std::expected<uint16_t, sock_error> recvfrom(socket_id sid, uint8_t * buf, uint1
sock_pack_info[sn] = PACK_NONE;
break;
}
if (sock_io_mode & (1 << sn)) FAIL(busy);
if (sock_io_mode_bits & (1 << sn)) FAIL(busy);
};
}
@@ -1648,7 +1686,7 @@ std::expected<uint16_t, sock_error> recvfrom(socket_id sid, uint8_t * buf, uint1
}
if (len < sock_remained_size[sn]) pack_len = len;
else pack_len = sock_remained_size[sn];
wiz_recv_data(sn, buf, pack_len);
wiz_recv_data(sn, buf.data(), pack_len);
break;
case Sn_MR_IPRAW6:
case Sn_MR_IPRAW4:
@@ -1680,7 +1718,7 @@ std::expected<uint16_t, sock_error> recvfrom(socket_id sid, uint8_t * buf, uint1
if (len < sock_remained_size[sn]) pack_len = len;
else pack_len = sock_remained_size[sn];
wiz_recv_data(sn, buf, pack_len);
wiz_recv_data(sn, buf.data(), pack_len);
setSn_CR(sn, Sn_CR_RECV);
while (getSn_CR(sn));
@@ -1698,12 +1736,12 @@ std::expected<void, sock_error> ctl_socket(socket_id sid, sock_ctl cstype, void*
tmp = *((uint8_t*)arg);
switch (cstype) {
case CS_SET_IOMODE:
if (tmp == SOCK_IO_NONBLOCK) sock_io_mode |= (1 << sn);
else if (tmp == SOCK_IO_BLOCK) sock_io_mode &= ~(1 << sn);
if (tmp == SOCK_IO_NONBLOCK) sock_io_mode_bits |= (1 << sn);
else if (tmp == SOCK_IO_BLOCK) sock_io_mode_bits &= ~(1 << sn);
else FAIL(arg);
break;
case CS_GET_IOMODE:
*((uint8_t*)arg) = (uint8_t)((sock_io_mode >> sn) & 0x0001);
*((uint8_t*)arg) = (uint8_t)((sock_io_mode_bits >> sn) & 0x0001);
break;
case CS_GET_MAXTXBUF:
*((uint16_t*)arg) = getSn_TxMAX(sn);
@@ -1752,7 +1790,7 @@ std::expected<void, sock_error> set_sockopt(socket_id sid, sockopt_type sotype,
setSn_MSSR(sn, *(uint16_t*)arg);
break;
case SO_DESTIP:
if (((ip_address *)arg)->len == 16) setSn_DIP6R(sn, ((ip_address*)arg)->ip);
if (((ip_address *)arg)->len == 16) setSn_DIP6R(sn, ((ip_address*)arg)->ip.data());
else setSn_DIPR(sn, (uint8_t*)arg);
break;
case SO_DESTPORT:
@@ -1784,7 +1822,7 @@ std::expected<void, sock_error> get_sockopt(socket_id sid, sockopt_type sotype,
CHECK_SOCKNUM();
switch (sotype) {
case SO_FLAG:
*(uint8_t*)arg = (getSn_MR(sn) & 0xF0) | (getSn_MR2(sn)) | ((uint8_t)(((sock_io_mode >> sn) & 0x0001) << 3));
*(uint8_t*)arg = (getSn_MR(sn) & 0xF0) | (getSn_MR2(sn)) | ((uint8_t)(((sock_io_mode_bits >> sn) & 0x0001) << 3));
break;
case SO_TTL:
*(uint8_t*)arg = getSn_TTL(sn);
@@ -1798,10 +1836,10 @@ std::expected<void, sock_error> get_sockopt(socket_id sid, sockopt_type sotype,
case SO_DESTIP:
CHECK_TCPMODE();
if (getSn_ESR(sn) & TCPSOCK_MODE) {
getSn_DIP6R(sn, ((ip_address*)arg)->ip);
getSn_DIP6R(sn, ((ip_address*)arg)->ip.data());
((ip_address*)arg)->len = 16;
} else {
getSn_DIPR(sn, ((ip_address*)arg)->ip);
getSn_DIPR(sn, ((ip_address*)arg)->ip.data());
((ip_address*)arg)->len = 4;
}
break;
@@ -1844,7 +1882,8 @@ std::expected<void, sock_error> get_sockopt(socket_id sid, sockopt_type sotype,
return {};
}
std::optional<uint16_t> peek_socket_msg(socket_id sid, uint8_t* submsg, uint16_t subsize) {
std::optional<uint16_t> peek_socket_msg(socket_id sid, std::span<const uint8_t> submsg) {
uint16_t subsize = submsg.size();
uint8_t sn = static_cast<uint8_t>(sid);
uint32_t rx_ptr = 0;
uint16_t i = 0, sub_idx = 0;
@@ -1897,4 +1936,166 @@ void init_net(net_info net_info) {
ctl_net(CN_SET_NETINFO, (void *)&net_info);
}
std::expected<void, sock_error> set_socket_io_mode(socket_id sid, sock_io_mode mode) {
uint8_t sn = static_cast<uint8_t>(sid);
if (sn >= _SOCK_COUNT_) FAIL(sock_num);
if (mode == sock_io_mode::nonblock) sock_io_mode_bits |= (1 << sn);
else if (mode == sock_io_mode::block) sock_io_mode_bits &= ~(1 << sn);
else FAIL(arg);
return {};
}
sock_io_mode get_socket_io_mode(socket_id sid) {
uint8_t sn = static_cast<uint8_t>(sid);
return static_cast<sock_io_mode>((sock_io_mode_bits >> sn) & 0x01);
}
uint16_t get_socket_max_tx(socket_id sid) {
return getSn_TxMAX(static_cast<uint8_t>(sid));
}
uint16_t get_socket_max_rx(socket_id sid) {
return getSn_RxMAX(static_cast<uint8_t>(sid));
}
std::expected<void, sock_error> clear_socket_interrupt(socket_id sid, uint8_t flags) {
uint8_t sn = static_cast<uint8_t>(sid);
if (sn >= _SOCK_COUNT_) FAIL(sock_num);
if (flags > SIK_ALL) FAIL(arg);
setSn_IR(sn, flags);
return {};
}
uint8_t get_socket_interrupt(socket_id sid) {
return getSn_IR(static_cast<uint8_t>(sid));
}
std::expected<void, sock_error> set_socket_interrupt_mask(socket_id sid, uint8_t mask) {
uint8_t sn = static_cast<uint8_t>(sid);
if (sn >= _SOCK_COUNT_) FAIL(sock_num);
if (mask > SIK_ALL) FAIL(arg);
setSn_IMR(sn, mask);
return {};
}
uint8_t get_socket_interrupt_mask(socket_id sid) {
return getSn_IMR(static_cast<uint8_t>(sid));
}
std::expected<void, sock_error> set_socket_prefer(socket_id sid, srcv6_prefer pref) {
uint8_t sn = static_cast<uint8_t>(sid);
if (sn >= _SOCK_COUNT_) FAIL(sock_num);
uint8_t v = static_cast<uint8_t>(pref);
if ((v & 0x03) == 0x01) FAIL(arg);
setSn_PSR(sn, v);
return {};
}
srcv6_prefer get_socket_prefer(socket_id sid) {
return static_cast<srcv6_prefer>(getSn_PSR(static_cast<uint8_t>(sid)));
}
void set_socket_ttl(socket_id sid, uint8_t ttl) {
setSn_TTL(static_cast<uint8_t>(sid), ttl);
}
uint8_t get_socket_ttl(socket_id sid) {
return getSn_TTL(static_cast<uint8_t>(sid));
}
void set_socket_tos(socket_id sid, uint8_t tos) {
setSn_TOS(static_cast<uint8_t>(sid), tos);
}
uint8_t get_socket_tos(socket_id sid) {
return getSn_TOS(static_cast<uint8_t>(sid));
}
void set_socket_mss(socket_id sid, uint16_t mss) {
setSn_MSSR(static_cast<uint8_t>(sid), mss);
}
uint16_t get_socket_mss(socket_id sid) {
return getSn_MSSR(static_cast<uint8_t>(sid));
}
void set_socket_dest_ip(socket_id sid, const ip_address& addr) {
uint8_t sn = static_cast<uint8_t>(sid);
if (addr.len == 16) setSn_DIP6R(sn, const_cast<uint8_t*>(addr.ip.data()));
else setSn_DIPR(sn, const_cast<uint8_t*>(addr.ip.data()));
}
ip_address get_socket_dest_ip(socket_id sid) {
uint8_t sn = static_cast<uint8_t>(sid);
ip_address addr = {};
if (getSn_ESR(sn) & TCPSOCK_MODE) {
getSn_DIP6R(sn, addr.ip.data());
addr.len = 16;
} else {
getSn_DIPR(sn, addr.ip.data());
addr.len = 4;
}
return addr;
}
void set_socket_dest_port(socket_id sid, port_num port) {
setSn_DPORTR(static_cast<uint8_t>(sid), static_cast<uint16_t>(port));
}
port_num get_socket_dest_port(socket_id sid) {
return static_cast<port_num>(getSn_DPORTR(static_cast<uint8_t>(sid)));
}
std::expected<void, sock_error> send_keepalive(socket_id sid) {
uint8_t sn = static_cast<uint8_t>(sid);
if ((getSn_MR(sn) & 0x03) != 0x01) FAIL(sock_mode);
if (getSn_KPALVTR(sn) != 0) FAIL(sock_opt);
setSn_CR(sn, Sn_CR_SEND_KEEP);
while (getSn_CR(sn) != 0) {
if (getSn_IR(sn) & Sn_IR_TIMEOUT) {
setSn_IR(sn, Sn_IR_TIMEOUT);
FAIL(timeout);
}
}
return {};
}
void set_socket_keepalive_auto(socket_id sid, uint8_t interval) {
setSn_KPALVTR(static_cast<uint8_t>(sid), interval);
}
uint8_t get_socket_keepalive_auto(socket_id sid) {
return getSn_KPALVTR(static_cast<uint8_t>(sid));
}
uint16_t get_socket_send_buf(socket_id sid) {
return getSn_TX_FSR(static_cast<uint8_t>(sid));
}
uint16_t get_socket_recv_buf(socket_id sid) {
return getSn_RX_RSR(static_cast<uint8_t>(sid));
}
uint8_t get_socket_status(socket_id sid) {
return getSn_SR(static_cast<uint8_t>(sid));
}
uint8_t get_socket_ext_status(socket_id sid) {
return getSn_ESR(static_cast<uint8_t>(sid)) & 0x07;
}
uint8_t get_socket_mode(socket_id sid) {
return getSn_MR(static_cast<uint8_t>(sid)) & 0x0F;
}
uint16_t get_socket_remain_size(socket_id sid) {
uint8_t sn = static_cast<uint8_t>(sid);
if (getSn_MR(sn) & 0x01) return getSn_RX_RSR(sn);
return sock_remained_size[sn];
}
pack_info get_socket_pack_info(socket_id sid) {
return static_cast<pack_info>(sock_pack_info[static_cast<uint8_t>(sid)]);
}
} // namespace w6300