static int sal_wifi_close(int fd,
int32_t remote_port)
{
int link_id;
char cmd[STOP_CMD_LEN] = {0}, out[64];
link_id = fd_to_linkid(fd);
if (link_id >= LINK_ID_MAX) {
LOGE(TAG, "No connection found for fd (%d) in %s", fd, __func__);
return -1;
}
snprintf(cmd, STOP_CMD_LEN - 1, "%s=%d", STOP_CMD, link_id);
LOGD(TAG, "%s %d - AT cmd to run: %s", __func__, __LINE__, cmd);
at.send_raw(cmd, out, sizeof(out));
LOGD(TAG, "The AT response is: %s", out);
if (strstr(out, CMD_FAIL_RSP) != NULL) {
LOGE(TAG, "%s %d failed", __func__, __LINE__);
goto err;
}
if (aos_sem_wait(&g_link[link_id].sem_close, AOS_WAIT_FOREVER) != 0) {
LOGE(TAG, "%s sem_wait failed", __func__);
goto err;
}
LOGD(TAG, "%s sem_wait succeed.", __func__);
err:
if (aos_mutex_lock(&g_link_mutex, AOS_WAIT_FOREVER) != 0) {
LOGE(TAG, "Failed to lock mutex (%s).", __func__);
return -1;
}
if (aos_sem_is_valid(&g_link[link_id].sem_start)) {
aos_sem_free(&g_link[link_id].sem_start);
}
if (aos_sem_is_valid(&g_link[link_id].sem_close)) {
aos_sem_free(&g_link[link_id].sem_close);
}
g_link[link_id].fd = -1;
aos_mutex_unlock(&g_link_mutex);
return -1;
}
int k_sem_delete(struct k_sem *sem)
{
if (NULL == sem) {
BT_ERR("sem is NULL\n");
return -EINVAL;
}
aos_sem_free(&sem->sem);
return 0;
}
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;
}
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;
}
int sal_wifi_start(sal_conn_t *c)
{
int link_id;
char cmd[START_CMD_LEN] = {0};
char out[256] = {0};
if (!c || !c->addr) {
LOGE(TAG, "%s %d - invalid argument", __func__, __LINE__);
return -1;
}
if (aos_mutex_lock(&g_link_mutex, AOS_WAIT_FOREVER) != 0) {
LOGE(TAG, "Failed to lock mutex (%s).", __func__);
return -1;
}
for (link_id = 0; link_id < LINK_ID_MAX; link_id++) {
if (g_link[link_id].fd >= 0) {
continue;
} else {
g_link[link_id].fd = c->fd;
if (aos_sem_new(&g_link[link_id].sem_start, 0) != 0) {
LOGE(TAG, "failed to allocate semaphore %s", __func__);
g_link[link_id].fd = -1;
return -1;
}
if (aos_sem_new(&g_link[link_id].sem_close, 0) != 0) {
LOGE(TAG, "failed to allocate semaphore %s", __func__);
aos_sem_free(&g_link[link_id].sem_start);
g_link[link_id].fd = -1;
return -1;
}
break;
}
}
aos_mutex_unlock(&g_link_mutex);
// The caller should deal with this failure
if (link_id >= LINK_ID_MAX) {
LOGI(TAG, "No link available for now, %s failed.", __func__);
return -1;
}
LOGD(TAG, "Creating %s connection ...", start_cmd_type_str[c->type]);
switch (c->type) {
case TCP_SERVER:
snprintf(cmd, START_CMD_LEN - 1, "%s=%d,%s,%d,",
START_CMD, link_id, start_cmd_type_str[c->type], c->l_port);
break;
case TCP_CLIENT:
case SSL_CLIENT:
snprintf(cmd, START_CMD_LEN - 5 - 1, "%s=%d,%s,%s,%d",
START_CMD, link_id, start_cmd_type_str[c->type],
c->addr, c->r_port);
if (c->l_port >= 0) {
snprintf(cmd + strlen(cmd), 7, ",%d", c->l_port);
}
break;
case UDP_BROADCAST:
case UDP_UNICAST:
snprintf(cmd, START_CMD_LEN - 1, "%s=%d,%s,%s,%d,%d",
START_CMD, link_id, start_cmd_type_str[c->type],
c->addr, c->r_port, c->l_port);
break;
default:
LOGE(TAG, "Invalid connection type.");
goto err;
}
LOGD(TAG, "\r\n%s %d - AT cmd to run: %s \r\n", __func__, __LINE__, cmd);
at.send_raw(cmd, out, sizeof(out));
LOGD(TAG, "The AT response is: %s", out);
if (strstr(out, CMD_FAIL_RSP) != NULL) {
LOGE(TAG, "%s %d failed", __func__, __LINE__);
goto err;
}
if (aos_sem_wait(&g_link[link_id].sem_start, AOS_WAIT_FOREVER) != 0) {
LOGE(TAG, "%s sem_wait failed", __func__);
goto err;
}
LOGD(TAG, "%s sem_wait succeed.", __func__);
return 0;
err:
if (aos_mutex_lock(&g_link_mutex, AOS_WAIT_FOREVER) != 0) {
LOGE(TAG, "Failed to lock mutex (%s).", __func__);
return -1;
}
if (aos_sem_is_valid(&g_link[link_id].sem_start)) {
aos_sem_free(&g_link[link_id].sem_start);
}
if (aos_sem_is_valid(&g_link[link_id].sem_close)) {
aos_sem_free(&g_link[link_id].sem_close);
}
g_link[link_id].fd = -1;
aos_mutex_unlock(&g_link_mutex);
return -1;
}
static void deinit_parg(struct poll_arg *parg)
{
aos_sem_free(&parg->sem);
cpu_io_unregister(vfs_io_cb, parg);
}
static void deinit_parg(struct poll_arg *parg)
{
aos_sem_free(&parg->sem);
}
