pinebuds/services/communication/comminication_knowles/communication_sysapi.cpp

#include "cmsis_os.h"
#include "stdint.h"
#include "stdbool.h"
#include "string.h"
#include "cmsis_nvic.h"
#include "tool_msg.h"
#include "app_ai_if_config.h"
//#include "hal_timer_raw.h"
#include "hal_uart.h"
#include "hal_cmu.h"
#include "hal_bootmode.h"
#include "hal_iomux.h"
#include "pmu.h"
#include "app_thread.h"
#include "communication_sysapi.h"
#include "tgt_hardware.h"

//#define FLASH_BASE                              0x6C000000
//#define FLASH_TO_FLASHX(d)                      ((uint32_t)(d) & 0x0FFFFFFF)

#define WAIT_TRACE_TIMEOUT                      MS_TO_TICKS(200)

static uint32_t send_timeout = MS_TO_TICKS(500);

static const struct HAL_UART_CFG_T uart_cfg = {
    HAL_UART_PARITY_NONE,
#ifdef __KNOWLES
	HAL_UART_STOP_BITS_2,
#else
    HAL_UART_STOP_BITS_1,
#endif
    HAL_UART_DATA_BITS_8,
    HAL_UART_FLOW_CONTROL_NONE, // RTC/CTS pins might be unavailable for some chip packages
    HAL_UART_FIFO_LEVEL_1_2,
    HAL_UART_FIFO_LEVEL_1_2,
#ifdef __PC_CMD_UART__
        115200,
#else
        921600,
#endif
    true,
    false,
    false,
};
#ifdef __PC_CMD_UART__
static const enum HAL_UART_ID_T comm_uart = HAL_UART_ID_0;
#else
#ifdef CHIP_BEST2300P
static const enum HAL_UART_ID_T comm_uart = HAL_UART_ID_2;
#else
static const enum HAL_UART_ID_T comm_uart = HAL_UART_ID_1;
#endif
#endif
static volatile enum UART_DMA_STATE uart_dma_rx_state = UART_DMA_IDLE;
static volatile uint32_t uart_dma_rx_size = 0;
static bool uart_opened = false;


static volatile bool cancel_xfer = false;

static uint32_t xfer_err_time = 0;
static uint32_t xfer_err_cnt = 0;

#ifdef __KNOWLES

#include "Knowles_mic_demo.h"
#include "audio_dump.h"
#include "cqueue.h"

uint32_t kw_start_index = 0;
uint32_t kw_end_index = 0;
bool is_markers_read_done = false;

#ifdef KNOWLES_UART_DATA
uint8_t out_buf[ FRAME_SIZE ];
uint8_t found = 0;

static osMutexId uart_audio_pcmbuff_mutex_id = NULL;
osMutexDef(uart_audio_pcmbuff_mutex);

typedef enum {
    PP_PING = 0,
    PP_PANG = 1
} FIR_PP_T;


#define PP_PINGPANG(v) \
    (v == PP_PING ? PP_PANG: PP_PING)

static FIR_PP_T pp_index=PP_PING;
static uint32_t uart_dma_interval;

#define knowles_uart_packet_len FRAME_SIZE //640//20MS
static uint8_t audio_data_receive_buf[knowles_uart_packet_len*2]; //ping_pong_buffer


#ifdef SYSTEM_USE_PSRAM
#include "hal_location.h"
#define AMA_STREAM_UART_FIFO_SIZE (1024*32)
PSRAM_BSS_LOC  static unsigned char ama_uart_buff[AMA_STREAM_UART_FIFO_SIZE];
#else
#define AMA_STREAM_UART_FIFO_SIZE (1024*16)
static unsigned char ama_uart_buff[AMA_STREAM_UART_FIFO_SIZE];
#endif
static CQueue ama_uart_queue = {0};

extern osThreadId knowles_uart_audio_tid;

#define APP_UART_FLOW_CONTROL_TIMEOUT_INTERVEL           (12)

static void app_uart_flow_control_timeout_timer_cb(void const *n);
osTimerDef (APP_UART_FLOW_CONTROL_TIMEOUT, app_uart_flow_control_timeout_timer_cb);
osTimerId	app_uart_flow_control_timeout_timer_id = NULL;



static void app_uart_flow_control_timeout_timer_cb(void const *n)
{
    uint32_t available_buffer;
    unsigned char get_next_chunk_cmd[4];
    smart_mic_get_nextchunk_cmd(get_next_chunk_cmd);

    available_buffer = avil_len_of_the_fifo();
    available_buffer = AMA_STREAM_UART_FIFO_SIZE - available_buffer;

    TRACE(1,"UART_FLOW_CONTROL: Available UART Buffer %d\n", available_buffer);
    if(available_buffer > 1024)
    {
        //TRACE(0,"More than 1024 bytes availble hence sending next chunk command \n");
        send_data(get_next_chunk_cmd, 4);
        osTimerStop(app_uart_flow_control_timeout_timer_id);
        osTimerStart(app_uart_flow_control_timeout_timer_id, APP_UART_FLOW_CONTROL_TIMEOUT_INTERVEL);
    }
    else
    {
        //TRACE(0,"no buffer available hence triggering timer for 10ms\n");
        osTimerStop(app_uart_flow_control_timeout_timer_id);
        osTimerStart(app_uart_flow_control_timeout_timer_id, APP_UART_FLOW_CONTROL_TIMEOUT_INTERVEL);
    }
}

void ama_uart_stream_fifo_init()
{
    if (uart_audio_pcmbuff_mutex_id == NULL)
    {
        uart_audio_pcmbuff_mutex_id = osMutexCreate((osMutex(uart_audio_pcmbuff_mutex)));
    }

    pp_index=PP_PING;

    if (knowles_uart_audio_tid)
    {
        osSignalClear(knowles_uart_audio_tid, UART_OUT_SIGNAL_ID);
    }

    memset(audio_data_receive_buf,0,sizeof(audio_data_receive_buf));
    InitCQueue(&ama_uart_queue, AMA_STREAM_UART_FIFO_SIZE,
                (CQItemType *)ama_uart_buff);
}

uint32_t ama_uart_get_fifo_data(uint8_t *buf)
{
    uint32_t avail = 0;

    avail = LengthOfCQueue(&ama_uart_queue);
    if (avail > 0) {
        if (avail < knowles_uart_packet_len) {
            TRACE(2,"%s: Invalid  UART STREAM SIZE: %d", __FUNCTION__, avail);
            return 0;
        } else {
            //TRACE(1,"UART_GET_len %d",knowles_uart_packet_len);
            if(!DeCQueue(&ama_uart_queue, buf, knowles_uart_packet_len))
                return knowles_uart_packet_len;
            TRACE(2,"%s: queue get data error len %d", __func__, knowles_uart_packet_len);
            return 0;
        }
    } else {
        TRACE(0,"uart no stream to get");
        return 0;
    }
}

uint32_t avil_len_of_the_fifo()
{
	return LengthOfCQueue(&ama_uart_queue);
}

extern "C" void OS_NotifyEvm(void);

void send_message()
{
	OS_NotifyEvm();
}
#endif
#endif

static void uart_break_handler(void)
{
    TRACE(0,"****** Handle break ******");

    cancel_xfer = true;
    hal_uart_stop_dma_recv(comm_uart);
    hal_uart_stop_dma_send(comm_uart);
    uart_dma_rx_state = UART_DMA_ERROR;
}

extern "C" uint8_t app_ai_is_stream_running(void);
static void uart_rx_dma_handler(uint32_t xfer_size, int dma_error, union HAL_UART_IRQ_T status)
{
    if (status.BE) {
        uart_break_handler();
        return;
    }

    // The DMA transfer has been cancelled
#ifndef KNOWLES_UART_DATA
    if (uart_dma_rx_state != UART_DMA_START) {
        return;
    }
#endif
    uart_dma_rx_size = xfer_size;
    if (dma_error || status.FE || status.OE || status.PE || status.BE) {
        TRACE(2,"UART-RX Error: dma_error=%d, status=0x%08x", dma_error, status.reg);
        uart_dma_rx_state = UART_DMA_ERROR;
    } else {
        //TRACE(1,"UART-RX OK: rx_size=%d", uart_dma_rx_size);
        uart_dma_rx_state = UART_DMA_DONE;
        int ret = 0;
        //TRACE(1,"UART DMA INTERUPT TIME=%d",hal_sys_timer_get()-uart_dma_interval);
        uart_dma_interval=hal_sys_timer_get();
         if(app_ai_is_stream_running())
         {
            if(!EnCQueue(&ama_uart_queue, (uint8_t *)&audio_data_receive_buf[pp_index*knowles_uart_packet_len], FRAME_SIZE))
                ret = FRAME_SIZE;
            if (ret < FRAME_SIZE) {
                TRACE(2,"%s:WARNING !!! UART STREAM OVERFLOW Dropping %d Bytes", __FUNCTION__, (FRAME_SIZE - ret));
            }

            osSignalSet(knowles_uart_audio_tid, UART_OUT_SIGNAL_ID);
         }
        pp_index=PP_PINGPANG(pp_index);
    }
}

void recv_data_state_get(enum UART_DMA_STATE *state)
{
    *state = uart_dma_rx_state;
}

void recv_data_reset(void)
{
    union HAL_UART_IRQ_T mask;
    mask.reg = 0;
    mask.BE = 1;
    hal_uart_irq_set_mask(comm_uart, mask);
    uart_dma_rx_state = UART_DMA_IDLE;
}

void init_transport(void)
{
    union HAL_UART_IRQ_T mask;
    struct HAL_UART_CFG_T comm_uart_cfg;
#ifdef KNOWLES_UART_DATA
	//audio_dump_init(320, 1);
	ama_uart_stream_fifo_init();
#endif
    if (!uart_opened) {
#ifdef __PC_CMD_UART__
		hal_iomux_set_uart0();
#else
#ifdef CHIP_BEST2300P
		hal_iomux_init(cfg_pinmux_uart, ARRAY_SIZE(cfg_pinmux_uart));
#else
        hal_iomux_set_uart1();
#endif
#endif
        memcpy(&comm_uart_cfg, &uart_cfg, sizeof(comm_uart_cfg));
        hal_uart_open(comm_uart, &comm_uart_cfg);
        mask.reg = 0;
        mask.BE = 1;
        mask.FE = 1;
        mask.OE = 1;
        mask.PE = 1;

        hal_uart_irq_set_dma_handler(comm_uart, uart_rx_dma_handler, NULL);
        hal_uart_irq_set_mask(comm_uart, mask);
        uart_opened = true;
    }

    cancel_xfer = false;

    hal_uart_flush(comm_uart,0);
#ifdef KNOWLES_UART_DATA
    if(recv_data(&audio_data_receive_buf[0], knowles_uart_packet_len*2) < 0)
        TRACE(1,"%s error", __func__);
    smart_mic_stream_header_parser_init(FRAME_SIZE);
#endif

    app_uart_flow_control_timeout_timer_id = osTimerCreate(osTimer(APP_UART_FLOW_CONTROL_TIMEOUT), osTimerOnce, NULL);

}


void deinit_transport(void)
{
    union HAL_UART_IRQ_T mask;

    mask.reg = 0;

	//audio_dump_clear_up(); //added by punith

    hal_uart_stop_dma_recv(comm_uart);//punith
    uart_dma_rx_state = UART_DMA_IDLE;
    hal_uart_irq_set_mask(comm_uart, mask);
    hal_uart_irq_set_dma_handler(comm_uart, NULL, NULL);
    hal_uart_close(comm_uart);


	hal_uart_flush(comm_uart,0);
    uart_opened = false;
	cancel_xfer = true;

	osTimerStop(app_uart_flow_control_timeout_timer_id);
    if (osTimerDelete(app_uart_flow_control_timeout_timer_id) != osOK)
    {
        TRACE(0,"app_uart_flow_control_timeout_timer_id Failed !!!!");
    }

}




void reinit_transport(void)
{
    union HAL_UART_IRQ_T mask;
    struct HAL_UART_CFG_T comm_uart_cfg;

    uart_opened = false;
    memcpy(&comm_uart_cfg, &uart_cfg, sizeof(comm_uart_cfg));
    hal_uart_open(comm_uart, &comm_uart_cfg);
    mask.reg = 0;
    mask.BE = 1;
    mask.FE = 1;
    mask.OE = 1;
    mask.PE = 1;
    hal_uart_irq_set_dma_handler(comm_uart, uart_rx_dma_handler, NULL);
    hal_uart_irq_set_mask(comm_uart, mask);
    uart_opened = true;

    cancel_xfer = false;

    hal_uart_flush(comm_uart,0);
}

void set_send_timeout(uint32_t timeout)
{
    send_timeout = MS_TO_TICKS(timeout);
}

int debug_read_enabled(void)
{
    return !!(hal_sw_bootmode_get() & HAL_SW_BOOTMODE_READ_ENABLED);
}

int debug_write_enabled(void)
{
    return !!(hal_sw_bootmode_get() & HAL_SW_BOOTMODE_WRITE_ENABLED);
}

static int uart_send_data(const unsigned char *buf, unsigned int len)
{
    uint32_t start;
    uint32_t sent = 0;

    start = hal_sys_timer_get();
    while (sent < len) {
        while (!cancel_xfer && !hal_uart_writable(comm_uart) &&
                hal_sys_timer_get() - start < send_timeout);
        if (cancel_xfer) {
            break;
        }
        if (hal_uart_writable(comm_uart)) {
            hal_uart_putc(comm_uart, buf[sent++]);
        } else {
            break;
        }
    }

    if (sent != len) {
        return 1;
    }

    return 0;
}

int send_data(const unsigned char *buf, unsigned int len)
{
    if (cancel_xfer) {
        return -1;
    }

    return uart_send_data(buf, len);
}


static struct HAL_DMA_DESC_T dma_desc[17] = {0};

static int uart_recv_data_dma(unsigned char *buf, unsigned int len, unsigned int expect)
{
    int ret;
    union HAL_UART_IRQ_T mask;

    uint32_t desc_cnt = ARRAY_SIZE(dma_desc);

    if (uart_dma_rx_state != UART_DMA_IDLE) {
        ret = -3;
        goto _no_state_exit;
    }

    uart_dma_rx_state = UART_DMA_START;
    uart_dma_rx_size = 0;

#ifdef KNOWLES_UART_DATA
	ret = hal_uart_dma_recv_pingpang(comm_uart, buf, expect, &dma_desc[0], &desc_cnt);
#else
	ret = hal_uart_dma_recv(comm_uart, buf, expect, &dma_desc[0], &desc_cnt);
#endif

    if (ret) {
        uart_dma_rx_state = UART_DMA_ERROR;
        goto err_exit;
    }

    mask.reg = 0;
    mask.BE = 1;
    mask.FE = 1;
    mask.OE = 1;
    mask.PE = 1;
    //mask.RT = 1;
    hal_uart_irq_set_mask(comm_uart, mask);

_no_state_exit:
    TRACE(2,"%s ret %d", __func__, ret);
    return ret;
err_exit:
    TRACE(2,"%s err_exit ret %d", __func__, ret);
    return -1;
}

int recv_data(unsigned char *buf, unsigned int len)
{
	TRACE(3,"%s %d %d",__func__, cancel_xfer, len);
    if (cancel_xfer) {
        return -1;
    }
    return uart_recv_data_dma(buf, len, len);
}

int recv_data_dma(unsigned char *buf, unsigned int len, unsigned int expect)
{
    if (cancel_xfer) {
        return -1;
    }

    return uart_recv_data_dma(buf, len, expect);
}

static int uart_handle_error(void)
{
    TRACE(0,"****** Send break ******");

    // Send break signal, to tell the peer to reset the connection
    hal_uart_break_set(comm_uart);
    osDelay(100);
    hal_uart_break_clear(comm_uart);

    return 0;
}

int handle_error(void)
{
    int ret = 0;
    uint32_t err_time;

    osDelay(200);

    if (!cancel_xfer) {
        ret = uart_handle_error();
    }

    xfer_err_cnt++;
    err_time = hal_sys_timer_get();
    if (err_time - xfer_err_time > MS_TO_TICKS(5000)) {
        xfer_err_cnt = 0;
    }
    xfer_err_time = err_time;
    if (xfer_err_cnt < 2) {
        osDelay(500);
    } else if (xfer_err_cnt < 5) {
        osDelay(1000);
    } else {
        osDelay(2000);
    }

    return ret;
}

static int uart_cancel_input(void)
{
    hal_uart_flush(comm_uart,0);
    return 0;
}

int cancel_input(void)
{
    return uart_cancel_input();
}

void system_reboot(void)
{
    hal_cmu_sys_reboot();
}

void system_shutdown(void)
{
    pmu_shutdown();
}

void system_set_bootmode(unsigned int bootmode)
{
    bootmode &= ~(HAL_SW_BOOTMODE_READ_ENABLED | HAL_SW_BOOTMODE_WRITE_ENABLED);
    hal_sw_bootmode_set(bootmode);
}

void system_clear_bootmode(unsigned int bootmode)
{
    bootmode &= ~(HAL_SW_BOOTMODE_READ_ENABLED | HAL_SW_BOOTMODE_WRITE_ENABLED);
    hal_sw_bootmode_clear(bootmode);
}

unsigned int system_get_bootmode(void)
{
    return hal_sw_bootmode_get();
}

void wait_trace_finished(void)
{
    uint32_t time;
    int idle_cnt = 0;

    time = hal_sys_timer_get();

    while (idle_cnt < 2 && hal_sys_timer_get() - time < WAIT_TRACE_TIMEOUT) {
        osDelay(10);
        idle_cnt = hal_trace_busy() ? 0 : (idle_cnt + 1);
    }
}

unsigned int get_current_time(void)
{
    return hal_sys_timer_get();
}

#ifdef KNOWLES_UART_DATA
uint8_t *uart_stream_buf;
bool send_start_speech = false;
extern bool is_markers_read_done;
#endif
#ifdef KNOWLES_UART_DATA
osThreadId  knowles_uart_audio_tid = NULL;
static void uart_data_process_thread(const void *arg);
osThreadDef(uart_data_process_thread, (osPriorityAboveNormal), 1, (1024*12), "UART_DATA");

int app_ai_voice_uart_audio_init()
{
    ama_uart_stream_fifo_init();
    if(knowles_uart_audio_tid==NULL)
        knowles_uart_audio_tid = osThreadCreate(osThread(uart_data_process_thread), NULL);
    if (knowles_uart_audio_tid == NULL)  {
        TRACE(0,"[UART AUDIO]Create thread error\n");
        return -1;
    }

    return 0;
}
void uart_data_process_thread(const void *arg)
{
    uint32_t ret = 0;
    uint32_t frame_len=0;
    //uint32_t stime,etime;
    //stime=hal_sys_timer_get();
    
    while(1)
    {
        //TRACE(0,"---in uart_process_thread\n");
        osEvent evt;
        
        if(avil_len_of_the_fifo()<=640){
            evt = osSignalWait(0x0, osWaitForever);
        }

        //TRACE(1,"#####Available len of fifo  %d####",avil_len_of_the_fifo());
        //get role from signal value
        if(evt.status == osEventSignal)
        {
            if(evt.value.signals & UART_OUT_SIGNAL_ID)
            {
                if(app_ai_is_stream_running()) {
                    frame_len = ama_uart_get_fifo_data(uart_stream_buf);
                } else {
                    frame_len = 0;
                }

                if(frame_len != 0) {
                    TRACE(1,"--data start encode %d", frame_len);
                    //DUMP8("%02x ",uart_stream_buf,10);

                    //stime=hal_sys_timer_get();

                    ret=voice_compression_handle(app_ai_get_encode_type(), uart_stream_buf, VOB_PCM_SIZE_TO_SAMPLE_CNT(640), app_ai_is_algorithm_engine_reset());
                    app_ai_set_algorithm_engine_reset(false);

                    ai_function_handle(API_DATA_SEND, NULL, 0);

                    //etime=hal_sys_timer_get();
                    //TRACE(1,"OPUS COST TIME %d", TICKS_TO_MS(etime-stime));
                    //TRACE(2,"%s ====>sys freq calc : %d\n", __func__, hal_sys_timer_calc_cpu_freq(50, 0));
                    audio_dump_add_channel_data(0, (short *)uart_stream_buf, frame_len/2); 
                    audio_dump_run();
                    send_message();
                    if(ret < 0) {
                        goto __EXCEPTION;
                    }
                }
            }
        }

        continue;

        __EXCEPTION:
        app_ai_voice_stop_stream();
    }
}
#endif