introduced EOSMessage struct for SPI and Event queue messages; added APP <-> FE310 bridge SPI messages; LCD/touch panel driver for app module; save relevant state to AON module before sleep;

17 files changed, 464 insertions, 225 deletions

diff --git a/fw/fe310/eos/dev/aon.c b/fw/fe310/eos/dev/aon.c
index 7e4f5ec..abf75d3 100644
--- a/fw/fe310/eos/dev/aon.c
+++ b/fw/fe310/eos/dev/aon.c
@@ -7,24 +7,62 @@
 #include "aon.h"
 
 #define AON_EVE_REG         0
-#define AON_EVE_MASK        0x03
-
 #define AON_NET_REG         0
-#define AON_NET_MASK        0x04
+#define AON_APP_REG         0
+
+#define AON_EVE_PWM_MASK    0x000000FF
+#define AON_EVE_PWR_MASK    0x00000300
+#define AON_EVE_LCD_MASK    0x00000400
+#define AON_NET_MASK        0x00000800
+#define AON_APP_MASK        0x00001000
+
+void eos_aon_save4eve_pwm(uint8_t brightness) {
+    uint32_t reg;
+
+    reg = eos_aon_get_reg(AON_EVE_REG);
+    reg &= ~AON_EVE_PWM_MASK;
+    reg |= brightness;
+
+    eos_aon_set_reg(AON_EVE_REG, reg);
+}
+
+uint8_t eos_aon_load4eve_pwm(void) {
+    uint32_t reg;
+
+    reg = eos_aon_get_reg(AON_EVE_REG) & AON_EVE_PWM_MASK;
+    return reg;
+}
+
+void eos_aon_save4eve_pwr(uint8_t power_state) {
+    uint32_t reg;
+
+    reg = eos_aon_get_reg(AON_EVE_REG);
+    reg &= ~AON_EVE_PWR_MASK;
+    reg |= ((uint32_t)power_state << 8) & AON_EVE_PWR_MASK;
+
+    eos_aon_set_reg(AON_EVE_REG, reg);
+}
+
+uint8_t eos_aon_load4eve_pwr(void) {
+    uint32_t reg;
+
+    reg = eos_aon_get_reg(AON_EVE_REG) & AON_EVE_PWR_MASK;
+    reg = reg >> 8;
+    return reg;
+}
 
-void eos_aon_save4eve(uint8_t power_state) {
+void eos_aon_save4eve_lcd(int absent) {
     uint32_t reg;
 
-    power_state &= AON_EVE_MASK;
     reg = eos_aon_get_reg(AON_EVE_REG);
-    reg &= ~AON_EVE_MASK;
-    reg |= power_state;
+    reg &= ~AON_EVE_LCD_MASK;
+    if (absent) reg |= AON_EVE_LCD_MASK;
 
     eos_aon_set_reg(AON_EVE_REG, reg);
 }
 
-uint8_t eos_aon_load4eve(void) {
-    return (eos_aon_get_reg(AON_EVE_REG) & AON_EVE_MASK);
+int eos_aon_load4eve_lcd(void) {
+    return !!(eos_aon_get_reg(AON_EVE_REG) & AON_EVE_LCD_MASK);
 }
 
 void eos_aon_save4net(int absent) {
@@ -39,4 +77,19 @@ void eos_aon_save4net(int absent) {
 
 int eos_aon_load4net(void) {
     return !!(eos_aon_get_reg(AON_NET_REG) & AON_NET_MASK);
+}
+
+void eos_aon_save4app(int ctp_sel) {
+    uint32_t reg;
+
+    reg = eos_aon_get_reg(AON_APP_REG);
+    reg &= ~AON_APP_MASK;
+    if (ctp_sel) reg |= AON_APP_MASK;
+
+    eos_aon_set_reg(AON_APP_REG, reg);
+
+}
+
+int eos_aon_load4app(void) {
+    return !!(eos_aon_get_reg(AON_APP_REG) & AON_APP_MASK);
 }
\ No newline at end of file
diff --git a/fw/fe310/eos/dev/aon.h b/fw/fe310/eos/dev/aon.h
index 4551cc0..eb3953c 100644
--- a/fw/fe310/eos/dev/aon.h
+++ b/fw/fe310/eos/dev/aon.h
@@ -1,7 +1,16 @@
 #include <stdint.h>
 
-void eos_aon_save4eve(uint8_t power_state);
-uint8_t eos_aon_load4eve(void);
+void eos_aon_save4eve_pwm(uint8_t brightness);
+uint8_t eos_aon_load4eve_pwm(void);
+
+void eos_aon_save4eve_pwr(uint8_t power_state);
+uint8_t eos_aon_load4eve_pwr(void);
+
+void eos_aon_save4eve_lcd(int absent);
+int eos_aon_load4eve_lcd(void);
 
 void eos_aon_save4net(int absent);
-int eos_aon_load4net(void);
\ No newline at end of file
+int eos_aon_load4net(void);
+
+void eos_aon_save4app(int ctp_sel);
+int eos_aon_load4app(void);
\ No newline at end of file
diff --git a/fw/fe310/eos/dev/app.c b/fw/fe310/eos/dev/app.c
index ce2cf05..4c6b7cd 100644
--- a/fw/fe310/eos/dev/app.c
+++ b/fw/fe310/eos/dev/app.c
@@ -4,7 +4,18 @@
 #include "eos.h"
 #include "log.h"
 
+#include "eve/eve.h"
+#include "eve/eve_touch_engine.h"
+
+#include "egpio.h"
+#include "egpio_priv.h"
+#include "eve.h"
+
+#include "aon.h"
+#include "ctp.h"
+#include "lcd.h"
 #include "hpamp.h"
+
 #include "app.h"
 
 void eos_app_hp_change(int hp_det) {
@@ -18,3 +29,86 @@ void eos_app_hp_change(int hp_det) {
         }
     }
 }
+
+int eos_app_give(void) {
+    int rv, _rv;
+
+    if (!eos_egpio_get_val(EGPIO_PIN_DISP_SEL)) return EOS_ERR;
+
+    eos_aon_save4app(eos_egpio_get_val(EGPIO_PIN_CTP_SEL));
+
+    rv = eos_egpio_intr_disable();
+    if (rv) return rv;
+
+    rv = eve_select();
+    if (rv) goto app_give_err_select;
+
+    _eos_eve_sleep();
+
+    rv = eos_lcd_give();
+    if (rv) goto app_give_err;
+
+    rv = eos_egpio_set_val(EGPIO_PIN_CTP_SEL, 0);
+    if (rv) goto app_give_err;
+
+    rv = eos_egpio_set_val(EGPIO_PIN_DISP_SEL, 0);
+    if (rv) goto app_give_err;
+
+    eve_pwr_sleep();
+
+app_give_err:
+    if (rv) _eos_eve_wake();
+    eve_deselect();
+
+app_give_err_select:
+    _rv = eos_egpio_intr_set();
+    if (!rv && _rv) return _rv;
+
+    return rv;
+}
+
+int eos_app_take(void) {
+    int rv, _rv, ctp_sel;
+
+    if (eos_egpio_get_val(EGPIO_PIN_DISP_SEL)) return EOS_ERR;
+
+    ctp_sel = eos_aon_load4app();
+
+    rv = eos_egpio_intr_disable();
+    if (rv) return rv;
+
+    rv = eve_select();
+    if (rv) goto app_take_err_select;
+
+    eve_pwr_wake();
+
+    rv = eos_egpio_set_val(EGPIO_PIN_DISP_SEL, 1);
+    if (rv) goto app_take_err;
+
+    rv = eos_egpio_set_val(EGPIO_PIN_CTP_SEL, ctp_sel);
+    if (rv) goto app_take_err;
+
+    if (!ctp_sel) {
+        eve_touch_reset_engine();
+    }
+
+    rv = eos_lcd_take();
+    if (rv) goto app_take_err;
+
+    _eos_eve_wake();
+
+app_take_err:
+    if (rv) eve_pwr_sleep();
+    eve_deselect();
+
+    if (!rv && ctp_sel) {
+        _rv = _eos_ctp_reset();
+        if (_rv) rv = _rv;
+    }
+
+app_take_err_select:
+    _rv = eos_egpio_intr_set();
+    if (!rv && _rv) return _rv;
+
+    return rv;
+}
diff --git a/fw/fe310/eos/dev/app.h b/fw/fe310/eos/dev/app.h
index 4ee2e8d..e88ba20 100644
--- a/fw/fe310/eos/dev/app.h
+++ b/fw/fe310/eos/dev/app.h
@@ -1,3 +1,5 @@
 #include <stdint.h>
 
-void eos_app_hp_change(int hp_det);
\ No newline at end of file
+void eos_app_hp_change(int hp_det);
+int eos_app_give(void);
+int eos_app_take(void);
\ No newline at end of file
diff --git a/fw/fe310/eos/dev/ctp.c b/fw/fe310/eos/dev/ctp.c
index b6459b4..e58f929 100644
--- a/fw/fe310/eos/dev/ctp.c
+++ b/fw/fe310/eos/dev/ctp.c
@@ -32,6 +32,13 @@ int eos_ctp_init(void) {
     return rv;
 }
 
+int _eos_ctp_reset(void) {
+    if (eos_i2s_running() || !eos_egpio_get_val(EGPIO_PIN_CTP_SEL)) return EOS_ERR_BUSY;
+
+    gt911_reset();
+    return EOS_OK;
+}
+
 int eos_ctp_reset(void) {
     uint8_t status = 0;
     int rv;
@@ -49,6 +56,12 @@ int eos_ctp_reset(void) {
     return EOS_OK;
 }
 
+int _eos_ctp_sleep(void) {
+    if (eos_i2s_running() || !eos_egpio_get_val(EGPIO_PIN_CTP_SEL)) return EOS_ERR_BUSY;
+
+    return gt911_sleep();
+}
+
 int eos_ctp_sleep(void) {
     int rv;
 
@@ -67,6 +80,13 @@ int eos_ctp_sleep(void) {
     return EOS_OK;
 }
 
+int _eos_ctp_wake(void) {
+    if (eos_i2s_running() || !eos_egpio_get_val(EGPIO_PIN_CTP_SEL)) return EOS_ERR_BUSY;
+
+    gt911_wake();
+    return EOS_OK;
+}
+
 int eos_ctp_wake(void) {
     int rv;
 
@@ -85,7 +105,7 @@ int eos_ctp_wake(void) {
 }
 
 int eos_ctp_give(void) {
-    int rv;
+    int rv, _rv;
 
     if (!eos_egpio_get_val(EGPIO_PIN_DISP_SEL)) return EOS_ERR_BUSY;
     if (!eos_egpio_get_val(EGPIO_PIN_CTP_SEL)) return EOS_ERR;
@@ -94,22 +114,23 @@ int eos_ctp_give(void) {
     if (rv) return rv;
 
     rv = eos_egpio_set_val(EGPIO_PIN_CTP_SEL, 0);
-    if (rv) return rv;
+    if (rv) goto ctp_give_err;
 
     rv = eve_select();
-    if (rv) return rv;
+    if (rv) goto ctp_give_err;
 
     eve_touch_set_engine(EVE_TOUCH_ENGINE_GOODIX);
     eve_deselect();
 
-    rv = eos_egpio_intr_set();
-    if (rv) return rv;
+ctp_give_err:
+    _rv = eos_egpio_intr_set();
+    if (!rv && _rv) return _rv;
 
-    return EOS_OK;
+    return rv;
 }
 
 int eos_ctp_take(void) {
-    int rv;
+    int rv, _rv;
 
     if (eos_i2s_running() || !eos_egpio_get_val(EGPIO_PIN_DISP_SEL)) return EOS_ERR_BUSY;
     if (eos_egpio_get_val(EGPIO_PIN_CTP_SEL)) return EOS_ERR;
@@ -118,20 +139,21 @@ int eos_ctp_take(void) {
     if (rv) return rv;
 
     rv = eve_select();
-    if (rv) return rv;
+    if (rv) goto ctp_take_err;
 
     eve_touch_set_engine(EVE_TOUCH_ENGINE_HOST);
     eve_deselect();
 
     rv = eos_egpio_set_val(EGPIO_PIN_CTP_SEL, 1);
-    if (rv) return rv;
+    if (rv) goto ctp_take_err;
 
     gt911_reset();
 
-    rv = eos_egpio_intr_set();
-    if (rv) return rv;
+ctp_take_err:
+    _rv = eos_egpio_intr_set();
+    if (!rv && _rv) return _rv;
 
-    return EOS_OK;
+    return rv;
 }
 
 int eos_ctp_handle_intr(void) {
diff --git a/fw/fe310/eos/dev/ctp.h b/fw/fe310/eos/dev/ctp.h
index 72a0a75..c17f1e4 100644
--- a/fw/fe310/eos/dev/ctp.h
+++ b/fw/fe310/eos/dev/ctp.h
@@ -1,7 +1,14 @@
 #include <stdint.h>
 
 int eos_ctp_init(void);
+
+int _eos_ctp_reset(void);
 int eos_ctp_reset(void);
+
+int _eos_ctp_sleep(void);
 int eos_ctp_sleep(void);
+
+int _eos_ctp_wake(void);
 int eos_ctp_wake(void);
+
 int eos_ctp_handle_intr(void);
\ No newline at end of file
diff --git a/fw/fe310/eos/dev/egpio.c b/fw/fe310/eos/dev/egpio.c
index cfcd0f3..076986a 100644
--- a/fw/fe310/eos/dev/egpio.c
+++ b/fw/fe310/eos/dev/egpio.c
@@ -177,12 +177,10 @@ static int handle_egpio_evt(uint8_t chip_id) {
     return EOS_OK;
 }
 
-static void handle_evt(unsigned char type, unsigned char *buffer, uint16_t len) {
+static void handle_evt(unsigned char type, EOSMessage *msg, uint16_t len) {
     int rv;
 
-    type &= ~EOS_EVT_MASK;
-
-    switch (type) {
+    switch (type & ~EOS_EVT_MASK) {
         case EOS_EGPIO_ETYPE_INT: {
             rv = handle_egpio_evt(EGPIO_CHIP_FXL0);
             if (rv) goto handle_evt_fin;
@@ -217,6 +215,11 @@ handle_evt_fin:
             if (rv < 0) EOS_LOG(EOS_LOG_ERR, "CTP/EVE HANDLE INTR ERR:%d\n", rv);
             break;
         }
+
+        default:
+            eos_evtq_bad_handler(type, msg, len);
+            break;
+
     }
 }
 
diff --git a/fw/fe310/eos/dev/eve.c b/fw/fe310/eos/dev/eve.c
index 25a3558..873cd7a 100644
--- a/fw/fe310/eos/dev/eve.c
+++ b/fw/fe310/eos/dev/eve.c
@@ -61,14 +61,9 @@ int eos_eve_init(void) {
         eve_touch_init_engine(eos_egpio_get_val(EGPIO_PIN_CTP_SEL) ? EVE_TOUCH_ENGINE_HOST : EVE_TOUCH_ENGINE_GOODIX);
         gpio_reg = EVE_GPIO_DEFAULT;
     } else {
-        eve_pwr_set_state(eos_aon_load4eve());
-
         eve_activate();
         gpio_reg = eve_gpio_read();
         eve_cmd_set_offset();
-        if (gpio_reg & (1 << EVE_GPIO_DISP)) {
-            eve_pwr_set_state(EVE_PSTATE_ACTIVE);
-        }
         eve_deactivate();
     }
 
@@ -94,24 +89,32 @@ int eos_eve_run(void) {
 
     if (!rst) {
         /* was active before sleep */
-        if (eos_aon_load4eve() == EVE_PSTATE_ACTIVE) return EOS_OK;
+        if (eve_pwr_state() == EVE_PSTATE_ACTIVE) return EOS_OK;
 
-        /* DISP pin is off */
-        if (eve_pwr_state() != EVE_PSTATE_ACTIVE) return EOS_ERR_BUSY;
+        /* Display is attached to app module */
+        if (!eos_egpio_get_val(EGPIO_PIN_DISP_SEL)) return EOS_ERR_BUSY;
     }
 
     rv = eve_select();
     if (rv) return rv;
 
-    eve_touch_intr_enable();
-    eve_touch_start();
-    eve_intr_enable();
-    eve_clk_start();
+    if (!rst) eve_pwr_wake();
+    _eos_eve_wake();
+    if (rst) eve_set_brightness(0x40);
     eve_deselect();
 
     return EOS_OK;
 }
 
+void _eos_eve_sleep(void) {
+    eos_aon_save4eve_pwm(eve_get_brightness());
+    eve_set_brightness(0);
+    eve_clk_stop();
+    eve_intr_disable();
+    eve_touch_stop();
+    eve_touch_intr_disable();
+}
+
 int eos_eve_sleep(void) {
     int rv;
 
@@ -120,51 +123,38 @@ int eos_eve_sleep(void) {
     rv = eve_select();
     if (rv) return rv;
 
-    eve_brightness(0);
-    eve_clk_stop();
-    eve_intr_disable();
-    eve_touch_stop();
-    eve_touch_intr_disable();
+    _eos_eve_sleep();
     eve_pwr_sleep();
     eve_deselect();
 
     return EOS_OK;
 }
 
+void _eos_eve_wake(void) {
+    eve_touch_intr_enable();
+    eve_touch_start();
+    eve_intr_enable();
+    eve_clk_start();
+    eve_set_brightness(eos_aon_load4eve_pwm());
+}
+
 int eos_eve_wake(void) {
     int disp, rv;
 
     if (eve_pwr_state() == EVE_PSTATE_ACTIVE) return EOS_ERR;
+    if (!eos_egpio_get_val(EGPIO_PIN_DISP_SEL)) return EOS_ERR_BUSY;
 
     rv = eve_select();
     if (rv) return rv;
 
-    eve_activate();
-    disp = eve_gpio_get(EVE_GPIO_DISP);
-    if (disp) {
-        eve_pwr_set_state(EVE_PSTATE_ACTIVE);
-    }
-    eve_deactivate();
+    eve_pwr_wake();
+    _eos_eve_wake();
 
-    if (eve_pwr_state() != EVE_PSTATE_ACTIVE) {
-        rv = EOS_ERR_BUSY;
-        goto eve_wake_fin;
-    }
-
-    eve_touch_intr_enable();
-    eve_touch_start();
-    eve_intr_enable();
-    eve_clk_start();
-eve_wake_fin:
     eve_deselect();
 
     return rv;
 }
 
-void eos_eve_save2aon(void) {
-    eos_aon_save4eve(eve_pwr_state());
-}
-
 void eve_calibrate(void) {
     int rv, d;
     uint32_t matrix[6];
diff --git a/fw/fe310/eos/dev/eve.h b/fw/fe310/eos/dev/eve.h
index 564e8c1..11d7cc9 100644
--- a/fw/fe310/eos/dev/eve.h
+++ b/fw/fe310/eos/dev/eve.h
@@ -4,9 +4,10 @@ int eos_eve_handle_intr(void);
 
 int eos_eve_init(void);
 int eos_eve_run(void);
+void _eos_eve_sleep(void);
 int eos_eve_sleep(void);
+void _eos_eve_wake(void);
 int eos_eve_wake(void);
-void eos_eve_save2aon(void);
 
 void eve_calibrate(void);
 int eve_select(void);
diff --git a/fw/fe310/eos/dev/eve_priv.h b/fw/fe310/eos/dev/eve_priv.h
index 3863f5d..8baf6a4 100644
--- a/fw/fe310/eos/dev/eve_priv.h
+++ b/fw/fe310/eos/dev/eve_priv.h
@@ -1,6 +1,5 @@
 #define EVE_GPIO_DIR            0x800f
 #define EVE_GPIO_DEFAULT        0x8002  /* DISP on, EVEAUDIO_DIS */
-#define EVE_GPIO_MASK           0x800f
 
 #define EVE_GPIO_USR            0
 #define EVE_GPIO_EVEAUDIO_DIS   1       /* only when lspk is off */
diff --git a/fw/fe310/eos/dev/lcd.c b/fw/fe310/eos/dev/lcd.c
index 01d86e9..9fb8767 100644
--- a/fw/fe310/eos/dev/lcd.c
+++ b/fw/fe310/eos/dev/lcd.c
@@ -22,8 +22,6 @@
 static int lcd_enable(void) {
     int rv;
 
-    if (eos_i2s_running() || !eos_egpio_get_val(EGPIO_PIN_DISP_SEL)) return EOS_ERR_BUSY;
-
     rv = eos_egpio_set_val(EGPIO_PIN_LCD_EN, 1);
     return rv;
 }
@@ -31,8 +29,6 @@ static int lcd_enable(void) {
 static int lcd_disable(void) {
     int rv;
 
-    if (eos_i2s_running() || !eos_egpio_get_val(EGPIO_PIN_DISP_SEL)) return EOS_ERR_BUSY;
-
     rv = eos_egpio_set_val(EGPIO_PIN_LCD_EN, 0);
     return rv;
 }
@@ -44,7 +40,7 @@ static int lcd_enabled(void) {
 static int lcd_select(void) {
     int rv;
 
-    if (eos_i2s_running() || !eos_egpio_get_val(EGPIO_PIN_DISP_SEL)) return EOS_ERR_BUSY;
+    if (eos_i2s_running()) return EOS_ERR_BUSY;
 
     GPIO_REG(GPIO_OUTPUT_XOR)   |=  (1 << SPI_CSPIN_LCD);
     GPIO_REG(GPIO_OUTPUT_VAL)   |=  (1 << SPI_CSPIN_LCD);
@@ -85,13 +81,32 @@ static int lcd_init(void) {
     }
 
     rv = ili9806e_init();
-    if (rv == EOS_ERR_NOTFOUND) eve_lcd_absent();
+    if (rv == EOS_ERR_NOTFOUND) eve_lcd_set_absent(1);
     lcd_deselect();
 
     if (rv) lcd_disable();
     return rv;
 }
 
+static int lcd_reset(void) {
+    int rv;
+
+    if (!lcd_enabled()) return EOS_ERR;
+
+    rv = lcd_disable();
+    if (rv) return rv;
+
+    eos_sleep(10);
+
+    rv = lcd_init();
+    if (rv) {
+        lcd_enable();
+        return rv;
+    }
+
+    return EOS_OK;
+}
+
 static int lcd_sleep(void) {
     int rv;
 
@@ -109,6 +124,9 @@ int eos_lcd_init(void) {
     uint8_t wakeup_cause;
     int rv, rst;
 
+    if (!eos_egpio_get_val(EGPIO_PIN_DISP_SEL)) return EOS_ERR_BUSY;
+    if (lcd_enabled()) return EOS_ERR;
+
     wakeup_cause = eos_pwr_wakeup_cause();
     rst = (wakeup_cause == EOS_PWR_WAKE_RST);
     if (rst) {
@@ -137,3 +155,11 @@ int eos_lcd_wake(void) {
     rv = lcd_init();
     return rv;
 }
+
+int eos_lcd_take(void) {
+    return lcd_reset();
+}
+
+int eos_lcd_give(void) {
+    return lcd_reset();
+}
diff --git a/fw/fe310/eos/dev/lcd.h b/fw/fe310/eos/dev/lcd.h
index fafe2b4..f52ee8a 100644
--- a/fw/fe310/eos/dev/lcd.h
+++ b/fw/fe310/eos/dev/lcd.h
@@ -3,3 +3,5 @@
 int eos_lcd_init(void);
 int eos_lcd_sleep(void);
 int eos_lcd_wake(void);
+int eos_lcd_take(void);
+int eos_lcd_give(void);
diff --git a/fw/fe310/eos/dev/net.c b/fw/fe310/eos/dev/net.c
index c1fd9b5..7ab4947 100644
--- a/fw/fe310/eos/dev/net.c
+++ b/fw/fe310/eos/dev/net.c
@@ -7,7 +7,6 @@
 
 #include "eos.h"
 #include "log.h"
-#include "msgq.h"
 #include "event.h"
 
 #include "soc/interrupt.h"
@@ -24,36 +23,36 @@
 #define NET_DETECT_TIMEOUT          1000
 
 #define NET_SIZE_HDR                3
+#define NET_SIZE_BUFQ               2
+
 #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_RTS          0x0002
+#define NET_STATE_FLAG_CTS          0x0004
+#define NET_STATE_FLAG_INIT         0x0010
+#define NET_STATE_FLAG_XCHG         0x0020
+#define NET_STATE_FLAG_ONEW         0x0040
+#define NET_STATE_FLAG_SYNC         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 NET_STATE_FLAG_ERR_SIZE     0x0800
 
 #define MIN(X, Y)               (((X) < (Y)) ? (X) : (Y))
 #define MAX(X, Y)               (((X) > (Y)) ? (X) : (Y))
 
 static EOSBufQ net_buf_q;
-static unsigned char *net_bufq_array[EOS_NET_SIZE_BUFQ];
-static unsigned char net_bufq_buffer[EOS_NET_SIZE_BUFQ][EOS_NET_SIZE_BUF] __attribute__((section (".itim2")));
+static unsigned char *net_bufq_array[NET_SIZE_BUFQ];
+static unsigned char net_bufq_buffer[NET_SIZE_BUFQ][EOS_NET_MTU] __attribute__((section (".itim2")));
 
 static EOSMsgQ net_send_q;
-static EOSMsgItem net_sndq_array[EOS_NET_SIZE_BUFQ];
+static EOSMsgItem net_sndq_array[NET_SIZE_BUFQ];
 
 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;
 static unsigned char *net_state_buf = NULL;
+static uint16_t net_state_buf_sz = 0;
 
 static volatile uint8_t net_state_next_cnt = 0;
 static unsigned char * volatile net_state_next_buf = NULL;
@@ -96,8 +95,8 @@ static void net_xchg_sleep_req(void) {
     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;
+static void net_xchg_start(unsigned char type, EOSMessage *msg, uint16_t len) {
+    net_state_flags &= ~(NET_STATE_FLAG_CTS | NET_STATE_FLAG_ERR_SIZE);
     net_state_flags |= (NET_STATE_FLAG_INIT | NET_STATE_FLAG_XCHG);
 
     if (net_state_next_cnt && (net_state_next_buf == NULL)) type |= EOS_NET_MTYPE_FLAG_ONEW;
@@ -106,7 +105,8 @@ static void net_xchg_start(unsigned char type, unsigned char *buffer, uint16_t l
     net_state_type = type;
     net_state_len_tx = len;
     net_state_len_rx = 0;
-    net_state_buf = buffer;
+    net_state_buf = msg->buffer;
+    net_state_buf_sz = msg->size;
 
     SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_HOLD;
     SPI1_REG(SPI_REG_TXFIFO) = type;
@@ -116,23 +116,24 @@ static void net_xchg_start(unsigned char type, unsigned char *buffer, uint16_t l
     SPI1_REG(SPI_REG_IE) = SPI_IP_RXWM;
 }
 
-static int net_xchg_next(unsigned char *_buffer) {
+static int net_xchg_next(EOSMessage *_msg) {
     unsigned char type;
-    unsigned char *buffer = NULL;
+    EOSMessage msg;
     uint16_t len;
-    int do_release = _buffer ? 1 : 0;
+    int do_release = _msg ? 1 : 0;
 
-    eos_msgq_pop(&net_send_q, &type, &buffer, &len);
+    eos_msgq_pop(&net_send_q, &type, &msg, &len);
     if (type) {
-        net_xchg_start(type, buffer, len);
+        net_xchg_start(type, &msg, len);
     } else if (net_state_flags & NET_STATE_FLAG_RTS) {
-        if (_buffer) {
-            buffer = _buffer;
+        if (_msg) {
+            msg = *_msg;
             do_release = 0;
         } else {
-            buffer = eos_bufq_pop(&net_buf_q);
+            msg.buffer = eos_bufq_pop(&net_buf_q);
+            msg.size = EOS_NET_MTU;
         }
-        if (buffer) net_xchg_start(0, buffer, 0);
+        if (msg.buffer) net_xchg_start(0, &msg, 0);
     }
 
     return do_release;
@@ -155,42 +156,50 @@ static void net_handle_xchg(void) {
             r3 = 0;
         }
 
-        net_state_type    = (r1 & EOS_NET_MTYPE_MASK);
+        net_state_type    = r1;
         net_state_len_rx  = (r2 & 0xFF) << 8;
         net_state_len_rx |= (r3 & 0xFF);
         len = MAX(net_state_len_tx, net_state_len_rx);
 
-        // esp32 dma workaraund
+        /* esp32 dma workaraund */
         if (len < 8 - NET_SIZE_HDR) {
             len = 8 - NET_SIZE_HDR;
         } else if ((len + NET_SIZE_HDR) % 4 != 0) {
             len = ((len + NET_SIZE_HDR)/4 + 1) * 4 - NET_SIZE_HDR;
         }
 
-        if (len > EOS_NET_MTU) {
+        if (len > net_state_buf_sz) {
+            net_state_type = 0;
+            net_state_len_tx = 0;
+            net_state_len_rx = 0;
+            net_state_flags |= NET_STATE_FLAG_ERR_SIZE;
             net_state_flags &= ~NET_STATE_FLAG_XCHG;
             SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_AUTO;
             SPI1_REG(SPI_REG_IE) = 0x0;
             return;
         }
 
-        _eos_spi_xchg_init(net_state_buf, len, 0);
+        _eos_spi_xchg_init(net_state_buf, net_state_buf_sz, len, 0);
         SPI1_REG(SPI_REG_TXCTRL) = SPI_TXWM(SPI_SIZE_WM);
         SPI1_REG(SPI_REG_IE) = SPI_IP_TXWM;
         return;
     }
 
     eos_spi_handle_xchg();
-    if (SPI1_REG(SPI_REG_CSMODE) == SPI_CSMODE_AUTO) {  // exchange done
+    if (SPI1_REG(SPI_REG_CSMODE) == SPI_CSMODE_AUTO) {
+        /* exchange done */
         if (!(net_state_flags & NET_STATE_FLAG_SYNC)) {
             if (net_state_type) {
                 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 {
+                    EOSMessage msg;
                     int rv;
 
-                    rv = eos_evtq_push_isr(EOS_EVT_NET | (net_state_type & ~EOS_EVT_MASK), net_state_buf, net_state_len_rx);
+                    msg.buffer = net_state_buf;
+                    msg.size = net_state_buf_sz;
+                    rv = eos_evtq_push_isr(EOS_EVT_NET | (net_state_type & EOS_NET_MTYPE_MASK), &msg, 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);
@@ -202,7 +211,7 @@ static void net_handle_xchg(void) {
                 eos_bufq_push(&net_buf_q, net_state_buf);
             }
         }
-        net_state_flags &= ~(NET_STATE_FLAG_ONEW | NET_STATE_FLAG_XCHG);
+        net_state_flags &= ~(NET_STATE_FLAG_XCHG | NET_STATE_FLAG_ONEW);
     }
 }
 
@@ -232,13 +241,20 @@ static void net_handle_rts(void) {
     }
 }
 
-static void net_handle_evt(unsigned char type, unsigned char *buffer, uint16_t len) {
-    unsigned char idx = (type & ~EOS_EVT_MASK);
+static void net_handle_evt(unsigned char type, EOSMessage *msg, uint16_t len) {
+    unsigned char idx;
 
-    if (idx && (idx <= EOS_NET_MAX_MTYPE)) {
-        net_handler[idx - 1](type, buffer, len);
+    idx = type & EOS_NET_MTYPE_FLAG_BRIDGE ? EOS_NET_MTYPE_BRIDGE : (type & ~EOS_EVT_MASK);
+    type &= ~EOS_EVT_MASK;
+    if (msg && (idx < EOS_NET_MAX_MTYPE)) {
+        net_handler[idx](type, msg, len);
     } else {
-        eos_net_bad_handler(type, buffer, len);
+        eos_net_bad_handler(type, msg, len);
+    }
+    if (msg && msg->buffer) {
+        eos_net_free(msg, 0);
+    } else {
+        eos_net_release();
     }
 }
 
@@ -268,17 +284,17 @@ static int net_acquire(unsigned char reserved) {
     return ret;
 }
 
-static void evt_handler_wrapper(unsigned char type, unsigned char *buffer, uint16_t len, uint8_t idx) {
+static void evt_handler_wrapper(unsigned char type, EOSMessage *msg, uint16_t len, uint8_t idx) {
     uint16_t flag = (uint16_t)1 << idx;
     int rv;
 
     rv = net_acquire(net_wrapper_acq & flag);
     if (rv) {
-        eos_evtq_get_handler(type)(type, buffer, len);
+        eos_evtq_get_handler(type)(type, msg, len);
         eos_net_release();
         net_wrapper_acq &= ~flag;
     } else {
-        rv = eos_evtq_push_widx(type, buffer, len, &idx);
+        rv = eos_evtq_push_widx(type, msg, len, &idx);
         if (rv) {
             EOS_LOG(EOS_LOG_ERR, "NET WRAPPER EVTQ PUSH ERR:%d\n", rv);
             return;
@@ -288,7 +304,7 @@ static void evt_handler_wrapper(unsigned char type, unsigned char *buffer, uint1
     }
 }
 
-static void evt_handler(unsigned char type, unsigned char *buffer, uint16_t len, uint8_t _idx) {
+static void evt_handler(unsigned char type, EOSMessage *msg, uint16_t len, uint8_t _idx) {
     unsigned char idx = (type & EOS_EVT_MASK) >> 4;
 
     if (idx && (idx <= EOS_EVT_MAX)) {
@@ -296,12 +312,12 @@ static void evt_handler(unsigned char type, unsigned char *buffer, uint16_t len,
 
         idx--;
         if (flag & net_flags_acq[idx]) {
-            evt_handler_wrapper(type, buffer, len, _idx);
+            evt_handler_wrapper(type, msg, len, _idx);
         } else {
-            eos_evtq_get_handler(type)(type, buffer, len);
+            eos_evtq_get_handler(type)(type, msg, len);
         }
     } else {
-        eos_evtq_bad_handler(type, buffer, len);
+        eos_evtq_bad_handler(type, msg, len);
     }
 }
 
@@ -329,23 +345,31 @@ static void net_wait4cts(void) {
     }
 }
 
-static void net_wake(void) {
+static int net_wake(void) {
+    uint32_t start, timeout;
+
+    start = eos_get_tick();
+    timeout = NET_DETECT_TIMEOUT;
     while (net_state_flags & NET_STATE_FLAG_SLEEP) {
+        if (timeout && (eos_tdelta_ms(start) > timeout)) return EOS_ERR_NOTFOUND;
         net_xchg_reset();
         eos_sleep(10);
         set_csr(mstatus, MSTATUS_MIE);
         clear_csr(mstatus, MSTATUS_MIE);
     }
+
+    return EOS_OK;
 }
 
 static int net_select(int *dsel) {
+    int rv;
+
     *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;
 
+    rv = EOS_OK;
     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);
@@ -353,9 +377,9 @@ static int net_select(int *dsel) {
         *dsel = 1;
     }
     /* wake up remote if sleeping */
-    net_wake();
+    if (net_state_flags & NET_STATE_FLAG_SLEEP) rv = net_wake();
 
-    return EOS_OK;
+    return rv;
 }
 
 static void net_deselect(void) {
@@ -388,9 +412,9 @@ static void net_stop(void) {
 int eos_net_init(void) {
     int i;
 
-    eos_msgq_init(&net_send_q, net_sndq_array, EOS_NET_SIZE_BUFQ);
-    eos_bufq_init(&net_buf_q, net_bufq_array, EOS_NET_SIZE_BUFQ);
-    for (i=0; i<EOS_NET_SIZE_BUFQ; i++) {
+    eos_msgq_init(&net_send_q, net_sndq_array, NET_SIZE_BUFQ);
+    eos_bufq_init(&net_buf_q, net_bufq_array, NET_SIZE_BUFQ);
+    for (i=0; i<NET_SIZE_BUFQ; i++) {
         eos_bufq_push(&net_buf_q, net_bufq_buffer[i]);
     }
 
@@ -417,15 +441,16 @@ int eos_net_init(void) {
 
 int eos_net_run(void) {
     uint8_t wakeup_cause;
-    int rv;
+    int rv, rst;
 
     rv = EOS_OK;
     net_start();
 
     wakeup_cause = eos_pwr_wakeup_cause();
+    rst = (wakeup_cause == EOS_PWR_WAKE_RST);
 
     clear_csr(mstatus, MSTATUS_MIE);
-    if (wakeup_cause == EOS_PWR_WAKE_RST) {
+    if (rst) {
         uint32_t start, timeout;
 
         start = eos_get_tick();
@@ -436,18 +461,11 @@ int eos_net_run(void) {
                 break;
             }
         }
-        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 */
+            rv = EOS_ERR_NOTFOUND;
+        } else {
             net_state_flags |= NET_STATE_FLAG_SLEEP;
         }
     }
@@ -455,14 +473,26 @@ int eos_net_run(void) {
         /* 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();
+        GPIO_REG(GPIO_PULLUP_EN) &= ~(1 << NET_PIN_CTS);
+        /* wake up remote */
+        if (!rst) rv = net_wake();
+        if (!rv) net_resume();
+    } else {
+        net_state_flags |= NET_STATE_FLAG_ABSENT;
+        EOS_LOG(EOS_LOG_ERR, "NET DEVICE ABSENT\n");
     }
     set_csr(mstatus, MSTATUS_MIE);
 
+    /* save absent state */
+    if (rst) eos_aon_save4net(!!rv);
+
+    if (rv) net_stop();
     return rv;
 }
 
 void eos_net_start(void) {
+    if (net_state_flags & NET_STATE_FLAG_ABSENT) return;
+
     net_start();
 
     clear_csr(mstatus, MSTATUS_MIE);
@@ -471,6 +501,8 @@ void eos_net_start(void) {
 }
 
 void eos_net_stop(void) {
+    if (net_state_flags & NET_STATE_FLAG_ABSENT) return;
+
     clear_csr(mstatus, MSTATUS_MIE);
     net_pause();
     set_csr(mstatus, MSTATUS_MIE);
@@ -516,26 +548,16 @@ void eos_net_wake(void) {
     set_csr(mstatus, MSTATUS_MIE);
 }
 
-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) {
-    eos_evtq_bad_handler(type, buffer, len);
-    if (buffer) eos_net_free(buffer, 0);
+void eos_net_bad_handler(unsigned char type, EOSMessage *msg, uint16_t len) {
+    eos_evtq_bad_handler(type, msg, len);
 }
 
 void eos_net_set_handler(unsigned char mtype, eos_evt_handler_t handler) {
     if (handler == NULL) handler = eos_net_bad_handler;
-    if (mtype && (mtype <= EOS_NET_MAX_MTYPE)) net_handler[mtype - 1] = handler;
+    if (mtype < EOS_NET_MAX_MTYPE) net_handler[mtype] = handler;
 }
 
-void eos_net_acquire_for_evt(unsigned char type, char acq) {
+void eos_net_acquire_for_evt(unsigned char type, int acq) {
     unsigned char idx = (type & EOS_EVT_MASK) >> 4;
     uint16_t flag = type & ~EOS_EVT_MASK ? (uint16_t)1 << (type & ~EOS_EVT_MASK) : 0xFFFF;
 
@@ -547,7 +569,9 @@ void eos_net_acquire_for_evt(unsigned char type, char acq) {
 }
 
 void eos_net_acquire(void) {
-    unsigned char acq = net_acquire(0);
+    int acq;
+
+    acq = net_acquire(0);
     if (!acq) net_acquire(1);
 }
 
@@ -560,56 +584,59 @@ void eos_net_release(void) {
     set_csr(mstatus, MSTATUS_MIE);
 }
 
-unsigned char *eos_net_alloc(void) {
-    unsigned char *rv = NULL;
+void eos_net_alloc(EOSMessage *msg) {
+    msg->buffer = NULL;
+    msg->size = 0;
 
-    while (rv == NULL) {
+    while (msg->buffer == NULL) {
         clear_csr(mstatus, MSTATUS_MIE);
         if (net_state_next_buf) {
-            rv = net_state_next_buf;
+            msg->buffer = net_state_next_buf;
+            msg->size = EOS_NET_MTU;
             net_state_next_buf = NULL;
         } else {
             asm volatile ("wfi");
         }
         set_csr(mstatus, MSTATUS_MIE);
     }
-
-    return rv;
 }
 
-void eos_net_free(unsigned char *buffer, unsigned char more) {
-    uint8_t do_release = 1;
-
+void eos_net_free(EOSMessage *msg, int more) {
     clear_csr(mstatus, MSTATUS_MIE);
     if ((more || net_state_next_cnt) && (net_state_next_buf == NULL)) {
-        net_state_next_buf = buffer;
+        net_state_next_buf = msg->buffer;
     } else {
+        int do_release = 1;
+
         if ((net_state_flags & NET_STATE_FLAG_RUN) && (net_state_flags & NET_STATE_FLAG_CTS)) {
-            do_release = net_xchg_next(buffer);
+            do_release = net_xchg_next(msg);
         }
         if (do_release) {
-            eos_bufq_push(&net_buf_q, buffer);
+            eos_bufq_push(&net_buf_q, msg->buffer);
         }
     }
+    msg->buffer = NULL;
+    msg->size = 0;
     set_csr(mstatus, MSTATUS_MIE);
 }
 
-static int net_xchg(unsigned char *type, unsigned char *buffer, uint16_t *len, unsigned char flags) {
+static int net_xchg(unsigned char *type, EOSMessage *msg, uint16_t *len, unsigned char flags) {
     int rv = EOS_OK;
     int sync = 0, dsel = 0;
     unsigned char _type = *type & EOS_NET_MTYPE_MASK;
     uint16_t _len = *len;
 
-    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;
+	if ((flags & EOS_NET_FLAG_REPL) && (_type & EOS_NET_MTYPE_FLAG_BRIDGE)) return EOS_ERR;
+
+    if (flags & EOS_NET_FLAG_REPL) flags |= EOS_NET_FLAG_SYNC;
+
+    if (flags & EOS_NET_FLAG_MORE) _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;
 
     clear_csr(mstatus, MSTATUS_MIE);
     rv = net_select(&dsel);
-    if (rv) {
-        set_csr(mstatus, MSTATUS_MIE);
-        return rv;
-    }
+    if (rv) goto net_xchg_fin;
 
     if (dsel) sync = 1;
     if (sync) {
@@ -617,51 +644,58 @@ static int net_xchg(unsigned char *type, unsigned char *buffer, uint16_t *len, u
         net_pause();
         net_wait4cts();
         net_state_flags |= NET_STATE_FLAG_SYNC;
-        net_xchg_start(_type, buffer, _len);
-        if (flags & NET_FLAG_REPL) {
+        net_xchg_start(_type, msg, _len);
+        if (flags & EOS_NET_FLAG_REPL) {
             net_wait4cts();
-            net_xchg_start(0, buffer, 0);
+            net_xchg_start(0, msg, 0);
         }
         net_wait4xchg();
         net_state_flags &= ~NET_STATE_FLAG_SYNC;
-        *type = net_state_type & EOS_NET_MTYPE_MASK;
-        *len = net_state_len_rx;
+        if (flags & EOS_NET_FLAG_REPL) {
+            *type = 0;
+            *len = 0;
+            rv = (net_state_flags & NET_STATE_FLAG_ERR_SIZE) ? EOS_ERR_SIZE : EOS_OK;
+            if (!rv) {
+                *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);
+            net_xchg_start(_type, msg, _len);
         } else {
-            rv = eos_msgq_push(&net_send_q, _type, buffer, _len);
+            rv = eos_msgq_push(&net_send_q, _type, msg, _len);
         }
     }
 
+net_xchg_fin:
     set_csr(mstatus, MSTATUS_MIE);
-    if (sync && !(flags & NET_FLAG_SYNC)) eos_net_free(buffer, !!(flags & NET_FLAG_MORE));
+    if (!(flags & EOS_NET_FLAG_SYNC)) {
+        if (sync || rv) {
+            eos_net_free(msg, !!(flags & EOS_NET_FLAG_MORE));
+        } else {
+            msg->buffer = NULL;
+            msg->size = 0;
+        }
+    }
     if (dsel) net_deselect();
 
     return rv;
 }
 
-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 ? NET_FLAG_MORE : 0);
-    if (rv) eos_net_free(buffer, more);
-    return rv;
+int eos_net_send(unsigned char type, EOSMessage *msg, uint16_t len, int more) {
+    return net_xchg(&type, msg, &len, more ? EOS_NET_FLAG_MORE : 0);
 }
 
-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_send_sync(unsigned char type, EOSMessage *msg, uint16_t len) {
+    return net_xchg(&type, msg, &len, EOS_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_xchg(unsigned char *type, EOSMessage *msg, uint16_t *len) {
+    return net_xchg(type, msg, len, EOS_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(type, buffer, len, more);
-    } else {
-        return eos_net_send_sync(type, buffer, len);
-    }
+int _eos_net_send(unsigned char type, EOSMessage *msg, uint16_t len, unsigned char flags) {
+    return net_xchg(&type, msg, &len, flags);
 }
diff --git a/fw/fe310/eos/dev/net.h b/fw/fe310/eos/dev/net.h
index 12b4d14..ad544a3 100644
--- a/fw/fe310/eos/dev/net.h
+++ b/fw/fe310/eos/dev/net.h
@@ -2,26 +2,27 @@
 
 #include "../event.h"
 
-/* common */
 #define EOS_NET_MTU                 1500
-#define EOS_NET_SIZE_BUF            EOS_NET_MTU
 
-#define EOS_NET_MTYPE_SOCK          1
-#define EOS_NET_MTYPE_WIFI          2
-#define EOS_NET_MTYPE_CELL          3
-#define EOS_NET_MTYPE_APP           4
-#define EOS_NET_MTYPE_RNG         	5
+#define EOS_NET_MTYPE_BRIDGE        0       /* handler only */
+#define EOS_NET_MTYPE_WIFI          1
+#define EOS_NET_MTYPE_CELL          2
+#define EOS_NET_MTYPE_SOCK          3
+#define EOS_NET_MTYPE_RNG           4
 
 #define EOS_NET_MAX_MTYPE           5
 
-#define EOS_NET_MTYPE_SLEEP         0x10    /* does not have net handler */
+#define EOS_NET_MTYPE_SLEEP         0x20    /* does not have net handler */
 
-#define EOS_NET_MTYPE_FLAG_ONEW     0x40
-#define EOS_NET_MTYPE_FLAG_REPL     0x80
-#define EOS_NET_MTYPE_MASK          0x3F    /* 0x0F if mtype is handled by evtq */
+#define EOS_NET_MTYPE_FLAG_ONEW     0x80
+#define EOS_NET_MTYPE_FLAG_REPL     0x40
+#define EOS_NET_MTYPE_FLAG_BRIDGE   0x08
 
-/* fe310 specific */
-#define EOS_NET_SIZE_BUFQ           2
+#define EOS_NET_MTYPE_MASK          0x0F    /* must be the same as ~EOS_EVT_MASK */
+
+#define EOS_NET_FLAG_MORE           0x01
+#define EOS_NET_FLAG_SYNC           0x02
+#define EOS_NET_FLAG_REPL           0x04
 
 int eos_net_init(void);
 int eos_net_run(void);
@@ -30,17 +31,16 @@ void eos_net_stop(void);
 int eos_net_sleep(void);
 int eos_net_sleep_rdy(void);
 void eos_net_wake(void);
-void eos_net_save2aon(void);
 
-void eos_net_bad_handler(unsigned char type, unsigned char *buffer, uint16_t len);
+void eos_net_bad_handler(unsigned char type, EOSMessage *msg, uint16_t len);
 void eos_net_set_handler(unsigned char type, eos_evt_handler_t handler);
-void eos_net_acquire_for_evt(unsigned char type, char acq);
+void eos_net_acquire_for_evt(unsigned char type, int acq);
 
 void eos_net_acquire(void);
 void eos_net_release(void);
-unsigned char *eos_net_alloc(void);
-void eos_net_free(unsigned char *buffer, unsigned char more);
-int eos_net_send(unsigned char type, unsigned char *buffer, uint16_t len, unsigned char more);
-int eos_net_send_sync(unsigned char type, unsigned char *buffer, uint16_t len);
-int eos_net_xchg(unsigned char *type, unsigned char *buffer, uint16_t *len);
-int _eos_net_send(unsigned char type, unsigned char *buffer, uint16_t len, unsigned char async, unsigned char more);
+void eos_net_alloc(EOSMessage *msg);
+void eos_net_free(EOSMessage *msg, int more);
+int eos_net_send(unsigned char type, EOSMessage *msg, uint16_t len, int more);
+int eos_net_send_sync(unsigned char type, EOSMessage *msg, uint16_t len);
+int eos_net_xchg(unsigned char *type, EOSMessage *msg, uint16_t *len);
+int _eos_net_send(unsigned char type, EOSMessage *msg, uint16_t len, unsigned char flags);
\ No newline at end of file
diff --git a/fw/fe310/eos/dev/pwr.c b/fw/fe310/eos/dev/pwr.c
index 06a76d8..b60e35c 100644
--- a/fw/fe310/eos/dev/pwr.c
+++ b/fw/fe310/eos/dev/pwr.c
@@ -19,8 +19,6 @@
 
 static void pwr_sleep_rdy(void) {
     if ((eos_evtq_len() == 0) && eos_net_sleep_rdy()) {
-        eos_eve_save2aon();
-        eos_net_save2aon();
         eos_flash_norm();
 #ifdef EOS_DEBUG
         EOS_LOG(EOS_LOG_INFO, "PWR SLEEP\n");
diff --git a/fw/fe310/eos/dev/spi.c b/fw/fe310/eos/dev/spi.c
index 319816d..ea6d74a 100644
--- a/fw/fe310/eos/dev/spi.c
+++ b/fw/fe310/eos/dev/spi.c
@@ -6,7 +6,6 @@
 
 #include "eos.h"
 #include "log.h"
-#include "msgq.h"
 #include "event.h"
 
 #include "board.h"
diff --git a/fw/fe310/eos/dev/spi_cfg.h b/fw/fe310/eos/dev/spi_cfg.h
index 0320aa6..906de24 100644
--- a/fw/fe310/eos/dev/spi_cfg.h
+++ b/fw/fe310/eos/dev/spi_cfg.h
@@ -32,14 +32,14 @@ static const SPIConfig spi_cfg[SPI_MAX_DEV] = {
         .csid = SPI_CSID_SDC,
         .cspin = SPI_CSPIN_SDC,
         .flags = 0,
-        .evt = EOS_SPI_EVT_SDC,
+        .evt = EOS_SPI_ETYPE_SDC,
     },
     {   // DEV_CAM
         .div = SPI_DIV_CAM,
         .csid = SPI_CSID_CAM,
         .cspin = SPI_CSPIN_CAM,
         .flags = 0,
-        .evt = EOS_SPI_EVT_CAM,
+        .evt = EOS_SPI_ETYPE_CAM,
     },
     {   // DEV_HPAMP
         .div = SPI_DIV_HPAMP,