Merge w6300 cpp files into single translation unit
This commit is contained in:
Ian Gulliver
965
w6300/w6300.cpp
965
w6300/w6300.cpp
@@ -1,6 +1,57 @@
|
||||
#include "w6300.h"
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include "pico/stdlib.h"
|
||||
#include "pico/critical_section.h"
|
||||
#include "socket.h"
|
||||
#include "wizchip_spi.h"
|
||||
#include "wizchip_qspi_pio.h"
|
||||
|
||||
static critical_section_t g_cris_sec;
|
||||
|
||||
void wizchip_cris_enter() {
|
||||
critical_section_enter_blocking(&g_cris_sec);
|
||||
}
|
||||
|
||||
void wizchip_cris_exit() {
|
||||
critical_section_exit(&g_cris_sec);
|
||||
}
|
||||
|
||||
void wizchip_reset() {
|
||||
gpio_init(PIN_RST);
|
||||
gpio_set_dir(PIN_RST, GPIO_OUT);
|
||||
gpio_put(PIN_RST, 0);
|
||||
sleep_ms(100);
|
||||
gpio_put(PIN_RST, 1);
|
||||
sleep_ms(100);
|
||||
}
|
||||
|
||||
void wizchip_spi_initialize() {
|
||||
wizchip_pio_init();
|
||||
}
|
||||
|
||||
void wizchip_cris_initialize() {
|
||||
critical_section_init(&g_cris_sec);
|
||||
}
|
||||
|
||||
void wizchip_initialize() {
|
||||
wizchip_pio_frame_end();
|
||||
uint8_t memsize[2][8] = {{4, 4, 4, 4, 4, 4, 4, 4}, {4, 4, 4, 4, 4, 4, 4, 4}};
|
||||
ctlwizchip(CW_INIT_WIZCHIP, (void *)memsize);
|
||||
}
|
||||
|
||||
void wizchip_check() {
|
||||
if (getCIDR() != 0x6300) {
|
||||
printf("W6300 ACCESS ERR: CIDR = 0x%04x\n", getCIDR());
|
||||
while (1);
|
||||
}
|
||||
}
|
||||
|
||||
void network_initialize(wiz_NetInfo net_info) {
|
||||
uint8_t syslock = SYS_NET_LOCK;
|
||||
ctlwizchip(CW_SYS_UNLOCK, &syslock);
|
||||
ctlnetwork(CN_SET_NETINFO, (void *)&net_info);
|
||||
}
|
||||
|
||||
static uint8_t make_opcode(uint32_t addr, uint8_t rw) {
|
||||
return static_cast<uint8_t>((addr & 0xFF) | rw | _WIZCHIP_QSPI_MODE_);
|
||||
}
|
||||
@@ -104,3 +155,915 @@ uint16_t wiz_mdio_read(uint8_t phyregaddr) {
|
||||
while (getPHYACR());
|
||||
return getPHYDOR();
|
||||
}
|
||||
|
||||
static uint8_t dns_[4];
|
||||
static uint8_t dns6_[16];
|
||||
static ipconf_mode ipmode_;
|
||||
|
||||
static constexpr char WIZCHIP_ID[] = "W6300";
|
||||
|
||||
int8_t ctlwizchip(ctlwizchip_type cwtype, void* arg) {
|
||||
uint8_t tmp = *(uint8_t*)arg;
|
||||
uint8_t* ptmp[2] = {0, 0};
|
||||
switch (cwtype) {
|
||||
case CW_SYS_LOCK:
|
||||
if (tmp & SYS_CHIP_LOCK) CHIPLOCK();
|
||||
if (tmp & SYS_NET_LOCK) NETLOCK();
|
||||
if (tmp & SYS_PHY_LOCK) PHYLOCK();
|
||||
break;
|
||||
case CW_SYS_UNLOCK:
|
||||
if (tmp & SYS_CHIP_LOCK) CHIPUNLOCK();
|
||||
if (tmp & SYS_NET_LOCK) NETUNLOCK();
|
||||
if (tmp & SYS_PHY_LOCK) PHYUNLOCK();
|
||||
break;
|
||||
case CW_GET_SYSLOCK:
|
||||
*(uint8_t*)arg = getSYSR() >> 5;
|
||||
break;
|
||||
case CW_RESET_WIZCHIP:
|
||||
wizchip_sw_reset();
|
||||
break;
|
||||
case CW_INIT_WIZCHIP:
|
||||
if (arg) {
|
||||
ptmp[0] = (uint8_t*)arg;
|
||||
ptmp[1] = ptmp[0] + WIZCHIP_SOCK_NUM;
|
||||
}
|
||||
return wizchip_init(ptmp[0], ptmp[1]);
|
||||
case CW_CLR_INTERRUPT:
|
||||
wizchip_clrinterrupt(*((intr_kind*)arg));
|
||||
break;
|
||||
case CW_GET_INTERRUPT:
|
||||
*((intr_kind*)arg) = wizchip_getinterrupt();
|
||||
break;
|
||||
case CW_SET_INTRMASK:
|
||||
wizchip_setinterruptmask(*((intr_kind*)arg));
|
||||
break;
|
||||
case CW_GET_INTRMASK:
|
||||
*((intr_kind*)arg) = wizchip_getinterruptmask();
|
||||
break;
|
||||
case CW_SET_INTRTIME:
|
||||
setINTPTMR(*(uint16_t*)arg);
|
||||
break;
|
||||
case CW_GET_INTRTIME:
|
||||
*(uint16_t*)arg = getINTPTMR();
|
||||
break;
|
||||
case CW_GET_ID:
|
||||
memcpy(arg, WIZCHIP_ID, sizeof(WIZCHIP_ID));
|
||||
break;
|
||||
case CW_GET_VER:
|
||||
*(uint16_t*)arg = getVER();
|
||||
break;
|
||||
case CW_RESET_PHY:
|
||||
wizphy_reset();
|
||||
break;
|
||||
case CW_SET_PHYCONF:
|
||||
wizphy_setphyconf((wiz_PhyConf*)arg);
|
||||
break;
|
||||
case CW_GET_PHYCONF:
|
||||
wizphy_getphyconf((wiz_PhyConf*)arg);
|
||||
break;
|
||||
case CW_GET_PHYSTATUS:
|
||||
break;
|
||||
case CW_SET_PHYPOWMODE:
|
||||
wizphy_setphypmode(*(uint8_t*)arg);
|
||||
break;
|
||||
case CW_GET_PHYPOWMODE:
|
||||
tmp = wizphy_getphypmode();
|
||||
if ((int8_t)tmp == -1) return -1;
|
||||
*(uint8_t*)arg = tmp;
|
||||
break;
|
||||
case CW_GET_PHYLINK:
|
||||
tmp = wizphy_getphylink();
|
||||
if ((int8_t)tmp == -1) return -1;
|
||||
*(uint8_t*)arg = tmp;
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int8_t ctlnetwork(ctlnetwork_type cntype, void* arg) {
|
||||
switch (cntype) {
|
||||
case CN_SET_NETINFO: wizchip_setnetinfo((wiz_NetInfo*)arg); break;
|
||||
case CN_GET_NETINFO: wizchip_getnetinfo((wiz_NetInfo*)arg); break;
|
||||
case CN_SET_NETMODE: wizchip_setnetmode(*(netmode_type*)arg); break;
|
||||
case CN_GET_NETMODE: *(netmode_type*)arg = wizchip_getnetmode(); break;
|
||||
case CN_SET_TIMEOUT: wizchip_settimeout((wiz_NetTimeout*)arg); break;
|
||||
case CN_GET_TIMEOUT: wizchip_gettimeout((wiz_NetTimeout*)arg); break;
|
||||
case CN_SET_PREFER: setSLPSR(*(uint8_t*)arg); break;
|
||||
case CN_GET_PREFER: *(uint8_t*)arg = getSLPSR(); break;
|
||||
default: return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int8_t ctlnetservice(ctlnetservice_type cnstype, void* arg) {
|
||||
switch (cnstype) {
|
||||
case CNS_ARP: return wizchip_arp((wiz_ARP*)arg);
|
||||
case CNS_PING: return wizchip_ping((wiz_PING*)arg);
|
||||
case CNS_DAD: return wizchip_dad((uint8_t*)arg);
|
||||
case CNS_SLAAC: return wizchip_slaac((wiz_Prefix*)arg);
|
||||
case CNS_UNSOL_NA: return wizchip_unsolicited();
|
||||
case CNS_GET_PREFIX: return wizchip_getprefix((wiz_Prefix*)arg);
|
||||
default: return -1;
|
||||
}
|
||||
}
|
||||
|
||||
void wizchip_sw_reset() {
|
||||
uint8_t gw[4], sn[4], sip[4], mac[6];
|
||||
uint8_t gw6[16], sn6[16], lla[16], gua[16];
|
||||
uint8_t islock = getSYSR();
|
||||
|
||||
CHIPUNLOCK();
|
||||
getSHAR(mac); getGAR(gw); getSUBR(sn); getSIPR(sip);
|
||||
getGA6R(gw6); getSUB6R(sn6); getLLAR(lla); getGUAR(gua);
|
||||
setSYCR0(SYCR0_RST);
|
||||
getSYCR0();
|
||||
|
||||
NETUNLOCK();
|
||||
setSHAR(mac); setGAR(gw); setSUBR(sn); setSIPR(sip);
|
||||
setGA6R(gw6); setSUB6R(sn6); setLLAR(lla); setGUAR(gua);
|
||||
|
||||
if (islock & SYSR_CHPL) CHIPLOCK();
|
||||
if (islock & SYSR_NETL) NETLOCK();
|
||||
}
|
||||
|
||||
int8_t wizchip_init(uint8_t* txsize, uint8_t* rxsize) {
|
||||
wizchip_sw_reset();
|
||||
if (txsize) {
|
||||
int8_t tmp = 0;
|
||||
for (int i = 0; i < WIZCHIP_SOCK_NUM; i++) {
|
||||
tmp += txsize[i];
|
||||
if (tmp > 32) return -1;
|
||||
}
|
||||
for (int i = 0; i < WIZCHIP_SOCK_NUM; i++) setSn_TXBUF_SIZE(i, txsize[i]);
|
||||
}
|
||||
if (rxsize) {
|
||||
int8_t tmp = 0;
|
||||
for (int i = 0; i < WIZCHIP_SOCK_NUM; i++) {
|
||||
tmp += rxsize[i];
|
||||
if (tmp > 32) return -1;
|
||||
}
|
||||
for (int i = 0; i < WIZCHIP_SOCK_NUM; i++) setSn_RXBUF_SIZE(i, rxsize[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void wizchip_clrinterrupt(intr_kind intr) {
|
||||
setIRCLR((uint8_t)intr);
|
||||
uint8_t sir = (uint8_t)((uint16_t)intr >> 8);
|
||||
for (int i = 0; i < WIZCHIP_SOCK_NUM; i++)
|
||||
if (sir & (1 << i)) setSn_IRCLR(i, 0xFF);
|
||||
setSLIRCLR((uint8_t)((uint32_t)intr >> 16));
|
||||
}
|
||||
|
||||
intr_kind wizchip_getinterrupt() {
|
||||
uint32_t ret = getSIR();
|
||||
ret = (ret << 8) + getIR();
|
||||
ret = (((uint32_t)getSLIR()) << 16) | ret;
|
||||
return (intr_kind)ret;
|
||||
}
|
||||
|
||||
void wizchip_setinterruptmask(intr_kind intr) {
|
||||
setIMR((uint8_t)intr);
|
||||
setSIMR((uint8_t)((uint16_t)intr >> 8));
|
||||
setSLIMR((uint8_t)((uint32_t)intr >> 16));
|
||||
}
|
||||
|
||||
intr_kind wizchip_getinterruptmask() {
|
||||
uint32_t ret = getSIMR();
|
||||
ret = (ret << 8) + getIMR();
|
||||
ret = (((uint32_t)getSLIMR()) << 16) | ret;
|
||||
return (intr_kind)ret;
|
||||
}
|
||||
|
||||
int8_t wizphy_getphylink() {
|
||||
if (wiz_mdio_read(PHYRAR_BMSR) & BMSR_LINK_STATUS) return PHY_LINK_ON;
|
||||
return PHY_LINK_OFF;
|
||||
}
|
||||
|
||||
int8_t wizphy_getphypmode() {
|
||||
if (wiz_mdio_read(PHYRAR_BMCR) & BMCR_PWDN) return PHY_POWER_DOWN;
|
||||
return PHY_POWER_NORM;
|
||||
}
|
||||
|
||||
void wizphy_reset() {
|
||||
wiz_mdio_write(PHYRAR_BMCR, wiz_mdio_read(PHYRAR_BMCR) | BMCR_RST);
|
||||
while (wiz_mdio_read(PHYRAR_BMCR) & BMCR_RST);
|
||||
}
|
||||
|
||||
void wizphy_setphyconf(wiz_PhyConf* phyconf) {
|
||||
uint16_t tmp = wiz_mdio_read(PHYRAR_BMCR);
|
||||
if (phyconf->mode == PHY_MODE_TE) {
|
||||
setPHYCR1(getPHYCR1() | PHYCR1_TE);
|
||||
setPHYCR0(PHYCR0_AUTO);
|
||||
} else {
|
||||
setPHYCR1(getPHYCR1() & ~PHYCR1_TE);
|
||||
if (phyconf->mode == PHY_MODE_AUTONEGO) {
|
||||
tmp |= BMCR_ANE;
|
||||
} else {
|
||||
tmp &= ~(BMCR_ANE | BMCR_DPX | BMCR_SPD);
|
||||
if (phyconf->duplex == PHY_DUPLEX_FULL) tmp |= BMCR_DPX;
|
||||
if (phyconf->speed == PHY_SPEED_100) tmp |= BMCR_SPD;
|
||||
}
|
||||
wiz_mdio_write(PHYRAR_BMCR, tmp);
|
||||
}
|
||||
}
|
||||
|
||||
void wizphy_getphyconf(wiz_PhyConf* phyconf) {
|
||||
uint16_t tmp = wiz_mdio_read(PHYRAR_BMCR);
|
||||
phyconf->mode = (getPHYCR1() & PHYCR1_TE) ? PHY_MODE_TE : ((tmp & BMCR_ANE) ? PHY_MODE_AUTONEGO : PHY_MODE_MANUAL);
|
||||
phyconf->duplex = (tmp & BMCR_DPX) ? PHY_DUPLEX_FULL : PHY_DUPLEX_HALF;
|
||||
phyconf->speed = (tmp & BMCR_SPD) ? PHY_SPEED_100 : PHY_SPEED_10;
|
||||
}
|
||||
|
||||
void wizphy_getphystat(wiz_PhyConf* phyconf) {
|
||||
uint8_t tmp = getPHYSR();
|
||||
phyconf->mode = (getPHYCR1() & PHYCR1_TE) ? PHY_MODE_TE : ((tmp & (1 << 5)) ? PHY_MODE_MANUAL : PHY_MODE_AUTONEGO);
|
||||
phyconf->speed = (tmp & PHYSR_SPD) ? PHY_SPEED_10 : PHY_SPEED_100;
|
||||
phyconf->duplex = (tmp & PHYSR_DPX) ? PHY_DUPLEX_HALF : PHY_DUPLEX_FULL;
|
||||
}
|
||||
|
||||
void wizphy_setphypmode(uint8_t pmode) {
|
||||
uint16_t tmp = wiz_mdio_read(PHYRAR_BMCR);
|
||||
if (pmode == PHY_POWER_DOWN) tmp |= BMCR_PWDN;
|
||||
else tmp &= ~BMCR_PWDN;
|
||||
wiz_mdio_write(PHYRAR_BMCR, tmp);
|
||||
}
|
||||
|
||||
void wizchip_setnetinfo(wiz_NetInfo* 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);
|
||||
ipmode_ = p->ipmode;
|
||||
}
|
||||
|
||||
void wizchip_getnetinfo(wiz_NetInfo* 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);
|
||||
p->ipmode = ipmode_;
|
||||
}
|
||||
|
||||
void wizchip_setnetmode(netmode_type netmode) {
|
||||
uint32_t tmp = (uint32_t)netmode;
|
||||
setNETMR((uint8_t)tmp);
|
||||
setNETMR2((uint8_t)(tmp >> 8));
|
||||
setNET4MR((uint8_t)(tmp >> 16));
|
||||
setNET6MR((uint8_t)(tmp >> 24));
|
||||
}
|
||||
|
||||
netmode_type wizchip_getnetmode() {
|
||||
uint32_t ret = getNETMR();
|
||||
ret = (ret << 8) + getNETMR2();
|
||||
ret = (ret << 16) + getNET4MR();
|
||||
ret = (ret << 24) + getNET6MR();
|
||||
return (netmode_type)ret;
|
||||
}
|
||||
|
||||
void wizchip_settimeout(wiz_NetTimeout* t) {
|
||||
setRCR(t->s_retry_cnt); setRTR(t->s_time_100us);
|
||||
setSLRCR(t->sl_retry_cnt); setSLRTR(t->sl_time_100us);
|
||||
}
|
||||
|
||||
void wizchip_gettimeout(wiz_NetTimeout* t) {
|
||||
t->s_retry_cnt = getRCR(); t->s_time_100us = getRTR();
|
||||
t->sl_retry_cnt = getSLRCR(); t->sl_time_100us = getSLRTR();
|
||||
}
|
||||
|
||||
int8_t wizchip_arp(wiz_ARP* arp) {
|
||||
uint8_t tmp;
|
||||
if (arp->destinfo.len == 16) { setSLDIP6R(arp->destinfo.ip); setSLCR(SLCR_ARP6); }
|
||||
else { setSLDIP4R(arp->destinfo.ip); setSLCR(SLCR_ARP4); }
|
||||
while (getSLCR());
|
||||
while ((tmp = getSLIR()) == 0x00);
|
||||
setSLIRCLR(~SLIR_RA);
|
||||
if (tmp & (SLIR_ARP4 | SLIR_ARP6)) { getSLDHAR(arp->dha); return 0; }
|
||||
return -1;
|
||||
}
|
||||
|
||||
int8_t wizchip_ping(wiz_PING* 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); }
|
||||
while (getSLCR());
|
||||
while ((tmp = getSLIR()) == 0x00);
|
||||
setSLIRCLR(~SLIR_RA);
|
||||
if (tmp & (SLIR_PING4 | SLIR_PING6)) return 0;
|
||||
return -1;
|
||||
}
|
||||
|
||||
int8_t wizchip_dad(uint8_t* ipv6) {
|
||||
uint8_t tmp;
|
||||
setSLDIP6R(ipv6); setSLCR(SLCR_NS);
|
||||
while (getSLCR());
|
||||
while ((tmp = getSLIR()) == 0x00);
|
||||
setSLIRCLR(~SLIR_RA);
|
||||
if (tmp & SLIR_TOUT) return 0;
|
||||
return -1;
|
||||
}
|
||||
|
||||
int8_t wizchip_slaac(wiz_Prefix* prefix) {
|
||||
uint8_t tmp;
|
||||
setSLCR(SLCR_RS);
|
||||
while (getSLCR());
|
||||
while ((tmp = getSLIR()) == 0x00);
|
||||
setSLIRCLR(~SLIR_RA);
|
||||
if (tmp & SLIR_RS) {
|
||||
prefix->len = getPLR(); prefix->flag = getPFR();
|
||||
prefix->valid_lifetime = getVLTR(); prefix->preferred_lifetime = getPLTR();
|
||||
getPAR(prefix->prefix);
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
int8_t wizchip_unsolicited() {
|
||||
uint8_t tmp;
|
||||
setSLCR(SLCR_UNA);
|
||||
while (getSLCR());
|
||||
while ((tmp = getSLIR()) == 0x00);
|
||||
setSLIRCLR(~SLIR_RA);
|
||||
if (tmp & SLIR_TOUT) return 0;
|
||||
return -1;
|
||||
}
|
||||
|
||||
int8_t wizchip_getprefix(wiz_Prefix* prefix) {
|
||||
if (getSLIR() & SLIR_RA) {
|
||||
prefix->len = getPLR(); prefix->flag = getPFR();
|
||||
prefix->valid_lifetime = getVLTR(); prefix->preferred_lifetime = getPLTR();
|
||||
getPAR(prefix->prefix);
|
||||
setSLIRCLR(SLIR_RA);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
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_is_sending = 0;
|
||||
static uint16_t sock_remained_size[_WIZCHIP_SOCK_NUM_] = {0,};
|
||||
uint8_t sock_pack_info[_WIZCHIP_SOCK_NUM_] = {0,};
|
||||
|
||||
#define CHECK_SOCKNUM() do { if(sn >= _WIZCHIP_SOCK_NUM_) return SOCKERR_SOCKNUM; } while(0)
|
||||
#define CHECK_SOCKMODE(mode) do { if((getSn_MR(sn) & 0x0F) != mode) return SOCKERR_SOCKMODE; } while(0)
|
||||
#define CHECK_TCPMODE() do { if((getSn_MR(sn) & 0x03) != 0x01) return SOCKERR_SOCKMODE; } while(0)
|
||||
#define CHECK_UDPMODE() do { if((getSn_MR(sn) & 0x03) != 0x02) return SOCKERR_SOCKMODE; } while(0)
|
||||
#define CHECK_IPMODE() do { if((getSn_MR(sn) & 0x07) != 0x03) return SOCKERR_SOCKMODE; } while(0)
|
||||
#define CHECK_DGRAMMODE() do { if(getSn_MR(sn) == Sn_MR_CLOSED) return SOCKERR_SOCKMODE; if((getSn_MR(sn) & 0x03) == 0x01) return SOCKERR_SOCKMODE; } while(0)
|
||||
#define CHECK_SOCKINIT() do { if((getSn_SR(sn) != SOCK_INIT)) return SOCKERR_SOCKINIT; } while(0)
|
||||
#define CHECK_SOCKDATA() do { if(len == 0) return SOCKERR_DATALEN; } while(0)
|
||||
#define CHECK_IPZERO(addr, addrlen) do { uint16_t ipzero=0; for(uint8_t i=0; i<addrlen; i++) ipzero += (uint16_t)addr[i]; if(ipzero == 0) return SOCKERR_IPINVALID; } while(0)
|
||||
|
||||
int8_t socket(uint8_t sn, uint8_t protocol, uint16_t port, uint8_t flag) {
|
||||
uint8_t taddr[16];
|
||||
CHECK_SOCKNUM();
|
||||
switch (protocol & 0x0F) {
|
||||
case Sn_MR_TCP4:
|
||||
getSIPR(taddr);
|
||||
CHECK_IPZERO(taddr, 4);
|
||||
break;
|
||||
case Sn_MR_TCP6:
|
||||
getLLAR(taddr);
|
||||
CHECK_IPZERO(taddr, 16);
|
||||
break;
|
||||
case Sn_MR_TCPD:
|
||||
getSIPR(taddr);
|
||||
CHECK_IPZERO(taddr, 4);
|
||||
getLLAR(taddr);
|
||||
CHECK_IPZERO(taddr, 16);
|
||||
break;
|
||||
case Sn_MR_UDP:
|
||||
case Sn_MR_UDP6:
|
||||
case Sn_MR_UDPD:
|
||||
case Sn_MR_MACRAW:
|
||||
case Sn_MR_IPRAW4:
|
||||
case Sn_MR_IPRAW6:
|
||||
break;
|
||||
default:
|
||||
return SOCKERR_SOCKMODE;
|
||||
}
|
||||
if ((flag & 0x04) != 0) return SOCKERR_SOCKFLAG;
|
||||
|
||||
if (flag != 0) {
|
||||
switch (protocol) {
|
||||
case Sn_MR_MACRAW:
|
||||
if ((flag & (SF_DHA_MANUAL | SF_FORCE_ARP)) != 0) return SOCKERR_SOCKFLAG;
|
||||
break;
|
||||
case Sn_MR_TCP4:
|
||||
case Sn_MR_TCP6:
|
||||
case Sn_MR_TCPD:
|
||||
if ((flag & (SF_MULTI_ENABLE | SF_UNI_BLOCK)) != 0) return SOCKERR_SOCKFLAG;
|
||||
break;
|
||||
case Sn_MR_IPRAW4:
|
||||
case Sn_MR_IPRAW6:
|
||||
if (flag != 0) return SOCKERR_SOCKFLAG;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
close(sn);
|
||||
setSn_MR(sn, (protocol | (flag & 0xF0)));
|
||||
setSn_MR2(sn, flag & 0x03);
|
||||
if (!port) {
|
||||
port = sock_any_port++;
|
||||
if (sock_any_port == 0xFFF0) sock_any_port = SOCK_ANY_PORT_NUM;
|
||||
}
|
||||
setSn_PORTR(sn, port);
|
||||
setSn_CR(sn, Sn_CR_OPEN);
|
||||
while (getSn_CR(sn));
|
||||
sock_io_mode &= ~(1 << sn);
|
||||
sock_io_mode |= ((flag & (SF_IO_NONBLOCK >> 3)) << sn);
|
||||
sock_is_sending &= ~(1 << sn);
|
||||
sock_remained_size[sn] = 0;
|
||||
sock_pack_info[sn] = PACK_COMPLETED;
|
||||
while (getSn_SR(sn) == SOCK_CLOSED);
|
||||
return (int8_t)sn;
|
||||
}
|
||||
|
||||
int8_t close(uint8_t sn) {
|
||||
CHECK_SOCKNUM();
|
||||
setSn_CR(sn, Sn_CR_CLOSE);
|
||||
while (getSn_CR(sn));
|
||||
setSn_IR(sn, 0xFF);
|
||||
sock_io_mode &= ~(1 << sn);
|
||||
sock_is_sending &= ~(1 << sn);
|
||||
sock_remained_size[sn] = 0;
|
||||
sock_pack_info[sn] = PACK_NONE;
|
||||
while (getSn_SR(sn) != SOCK_CLOSED);
|
||||
return SOCK_OK;
|
||||
}
|
||||
|
||||
int8_t listen(uint8_t sn) {
|
||||
CHECK_SOCKNUM();
|
||||
CHECK_TCPMODE();
|
||||
CHECK_SOCKINIT();
|
||||
setSn_CR(sn, Sn_CR_LISTEN);
|
||||
while (getSn_CR(sn));
|
||||
while (getSn_SR(sn) != SOCK_LISTEN) {
|
||||
close(sn);
|
||||
return SOCKERR_SOCKCLOSED;
|
||||
}
|
||||
return SOCK_OK;
|
||||
}
|
||||
|
||||
int8_t connect_W6x00(uint8_t sn, uint8_t * addr, uint16_t port, uint8_t addrlen) {
|
||||
CHECK_SOCKNUM();
|
||||
CHECK_TCPMODE();
|
||||
CHECK_SOCKINIT();
|
||||
CHECK_IPZERO(addr, addrlen);
|
||||
if (port == 0) return SOCKERR_PORTZERO;
|
||||
|
||||
setSn_DPORTR(sn, port);
|
||||
if (addrlen == 16) {
|
||||
if (getSn_MR(sn) & 0x08) {
|
||||
setSn_DIP6R(sn, addr);
|
||||
setSn_CR(sn, Sn_CR_CONNECT6);
|
||||
} else {
|
||||
return SOCKERR_SOCKMODE;
|
||||
}
|
||||
} else {
|
||||
if (getSn_MR(sn) == Sn_MR_TCP6) return SOCKERR_SOCKMODE;
|
||||
setSn_DIPR(sn, addr);
|
||||
setSn_CR(sn, Sn_CR_CONNECT);
|
||||
}
|
||||
while (getSn_CR(sn));
|
||||
if (sock_io_mode & (1 << sn)) return SOCK_BUSY;
|
||||
while (getSn_SR(sn) != SOCK_ESTABLISHED) {
|
||||
if (getSn_IR(sn) & Sn_IR_TIMEOUT) {
|
||||
setSn_IR(sn, Sn_IR_TIMEOUT);
|
||||
return SOCKERR_TIMEOUT;
|
||||
}
|
||||
if (getSn_SR(sn) == SOCK_CLOSED) return SOCKERR_SOCKCLOSED;
|
||||
}
|
||||
return SOCK_OK;
|
||||
}
|
||||
|
||||
int8_t disconnect(uint8_t sn) {
|
||||
CHECK_SOCKNUM();
|
||||
CHECK_TCPMODE();
|
||||
if (getSn_SR(sn) != SOCK_CLOSED) {
|
||||
setSn_CR(sn, Sn_CR_DISCON);
|
||||
while (getSn_CR(sn));
|
||||
sock_is_sending &= ~(1 << sn);
|
||||
if (sock_io_mode & (1 << sn)) return SOCK_BUSY;
|
||||
while (getSn_SR(sn) != SOCK_CLOSED) {
|
||||
if (getSn_IR(sn) & Sn_IR_TIMEOUT) {
|
||||
close(sn);
|
||||
return SOCKERR_TIMEOUT;
|
||||
}
|
||||
}
|
||||
}
|
||||
return SOCK_OK;
|
||||
}
|
||||
|
||||
int32_t send(uint8_t sn, uint8_t * buf, uint16_t len) {
|
||||
uint8_t tmp = 0;
|
||||
uint16_t freesize = 0;
|
||||
|
||||
freesize = getSn_TxMAX(sn);
|
||||
if (len > freesize) len = freesize;
|
||||
while (1) {
|
||||
freesize = (uint16_t)getSn_TX_FSR(sn);
|
||||
tmp = getSn_SR(sn);
|
||||
if ((tmp != SOCK_ESTABLISHED) && (tmp != SOCK_CLOSE_WAIT)) {
|
||||
if (tmp == SOCK_CLOSED) close(sn);
|
||||
return SOCKERR_SOCKSTATUS;
|
||||
}
|
||||
if ((sock_io_mode & (1 << sn)) && (len > freesize)) return SOCK_BUSY;
|
||||
if (len <= freesize) break;
|
||||
}
|
||||
wiz_send_data(sn, buf, len);
|
||||
if (sock_is_sending & (1 << sn)) {
|
||||
while (!(getSn_IR(sn) & Sn_IR_SENDOK)) {
|
||||
tmp = getSn_SR(sn);
|
||||
if ((tmp != SOCK_ESTABLISHED) && (tmp != SOCK_CLOSE_WAIT)) {
|
||||
if ((tmp == SOCK_CLOSED) || (getSn_IR(sn) & Sn_IR_TIMEOUT)) close(sn);
|
||||
return SOCKERR_SOCKSTATUS;
|
||||
}
|
||||
if (sock_io_mode & (1 << sn)) return SOCK_BUSY;
|
||||
}
|
||||
setSn_IR(sn, Sn_IR_SENDOK);
|
||||
}
|
||||
setSn_CR(sn, Sn_CR_SEND);
|
||||
while (getSn_CR(sn));
|
||||
sock_is_sending |= (1 << sn);
|
||||
return len;
|
||||
}
|
||||
|
||||
int32_t recv(uint8_t sn, uint8_t * buf, uint16_t len) {
|
||||
uint8_t tmp = 0;
|
||||
uint16_t recvsize = 0;
|
||||
|
||||
CHECK_SOCKNUM();
|
||||
CHECK_SOCKMODE(Sn_MR_TCP);
|
||||
CHECK_SOCKDATA();
|
||||
|
||||
recvsize = getSn_RxMAX(sn);
|
||||
if (recvsize < len) len = recvsize;
|
||||
|
||||
while (1) {
|
||||
recvsize = (uint16_t)getSn_RX_RSR(sn);
|
||||
tmp = getSn_SR(sn);
|
||||
if (tmp != SOCK_ESTABLISHED) {
|
||||
if (tmp == SOCK_CLOSE_WAIT) {
|
||||
if (recvsize != 0) break;
|
||||
else if (getSn_TX_FSR(sn) == getSn_TxMAX(sn)) {
|
||||
close(sn);
|
||||
return SOCKERR_SOCKSTATUS;
|
||||
}
|
||||
} else {
|
||||
close(sn);
|
||||
return SOCKERR_SOCKSTATUS;
|
||||
}
|
||||
}
|
||||
if (recvsize != 0) break;
|
||||
if (sock_io_mode & (1 << sn)) return SOCK_BUSY;
|
||||
};
|
||||
|
||||
if (recvsize < len) len = recvsize;
|
||||
wiz_recv_data(sn, buf, len);
|
||||
setSn_CR(sn, Sn_CR_RECV);
|
||||
while (getSn_CR(sn));
|
||||
return (int32_t)len;
|
||||
}
|
||||
|
||||
int32_t sendto_W6x00(uint8_t sn, uint8_t * buf, uint16_t len, uint8_t * addr, uint16_t port, uint8_t addrlen) {
|
||||
uint8_t tmp = 0;
|
||||
uint8_t tcmd = Sn_CR_SEND;
|
||||
uint16_t freesize = 0;
|
||||
|
||||
CHECK_SOCKNUM();
|
||||
switch (getSn_MR(sn) & 0x0F) {
|
||||
case Sn_MR_UDP:
|
||||
case Sn_MR_MACRAW:
|
||||
case Sn_MR_IPRAW:
|
||||
case Sn_MR_IPRAW6:
|
||||
break;
|
||||
default:
|
||||
return SOCKERR_SOCKMODE;
|
||||
}
|
||||
tmp = getSn_MR(sn);
|
||||
if (tmp != Sn_MR_MACRAW) {
|
||||
if (addrlen == 16) {
|
||||
if (tmp & 0x08) {
|
||||
setSn_DIP6R(sn, addr);
|
||||
tcmd = Sn_CR_SEND6;
|
||||
} else {
|
||||
return SOCKERR_SOCKMODE;
|
||||
}
|
||||
} else if (addrlen == 4) {
|
||||
if (tmp == Sn_MR_UDP6 || tmp == Sn_MR_IPRAW6) return SOCKERR_SOCKMODE;
|
||||
setSn_DIPR(sn, addr);
|
||||
tcmd = Sn_CR_SEND;
|
||||
} else {
|
||||
return SOCKERR_IPINVALID;
|
||||
}
|
||||
}
|
||||
if ((tmp & 0x03) == 0x02) {
|
||||
if (port) {
|
||||
setSn_DPORTR(sn, port);
|
||||
} else {
|
||||
return SOCKERR_PORTZERO;
|
||||
}
|
||||
}
|
||||
|
||||
freesize = getSn_TxMAX(sn);
|
||||
if (len > freesize) len = freesize;
|
||||
while (1) {
|
||||
freesize = getSn_TX_FSR(sn);
|
||||
if (getSn_SR(sn) == SOCK_CLOSED) return SOCKERR_SOCKCLOSED;
|
||||
if ((sock_io_mode & (1 << sn)) && (len > freesize)) return SOCK_BUSY;
|
||||
if (len <= freesize) break;
|
||||
};
|
||||
wiz_send_data(sn, buf, len);
|
||||
setSn_CR(sn, tcmd);
|
||||
while (getSn_CR(sn));
|
||||
while (1) {
|
||||
tmp = getSn_IR(sn);
|
||||
if (tmp & Sn_IR_SENDOK) {
|
||||
setSn_IR(sn, Sn_IR_SENDOK);
|
||||
break;
|
||||
} else if (tmp & Sn_IR_TIMEOUT) {
|
||||
setSn_IR(sn, Sn_IR_TIMEOUT);
|
||||
return SOCKERR_TIMEOUT;
|
||||
}
|
||||
}
|
||||
return (int32_t)len;
|
||||
}
|
||||
|
||||
int32_t recvfrom_W6x00(uint8_t sn, uint8_t * buf, uint16_t len, uint8_t * addr, uint16_t *port, uint8_t *addrlen) {
|
||||
uint8_t mr;
|
||||
uint8_t head[8];
|
||||
uint16_t pack_len = 0;
|
||||
|
||||
CHECK_SOCKNUM();
|
||||
CHECK_SOCKDATA();
|
||||
|
||||
switch ((mr = getSn_MR(sn)) & 0x0F) {
|
||||
case Sn_MR_UDP:
|
||||
case Sn_MR_IPRAW:
|
||||
case Sn_MR_IPRAW6:
|
||||
case Sn_MR_MACRAW:
|
||||
break;
|
||||
default:
|
||||
return SOCKERR_SOCKMODE;
|
||||
}
|
||||
|
||||
if (sock_remained_size[sn] == 0) {
|
||||
while (1) {
|
||||
pack_len = getSn_RX_RSR(sn);
|
||||
if (getSn_SR(sn) == SOCK_CLOSED) return SOCKERR_SOCKCLOSED;
|
||||
if (pack_len != 0) {
|
||||
sock_pack_info[sn] = PACK_NONE;
|
||||
break;
|
||||
}
|
||||
if (sock_io_mode & (1 << sn)) return SOCK_BUSY;
|
||||
};
|
||||
}
|
||||
|
||||
wiz_recv_data(sn, head, 2);
|
||||
setSn_CR(sn, Sn_CR_RECV);
|
||||
while (getSn_CR(sn));
|
||||
pack_len = head[0] & 0x07;
|
||||
pack_len = (pack_len << 8) + head[1];
|
||||
|
||||
switch (mr & 0x07) {
|
||||
case Sn_MR_UDP4:
|
||||
case Sn_MR_UDP6:
|
||||
case Sn_MR_UDPD:
|
||||
if (addr == 0) return SOCKERR_ARG;
|
||||
sock_pack_info[sn] = head[0] & 0xF8;
|
||||
if (sock_pack_info[sn] & PACK_IPv6) *addrlen = 16;
|
||||
else *addrlen = 4;
|
||||
wiz_recv_data(sn, addr, *addrlen);
|
||||
setSn_CR(sn, Sn_CR_RECV);
|
||||
while (getSn_CR(sn));
|
||||
break;
|
||||
case Sn_MR_MACRAW:
|
||||
if (sock_remained_size[sn] == 0) {
|
||||
sock_remained_size[sn] = head[0];
|
||||
sock_remained_size[sn] = (sock_remained_size[sn] << 8) + head[1] - 2;
|
||||
if (sock_remained_size[sn] > 1514) {
|
||||
close(sn);
|
||||
return SOCKFATAL_PACKLEN;
|
||||
}
|
||||
sock_pack_info[sn] = PACK_FIRST;
|
||||
}
|
||||
if (len < sock_remained_size[sn]) pack_len = len;
|
||||
else pack_len = sock_remained_size[sn];
|
||||
wiz_recv_data(sn, buf, pack_len);
|
||||
break;
|
||||
case Sn_MR_IPRAW6:
|
||||
case Sn_MR_IPRAW4:
|
||||
if (sock_remained_size[sn] == 0) {
|
||||
if (*addr == 0) return SOCKERR_ARG;
|
||||
sock_pack_info[sn] = head[0] & 0xF8;
|
||||
if (sock_pack_info[sn] & PACK_IPv6) *addrlen = 16;
|
||||
else *addrlen = 4;
|
||||
wiz_recv_data(sn, addr, *addrlen);
|
||||
setSn_CR(sn, Sn_CR_RECV);
|
||||
while (getSn_CR(sn));
|
||||
}
|
||||
break;
|
||||
default:
|
||||
wiz_recv_ignore(sn, pack_len);
|
||||
sock_remained_size[sn] = pack_len;
|
||||
break;
|
||||
}
|
||||
|
||||
sock_remained_size[sn] = pack_len;
|
||||
sock_pack_info[sn] |= PACK_FIRST;
|
||||
if ((getSn_MR(sn) & 0x03) == 0x02) {
|
||||
if (port == 0) return SOCKERR_ARG;
|
||||
wiz_recv_data(sn, head, 2);
|
||||
*port = (((uint16_t)head[0]) << 8) + head[1];
|
||||
setSn_CR(sn, Sn_CR_RECV);
|
||||
while (getSn_CR(sn));
|
||||
}
|
||||
|
||||
if (len < sock_remained_size[sn]) pack_len = len;
|
||||
else pack_len = sock_remained_size[sn];
|
||||
wiz_recv_data(sn, buf, pack_len);
|
||||
setSn_CR(sn, Sn_CR_RECV);
|
||||
while (getSn_CR(sn));
|
||||
|
||||
sock_remained_size[sn] -= pack_len;
|
||||
if (sock_remained_size[sn] != 0) sock_pack_info[sn] |= PACK_REMAINED;
|
||||
else sock_pack_info[sn] |= PACK_COMPLETED;
|
||||
|
||||
return (int32_t)pack_len;
|
||||
}
|
||||
|
||||
int8_t ctlsocket(uint8_t sn, ctlsock_type cstype, void* arg) {
|
||||
uint8_t tmp = 0;
|
||||
CHECK_SOCKNUM();
|
||||
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);
|
||||
else return SOCKERR_ARG;
|
||||
break;
|
||||
case CS_GET_IOMODE:
|
||||
*((uint8_t*)arg) = (uint8_t)((sock_io_mode >> sn) & 0x0001);
|
||||
break;
|
||||
case CS_GET_MAXTXBUF:
|
||||
*((uint16_t*)arg) = getSn_TxMAX(sn);
|
||||
break;
|
||||
case CS_GET_MAXRXBUF:
|
||||
*((uint16_t*)arg) = getSn_RxMAX(sn);
|
||||
break;
|
||||
case CS_CLR_INTERRUPT:
|
||||
if (tmp > SIK_ALL) return SOCKERR_ARG;
|
||||
setSn_IR(sn, tmp);
|
||||
break;
|
||||
case CS_GET_INTERRUPT:
|
||||
*((uint8_t*)arg) = getSn_IR(sn);
|
||||
break;
|
||||
case CS_SET_INTMASK:
|
||||
if (tmp > SIK_ALL) return SOCKERR_ARG;
|
||||
setSn_IMR(sn, tmp);
|
||||
break;
|
||||
case CS_GET_INTMASK:
|
||||
*((uint8_t*)arg) = getSn_IMR(sn);
|
||||
break;
|
||||
case CS_SET_PREFER:
|
||||
if ((tmp & 0x03) == 0x01) return SOCKERR_ARG;
|
||||
setSn_PSR(sn, tmp);
|
||||
break;
|
||||
case CS_GET_PREFER:
|
||||
*(uint8_t*)arg = getSn_PSR(sn);
|
||||
break;
|
||||
default:
|
||||
return SOCKERR_ARG;
|
||||
}
|
||||
return SOCK_OK;
|
||||
}
|
||||
|
||||
int8_t setsockopt(uint8_t sn, sockopt_type sotype, void* arg) {
|
||||
CHECK_SOCKNUM();
|
||||
switch (sotype) {
|
||||
case SO_TTL:
|
||||
setSn_TTL(sn, *(uint8_t*)arg);
|
||||
break;
|
||||
case SO_TOS:
|
||||
setSn_TOS(sn, *(uint8_t*)arg);
|
||||
break;
|
||||
case SO_MSS:
|
||||
setSn_MSSR(sn, *(uint16_t*)arg);
|
||||
break;
|
||||
case SO_DESTIP:
|
||||
if (((wiz_IPAddress *)arg)->len == 16) setSn_DIP6R(sn, ((wiz_IPAddress*)arg)->ip);
|
||||
else setSn_DIPR(sn, (uint8_t*)arg);
|
||||
break;
|
||||
case SO_DESTPORT:
|
||||
setSn_DPORTR(sn, *(uint16_t*)arg);
|
||||
break;
|
||||
case SO_KEEPALIVESEND:
|
||||
CHECK_TCPMODE();
|
||||
if (getSn_KPALVTR(sn) != 0) return SOCKERR_SOCKOPT;
|
||||
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);
|
||||
return SOCKERR_TIMEOUT;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case SO_KEEPALIVEAUTO:
|
||||
CHECK_TCPMODE();
|
||||
setSn_KPALVTR(sn, *(uint8_t*)arg);
|
||||
break;
|
||||
default:
|
||||
return SOCKERR_ARG;
|
||||
}
|
||||
return SOCK_OK;
|
||||
}
|
||||
|
||||
int8_t getsockopt(uint8_t sn, sockopt_type sotype, void* arg) {
|
||||
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));
|
||||
break;
|
||||
case SO_TTL:
|
||||
*(uint8_t*)arg = getSn_TTL(sn);
|
||||
break;
|
||||
case SO_TOS:
|
||||
*(uint8_t*)arg = getSn_TOS(sn);
|
||||
break;
|
||||
case SO_MSS:
|
||||
*(uint16_t*)arg = getSn_MSSR(sn);
|
||||
break;
|
||||
case SO_DESTIP:
|
||||
CHECK_TCPMODE();
|
||||
if (getSn_ESR(sn) & TCPSOCK_MODE) {
|
||||
getSn_DIP6R(sn, ((wiz_IPAddress*)arg)->ip);
|
||||
((wiz_IPAddress*)arg)->len = 16;
|
||||
} else {
|
||||
getSn_DIPR(sn, ((wiz_IPAddress*)arg)->ip);
|
||||
((wiz_IPAddress*)arg)->len = 4;
|
||||
}
|
||||
break;
|
||||
case SO_DESTPORT:
|
||||
*(uint16_t*)arg = getSn_DPORTR(sn);
|
||||
break;
|
||||
case SO_KEEPALIVEAUTO:
|
||||
CHECK_TCPMODE();
|
||||
*(uint16_t*)arg = getSn_KPALVTR(sn);
|
||||
break;
|
||||
case SO_SENDBUF:
|
||||
*(uint16_t*)arg = getSn_TX_FSR(sn);
|
||||
break;
|
||||
case SO_RECVBUF:
|
||||
*(uint16_t*)arg = getSn_RX_RSR(sn);
|
||||
break;
|
||||
case SO_STATUS:
|
||||
*(uint8_t*)arg = getSn_SR(sn);
|
||||
break;
|
||||
case SO_EXTSTATUS:
|
||||
CHECK_TCPMODE();
|
||||
*(uint8_t*)arg = getSn_ESR(sn) & 0x07;
|
||||
break;
|
||||
case SO_REMAINSIZE:
|
||||
if (getSn_MR(sn) == SOCK_CLOSED) return SOCKERR_SOCKSTATUS;
|
||||
if (getSn_MR(sn) & 0x01) *(uint16_t*)arg = getSn_RX_RSR(sn);
|
||||
else *(uint16_t*)arg = sock_remained_size[sn];
|
||||
break;
|
||||
case SO_PACKINFO:
|
||||
if (getSn_MR(sn) == SOCK_CLOSED) return SOCKERR_SOCKSTATUS;
|
||||
if (getSn_MR(sn) & 0x01) return SOCKERR_SOCKMODE;
|
||||
else *(uint8_t*)arg = sock_pack_info[sn];
|
||||
break;
|
||||
case SO_MODE:
|
||||
*(uint8_t*)arg = 0x0F & getSn_MR(sn);
|
||||
break;
|
||||
default:
|
||||
return SOCKERR_SOCKOPT;
|
||||
}
|
||||
return SOCK_OK;
|
||||
}
|
||||
|
||||
int16_t peeksockmsg(uint8_t sn, uint8_t* submsg, uint16_t subsize) {
|
||||
uint32_t rx_ptr = 0;
|
||||
uint16_t i = 0, sub_idx = 0;
|
||||
if ((getSn_RX_RSR(sn) > 0) && (subsize > 0)) {
|
||||
rx_ptr = ((uint32_t)getSn_RX_RD(sn) << 8) + WIZCHIP_RXBUF_BLOCK(sn);
|
||||
sub_idx = 0;
|
||||
for (i = 0; i < getSn_RX_RSR(sn); i++) {
|
||||
if (WIZCHIP_READ(rx_ptr) == submsg[sub_idx]) {
|
||||
sub_idx++;
|
||||
if (sub_idx == subsize) return (i + 1 - sub_idx);
|
||||
} else {
|
||||
sub_idx = 0;
|
||||
}
|
||||
rx_ptr = WIZCHIP_OFFSET_INC(rx_ptr, 1);
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user