summaryrefslogtreecommitdiff
path: root/fw/fe310/eos/dev/net.c
diff options
context:
space:
mode:
Diffstat (limited to 'fw/fe310/eos/dev/net.c')
-rw-r--r--fw/fe310/eos/dev/net.c384
1 files changed, 227 insertions, 157 deletions
diff --git a/fw/fe310/eos/dev/net.c b/fw/fe310/eos/dev/net.c
index c8b90f3..c1fd9b5 100644
--- a/fw/fe310/eos/dev/net.c
+++ b/fw/fe310/eos/dev/net.c
@@ -6,6 +6,7 @@
#include "board.h"
#include "eos.h"
+#include "log.h"
#include "msgq.h"
#include "event.h"
@@ -16,17 +17,27 @@
#include "soc/spi_priv.h"
#include "spi.h"
+#include "aon.h"
#include "net.h"
-#define NET_SIZE_HDR 3
-#define NET_STATE_FLAG_RUN 0x01
-#define NET_STATE_FLAG_INIT 0x02
-#define NET_STATE_FLAG_XCHG 0x04
-#define NET_STATE_FLAG_ONEW 0x10
-#define NET_STATE_FLAG_SYNC 0x20
-#define NET_STATE_FLAG_RTS 0x40
-#define NET_STATE_FLAG_CTS 0x80
+#define NET_DETECT_TIMEOUT 1000
+
+#define NET_SIZE_HDR 3
+#define NET_STATE_FLAG_RUN 0x0001
+#define NET_STATE_FLAG_INIT 0x0002
+#define NET_STATE_FLAG_XCHG 0x0004
+#define NET_STATE_FLAG_ONEW 0x0010
+#define NET_STATE_FLAG_SYNC 0x0020
+#define NET_STATE_FLAG_RTS 0x0040
+#define NET_STATE_FLAG_CTS 0x0080
+#define NET_STATE_FLAG_SLEEP 0x0100
+#define NET_STATE_FLAG_SLEEP_REQ 0x0200
+#define NET_STATE_FLAG_ABSENT 0x0400
+
+#define NET_FLAG_MORE 0x01
+#define NET_FLAG_SYNC 0x02
+#define NET_FLAG_REPL 0x04
#define MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
#define MAX(X, Y) (((X) > (Y)) ? (X) : (Y))
@@ -38,7 +49,7 @@ static unsigned char net_bufq_buffer[EOS_NET_SIZE_BUFQ][EOS_NET_SIZE_BUF] __attr
static EOSMsgQ net_send_q;
static EOSMsgItem net_sndq_array[EOS_NET_SIZE_BUFQ];
-static volatile uint8_t net_state_flags = 0;
+static volatile uint16_t net_state_flags = 0;
static volatile unsigned char net_state_type = 0;
static uint32_t net_state_len_tx = 0;
static volatile uint32_t net_state_len_rx = 0;
@@ -48,40 +59,35 @@ static volatile uint8_t net_state_next_cnt = 0;
static unsigned char * volatile net_state_next_buf = NULL;
static eos_evt_handler_t net_handler[EOS_NET_MAX_MTYPE];
-static uint16_t net_wrapper_acq[EOS_EVT_MAX_EVT];
-static uint16_t net_flags_acq[EOS_EVT_MAX_EVT];
+static uint16_t net_wrapper_acq;
+static uint16_t net_flags_acq[EOS_EVT_MAX];
-static int net_xchg_sleep(void) {
- int i;
- int rv = EOS_OK;
+static void net_xchg_reset(void) {
volatile uint32_t x = 0;
+
net_state_flags &= ~NET_STATE_FLAG_CTS;
SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_HOLD;
- SPI1_REG(SPI_REG_TXFIFO) = 0xFF;
+ SPI1_REG(SPI_REG_TXFIFO) = 0;
while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
- if (x & 0xFF) rv = EOS_ERR_BUSY;
-
- for (i=0; i<7; i++) {
- while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
- SPI1_REG(SPI_REG_TXFIFO) = 0;
- while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
- }
SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_AUTO;
-
- return rv;
}
-static void net_xchg_wake(void) {
- int i;
+static void net_xchg_sleep_req(void) {
volatile uint32_t x = 0;
+ int i;
+
net_state_flags &= ~NET_STATE_FLAG_CTS;
SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_HOLD;
- for (i=0; i<8; i++) {
+ SPI1_REG(SPI_REG_TXFIFO) = EOS_NET_MTYPE_SLEEP | EOS_NET_MTYPE_FLAG_ONEW;
+ while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+
+ /* minimum 8 bytes for esp32 */
+ for (i=0; i<7; i++) {
while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
SPI1_REG(SPI_REG_TXFIFO) = 0;
while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
@@ -90,18 +96,6 @@ static void net_xchg_wake(void) {
SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_AUTO;
}
-static void net_xchg_reset(void) {
- volatile uint32_t x = 0;
- net_state_flags &= ~NET_STATE_FLAG_CTS;
-
- SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_HOLD;
-
- SPI1_REG(SPI_REG_TXFIFO) = 0;
- while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
-
- SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_AUTO;
-}
-
static void net_xchg_start(unsigned char type, unsigned char *buffer, uint16_t len) {
net_state_flags &= ~NET_STATE_FLAG_CTS;
net_state_flags |= (NET_STATE_FLAG_INIT | NET_STATE_FLAG_XCHG);
@@ -126,7 +120,7 @@ static int net_xchg_next(unsigned char *_buffer) {
unsigned char type;
unsigned char *buffer = NULL;
uint16_t len;
- int ret = _buffer ? 1 : 0;
+ int do_release = _buffer ? 1 : 0;
eos_msgq_pop(&net_send_q, &type, &buffer, &len);
if (type) {
@@ -134,14 +128,14 @@ static int net_xchg_next(unsigned char *_buffer) {
} else if (net_state_flags & NET_STATE_FLAG_RTS) {
if (_buffer) {
buffer = _buffer;
- ret = 0;
+ do_release = 0;
} else {
buffer = eos_bufq_pop(&net_buf_q);
}
if (buffer) net_xchg_start(0, buffer, 0);
}
- return ret;
+ return do_release;
}
static void net_handle_xchg(void) {
@@ -161,7 +155,7 @@ static void net_handle_xchg(void) {
r3 = 0;
}
- net_state_type = (r1 & 0xFF);
+ net_state_type = (r1 & EOS_NET_MTYPE_MASK);
net_state_len_rx = (r2 & 0xFF) << 8;
net_state_len_rx |= (r3 & 0xFF);
len = MAX(net_state_len_tx, net_state_len_rx);
@@ -190,8 +184,18 @@ static void net_handle_xchg(void) {
if (SPI1_REG(SPI_REG_CSMODE) == SPI_CSMODE_AUTO) { // exchange done
if (!(net_state_flags & NET_STATE_FLAG_SYNC)) {
if (net_state_type) {
- int r = eos_evtq_push_isr(EOS_EVT_NET | (net_state_type & ~EOS_NET_MTYPE_FLAG_MASK), net_state_buf, net_state_len_rx);
- if (r) eos_bufq_push(&net_buf_q, net_state_buf);
+ if (net_state_type == EOS_NET_MTYPE_SLEEP) {
+ net_state_flags |= NET_STATE_FLAG_SLEEP;
+ eos_bufq_push(&net_buf_q, net_state_buf);
+ } else {
+ int rv;
+
+ rv = eos_evtq_push_isr(EOS_EVT_NET | (net_state_type & ~EOS_EVT_MASK), net_state_buf, net_state_len_rx);
+ if (rv) {
+ EOS_LOG(EOS_LOG_ERR, "NET XCHG EVTQ PUSH ERR:%d\n", rv);
+ eos_bufq_push(&net_buf_q, net_state_buf);
+ }
+ }
} else if (((net_state_flags & NET_STATE_FLAG_ONEW) || net_state_next_cnt) && (net_state_next_buf == NULL)) {
net_state_next_buf = net_state_buf;
} else {
@@ -203,8 +207,9 @@ static void net_handle_xchg(void) {
}
static void net_handle_cts(void) {
- GPIO_REG(GPIO_RISE_IP) = (1 << NET_PIN_CTS);
+ GPIO_REG(GPIO_FALL_IP) = (1 << NET_PIN_CTS);
net_state_flags |= NET_STATE_FLAG_CTS;
+ net_state_flags &= ~NET_STATE_FLAG_SLEEP;
if (net_state_flags & NET_STATE_FLAG_RUN) {
net_xchg_next(NULL);
@@ -214,23 +219,24 @@ static void net_handle_cts(void) {
static void net_handle_rts(void) {
uint32_t rts_offset = (1 << NET_PIN_RTS);
- if (GPIO_REG(GPIO_RISE_IP) & rts_offset) {
- GPIO_REG(GPIO_RISE_IP) = rts_offset;
+ if (GPIO_REG(GPIO_FALL_IP) & rts_offset) {
+ GPIO_REG(GPIO_FALL_IP) = rts_offset;
net_state_flags |= NET_STATE_FLAG_RTS;
if ((net_state_flags & NET_STATE_FLAG_RUN) && (net_state_flags & NET_STATE_FLAG_CTS)) {
net_xchg_reset();
}
- } else if (GPIO_REG(GPIO_FALL_IP) & rts_offset) {
- GPIO_REG(GPIO_FALL_IP) = rts_offset;
+ }
+ if (GPIO_REG(GPIO_RISE_IP) & rts_offset) {
+ GPIO_REG(GPIO_RISE_IP) = rts_offset;
net_state_flags &= ~NET_STATE_FLAG_RTS;
}
}
static void net_handle_evt(unsigned char type, unsigned char *buffer, uint16_t len) {
- unsigned char idx = (type & ~EOS_EVT_MASK) - 1;
+ unsigned char idx = (type & ~EOS_EVT_MASK);
- if (idx < EOS_NET_MAX_MTYPE) {
- net_handler[idx](type, buffer, len);
+ if (idx && (idx <= EOS_NET_MAX_MTYPE)) {
+ net_handler[idx - 1](type, buffer, len);
} else {
eos_net_bad_handler(type, buffer, len);
}
@@ -262,29 +268,35 @@ static int net_acquire(unsigned char reserved) {
return ret;
}
-static void evt_handler_wrapper(unsigned char type, unsigned char *buffer, uint16_t len, unsigned char idx, uint16_t flag) {
- int ok;
+static void evt_handler_wrapper(unsigned char type, unsigned char *buffer, uint16_t len, uint8_t idx) {
+ uint16_t flag = (uint16_t)1 << idx;
+ int rv;
- ok = net_acquire(net_wrapper_acq[idx] & flag);
- if (ok) {
+ rv = net_acquire(net_wrapper_acq & flag);
+ if (rv) {
eos_evtq_get_handler(type)(type, buffer, len);
eos_net_release();
- net_wrapper_acq[idx] &= ~flag;
+ net_wrapper_acq &= ~flag;
} else {
- net_wrapper_acq[idx] |= flag;
- eos_evtq_push(type, buffer, len);
+ rv = eos_evtq_push_widx(type, buffer, len, &idx);
+ if (rv) {
+ EOS_LOG(EOS_LOG_ERR, "NET WRAPPER EVTQ PUSH ERR:%d\n", rv);
+ return;
+ }
+ flag = (uint16_t)1 << idx;
+ net_wrapper_acq |= flag;
}
}
-static void evt_handler(unsigned char type, unsigned char *buffer, uint16_t len) {
+static void evt_handler(unsigned char type, unsigned char *buffer, uint16_t len, uint8_t _idx) {
unsigned char idx = (type & EOS_EVT_MASK) >> 4;
- if (idx && (idx <= EOS_EVT_MAX_EVT)) {
+ if (idx && (idx <= EOS_EVT_MAX)) {
uint16_t flag = (uint16_t)1 << (type & ~EOS_EVT_MASK);
idx--;
if (flag & net_flags_acq[idx]) {
- evt_handler_wrapper(type, buffer, len, idx, flag);
+ evt_handler_wrapper(type, buffer, len, _idx);
} else {
eos_evtq_get_handler(type)(type, buffer, len);
}
@@ -293,6 +305,14 @@ static void evt_handler(unsigned char type, unsigned char *buffer, uint16_t len)
}
}
+static void net_flushq(void) {
+ while (eos_msgq_len(&net_send_q)) {
+ asm volatile ("wfi");
+ set_csr(mstatus, MSTATUS_MIE);
+ clear_csr(mstatus, MSTATUS_MIE);
+ }
+}
+
static void net_wait4xchg(void) {
while (net_state_flags & NET_STATE_FLAG_XCHG) {
asm volatile ("wfi");
@@ -309,12 +329,47 @@ static void net_wait4cts(void) {
}
}
+static void net_wake(void) {
+ while (net_state_flags & NET_STATE_FLAG_SLEEP) {
+ net_xchg_reset();
+ eos_sleep(10);
+ set_csr(mstatus, MSTATUS_MIE);
+ clear_csr(mstatus, MSTATUS_MIE);
+ }
+}
+
+static int net_select(int *dsel) {
+ *dsel = 0;
+ if (net_state_flags & NET_STATE_FLAG_ABSENT) return EOS_ERR_NOTFOUND;
+ if (net_state_flags & NET_STATE_FLAG_SLEEP_REQ) return EOS_ERR_BUSY;
+
+ if (!(net_state_flags & NET_STATE_FLAG_RUN)) {
+ int rv;
+
+ set_csr(mstatus, MSTATUS_MIE);
+ rv = eos_spi_select(EOS_SPI_DEV_NET);
+ clear_csr(mstatus, MSTATUS_MIE);
+ if (rv) return rv;
+ *dsel = 1;
+ }
+ /* wake up remote if sleeping */
+ net_wake();
+
+ return EOS_OK;
+}
+
+static void net_deselect(void) {
+ eos_spi_deselect();
+}
+
static void net_pause(void) {
net_state_flags &= ~NET_STATE_FLAG_RUN;
net_wait4xchg();
}
static void net_resume(void) {
+ if (net_state_flags & NET_STATE_FLAG_ABSENT) return;
+
net_state_flags |= NET_STATE_FLAG_RUN;
if (net_state_flags & NET_STATE_FLAG_CTS) {
net_xchg_next(NULL);
@@ -342,50 +397,69 @@ int eos_net_init(void) {
for (i=0; i<EOS_NET_MAX_MTYPE; i++) {
net_handler[i] = eos_net_bad_handler;
}
- eos_evtq_set_handler(0, evt_handler);
+ eos_evtq_set_handler_global(evt_handler);
eos_evtq_set_handler(EOS_EVT_NET, net_handle_evt);
+ GPIO_REG(GPIO_PULLUP_EN) |= (1 << NET_PIN_CTS);
GPIO_REG(GPIO_INPUT_EN) |= (1 << NET_PIN_CTS);
- GPIO_REG(GPIO_RISE_IE) |= (1 << NET_PIN_CTS);
+ GPIO_REG(GPIO_FALL_IE) |= (1 << NET_PIN_CTS);
eos_intr_set(INT_GPIO_BASE + NET_PIN_CTS, IRQ_PRIORITY_NET_CTS, net_handle_cts);
+ /* XXX: pull-up not needed for new board */
+ GPIO_REG(GPIO_PULLUP_EN) |= (1 << NET_PIN_RTS);
GPIO_REG(GPIO_INPUT_EN) |= (1 << NET_PIN_RTS);
GPIO_REG(GPIO_RISE_IE) |= (1 << NET_PIN_RTS);
GPIO_REG(GPIO_FALL_IE) |= (1 << NET_PIN_RTS);
eos_intr_set(INT_GPIO_BASE + NET_PIN_RTS, IRQ_PRIORITY_NET_RTS, net_handle_rts);
- /* set initial state */
- clear_csr(mstatus, MSTATUS_MIE);
- if (GPIO_REG(GPIO_INPUT_VAL) & (1 << NET_PIN_CTS)) net_state_flags |= NET_STATE_FLAG_CTS;
- if (GPIO_REG(GPIO_INPUT_VAL) & (1 << NET_PIN_RTS)) net_state_flags |= NET_STATE_FLAG_RTS;
- set_csr(mstatus, MSTATUS_MIE);
-
return EOS_OK;
}
int eos_net_run(void) {
uint8_t wakeup_cause;
+ int rv;
+ rv = EOS_OK;
net_start();
wakeup_cause = eos_pwr_wakeup_cause();
+
clear_csr(mstatus, MSTATUS_MIE);
- if (wakeup_cause != EOS_PWR_WAKE_RST) {
- if (wakeup_cause != EOS_PWR_WAKE_PIN) {
- net_xchg_wake();
- }
- if (!(net_state_flags & NET_STATE_FLAG_CTS)) {
- while (!(GPIO_REG(GPIO_RISE_IP) & (1 << NET_PIN_CTS))) {
- asm volatile ("wfi");
+ if (wakeup_cause == EOS_PWR_WAKE_RST) {
+ uint32_t start, timeout;
+
+ start = eos_get_tick();
+ timeout = NET_DETECT_TIMEOUT;
+ while (GPIO_REG(GPIO_INPUT_VAL) & (1 << NET_PIN_CTS)) {
+ if (timeout && (eos_tdelta_ms(start) > timeout)) {
+ rv = EOS_ERR_NOTFOUND;
+ break;
}
- GPIO_REG(GPIO_RISE_IP) = (1 << NET_PIN_CTS);
}
- net_xchg_reset();
+ if (!rv) {
+ GPIO_REG(GPIO_PULLUP_EN) &= ~(1 << NET_PIN_CTS);
+ } else {
+ net_state_flags |= NET_STATE_FLAG_ABSENT;
+ EOS_LOG(EOS_LOG_ERR, "NET DEVICE ABSENT\n");
+ }
+ } else {
+ if (eos_aon_load4net()) {
+ /* device previously declared as absent */
+ net_state_flags |= NET_STATE_FLAG_ABSENT;
+ } else if (!(net_state_flags & NET_STATE_FLAG_CTS)) {
+ /* will assume that remote device is sleeping */
+ net_state_flags |= NET_STATE_FLAG_SLEEP;
+ }
+ }
+ if (!rv) {
+ /* set initial state */
+ if (!(GPIO_REG(GPIO_INPUT_VAL) & (1 << NET_PIN_CTS))) net_state_flags |= NET_STATE_FLAG_CTS;
+ if (!(GPIO_REG(GPIO_INPUT_VAL) & (1 << NET_PIN_RTS))) net_state_flags |= NET_STATE_FLAG_RTS;
+ net_resume();
}
- net_resume();
set_csr(mstatus, MSTATUS_MIE);
- return EOS_OK;
+ return rv;
}
void eos_net_start(void) {
@@ -404,47 +478,51 @@ void eos_net_stop(void) {
net_stop();
}
-int eos_net_sleep(uint32_t timeout) {
- uint32_t start;
- uint8_t done = 0;
- int rv = EOS_OK;
+int eos_net_sleep(void) {
+ int dsel = 0;
+ int rv;
clear_csr(mstatus, MSTATUS_MIE);
- if (!(net_state_flags & NET_STATE_FLAG_RUN)) rv = EOS_ERR;
+ rv = net_select(&dsel);
+ if (rv) {
+ set_csr(mstatus, MSTATUS_MIE);
+ return rv;
+ }
+ net_state_flags |= NET_STATE_FLAG_SLEEP_REQ;
+ net_flushq();
+ net_pause();
+ net_wait4cts();
+ net_xchg_sleep_req();
+ net_resume();
set_csr(mstatus, MSTATUS_MIE);
+ if (dsel) net_deselect();
- if (rv) return rv;
+ return EOS_OK;
+}
- start = eos_get_tick();
- do {
- if (eos_tdelta_ms(start) > timeout) return EOS_ERR_TIMEOUT;
- clear_csr(mstatus, MSTATUS_MIE);
- eos_evtq_flush_isr();
- done = (eos_msgq_len(&net_send_q) == 0);
- done = done && (!(net_state_flags & NET_STATE_FLAG_RTS) && (net_state_flags & NET_STATE_FLAG_CTS));
- if (done) done = (net_xchg_sleep() == EOS_OK);
- if (!done) {
- asm volatile ("wfi");
- set_csr(mstatus, MSTATUS_MIE);
- }
- } while (!done);
+int eos_net_sleep_rdy(void) {
+ int rv;
- while (!(GPIO_REG(GPIO_RISE_IP) & (1 << NET_PIN_CTS))) {
- if (eos_tdelta_ms(start) > timeout) {
- rv = EOS_ERR_TIMEOUT;
- break;
- }
- asm volatile ("wfi");
- }
+ clear_csr(mstatus, MSTATUS_MIE);
+ rv = !!(net_state_flags & NET_STATE_FLAG_SLEEP);
+ set_csr(mstatus, MSTATUS_MIE);
- if (!rv) {
- GPIO_REG(GPIO_RISE_IP) = (1 << NET_PIN_CTS);
- net_state_flags &= ~NET_STATE_FLAG_RUN;
- }
+ return rv;
+}
+void eos_net_wake(void) {
+ clear_csr(mstatus, MSTATUS_MIE);
+ net_state_flags &= ~NET_STATE_FLAG_SLEEP_REQ;
set_csr(mstatus, MSTATUS_MIE);
+}
- return rv;
+void eos_net_save2aon(void) {
+ int absent;
+
+ clear_csr(mstatus, MSTATUS_MIE);
+ absent = !!(net_state_flags & NET_STATE_FLAG_ABSENT);
+ set_csr(mstatus, MSTATUS_MIE);
+ eos_aon_save4net(absent);
}
void eos_net_bad_handler(unsigned char type, unsigned char *buffer, uint16_t len) {
@@ -461,7 +539,7 @@ void eos_net_acquire_for_evt(unsigned char type, char acq) {
unsigned char idx = (type & EOS_EVT_MASK) >> 4;
uint16_t flag = type & ~EOS_EVT_MASK ? (uint16_t)1 << (type & ~EOS_EVT_MASK) : 0xFFFF;
- if (idx && (idx <= EOS_EVT_MAX_EVT)) {
+ if (idx && (idx <= EOS_EVT_MAX)) {
idx--;
net_flags_acq[idx] &= ~flag;
if (acq) net_flags_acq[idx] |= flag;
@@ -483,12 +561,12 @@ void eos_net_release(void) {
}
unsigned char *eos_net_alloc(void) {
- unsigned char *ret = NULL;
+ unsigned char *rv = NULL;
- while (ret == NULL) {
+ while (rv == NULL) {
clear_csr(mstatus, MSTATUS_MIE);
if (net_state_next_buf) {
- ret = net_state_next_buf;
+ rv = net_state_next_buf;
net_state_next_buf = NULL;
} else {
asm volatile ("wfi");
@@ -496,7 +574,7 @@ unsigned char *eos_net_alloc(void) {
set_csr(mstatus, MSTATUS_MIE);
}
- return ret;
+ return rv;
}
void eos_net_free(unsigned char *buffer, unsigned char more) {
@@ -519,79 +597,71 @@ void eos_net_free(unsigned char *buffer, unsigned char more) {
static int net_xchg(unsigned char *type, unsigned char *buffer, uint16_t *len, unsigned char flags) {
int rv = EOS_OK;
int sync = 0, dsel = 0;
- unsigned char _type = *type;
+ unsigned char _type = *type & EOS_NET_MTYPE_MASK;
uint16_t _len = *len;
- if (flags & EOS_NET_FLAG_ONEW) _type |= EOS_NET_MTYPE_FLAG_ONEW;
- if (flags & EOS_NET_FLAG_REPL) _type |= EOS_NET_MTYPE_FLAG_REPL;
- if (flags & EOS_NET_FLAG_SYNC) sync = 1;
+ if (flags & NET_FLAG_MORE) _type |= EOS_NET_MTYPE_FLAG_ONEW;
+ if (flags & NET_FLAG_REPL) _type |= EOS_NET_MTYPE_FLAG_REPL;
+ if (flags & NET_FLAG_SYNC) sync = 1;
clear_csr(mstatus, MSTATUS_MIE);
- if ((flags & EOS_NET_FLAG_ONEW) && !(net_state_flags & NET_STATE_FLAG_RUN)) sync = 1;
-
- if (sync && !(net_state_flags & NET_STATE_FLAG_RUN)) {
+ rv = net_select(&dsel);
+ if (rv) {
set_csr(mstatus, MSTATUS_MIE);
-
- rv = eos_spi_select(EOS_SPI_DEV_NET);
- if (rv) return rv;
-
- dsel = 1;
- clear_csr(mstatus, MSTATUS_MIE);
+ return rv;
}
+ if (dsel) sync = 1;
if (sync) {
+ _type |= EOS_NET_MTYPE_FLAG_ONEW;
net_pause();
net_wait4cts();
- if (flags & EOS_NET_FLAG_SYNC) {
- net_state_flags |= NET_STATE_FLAG_SYNC;
- }
+ net_state_flags |= NET_STATE_FLAG_SYNC;
net_xchg_start(_type, buffer, _len);
- if (flags & EOS_NET_FLAG_SYNC) {
- if (flags & EOS_NET_FLAG_REPL) {
- net_wait4cts();
- net_xchg_start(0, buffer, 0);
- }
- net_wait4xchg();
- net_state_flags &= ~NET_STATE_FLAG_SYNC;
- *type = (net_state_type & ~EOS_NET_MTYPE_FLAG_MASK);
- *len = net_state_len_rx;
+ if (flags & NET_FLAG_REPL) {
+ net_wait4cts();
+ net_xchg_start(0, buffer, 0);
}
+ net_wait4xchg();
+ net_state_flags &= ~NET_STATE_FLAG_SYNC;
+ *type = net_state_type & EOS_NET_MTYPE_MASK;
+ *len = net_state_len_rx;
net_resume();
} else {
if ((net_state_flags & NET_STATE_FLAG_RUN) && (net_state_flags & NET_STATE_FLAG_CTS)) {
net_xchg_start(_type, buffer, _len);
} else {
rv = eos_msgq_push(&net_send_q, _type, buffer, _len);
- if (rv) eos_bufq_push(&net_buf_q, buffer);
}
}
set_csr(mstatus, MSTATUS_MIE);
- if (dsel) eos_spi_deselect();
+ if (sync && !(flags & NET_FLAG_SYNC)) eos_net_free(buffer, !!(flags & NET_FLAG_MORE));
+ if (dsel) net_deselect();
return rv;
}
-int eos_net_xchg(unsigned char *type, unsigned char *buffer, uint16_t *len) {
- return net_xchg(type, buffer, len, (EOS_NET_FLAG_ONEW | EOS_NET_FLAG_SYNC | EOS_NET_FLAG_REPL));
-}
-
-int eos_net_send(unsigned char type, unsigned char *buffer, uint16_t len) {
- return net_xchg(&type, buffer, &len, (EOS_NET_FLAG_ONEW | EOS_NET_FLAG_SYNC));
-}
-
-int eos_net_send_async(unsigned char type, unsigned char *buffer, uint16_t len, unsigned char more) {
+int eos_net_send(unsigned char type, unsigned char *buffer, uint16_t len, unsigned char more) {
int rv;
- rv = net_xchg(&type, buffer, &len, more ? EOS_NET_FLAG_ONEW : 0);
+ rv = net_xchg(&type, buffer, &len, more ? NET_FLAG_MORE : 0);
if (rv) eos_net_free(buffer, more);
return rv;
}
+int eos_net_send_sync(unsigned char type, unsigned char *buffer, uint16_t len) {
+ return net_xchg(&type, buffer, &len, NET_FLAG_SYNC);
+}
+
+int eos_net_xchg(unsigned char *type, unsigned char *buffer, uint16_t *len) {
+ return net_xchg(type, buffer, len, (NET_FLAG_SYNC | NET_FLAG_REPL));
+}
+
int _eos_net_send(unsigned char type, unsigned char *buffer, uint16_t len, unsigned char async, unsigned char more) {
if (async) {
- return eos_net_send_async(type, buffer, len, more);
+ return eos_net_send(type, buffer, len, more);
} else {
- return eos_net_send(type, buffer, len);
+ return eos_net_send_sync(type, buffer, len);
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-31 22:03:38 +0000