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;

8 files changed, 353 insertions, 431 deletions

diff --git a/fw/fe310/eos/net/Makefile b/fw/fe310/eos/net/Makefile
index 0646956..d743a54 100644
--- a/fw/fe310/eos/net/Makefile
+++ b/fw/fe310/eos/net/Makefile
@@ -1,6 +1,6 @@
 include ../../common.mk
 
-obj = rng.o wifi.o sock.o cell.o
+obj = rng.o wifi.o cell.o sock.o
 lib = ../../libeos-net.a
 
 
diff --git a/fw/fe310/eos/net/cell.c b/fw/fe310/eos/net/cell.c
index c0c77af..aa1200d 100644
--- a/fw/fe310/eos/net/cell.c
+++ b/fw/fe310/eos/net/cell.c
@@ -10,21 +10,21 @@
 
 static eos_evt_handler_t evt_handler[EOS_CELL_MAX_MTYPE];
 
-static void cell_handle_msg(unsigned char type, unsigned char *buffer, uint16_t buf_len) {
+static void cell_handle_msg(unsigned char type, EOSMessage *msg, uint16_t len) {
     unsigned char mtype;
     unsigned char idx;
 
-    if ((buffer == NULL) || (buf_len < 1)) {
-        eos_net_bad_handler(type, buffer, buf_len);
+    if ((msg == NULL) || (len < 1)) {
+        eos_net_bad_handler(type, msg, len);
         return;
     }
 
-    mtype = buffer[0];
+    mtype = msg->buffer[0];
     idx = (mtype & EOS_CELL_MTYPE_MASK) >> 4;
     if ((idx < EOS_CELL_MAX_MTYPE) && evt_handler[idx]) {
-        evt_handler[idx](mtype & ~EOS_CELL_MTYPE_MASK, buffer, buf_len);
+        evt_handler[idx](mtype & ~EOS_CELL_MTYPE_MASK, msg, len);
     } else {
-        eos_net_bad_handler(type, buffer, buf_len);
+        eos_net_bad_handler(type, msg, len);
     }
 }
 
@@ -50,166 +50,141 @@ eos_evt_handler_t eos_cell_get_handler(unsigned char mtype) {
     return NULL;
 }
 
-int eos_cell_send_buffer(unsigned char *buffer, uint16_t buf_len, uint16_t offset, int sync) {
-    buffer -= offset;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, buf_len + offset, !sync, 1);
-}
+int eos_cell_status_parse(EOSMessage *msg, uint16_t len, uint8_t *status, uint8_t *connected) {
+    unsigned char *buffer = msg->buffer;
 
-int eos_cell_status_parse(unsigned char *buffer, uint16_t buf_len, uint8_t *status, uint8_t *connected) {
-    if (buf_len < 2) return EOS_ERR_SIZE;
+    if (len < 2) return EOS_ERR_SIZE;
 
     if (buffer[0] != (EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_STATUS)) return EOS_ERR_NET;
     buffer++;
-    buf_len--;
+    len--;
 
     *status = buffer[0];
     buffer++;
-    buf_len--;
+    len--;
 
     if (*status == EOS_CELL_STATUS_PPP) {
-        if (buf_len < 1) return EOS_ERR_SIZE;
+        if (len < 1) return EOS_ERR_SIZE;
         if (connected) *connected = buffer[0];
         buffer++;
-        buf_len--;
+        len--;
     }
     return EOS_OK;
 }
 
-int eos_cell_status(uint8_t *status, uint8_t *connected, unsigned char *buffer) {
+int eos_cell_status(uint8_t *status, uint8_t *connected, EOSMessage *msg) {
     unsigned char type;
-    uint16_t buf_len;
-    int do_release;
+    uint16_t len;
     int rv;
 
-    do_release = 0;
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        do_release = 1;
-    }
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
     type = EOS_NET_MTYPE_CELL;
-    buf_len = 1;
-    buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_STATUS;
+    len = 1;
+    msg->buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_STATUS;
 
-    rv = eos_net_xchg(&type, buffer, &buf_len);
-    if (rv) goto cell_status_fin;
+    rv = eos_net_xchg(&type, msg, &len);
+    if (rv) return rv;
 
-    if (type != EOS_NET_MTYPE_CELL) {
-        rv = EOS_ERR_NET;
-        goto cell_status_fin;
-    }
+    if (type != EOS_NET_MTYPE_CELL) return EOS_ERR_NET;
 
-    rv = eos_cell_status_parse(buffer, buf_len, status, connected);
+    return eos_cell_status_parse(msg, len, status, connected);
+}
+
+int eos_cell_uart_take(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-cell_status_fin:
-    if (do_release) eos_net_free(buffer, 1);
-    return rv;
+    msg->buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_TAKE;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1);
 }
 
-int eos_cell_uart_take(unsigned char *buffer, int sync) {
-    int async;
+int eos_cell_uart_give(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_TAKE;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_GIVE;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1);
 }
 
-int eos_cell_uart_give(unsigned char *buffer, int sync) {
-    int async;
+unsigned char *eos_cell_uart_msg2data(EOSMessage *msg, uint16_t *len, uint16_t *size) {
+    if (len && (*len < 1)) return NULL;
+    if (msg->size < 1) return NULL;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_GIVE;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1, async, 1);
+    if (len && (msg->buffer[0] != (EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_DATA))) return NULL;
+
+    if (len) *len -= 1;
+    if (size) *size = msg->size - 1;
+    return msg->buffer + 1;
 }
 
-unsigned char *eos_cell_uart_data_alloc(uint16_t *offset) {
-    unsigned char *buffer;
+int eos_cell_uart_send(EOSMessage *msg, uint16_t len) {
+    msg->buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_DATA;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, len + 1);
+}
 
-    buffer = eos_net_alloc();
-    buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_DATA;
-    *offset = 1;
-    return buffer + *offset;
+int eos_cell_uart_send_async(EOSMessage *msg, uint16_t len, int more) {
+    msg->buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_DATA;
+    return eos_net_send(EOS_NET_MTYPE_CELL, msg, len + 1, more);
 }
 
-int eos_cell_voice_dial(char *num, unsigned char *buffer, int sync) {
+int eos_cell_voice_dial(char *num, EOSMessage *msg) {
     int async;
     size_t num_len;
 
     num_len = strlen(num);
     if (num_len > EOS_CELL_SIZE_PHNUM) return EOS_ERR_SIZE;
+    if (msg->size < 1 + num_len) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_DIAL;
-    memcpy(buffer + 1, num, num_len);
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1 + num_len, async, 1);
+    msg->buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_DIAL;
+    memcpy(msg->buffer + 1, num, num_len);
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1 + num_len);
 }
 
-int eos_cell_voice_answer(unsigned char *buffer, int sync) {
-    int async;
+int eos_cell_voice_answer(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_ANSWER;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_ANSWER;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1);
 }
 
-int eos_cell_voice_hangup(unsigned char *buffer, int sync) {
-    int async;
+int eos_cell_voice_hangup(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_HANGUP;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_HANGUP;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1);
 }
 
-unsigned char *eos_cell_voice_pcm_alloc(uint16_t *offset) {
-    unsigned char *buffer;
+unsigned char *eos_cell_voice_msg2pcm(EOSMessage *msg, uint16_t *len, uint16_t *size) {
+    if (len && (*len < 1)) return NULL;
+    if (msg->size < 1) return NULL;
+
+    if (len && (msg->buffer[0] != (EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_PCM))) return NULL;
 
-    buffer = eos_net_alloc();
-    buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_PCM;
-    *offset = 1;
-    return buffer + *offset;
+    if (len) *len -= 1;
+    if (size) *size = msg->size - 1;
+    return msg->buffer + 1;
 }
 
-int eos_cell_sms_send(char *addr, char *txt, unsigned char *buffer, int sync) {
-    int async;
+int eos_cell_voice_pcm_send(EOSMessage *msg, uint16_t len) {
+    msg->buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_PCM;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, len + 1);
+}
+
+int eos_cell_voice_pcm_send_async(EOSMessage *msg, uint16_t len, int more) {
+    msg->buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_PCM;
+    return eos_net_send(EOS_NET_MTYPE_CELL, msg, len + 1, more);
+}
+
+int eos_cell_sms_send(char *addr, char *txt, EOSMessage *msg) {
+    unsigned char *buffer = msg->buffer;
     size_t addr_len, txt_len;
-    uint16_t buf_len;
+    uint16_t len;
 
     addr_len = strlen(addr);
     txt_len = strlen(txt);
     if (addr_len > EOS_CELL_SMS_SIZE_ADDR) return EOS_ERR_SIZE;
     if (txt_len > EOS_CELL_SMS_SIZE_TXT) return EOS_ERR_SIZE;
+    if (msg->size < 5) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
     buffer[0] = EOS_CELL_MTYPE_SMS | EOS_CELL_MTYPE_SMS_MSG;
     buffer[1] = 0;
     buffer[2] = 0;
@@ -221,49 +196,60 @@ int eos_cell_sms_send(char *addr, char *txt, unsigned char *buffer, int sync) {
         buffer[3] = EOS_CELL_SMS_ADDRTYPE_OTHER;
     }
     buffer[4] = addr_len;
-    buf_len = 5;
-    memcpy(buffer + buf_len, addr, addr_len);
-    buf_len += addr_len;
-    memcpy(buffer + buf_len, txt, txt_len);
-    buf_len += txt_len;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, buf_len, async, 1);
+
+    buffer += 5;
+    len = 5;
+
+    if (msg->size < 5 + addr_len + txt_len) return EOS_ERR_SIZE;
+
+    memcpy(buffer, addr, addr_len);
+    buffer += addr_len;
+    len += addr_len;
+
+    memcpy(buffer, txt, txt_len);
+    buffer += txt_len;
+    len += txt_len;
+
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, len);
 }
 
-int _eos_cell_sms_parse(unsigned char *buffer, uint16_t buf_len, char **addr, uint16_t *addr_len, char **txt, uint16_t *txt_len) {
+int _eos_cell_sms_parse(EOSMessage *msg, uint16_t len, char **addr, uint16_t *addr_len, char **txt, uint16_t *txt_len) {
+    unsigned char *buffer = msg->buffer;
     uint16_t _addr_len;
 
-    if (buf_len < 4 + EOS_CELL_SMS_SIZE_TS) return EOS_ERR_SIZE;
+    if (len < 4 + EOS_CELL_SMS_SIZE_TS) return EOS_ERR_SIZE;
 
     if (buffer[0] != (EOS_CELL_MTYPE_SMS | EOS_CELL_MTYPE_SMS_MSG)) return EOS_ERR_NET;
     buffer += 3 + EOS_CELL_SMS_SIZE_TS;
-    buf_len -= 3 + EOS_CELL_SMS_SIZE_TS;
+    len -= 3 + EOS_CELL_SMS_SIZE_TS;
 
     _addr_len = *buffer;
     if (_addr_len > EOS_CELL_SMS_SIZE_ADDR) return EOS_ERR_SIZE;
-    if ((_addr_len == 0) || (buf_len < (_addr_len + 1))) return EOS_ERR_SIZE;
+    if ((_addr_len == 0) || (len < (_addr_len + 1))) return EOS_ERR_SIZE;
     if (addr && addr_len) {
         *addr = buffer + 1;
         *addr_len = _addr_len;
     }
     buffer += _addr_len + 1;
-    buf_len -= _addr_len + 1;
+    len -= _addr_len + 1;
 
-    if (buf_len > EOS_CELL_SMS_SIZE_TXT) return EOS_ERR_SIZE;
+    if (len > EOS_CELL_SMS_SIZE_TXT) return EOS_ERR_SIZE;
     if (txt && txt_len) {
         *txt = buffer;
-        *txt_len = buf_len;
+        *txt_len = len;
     }
 
     return EOS_OK;
 }
 
-int eos_cell_sms_parse(unsigned char *buffer, uint16_t buf_len, char *addr, uint16_t addr_size, char *txt, uint16_t txt_size) {
+int eos_cell_sms_parse(EOSMessage *msg, uint16_t len, char *addr, uint16_t addr_size, char *txt, uint16_t txt_size) {
     char *_addr, *_txt;
     uint16_t _addr_len, _txt_len;
     int rv;
 
-    rv = _eos_cell_sms_parse(buffer, buf_len, &_addr, &_addr_len, &_txt, &_txt_len);
+    rv = _eos_cell_sms_parse(msg, len, &_addr, &_addr_len, &_txt, &_txt_len);
     if (rv) return rv;
+
     if (addr_size <  _addr_len + 1) return EOS_ERR_SIZE;
     if (txt_size <  _txt_len + 1) return EOS_ERR_SIZE;
     memcpy(addr, _addr, _addr_len);
@@ -274,107 +260,89 @@ int eos_cell_sms_parse(unsigned char *buffer, uint16_t buf_len, char *addr, uint
     return EOS_OK;
 }
 
-int eos_cell_pdp_get(unsigned char atype, char *arg, uint16_t arg_size, unsigned char *buffer) {
+char *eos_cell_sms_msg2txt(EOSMessage *msg, uint16_t *len) {
+    char *txt;
+    uint16_t txt_len;
+    int rv;
+
+    rv = _eos_cell_sms_parse(msg, *len, NULL, NULL, &txt, &txt_len);
+    if (rv) return NULL;
+
+    *len = txt_len;
+    return txt;
+}
+
+int eos_cell_pdp_get(unsigned char atype, char *arg, uint16_t arg_size, EOSMessage *msg) {
     unsigned char type;
-    uint16_t buf_len;
-    int do_release;
+    uint16_t len;
     int rv;
 
-    do_release = 0;
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        do_release = 1;
-    }
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
     type = EOS_NET_MTYPE_CELL;
-    buf_len = 1;
-    buffer[0] = EOS_CELL_MTYPE_PDP | atype;
+    len = 1;
+    msg->buffer[0] = EOS_CELL_MTYPE_PDP | atype;
 
-    rv = eos_net_xchg(&type, buffer, &buf_len);
-    if (rv) goto cell_pdp_get_fin;
+    rv = eos_net_xchg(&type, msg, &len);
+    if (rv) return rv;
 
-    if ((type != EOS_NET_MTYPE_CELL) || (buf_len == 0) || (buffer[0] != EOS_CELL_MTYPE_PDP | atype)) {
-        rv = EOS_ERR_NET;
-        goto cell_pdp_get_fin;
-    }
+    if ((type != EOS_NET_MTYPE_CELL) || (len < 1) || (msg->buffer[0] != EOS_CELL_MTYPE_PDP | atype)) return EOS_ERR_NET;
 
-    buf_len--;
-    if ((buf_len > EOS_CELL_PDP_SIZE_ARG) || (buf_len > arg_size - 1)) {
-        rv = EOS_ERR_SIZE;
-        goto cell_pdp_get_fin;
-    }
-    memcpy(buffer + 1, arg, buf_len);
-    arg[buf_len] = '\0';
+    len--;
+    if ((len > EOS_CELL_PDP_SIZE_ARG) || (len > arg_size - 1)) return EOS_ERR_SIZE;
+
+    memcpy(msg->buffer + 1, arg, len);
+    arg[len] = '\0';
 
-cell_pdp_get_fin:
-    if (do_release) eos_net_free(buffer, 1);
-    return rv;
+    return EOS_OK;
 }
 
-int eos_cell_pdp_set(unsigned char atype, char *arg, unsigned char *buffer, int sync) {
-    int async;
+int eos_cell_pdp_set(unsigned char atype, char *arg, EOSMessage *msg) {
     size_t arg_len;
 
     arg_len = strlen(arg);
     if (arg_len > EOS_CELL_PDP_SIZE_ARG) return EOS_ERR_SIZE;
+    if (msg->size < 1 + arg_len) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_PDP | atype;
-    memcpy(buffer + 1, arg, arg_len);
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1 + arg_len, async, 1);
+    msg->buffer[0] = EOS_CELL_MTYPE_PDP | atype;
+    memcpy(msg->buffer + 1, arg, arg_len);
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1 + arg_len);
 }
 
-int eos_cell_pdp_get_apn(char *apn, uint16_t apn_size, unsigned char *buffer) {
-    return eos_cell_pdp_get(EOS_CELL_MTYPE_PDP_GET_APN, apn, apn_size, buffer);
+int eos_cell_pdp_get_apn(char *apn, uint16_t apn_size, EOSMessage *msg) {
+    return eos_cell_pdp_get(EOS_CELL_MTYPE_PDP_GET_APN, apn, apn_size, msg);
 }
 
-int eos_cell_pdp_set_apn(char *apn, unsigned char *buffer, int sync) {
-    return eos_cell_pdp_set(EOS_CELL_MTYPE_PDP_SET_APN, apn, buffer, sync);
+int eos_cell_pdp_set_apn(char *apn, EOSMessage *msg) {
+    return eos_cell_pdp_set(EOS_CELL_MTYPE_PDP_SET_APN, apn, msg);
 }
 
-int eos_cell_pdp_get_usr(char *usr, uint16_t usr_size, unsigned char *buffer) {
-    return eos_cell_pdp_get(EOS_CELL_MTYPE_PDP_GET_USR, usr, usr_size, buffer);
+int eos_cell_pdp_get_usr(char *usr, uint16_t usr_size, EOSMessage *msg) {
+    return eos_cell_pdp_get(EOS_CELL_MTYPE_PDP_GET_USR, usr, usr_size, msg);
 }
 
-int eos_cell_pdp_set_usr(char *usr, unsigned char *buffer, int sync) {
-    return eos_cell_pdp_set(EOS_CELL_MTYPE_PDP_SET_USR, usr, buffer, sync);
+int eos_cell_pdp_set_usr(char *usr, EOSMessage *msg) {
+    return eos_cell_pdp_set(EOS_CELL_MTYPE_PDP_SET_USR, usr, msg);
 }
 
-int eos_cell_pdp_get_pwd(char *pwd, uint16_t pwd_size, unsigned char *buffer) {
-    return eos_cell_pdp_get(EOS_CELL_MTYPE_PDP_GET_PWD, pwd, pwd_size, buffer);
+int eos_cell_pdp_get_pwd(char *pwd, uint16_t pwd_size, EOSMessage *msg) {
+    return eos_cell_pdp_get(EOS_CELL_MTYPE_PDP_GET_PWD, pwd, pwd_size, msg);
 }
 
-int eos_cell_pdp_set_pwd(char *pwd, unsigned char *buffer, int sync) {
-    return eos_cell_pdp_set(EOS_CELL_MTYPE_PDP_SET_PWD, pwd, buffer, sync);
+int eos_cell_pdp_set_pwd(char *pwd, EOSMessage *msg) {
+    return eos_cell_pdp_set(EOS_CELL_MTYPE_PDP_SET_PWD, pwd, msg);
 }
 
-int eos_cell_pdp_connect(unsigned char *buffer, int sync) {
-    int async;
+int eos_cell_pdp_connect(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_PDP | EOS_CELL_MTYPE_PDP_CONNECT;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_CELL_MTYPE_PDP | EOS_CELL_MTYPE_PDP_CONNECT;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1);
 }
 
-int eos_cell_pdp_disconnect(unsigned char *buffer, int sync) {
-    int async;
+int eos_cell_pdp_disconnect(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_PDP | EOS_CELL_MTYPE_PDP_DISCONNECT;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_CELL_MTYPE_PDP | EOS_CELL_MTYPE_PDP_DISCONNECT;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1);
 }
diff --git a/fw/fe310/eos/net/cell.h b/fw/fe310/eos/net/cell.h
index 3264022..9517d8e 100644
--- a/fw/fe310/eos/net/cell.h
+++ b/fw/fe310/eos/net/cell.h
@@ -71,30 +71,35 @@
 void eos_cell_init(void);
 void eos_cell_set_handler(unsigned char mtype, eos_evt_handler_t handler);
 eos_evt_handler_t eos_cell_get_handler(unsigned char mtype);
-int eos_cell_send_buffer(unsigned char *buffer, uint16_t buf_len, uint16_t offset, int sync);
-
-int eos_cell_status_parse(unsigned char *buffer, uint16_t buf_len, uint8_t *status, uint8_t *connected);
-int eos_cell_status(uint8_t *status, uint8_t *connected, unsigned char *buffer);
-
-int eos_cell_uart_take(unsigned char *buffer, int sync);
-int eos_cell_uart_give(unsigned char *buffer, int sync);
-unsigned char *eos_cell_uart_data_alloc(uint16_t *offset);
-
-int eos_cell_voice_dial(char *num, unsigned char *buffer, int sync);
-int eos_cell_voice_answer(unsigned char *buffer, int sync);
-int eos_cell_voice_hangup(unsigned char *buffer, int sync);
-unsigned char *eos_cell_voice_pcm_alloc(uint16_t *offset);
-int eos_cell_sms_send(char *addr, char *txt, unsigned char *buffer, int sync);
-int _eos_cell_sms_parse(unsigned char *buffer, uint16_t buf_len, char **addr, uint16_t *addr_len, char **txt, uint16_t *txt_len);
-int eos_cell_sms_parse(unsigned char *buffer, uint16_t buf_len, char *addr, uint16_t addr_size, char *txt, uint16_t txt_size);
-
-int eos_cell_pdp_get(unsigned char atype, char *arg, uint16_t arg_size, unsigned char *buffer);
-int eos_cell_pdp_set(unsigned char atype, char *arg, unsigned char *buffer, int sync);
-int eos_cell_pdp_get_apn(char *apn, uint16_t apn_size, unsigned char *buffer);
-int eos_cell_pdp_set_apn(char *apn, unsigned char *buffer, int sync);
-int eos_cell_pdp_get_usr(char *usr, uint16_t usr_size, unsigned char *buffer);
-int eos_cell_pdp_set_usr(char *usr, unsigned char *buffer, int sync);
-int eos_cell_pdp_get_pwd(char *pwd, uint16_t pwd_size, unsigned char *buffer);
-int eos_cell_pdp_set_pwd(char *pwd, unsigned char *buffer, int sync);
-int eos_cell_pdp_connect(unsigned char *buffer, int sync);
-int eos_cell_pdp_disconnect(unsigned char *buffer, int sync);
+
+int eos_cell_status_parse(EOSMessage *msg, uint16_t len, uint8_t *status, uint8_t *connected);
+int eos_cell_status(uint8_t *status, uint8_t *connected, EOSMessage *msg);
+
+int eos_cell_uart_take(EOSMessage *msg);
+int eos_cell_uart_give(EOSMessage *msg);
+unsigned char *eos_cell_uart_msg2data(EOSMessage *msg, uint16_t *len, uint16_t *size);
+int eos_cell_uart_send(EOSMessage *msg, uint16_t len);
+int eos_cell_uart_send_async(EOSMessage *msg, uint16_t len, int more);
+
+int eos_cell_voice_dial(char *num, EOSMessage *msg);
+int eos_cell_voice_answer(EOSMessage *msg);
+int eos_cell_voice_hangup(EOSMessage *msg);
+unsigned char *eos_cell_voice_msg2pcm(EOSMessage *msg, uint16_t *len, uint16_t *size);
+int eos_cell_voice_pcm_send(EOSMessage *msg, uint16_t len);
+int eos_cell_voice_pcm_send_async(EOSMessage *msg, uint16_t len, int more);
+
+int eos_cell_sms_send(char *addr, char *txt, EOSMessage *msg);
+int _eos_cell_sms_parse(EOSMessage *msg, uint16_t len, char **addr, uint16_t *addr_len, char **txt, uint16_t *txt_len);
+int eos_cell_sms_parse(EOSMessage *msg, uint16_t len, char *addr, uint16_t addr_size, char *txt, uint16_t txt_size);
+char *eos_cell_sms_msg2txt(EOSMessage *msg, uint16_t *len);
+
+int eos_cell_pdp_get(unsigned char atype, char *arg, uint16_t arg_size, EOSMessage *msg);
+int eos_cell_pdp_set(unsigned char atype, char *arg, EOSMessage *msg);
+int eos_cell_pdp_get_apn(char *apn, uint16_t apn_size, EOSMessage *msg);
+int eos_cell_pdp_set_apn(char *apn, EOSMessage *msg);
+int eos_cell_pdp_get_usr(char *usr, uint16_t usr_size, EOSMessage *msg);
+int eos_cell_pdp_set_usr(char *usr, EOSMessage *msg);
+int eos_cell_pdp_get_pwd(char *pwd, uint16_t pwd_size, EOSMessage *msg);
+int eos_cell_pdp_set_pwd(char *pwd, EOSMessage *msg);
+int eos_cell_pdp_connect(EOSMessage *msg);
+int eos_cell_pdp_disconnect(EOSMessage *msg);
diff --git a/fw/fe310/eos/net/rng.c b/fw/fe310/eos/net/rng.c
index 7d05a81..414a6fa 100644
--- a/fw/fe310/eos/net/rng.c
+++ b/fw/fe310/eos/net/rng.c
@@ -2,26 +2,34 @@
 #include <stdint.h>
 #include <string.h>
 
+#include "eos.h"
+#include "event.h"
 #include "dev/net.h"
 
 int getentropy(unsigned char *b, size_t sz) {
     unsigned char type;
-    unsigned char *buffer;
+    EOSMessage msg;
     uint16_t len;
     int rv;
 
-    buffer = eos_net_alloc();
-
     type = EOS_NET_MTYPE_RNG;
     len = sizeof(uint16_t);
-    buffer[0] = sz >> 8;
-    buffer[1] = sz;
 
-    rv = eos_net_xchg(&type, buffer, &len);
+    eos_net_alloc(&msg);
+
+    if ((msg.size < len) || (msg.size < sz)) {
+        eos_net_free(&msg, 1);
+        return -1;
+    }
+
+    msg.buffer[0] = sz >> 8;
+    msg.buffer[1] = sz;
+
+    rv = eos_net_xchg(&type, &msg, &len);
     if (rv || (len != sz)) rv = -1;
 
-    if (!rv) memcpy(b, buffer, sz);
-    eos_net_free(buffer, 1);
+    if (!rv) memcpy(b, msg.buffer, sz);
+    eos_net_free(&msg, 1);
 
     return rv;
 }
diff --git a/fw/fe310/eos/net/sock.c b/fw/fe310/eos/net/sock.c
index c55b8e8..0c2f07d 100644
--- a/fw/fe310/eos/net/sock.c
+++ b/fw/fe310/eos/net/sock.c
@@ -10,40 +10,41 @@
 
 static eos_evt_handler_t evt_handler[EOS_SOCK_MAX_SOCK];
 
-static void sock_handle_msg(unsigned char type, unsigned char *buffer, uint16_t buf_len) {
+static void sock_handle_msg(unsigned char type, EOSMessage *msg, uint16_t len) {
     unsigned char sock;
     int i;
 
-    if ((buffer == NULL) || (buf_len < 2)) {
-        eos_net_bad_handler(type, buffer, buf_len);
+    if ((msg == NULL) || (len < 2)) {
+        eos_net_bad_handler(type, msg, len);
         return;
     }
 
-    switch(buffer[0]) {
+    switch(msg->buffer[0]) {
         case EOS_SOCK_MTYPE_PKT: {
-            sock = buffer[1];
+            sock = msg->buffer[1];
             if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK) || (evt_handler[sock - 1] == NULL)) {
-                eos_net_bad_handler(type, buffer, buf_len);
+                eos_net_bad_handler(type, msg, len);
                 return;
             }
-            evt_handler[sock - 1](type, buffer, buf_len);
+            evt_handler[sock - 1](type, msg, len);
             break;
         }
 
         case EOS_SOCK_MTYPE_CLOSE: {
-            for (i=1; i<buf_len; i++) {
-                sock = buffer[i];
+            for (i=1; i<len; i++) {
+                sock = msg->buffer[i];
                 if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK) || (evt_handler[sock - 1] == NULL)) {
-                    eos_net_bad_handler(type, buffer, buf_len);
-                    return;
+                    eos_net_bad_handler(type, msg, len);
+                    continue;
                 }
-                evt_handler[sock - 1](type, buffer, buf_len);
+                evt_handler[sock - 1](type, msg, len);
+                evt_handler[sock - 1] = NULL;
             }
             break;
         }
 
         default:
-            eos_net_bad_handler(type, buffer, buf_len);
+            eos_net_bad_handler(type, msg, len);
             break;
     }
 }
@@ -66,85 +67,44 @@ eos_evt_handler_t eos_sock_get_handler(unsigned char sock) {
     return NULL;
 }
 
-int eos_sock_open_udp(eos_evt_handler_t handler, unsigned char *buffer) {
+int eos_sock_open_udp(eos_evt_handler_t handler, EOSMessage *msg) {
     unsigned char type;
-    uint16_t buf_len;
-    int do_release;
+    uint16_t len;
     int rv, sock;
 
-    do_release = 0;
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        do_release = 1;
-    }
+    if (msg->size < 2) return EOS_ERR_SIZE;
 
     type = EOS_NET_MTYPE_SOCK;
-    buf_len = 1;
-    buffer[0] = EOS_SOCK_MTYPE_OPEN_DGRAM;
+    len = 1;
+    msg->buffer[0] = EOS_SOCK_MTYPE_OPEN_DGRAM;
 
-    rv = eos_net_xchg(&type, buffer, &buf_len);
-    if (rv) goto sock_open_udp_fin;
+    rv = eos_net_xchg(&type, msg, &len);
+    if (rv) return rv;
 
-    if (type != EOS_NET_MTYPE_SOCK) {
-        rv = EOS_ERR_NET;
-        goto sock_open_udp_fin;
-    }
-    if (buf_len < 2) {
-        rv = EOS_ERR_SIZE;
-        goto sock_open_udp_fin;
-    }
+    if (type != EOS_NET_MTYPE_SOCK) return EOS_ERR_NET;
+    if (len < 2) return EOS_ERR_SIZE;
 
-    sock = buffer[1];
-    if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK)) {
-        rv = EOS_ERR_NET;
-        goto sock_open_udp_fin;
-    }
+    sock = msg->buffer[1];
+    if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK)) return EOS_ERR_NET;
 
-    rv = sock;
     eos_sock_set_handler(sock, handler);
-
-sock_open_udp_fin:
-    if (do_release) eos_net_free(buffer, 1);
-    return rv;
+    return sock;
 }
 
-void eos_sock_close(unsigned char sock, unsigned char *buffer) {
-    int async;
+void eos_sock_close(unsigned char sock, EOSMessage *msg) {
+    if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK)) return;
+    if (msg->size < 2) return;
 
-    async = 0;
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    }
-    buffer[0] = EOS_SOCK_MTYPE_CLOSE;
-    buffer[1] = sock;
-    _eos_net_send(EOS_NET_MTYPE_SOCK, buffer, 2, async, 1);
+    msg->buffer[0] = EOS_SOCK_MTYPE_CLOSE;
+    msg->buffer[1] = sock;
+    eos_net_send_sync(EOS_NET_MTYPE_SOCK, msg, 2);
     eos_sock_set_handler(sock, NULL);
 }
 
-int eos_sock_pkt_alloc(unsigned char **buffer, unsigned char *pkt, size_t pkt_len) {
-    *buffer = NULL;
-
-    if (pkt && (pkt_len + EOS_SOCK_SIZE_UDP_HDR > EOS_NET_SIZE_BUF)) return EOS_ERR_SIZE;
-
-    *buffer = eos_net_alloc();
-    *buffer += EOS_SOCK_SIZE_UDP_HDR;
-    if (pkt) memcpy(*buffer, pkt, pkt_len);
-
-    return EOS_OK;
-}
-
-unsigned char *eos_sock_buf2pkt(unsigned char *buf, uint16_t buf_len) {
-    if (buf_len < EOS_SOCK_SIZE_UDP_HDR) return NULL;
+static void sock_sendto(unsigned char sock, EOSNetAddr *addr, EOSMessage *msg) {
+    unsigned char *buffer;
 
-    return buf + EOS_SOCK_SIZE_UDP_HDR;
-}
-
-unsigned char *eos_sock_pkt2buf(unsigned char *pkt) {
-    return pkt - EOS_SOCK_SIZE_UDP_HDR;
-}
-
-static void sock_sendto(unsigned char sock, EOSNetAddr *addr, unsigned char *buffer) {
+    buffer = msg->buffer;
     buffer[0] = EOS_SOCK_MTYPE_PKT;
     buffer[1] = sock;
     buffer += 2;
@@ -155,28 +115,24 @@ static void sock_sendto(unsigned char sock, EOSNetAddr *addr, unsigned char *buf
     buffer += sizeof(addr->port);
 }
 
-int eos_sock_sendto(unsigned char sock, EOSNetAddr *addr, unsigned char *buffer, uint16_t buf_len, unsigned char more) {
-    int rv;
+int eos_sock_sendto(unsigned char sock, EOSNetAddr *addr, EOSMessage *msg, uint16_t pkt_len) {
+    if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK)) return EOS_ERR_NET;
 
-    buffer -= EOS_SOCK_SIZE_UDP_HDR;
-    sock_sendto(sock, addr, buffer);
-
-    rv = eos_net_send(EOS_NET_MTYPE_SOCK, buffer, buf_len + EOS_SOCK_SIZE_UDP_HDR, more);
-    return rv;
+    sock_sendto(sock, addr, msg);
+    return eos_net_send_sync(EOS_NET_MTYPE_SOCK, msg, pkt_len + EOS_SOCK_SIZE_UDP_HDR);
 }
 
-int eos_sock_sendto_sync(unsigned char sock, EOSNetAddr *addr, unsigned char *buffer, uint16_t buf_len) {
-    int rv;
-
-    buffer -= EOS_SOCK_SIZE_UDP_HDR;
-    sock_sendto(sock, addr, buffer);
+int eos_sock_sendto_async(unsigned char sock, EOSNetAddr *addr, EOSMessage *msg, uint16_t pkt_len, int more) {
+    if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK)) return EOS_ERR_NET;
 
-    rv = eos_net_send_sync(EOS_NET_MTYPE_SOCK, buffer, buf_len + EOS_SOCK_SIZE_UDP_HDR);
-    return rv;
+    sock_sendto(sock, addr, msg);
+    return eos_net_send(EOS_NET_MTYPE_SOCK, msg, pkt_len + EOS_SOCK_SIZE_UDP_HDR, more);
 }
 
-int eos_sock_recvfrom(unsigned char *buffer, uint16_t buf_len, EOSNetAddr *addr, unsigned char *pkt, size_t pkt_size) {
-    if (buf_len < EOS_SOCK_SIZE_UDP_HDR) return EOS_ERR_SIZE;
+int eos_sock_recvfrom(EOSMessage *msg, uint16_t len, EOSNetAddr *addr, unsigned char *pkt, size_t pkt_size) {
+    char *buffer = msg->buffer;
+
+    if (len < EOS_SOCK_SIZE_UDP_HDR) return EOS_ERR_SIZE;
 
     if (buffer[0] == EOS_SOCK_MTYPE_CLOSE) return EOS_SOCK_ERR_CLOSED;
     if (buffer[0] != EOS_SOCK_MTYPE_PKT) return EOS_ERR_NET;
@@ -192,9 +148,25 @@ int eos_sock_recvfrom(unsigned char *buffer, uint16_t buf_len, EOSNetAddr *addr,
     }
     buffer += sizeof(addr->port);
     if (pkt) {
-        if (pkt_size < buf_len - EOS_SOCK_SIZE_UDP_HDR) return EOS_ERR_SIZE;
-        memcpy(pkt, buffer, buf_len - EOS_SOCK_SIZE_UDP_HDR);
+        if (pkt_size < len - EOS_SOCK_SIZE_UDP_HDR) return EOS_ERR_SIZE;
+        memcpy(pkt, buffer, len - EOS_SOCK_SIZE_UDP_HDR);
     }
 
     return EOS_OK;
 }
+
+unsigned char *eos_sock_msg2pkt(EOSMessage *msg, uint16_t *len, uint16_t *pkt_size) {
+    if (len && (*len < EOS_SOCK_SIZE_UDP_HDR)) return NULL;
+    if (msg->size < EOS_SOCK_SIZE_UDP_HDR) return NULL;
+
+    if (len && (msg->buffer[0] != EOS_SOCK_MTYPE_PKT)) return NULL;
+
+    if (len) *len -= EOS_SOCK_SIZE_UDP_HDR;
+    if (pkt_size) *pkt_size = msg->size - EOS_SOCK_SIZE_UDP_HDR;
+    return msg->buffer + EOS_SOCK_SIZE_UDP_HDR;
+}
+
+void eos_sock_pkt2msg(EOSMessage *msg, unsigned char *pkt, uint16_t pkt_size) {
+    msg->buffer = pkt - EOS_SOCK_SIZE_UDP_HDR;
+    msg->size = pkt_size + EOS_SOCK_SIZE_UDP_HDR;
+}
diff --git a/fw/fe310/eos/net/sock.h b/fw/fe310/eos/net/sock.h
index 8dbb111..e873a7d 100644
--- a/fw/fe310/eos/net/sock.h
+++ b/fw/fe310/eos/net/sock.h
@@ -23,13 +23,12 @@ void eos_sock_init(void);
 void eos_sock_set_handler(unsigned char sock, eos_evt_handler_t handler);
 eos_evt_handler_t eos_sock_get_handler(unsigned char sock);
 
-int eos_sock_open_udp(eos_evt_handler_t handler, unsigned char *buffer);
-void eos_sock_close(unsigned char sock, unsigned char *buffer);
+int eos_sock_open_udp(eos_evt_handler_t handler, EOSMessage *msg);
+void eos_sock_close(unsigned char sock, EOSMessage *msg);
 
-int eos_sock_pkt_alloc(unsigned char **buffer, unsigned char *pkt, size_t pkt_len);
-unsigned char *eos_sock_buf2pkt(unsigned char *buf, uint16_t buf_len);
-unsigned char *eos_sock_pkt2buf(unsigned char *pkt);
+int eos_sock_sendto(unsigned char sock, EOSNetAddr *addr, EOSMessage *msg, uint16_t pkt_len);
+int eos_sock_sendto_async(unsigned char sock, EOSNetAddr *addr, EOSMessage *msg, uint16_t pkt_len, int more);
+int eos_sock_recvfrom(EOSMessage *msg, uint16_t len, EOSNetAddr *addr, unsigned char *pkt, size_t pkt_size);
 
-int eos_sock_sendto(unsigned char sock, EOSNetAddr *addr, unsigned char *buffer, uint16_t buf_len, unsigned char more);
-int eos_sock_sendto_sync(unsigned char sock, EOSNetAddr *addr, unsigned char *buffer, uint16_t buf_len);
-int eos_sock_recvfrom(unsigned char *buffer, uint16_t buf_len, EOSNetAddr *addr, unsigned char *pkt, size_t pkt_size);
+unsigned char *eos_sock_msg2pkt(EOSMessage *msg, uint16_t *len, uint16_t *pkt_size);
+void eos_sock_pkt2msg(EOSMessage *msg, unsigned char *pkt, uint16_t pkt_size);
diff --git a/fw/fe310/eos/net/wifi.c b/fw/fe310/eos/net/wifi.c
index 1391121..59f149c 100644
--- a/fw/fe310/eos/net/wifi.c
+++ b/fw/fe310/eos/net/wifi.c
@@ -10,19 +10,19 @@
 
 static eos_evt_handler_t evt_handler[EOS_WIFI_MAX_MTYPE];
 
-static void wifi_handle_msg(unsigned char type, unsigned char *buffer, uint16_t buf_len) {
+static void wifi_handle_msg(unsigned char type, EOSMessage *msg, uint16_t len) {
     unsigned char mtype;
 
-    if ((buffer == NULL) || (buf_len < 1)) {
-        eos_net_bad_handler(type, buffer, buf_len);
+    if ((msg == NULL) || (len < 1)) {
+        eos_net_bad_handler(type, msg, len);
         return;
     }
 
-    mtype = buffer[0];
+    mtype = msg->buffer[0];
     if ((mtype < EOS_WIFI_MAX_MTYPE) && evt_handler[mtype]) {
-        evt_handler[mtype](mtype, buffer, buf_len);
+        evt_handler[mtype](mtype, msg, len);
     } else {
-        eos_net_bad_handler(type, buffer, buf_len);
+        eos_net_bad_handler(type, msg, len);
     }
 }
 
@@ -44,147 +44,116 @@ eos_evt_handler_t eos_wifi_get_handler(unsigned char mtype) {
     return NULL;
 }
 
-int eos_wifi_status_parse(unsigned char *buffer, uint16_t buf_len, uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size) {
-    if (buf_len < 2) return EOS_ERR_SIZE;
+int eos_wifi_status_parse(EOSMessage *msg, uint16_t len, uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size) {
+    unsigned char *buffer = msg->buffer;
+
+    if (len < 2) return EOS_ERR_SIZE;
 
     if (buffer[0] != EOS_WIFI_MTYPE_STATUS) return EOS_ERR_NET;
     buffer++;
-    buf_len--;
+    len--;
 
     *status = buffer[0];
     buffer++;
-    buf_len--;
+    len--;
 
     switch (*status) {
         case EOS_WIFI_STATUS_GOT_IP:
-            if (buf_len < sizeof(uint32_t)) return EOS_ERR_SIZE;
+            if (len < sizeof(uint32_t)) return EOS_ERR_SIZE;
             if (ip_addr) memcpy(ip_addr, buffer, sizeof(uint32_t));
             buffer += sizeof(uint32_t);
-            buf_len -= sizeof(uint32_t);
+            len -= sizeof(uint32_t);
         case EOS_WIFI_STATUS_CONNECTED:
             if (ssid) {
-                if ((buf_len == 0) || (buf_len > EOS_WIFI_SIZE_SSID) || (buf_len > ssid_size - 1)) return EOS_ERR_SIZE;
-                memcpy(ssid, buffer, buf_len);
-                ssid[buf_len] = '\0';
+                if ((len == 0) || (len > EOS_WIFI_SIZE_SSID) || (len > ssid_size - 1)) return EOS_ERR_SIZE;
+                memcpy(ssid, buffer, len);
+                ssid[len] = '\0';
             }
             break;
     }
     return EOS_OK;
 }
 
-int eos_wifi_status(uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size, unsigned char *buffer) {
+int eos_wifi_status(uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size, EOSMessage *msg) {
     unsigned char type;
-    uint16_t buf_len;
-    int do_release;
+    uint16_t len;
     int rv;
 
-    do_release = 0;
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        do_release = 1;
-    }
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
     type = EOS_NET_MTYPE_WIFI;
-    buf_len = 1;
-    buffer[0] = EOS_WIFI_MTYPE_STATUS;
+    len = 1;
+    msg->buffer[0] = EOS_WIFI_MTYPE_STATUS;
 
-    rv = eos_net_xchg(&type, buffer, &buf_len);
-    if (rv) goto wifi_status_fin;
+    rv = eos_net_xchg(&type, msg, &len);
+    if (rv) return rv;
 
-    if (type != EOS_NET_MTYPE_WIFI) {
-        rv = EOS_ERR_NET;
-        goto wifi_status_fin;
-    }
-    rv = eos_wifi_status_parse(buffer, buf_len, status, ip_addr, ssid, ssid_size);
+    if (type != EOS_NET_MTYPE_WIFI) return EOS_ERR_NET;
 
-wifi_status_fin:
-    if (do_release) eos_net_free(buffer, 1);
-    return rv;
+    return eos_wifi_status_parse(msg, len, status, ip_addr, ssid, ssid_size);
 }
 
-int eos_wifi_start(unsigned char *buffer, int sync) {
-    int async;
+int eos_wifi_start(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_WIFI_MTYPE_START;
-    return _eos_net_send(EOS_NET_MTYPE_WIFI, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_WIFI_MTYPE_START;
+    return eos_net_send_sync(EOS_NET_MTYPE_WIFI, msg, 1);
 }
 
-int eos_wifi_stop(unsigned char *buffer, int sync) {
-    int async;
+int eos_wifi_stop(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_WIFI_MTYPE_STOP;
-    return _eos_net_send(EOS_NET_MTYPE_WIFI, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_WIFI_MTYPE_STOP;
+    return eos_net_send_sync(EOS_NET_MTYPE_WIFI, msg, 1);
 }
 
-int eos_wifi_scan(unsigned char *buffer, int sync) {
-    int async;
+int eos_wifi_scan(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_WIFI_MTYPE_SCAN;
-    return _eos_net_send(EOS_NET_MTYPE_WIFI, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_WIFI_MTYPE_SCAN;
+    return eos_net_send_sync(EOS_NET_MTYPE_WIFI, msg, 1);
+}
+
+unsigned char *eos_wifi_scan2data(EOSMessage *msg, uint16_t *len) {
+    if (*len < 1) return NULL;
+
+    if (msg->buffer[0] != EOS_WIFI_MTYPE_SCAN) return NULL;
+
+    if (len) *len -= 1;
+    return msg->buffer + 1;
 }
 
-int eos_wifi_connect(char *ssid, char *pwd, unsigned char *buffer, int sync) {
-    unsigned char *buf;
+int eos_wifi_connect(char *ssid, char *pwd, EOSMessage *msg) {
+    unsigned char *buffer = msg->buffer;
     size_t ssid_len, pwd_len;
-    int async;
 
     ssid_len = strlen(ssid);
     pwd_len = strlen(pwd);
     if (ssid_len > EOS_WIFI_SIZE_SSID) return EOS_ERR_SIZE;
     if (pwd_len > EOS_WIFI_SIZE_PWD) return EOS_ERR_SIZE;
+    if (msg->size < 3 + ssid_len + pwd_len) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buf = buffer;
-    buf[0] = EOS_WIFI_MTYPE_CONNECT;
-    buf++;
+    buffer[0] = EOS_WIFI_MTYPE_CONNECT;
+    buffer++;
 
-    *buf = ssid_len;
-    buf++;
+    *buffer = ssid_len;
+    buffer++;
 
-    memcpy(buf, ssid, ssid_len);
-    buf += ssid_len;
+    memcpy(buffer, ssid, ssid_len);
+    buffer += ssid_len;
 
-    *buf = pwd_len;
-    buf++;
+    *buffer = pwd_len;
+    buffer++;
 
-    memcpy(buf, pwd, pwd_len);
-    buf += pwd_len;
+    memcpy(buffer, pwd, pwd_len);
+    buffer += pwd_len;
 
-    return _eos_net_send(EOS_NET_MTYPE_WIFI, buffer, 3 + ssid_len + pwd_len, async, 1);
+    return eos_net_send_sync(EOS_NET_MTYPE_WIFI, msg, 3 + ssid_len + pwd_len);
 }
 
-int eos_wifi_disconnect(unsigned char *buffer, int sync) {
-    int async;
+int eos_wifi_disconnect(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_WIFI_MTYPE_DISCONNECT;
-    return _eos_net_send(EOS_NET_MTYPE_WIFI, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_WIFI_MTYPE_DISCONNECT;
+    return eos_net_send_sync(EOS_NET_MTYPE_WIFI, msg, 1);
 }
diff --git a/fw/fe310/eos/net/wifi.h b/fw/fe310/eos/net/wifi.h
index 800723e..1f64d73 100644
--- a/fw/fe310/eos/net/wifi.h
+++ b/fw/fe310/eos/net/wifi.h
@@ -25,10 +25,11 @@ void eos_wifi_init(void);
 void eos_wifi_set_handler(unsigned char mtype, eos_evt_handler_t handler);
 eos_evt_handler_t eos_wifi_get_handler(unsigned char mtype);
 
-int eos_wifi_status_parse(unsigned char *buffer, uint16_t buf_len, uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size);
-int eos_wifi_status(uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size, unsigned char *buffer);
-int eos_wifi_start(unsigned char *buffer, int sync);
-int eos_wifi_stop(unsigned char *buffer, int sync);
-int eos_wifi_scan(unsigned char *buffer, int sync);
-int eos_wifi_connect(char *ssid, char *pwd, unsigned char *buffer, int sync);
-int eos_wifi_disconnect(unsigned char *buffer, int sync);
+int eos_wifi_status_parse(EOSMessage *msg, uint16_t len, uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size);
+int eos_wifi_status(uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size, EOSMessage *msg);
+int eos_wifi_start(EOSMessage *msg);
+int eos_wifi_stop(EOSMessage *msg);
+int eos_wifi_scan(EOSMessage *msg);
+unsigned char *eos_wifi_scan2data(EOSMessage *msg, uint16_t *len);
+int eos_wifi_connect(char *ssid, char *pwd, EOSMessage *msg);
+int eos_wifi_disconnect(EOSMessage *msg);