void release_buff() {
if (NULL != msg_buf) {
aos_free(msg_buf);
}
if (NULL != msg_readbuf) {
aos_free(msg_readbuf);
}
}
void aos_queue_free(aos_queue_t *queue)
{
if (queue == NULL) {
return;
}
krhino_buf_queue_del(queue->hdl);
aos_free(queue->hdl);
queue->hdl = NULL;
}
void aos_sem_free(aos_sem_t *sem)
{
if (sem == NULL) {
return;
}
krhino_sem_del(sem->hdl);
aos_free(sem->hdl);
sem->hdl = NULL;
}
void aos_mutex_free(aos_mutex_t *mutex)
{
if (mutex == NULL) {
return;
}
krhino_mutex_del(mutex->hdl);
aos_free(mutex->hdl);
mutex->hdl = NULL;
}
int aos_workqueue_create(aos_workqueue_t *workqueue, int pri, int stack_size)
{
kstat_t ret;
cpu_stack_t *stk;
kworkqueue_t *wq;
if (workqueue == NULL) {
return -EINVAL;
}
if (stack_size < sizeof(cpu_stack_t)) {
return -EINVAL;
}
stk = aos_malloc(stack_size);
if (stk == NULL) {
return -ENOMEM;
}
wq = aos_malloc(sizeof(kworkqueue_t));
if (wq == NULL) {
aos_free(stk);
return -ENOMEM;
}
ret = krhino_workqueue_create(wq, "AOS", pri, stk,
stack_size / sizeof(cpu_stack_t));
if (ret != RHINO_SUCCESS) {
aos_free(wq);
aos_free(stk);
ERRNO_MAPPING(ret);
}
workqueue->hdl = wq;
workqueue->stk = stk;
return 0;
}
/**
* \brief Deinitialize usart interface
*/
int32_t usart_os_deinit(struct usart_os_descriptor *const descr)
{
ASSERT(descr);
_usart_async_deinit(&descr->device);
descr->io.read = NULL;
descr->io.write = NULL;
sem_deinit(&descr->rx_sem);
sem_deinit(&descr->tx_sem);
aos_mutex_free(&descr->rx_mutex);
aos_mutex_free(&descr->tx_mutex);
krhino_buf_queue_del(&descr->kbuf);
aos_free(descr->kbuf_data);
return ERR_NONE;
}
void aos_work_destroy(aos_work_t *work)
{
kwork_t *w;
if (work == NULL) {
return;
}
w = work->hdl;
if (w->timer != NULL) {
krhino_timer_stop(w->timer);
krhino_timer_dyn_del(w->timer);
}
aos_free(work->hdl);
work->hdl = NULL;
}
static int at_worker_task_del(at_task_t *tsk)
{
if (NULL == tsk) {
LOGE(MODULE_NAME, "invalid input %s \r\n", __func__);
return -1;
}
aos_mutex_lock(&at.task_mutex, AOS_WAIT_FOREVER);
slist_del(&tsk->next, &at.task_l);
aos_mutex_unlock(&at.task_mutex);
if (aos_sem_is_valid(&tsk->smpr)) {
aos_sem_free(&tsk->smpr);
}
if (tsk) {
aos_free(tsk);
}
return 0;
}
int aos_work_init(aos_work_t *work, void (*fn)(void *), void *arg, int dly)
{
kstat_t ret;
kwork_t *w;
if (work == NULL) {
return -EINVAL;
}
w = aos_malloc(sizeof(kwork_t));
if (w == NULL) {
return -ENOMEM;
}
ret = krhino_work_init(w, fn, arg, MS2TICK(dly));
if (ret != RHINO_SUCCESS) {
aos_free(w);
ERRNO_MAPPING(ret);
}
work->hdl = w;
return 0;
}
int aos_queue_new(aos_queue_t *queue, void *buf, unsigned int size, int max_msg)
{
kstat_t ret;
kbuf_queue_t *q;
if ((queue == NULL) || (buf == NULL)) {
return -EINVAL;
}
q = aos_malloc(sizeof(kbuf_queue_t));
if (q == NULL) {
return -ENOMEM;
}
ret = krhino_buf_queue_create(q, "AOS", buf, size, max_msg);
if (ret != RHINO_SUCCESS) {
aos_free(q);
ERRNO_MAPPING(ret);
}
queue->hdl = q;
return 0;
}
int aos_sem_new(aos_sem_t *sem, int count)
{
kstat_t ret;
ksem_t *s;
if (sem == NULL) {
return -EINVAL;
}
s = aos_malloc(sizeof(ksem_t));
if (s == NULL) {
return -ENOMEM;
}
ret = krhino_sem_create(s, "AOS", count);
if (ret != RHINO_SUCCESS) {
aos_free(s);
ERRNO_MAPPING(ret);
}
sem->hdl = s;
return 0;
}
int aos_mutex_new(aos_mutex_t *mutex)
{
kstat_t ret;
kmutex_t *m;
if (mutex == NULL) {
return -EINVAL;
}
m = aos_malloc(sizeof(kmutex_t));
if (m == NULL) {
return -ENOMEM;
}
ret = krhino_mutex_create(m, "AOS");
if (ret != RHINO_SUCCESS) {
aos_free(m);
ERRNO_MAPPING(ret);
}
mutex->hdl = m;
return 0;
}
static int at_reset()
{
int ret = 0;
char response[64] = {0};
char *commond = AT_RESET_CMD;
if (at._mode != ASYN) {
LOGE(MODULE_NAME, "Operation not supported in non asyn mode");
return -1;
}
at_task_t *tsk = (at_task_t *)aos_malloc(sizeof(at_task_t));
if (NULL == tsk) {
LOGE(MODULE_NAME, "tsk buffer allocating failed");
return -1;
}
if ((ret = aos_sem_new(&tsk->smpr, 0)) != 0) {
LOGE(MODULE_NAME, "failed to allocate semaphore");
goto end;
}
LOGD(MODULE_NAME, "at task created: %d, smpr: %d",
(uint32_t)tsk, (uint32_t)&tsk->smpr);
tsk->rsp = response;
tsk->rsp_offset = 0;
tsk->rsp_len = sizeof(response);
aos_mutex_lock(&at._mutex, AOS_WAIT_FOREVER);
slist_add_tail(&tsk->next, &at.task_l);
// uart operation should be inside mutex lock
if ((ret = hal_uart_send(&at._uart, (void *)commond,
strlen(commond), at._timeout)) != 0) {
aos_mutex_unlock(&at._mutex);
LOGE(MODULE_NAME, "uart send command failed");
goto end;
}
LOGD(MODULE_NAME, "Sending command %s", commond);
if ((ret = hal_uart_send(&at._uart, (void *)at._send_delimiter,
strlen(at._send_delimiter), at._timeout)) != 0) {
aos_mutex_unlock(&at._mutex);
LOGE(MODULE_NAME, "uart send delimiter failed");
goto end;
}
LOGD(MODULE_NAME, "Sending delimiter %s", at._send_delimiter);
aos_mutex_unlock(&at._mutex);
if ((ret = aos_sem_wait(&tsk->smpr, AOS_WAIT_FOREVER)) != 0) {
LOGE(MODULE_NAME, "sem_wait failed");
goto end;
}
LOGD(MODULE_NAME, "sem_wait succeed.");
end:
aos_mutex_lock(&at._mutex, AOS_WAIT_FOREVER);
slist_del(&tsk->next, &at.task_l);
aos_mutex_unlock(&at._mutex);
if (aos_sem_is_valid(&tsk->smpr)) {
aos_sem_free(&tsk->smpr);
}
if (tsk) {
aos_free(tsk);
}
return ret;
}
/**
* Example:
* AT+ENETRAWSEND=<len>
* ><data>
* OK
*
* Send data in 2 stages. These 2 stages must be finished inside
* one mutex lock.
* 1. Send 'fst' string (first stage);
* 2. Receving prompt, usually "<" character;
* 3. Send data (second stage) in 'len' length.
*/
static int at_send_data_2stage(const char *fst, const char *data,
uint32_t len, char *rsp, uint32_t rsplen/*, at_send_t t*/)
{
int ret = 0;
if (at._mode != ASYN) {
LOGE(MODULE_NAME, "Operation not supported in non asyn mode");
return -1;
}
if ((ret = at_reset()) != 0){
LOGE(MODULE_NAME, "There is something wrong with atparser and reset fail\n");
return -1;
}
at_task_t *tsk = (at_task_t *)aos_malloc(sizeof(at_task_t));
if (NULL == tsk) {
LOGE(MODULE_NAME, "tsk buffer allocating failed");
return -1;
}
if ((ret = aos_sem_new(&tsk->smpr, 0)) != 0) {
LOGE(MODULE_NAME, "failed to allocate semaphore");
goto end;
}
LOGD(MODULE_NAME, "at 2stage task created: %d, smpr: %d",
(uint32_t)tsk, (uint32_t)&tsk->smpr);
tsk->rsp = rsp;
tsk->rsp_offset = 0;
tsk->rsp_len = rsplen;
/* The 2 stages should be inside one mutex lock*/
/* Mutex context begin*/
aos_mutex_lock(&at._mutex, AOS_WAIT_FOREVER);
LOGD(MODULE_NAME, "%s: at lock got", __func__);
slist_add_tail(&tsk->next, &at.task_l);
// uart operation should be inside mutex lock
if ((ret = hal_uart_send(&at._uart, (void *)fst,
strlen(fst), at._timeout)) != 0) {
aos_mutex_unlock(&at._mutex);
LOGE(MODULE_NAME, "uart send 2stage prefix failed");
goto end;
}
LOGD(MODULE_NAME, "Sending 2stage prefix %s", fst);
if ((ret = hal_uart_send(&at._uart, (void *)at._send_delimiter,
strlen(at._send_delimiter), at._timeout)) != 0) {
aos_mutex_unlock(&at._mutex);
LOGE(MODULE_NAME, "uart send delimiter failed");
goto end;
}
LOGD(MODULE_NAME, "Sending delimiter %s", at._send_delimiter);
if ((ret = hal_uart_send(&at._uart, (void *)data,
len, at._timeout)) != 0) {
aos_mutex_unlock(&at._mutex);
LOGE(MODULE_NAME, "uart send 2stage data failed");
goto end;
}
LOGD(MODULE_NAME, "Sending 2stage data %s", data);
if ((ret = hal_uart_send(&at._uart, (void *)at._send_delimiter,
strlen(at._send_delimiter), at._timeout)) != 0) {
aos_mutex_unlock(&at._mutex);
LOGE(MODULE_NAME, "uart send delimiter failed");
goto end;
}
LOGD(MODULE_NAME, "Sending delimiter %s", at._send_delimiter);
aos_mutex_unlock(&at._mutex);
LOGD(MODULE_NAME, "%s: at lock released", __func__);
/* Mutex context end*/
if ((ret = aos_sem_wait(&tsk->smpr, AOS_WAIT_FOREVER)) != 0) {
LOGE(MODULE_NAME, "sem_wait failed");
goto end;
}
LOGD(MODULE_NAME, "sem_wait succeed.");
end:
aos_mutex_lock(&at._mutex, AOS_WAIT_FOREVER);
slist_del(&tsk->next, &at.task_l);
aos_mutex_unlock(&at._mutex);
if (aos_sem_is_valid(&tsk->smpr)) aos_sem_free(&tsk->smpr);
if (tsk) aos_free(tsk);
return ret;
}
static void handle_udp_broadcast_data()
{
uint32_t len = 0;
uint32_t remoteport = 0;
int32_t linkid = 0;
int32_t ret = 0;
char reader[16] = {0};
char ipaddr[16] = {0};
char *recvdata = NULL;
/* Eat the "DP_BROADCAST," */
at.read(reader, 13);
if (memcmp(reader, "DP_BROADCAST,", strlen("DP_BROADCAST,")) != 0) {
LOGE(TAG, "%s invalid event format!!!\r\n",
reader[0], reader[1], reader[2], reader[3], reader[4], reader[5]);
return;
}
/* get ip addr */
ret = socket_data_info_get(ipaddr, sizeof(ipaddr), &socket_ip_info_check);
if (ret) {
LOGE(TAG, "Invalid ip addr %s !!!\r\n", ipaddr);
return;
}
LOGD(TAG, "get broadcast form ip addr %s \r\n", ipaddr);
/* get ip port */
memset(reader, 0, sizeof(reader));
ret = socket_data_info_get(reader, sizeof(reader), &socket_data_len_check);
if (ret) {
LOGE(TAG, "Invalid ip addr %s !!!\r\n", reader);
return;
}
LOGD(TAG, "get broadcast form ip port %s \r\n", reader);
remoteport = atoi(reader);
memset(reader, 0, sizeof(reader));
ret = socket_data_info_get(reader, 1, &socket_data_len_check);
if (ret) {
LOGE(TAG, "Invalid link id 0x%02x !!!\r\n", reader[0]);
return;
}
linkid = reader[0] - '0';
LOGD(TAG, "get udp broadcast linkid %d \r\n", linkid);
/* len */
memset(reader, 0, sizeof(reader));
ret = socket_data_info_get(reader, sizeof(reader), &socket_data_len_check);
if (ret) {
LOGE(TAG, "Invalid datalen %s !!!\r\n", reader);
return;
}
len = atoi(reader);
if (len > MAX_DATA_LEN) {
LOGE(TAG, "invalid input socket data len %d \r\n", len);
return;
}
/* Prepare socket data */
recvdata = (char *)aos_malloc(len + 1);
if (!recvdata) {
LOGE(TAG, "Error: %s %d out of memory, len is %d. \r\n", __func__, __LINE__, len);
return;
}
at.read(recvdata, len);
recvdata[len] = '\0';
if (strcmp(ipaddr, localipaddr) != 0) {
if (g_netconn_data_input_cb && (g_link[linkid].fd >= 0)) {
if (g_netconn_data_input_cb(g_link[linkid].fd, recvdata, len, ipaddr, remoteport)) {
LOGE(TAG, " %s socket %d get data len %d fail to post to sal, drop it\n",
__func__, g_link[linkid].fd, len);
}
}
} else {
LOGD(TAG, "drop broadcast packet len %d \r\n", len);
}
aos_free(recvdata);
}
static void handle_socket_data()
{
int link_id = 0;
int ret = 0;
uint32_t len = 0;
char reader[16] = {0};
char *recvdata = NULL;
/* Eat the "OCKET," */
at.read(reader, 6);
if (memcmp(reader, "OCKET,", strlen("OCKET,")) != 0) {
LOGE(TAG, "0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x invalid event format!!!\r\n",
reader[0], reader[1], reader[2], reader[3], reader[4], reader[5]);
return;
}
memset(reader, 0, sizeof(reader));
ret = socket_data_info_get(reader, 1, &socket_data_len_check);
if (ret) {
LOGE(TAG, "Invalid link id 0x%02x !!!\r\n", reader[0]);
return;
}
link_id = reader[0] - '0';
memset(reader, 0, sizeof(reader));
/* len */
ret = socket_data_info_get(reader, sizeof(reader), &socket_data_len_check);
if (ret) {
LOGE(TAG, "Invalid datalen %s !!!\r\n", reader);
return;
}
len = atoi(reader);
if (len > MAX_DATA_LEN) {
LOGE(TAG, "invalid input socket data len %d \r\n", len);
return;
}
/* Prepare socket data */
recvdata = (char *)aos_malloc(len + 1);
if (!recvdata) {
LOGE(TAG, "Error: %s %d out of memory, len is %d. \r\n", __func__, __LINE__, len);
return;
}
at.read(recvdata, len);
recvdata[len] = '\0';
LOGD(TAG, "The socket data is %s", recvdata);
if (g_netconn_data_input_cb && (g_link[link_id].fd >= 0)) {
/* TODO get recv data src ip and port*/
if (g_netconn_data_input_cb(g_link[link_id].fd, recvdata, len, NULL, 0)) {
LOGE(TAG, " %s socket %d get data len %d fail to post to sal, drop it\n",
__func__, g_link[link_id].fd, len);
}
}
LOGD(TAG, "%s socket data on link %d with length %d posted to sal\n",
__func__, link_id, len);
aos_free(recvdata);
}
