static int at_worker_uart_send_mutex_init()
{
if (0 != aos_mutex_new(&at.at_uart_send_mutex)) {
LOGE(MODULE_NAME, "Creating at worker sem failed\r\n");
return -1;
}
return 0;
}
static int at_init_mutex()
{
if (0 != aos_mutex_new(&at._mutex)) {
LOGE(MODULE_NAME, "Creating mutex failed");
return -1;
}
return 0;
}
static int at_init_task_mutex()
{
if (0 != aos_mutex_new(&at.task_mutex)) {
LOGE(MODULE_NAME, "Creating task mutex failed\r\n");
return -1;
}
return 0;
}
void k_mutex_init(struct k_mutex *mutex)
{
if (NULL == mutex) {
BT_ERR("mutex is NULL\n");
return ;
}
aos_mutex_new(&mutex->mutex);
sys_dlist_init(&mutex->poll_events);
return ;
}
int vfs_init(void)
{
int ret = VFS_SUCCESS;
if (g_vfs_init == 1) {
return ret;
}
if ((ret = aos_mutex_new(&g_vfs_mutex)) != VFS_SUCCESS) {
return ret;
}
inode_init();
g_vfs_init = 1;
return ret;
}
static int sal_wifi_init(void)
{
int link;
char cmd[STOP_AUTOCONN_CMD_LEN] = {0};
char out[64] = {0};
if (inited) {
LOGW(TAG, "sal component is already initialized");
return 0;
}
if (0 != aos_mutex_new(&g_link_mutex)) {
LOGE(TAG, "Creating link mutex failed (%s %d).", __func__, __LINE__);
return -1;
}
memset(g_link, 0, sizeof(g_link));
for (link = 0; link < LINK_ID_MAX; link++) {
g_link[link].fd = -1;
}
/*wifi module fw version print */
snprintf(cmd, FWVER_CMD_LEN, "%s", FWVER_CMD);
at.send_raw(cmd, out, sizeof(out));
if (strstr(out, CMD_FAIL_RSP) != NULL) {
LOGE(TAG, "%s %d failed, out:%s", __func__, __LINE__, out);
} else {
if (strstr(out, "FWVER") != NULL) {
LOGI(TAG, "wifi bk7231 FW version is: %s", strstr(out, "FWVER"));
} else {
LOGI(TAG, "%s %d no found any wifi fw version!", __func__, __LINE__);
}
}
at.oob(NET_OOB_PREFIX, NULL, 0, net_event_handler, NULL);
at.oob(WIFIEVENT_OOB_PREFIX, NULL, 0, bk7231wifi_event_handler, NULL);
inited = 1;
return 0;
}
int audio_init(void)
{
int ret = 0;
if (aos_mutex_is_valid(&sai_mutex) || aos_sem_is_valid(&audio_sem)) {
KIDS_A10_PRT("Audio module initialization had completed before now.\n");
return -1;
}
ret = aos_mutex_new(&sai_mutex);
if (ret != 0) {
KIDS_A10_PRT("aos_mutex_new return failed.\n");
return -1;
}
ret = aos_sem_new(&audio_sem, 0);
if (ret != 0) {
KIDS_A10_PRT("aos_sem_new return failed.\n");
return -1;
}
return 0;
}
/**
* \brief Initialize usart interface
*/
int32_t usart_os_init(struct usart_os_descriptor *const descr, void *const hw, uint8_t *rx_buffer,
uint16_t rx_buffer_length, void *const func)
{
int32_t rc;
ASSERT(descr && hw && rx_buffer && rx_buffer_length);
if (ERR_NONE != ringbuffer_init(&descr->rx, rx_buffer, rx_buffer_length)) {
return ERR_INVALID_ARG;
}
descr->kbuf_data = aos_malloc(MAX_BUF_UART_BYTES);
if (descr->kbuf_data == NULL) {
return -1;
}
memset(descr->kbuf_data, 0, MAX_BUF_UART_BYTES);
rc = krhino_buf_queue_create(&descr->kbuf, "buf_queue_uart", descr->kbuf_data, MAX_BUF_UART_BYTES, 1);
rc = sem_init(&descr->rx_sem, 0);
if (rc < 0) {
return rc;
}
rc = sem_init(&descr->tx_sem, 0);
if (rc < 0) {
sem_deinit(&descr->rx_sem);
return rc;
}
rc = aos_mutex_new(&descr->rx_mutex);
if (rc < 0) {
sem_deinit(&descr->rx_sem);
sem_deinit(&descr->tx_sem);
return rc;
}
rc = aos_mutex_new(&descr->tx_mutex);
if (rc < 0) {
sem_deinit(&descr->rx_sem);
sem_deinit(&descr->tx_sem);
aos_mutex_free(&descr->rx_mutex);
return rc;
}
descr->sync_device.hw = hw;
rc = _usart_async_init(&descr->device, hw);
if (rc) {
sem_deinit(&descr->tx_sem);
sem_deinit(&descr->rx_sem);
aos_mutex_free(&descr->rx_mutex);
aos_mutex_free(&descr->tx_mutex);
return rc;
}
descr->rx_buffer = NULL;
descr->rx_size = 0;
descr->rx_length = 0;
descr->io.read = usart_async_read;
descr->io.write = usart_sync_write;
descr->device.usart_cb.tx_byte_sent = usart_os_process_byte_sent;
descr->device.usart_cb.rx_done_cb = usart_fill_rx_buffer;
descr->device.usart_cb.tx_done_cb = usart_os_transmission_complete;
descr->device.usart_cb.error_cb = usart_os_error;
_usart_async_set_irq_state(&descr->device, USART_ASYNC_RX_DONE, true);
_usart_async_set_irq_state(&descr->device, USART_ASYNC_ERROR, true);
return ERR_NONE;
}
