930 lines
20 KiB
C
Executable File
930 lines
20 KiB
C
Executable File
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
|
|
#include "cli.h"
|
|
#include <os/os.h>
|
|
#include <common/bk_compiler.h>
|
|
#include "shell_drv.h"
|
|
#include <components/ate.h>
|
|
#include <modules/pm.h>
|
|
#include <driver/gpio.h>
|
|
|
|
#if CONFIG_AT
|
|
#include "atsvr_unite.h"
|
|
#if CONFIG_AT_DATA_MODE
|
|
#include "../../../components/at/inc/at_sal_ex.h"
|
|
#endif
|
|
#endif
|
|
|
|
#if 0//def CONFIG_SYS_CPU0
|
|
|
|
const uart_config_t at_config =
|
|
{
|
|
.baud_rate = UART_BAUD_RATE,
|
|
.data_bits = UART_DATA_8_BITS,
|
|
.parity = UART_PARITY_NONE,
|
|
.stop_bits = UART_STOP_BITS_1,
|
|
.flow_ctrl = UART_FLOWCTRL_DISABLE,
|
|
.src_clk = UART_SCLK_XTAL_26M,
|
|
|
|
};
|
|
#endif
|
|
//#define ATSVR_TAG "atsvr"
|
|
|
|
#define DEV_UART 1
|
|
#define DEV_MAILBOX 2
|
|
|
|
#if CONFIG_SYS_PRINT_DEV_UART
|
|
#define CMD_DEV DEV_UART
|
|
#elif CONFIG_SYS_PRINT_DEV_MAILBOX
|
|
#define CMD_DEV DEV_MAILBOX
|
|
#endif
|
|
|
|
#if (CONFIG_SYS_CPU0)
|
|
#if CONFIG_MAILBOX
|
|
#define FWD_CMD_TO_SLAVE
|
|
#define RECV_CMD_LOG_FROM_SLAVE
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(FWD_CMD_TO_SLAVE)
|
|
#define SLAVE_RSP_BLK_ID 0
|
|
#define SLAVE_IND_BLK_ID 1
|
|
#endif
|
|
|
|
#define ATSVR_WAIT_OUT_TIME (2000) // 2s.
|
|
|
|
#define ATSVR_TASK_WAIT_TIME (100) // 100ms
|
|
#define ATSVR_TASK_WAKE_CYCLE (20) // 2s
|
|
|
|
#define ATSVR_EVENT_RX_IND 0x02
|
|
|
|
#if (CMD_DEV == DEV_MAILBOX)
|
|
#define ATSVR_RX_BUF_LEN 140
|
|
#endif
|
|
#if (CMD_DEV == DEV_UART)
|
|
#define ATSVR_RX_BUF_LEN 4
|
|
#endif
|
|
|
|
#if CONFIG_AT_DATA_MODE
|
|
#define ATSVR_CMD_BUF_LEN 4096
|
|
#else
|
|
#define ATSVR_CMD_BUF_LEN 200
|
|
#endif
|
|
#define ATSVR_RSP_BUF_LEN 140
|
|
#define ATSVR_IND_BUF_LEN 132
|
|
|
|
#define ATSVR_RSP_QUEUE_ID (7)
|
|
#define ATSVR_FWD_QUEUE_ID (8)
|
|
#define ATSVR_IND_QUEUE_ID (10)
|
|
|
|
enum
|
|
{
|
|
CMD_TYPE_TEXT = 0,
|
|
CMD_TYPE_INVALID,
|
|
};
|
|
|
|
typedef struct
|
|
{
|
|
u8 rsp_buff[ATSVR_RSP_BUF_LEN];
|
|
beken_semaphore_t rsp_buf_semaphore;
|
|
|
|
u8 rx_buff[ATSVR_RX_BUF_LEN];
|
|
|
|
u8 cur_cmd_type;
|
|
u8 cmd_buff[ATSVR_CMD_BUF_LEN];
|
|
u16 cmd_data_len;
|
|
|
|
|
|
u8 echo_enable;
|
|
|
|
/* patch for AT cmd handling. */
|
|
u8 cmd_ind_buff[ATSVR_IND_BUF_LEN];
|
|
beken_semaphore_t ind_buf_semaphore;
|
|
} cmd_line_t;
|
|
|
|
#define GET_BLOCK_ID(blocktag) ((blocktag) & 0xFF)
|
|
#define GET_QUEUE_ID(blocktag) (((blocktag) & 0x0F00) >> 8)
|
|
#define MAKE_BLOCK_TAG(blk_id, q_id) (((blk_id) & 0xFF) | (((q_id) & 0x0F) << 8) )
|
|
|
|
static cmd_line_t cmd_line_buf;
|
|
|
|
|
|
#if (CMD_DEV == DEV_UART)
|
|
#if (CONFIG_UART_PRINT_PORT == AT_UART_PORT_CFG)
|
|
extern shell_dev_t shell_uart;
|
|
static shell_dev_t * cmd_dev = &shell_uart;
|
|
#else
|
|
extern shell_dev_t atsvr_shell_uart;
|
|
static shell_dev_t * cmd_dev = &atsvr_shell_uart;
|
|
|
|
#endif
|
|
#endif
|
|
#if (CMD_DEV == DEV_MAILBOX)
|
|
//#if (0 == CONFIG_DEFAULT_AT_PORT)
|
|
//extern shell_dev_t shell_dev_mb;
|
|
//static shell_dev_t * cmd_dev = &shell_dev_mb;
|
|
//#else
|
|
extern shell_dev_t atsvr_shell_dev_mb;
|
|
static shell_dev_t * cmd_dev = &atsvr_shell_dev_mb;
|
|
//#endif
|
|
#endif
|
|
|
|
|
|
#if defined(FWD_CMD_TO_SLAVE) || defined(RECV_CMD_LOG_FROM_SLAVE)
|
|
|
|
typedef struct
|
|
{
|
|
log_cmd_t rsp_buf;
|
|
log_cmd_t ind_buf;
|
|
} fwd_slave_data_t;
|
|
|
|
static fwd_slave_data_t ipc_fwd_data;
|
|
extern shell_dev_ipc_t atsvr_shell_dev_ipc;
|
|
static shell_dev_ipc_t * ipc_dev = &atsvr_shell_dev_ipc;
|
|
|
|
static int result_fwd(int blk_id);
|
|
static u32 atsvr_ipc_rx_indication(u16 cmd, log_cmd_t *data, u16 cpu_id);
|
|
|
|
#endif
|
|
|
|
static inline uint32_t atsvr_task_enter_critical()
|
|
{
|
|
return rtos_enter_critical();
|
|
}
|
|
|
|
static inline void atsvr_task_exit_critical(uint32_t flags)
|
|
{
|
|
rtos_exit_critical(flags);
|
|
}
|
|
|
|
static const char atsvr_prompt_str[] = "\r\n>";
|
|
|
|
static u8 atsvr_init_ok = bFALSE;
|
|
|
|
static u32 atsvr_pm_wake_time = ATSVR_TASK_WAKE_CYCLE; // wait cycles before enter sleep.
|
|
static u8 atsvr_pm_wake_flag = 1;
|
|
|
|
#if 0
|
|
|
|
typedef struct
|
|
{
|
|
beken_semaphore_t event_semaphore; // will release from ISR.
|
|
u32 event_flag;
|
|
} os_ext_event_t;
|
|
|
|
static os_ext_event_t atsvr_task_event;
|
|
|
|
static bool_t atsvr_create_event(void)
|
|
{
|
|
atsvr_task_event.event_flag = 0;
|
|
rtos_init_semaphore(&atsvr_task_event.event_semaphore, 1);
|
|
|
|
return bTRUE;
|
|
}
|
|
|
|
/* this API may be called from ISR. */
|
|
bool_t atsvr_set_event(u32 event_flag)
|
|
{
|
|
u32 int_mask;
|
|
|
|
int_mask = atsvr_task_enter_critical();
|
|
|
|
atsvr_task_event.event_flag |= event_flag;
|
|
|
|
atsvr_task_exit_critical(int_mask);
|
|
|
|
rtos_set_semaphore(&atsvr_task_event.event_semaphore);
|
|
|
|
return bTRUE;
|
|
}
|
|
|
|
u32 atsvr_wait_any_event(u32 timeout)
|
|
{
|
|
u32 int_mask;
|
|
u32 event_flag;
|
|
|
|
int result;
|
|
|
|
while(bTRUE)
|
|
{
|
|
int_mask = atsvr_task_enter_critical();
|
|
|
|
event_flag = atsvr_task_event.event_flag;
|
|
atsvr_task_event.event_flag = 0;
|
|
|
|
atsvr_task_exit_critical(int_mask);
|
|
|
|
if((event_flag != 0) || (timeout == 0))
|
|
{
|
|
return event_flag;
|
|
}
|
|
else
|
|
{
|
|
result = rtos_get_semaphore(&atsvr_task_event.event_semaphore, timeout);
|
|
|
|
if(result == kTimeoutErr)
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static beken_semaphore_t atsvr_semaphore; // will release from ISR.
|
|
|
|
static bool_t atsvr_create_event(void)
|
|
{
|
|
rtos_init_semaphore(&atsvr_semaphore, 1);
|
|
|
|
return bTRUE;
|
|
}
|
|
|
|
static bool_t atsvr_set_event(u32 event_flag)
|
|
{
|
|
(void)event_flag;
|
|
|
|
rtos_set_semaphore(&atsvr_semaphore);
|
|
|
|
return bTRUE;
|
|
}
|
|
|
|
static u32 atsvr_wait_any_event(u32 timeout)
|
|
{
|
|
int result;
|
|
|
|
result = rtos_get_semaphore(&atsvr_semaphore, timeout);
|
|
|
|
if(result == kTimeoutErr)
|
|
return 0;
|
|
|
|
return ATSVR_EVENT_RX_IND;
|
|
}
|
|
#endif
|
|
|
|
|
|
/* call from cmd TX ISR. */
|
|
static int cmd_tx_complete(u8 *pbuf, u16 buf_tag)
|
|
{
|
|
u8 queue_id = GET_QUEUE_ID(buf_tag);
|
|
u16 blk_id = GET_BLOCK_ID(buf_tag);
|
|
|
|
/* rsp ok ?? */
|
|
if( queue_id == ATSVR_RSP_QUEUE_ID ) /* rsp. */
|
|
{
|
|
/* it is called from cmd_dev tx ISR. */
|
|
|
|
if ( (pbuf != cmd_line_buf.rsp_buff) || (blk_id != 0) )
|
|
{
|
|
/* something wrong!!! */
|
|
ATSVRLOGE("FAULT: in rsp.\r\n");
|
|
}
|
|
|
|
/* rsp compelete, rsp_buff can be used for next cmd/response. */
|
|
rtos_set_semaphore(&cmd_line_buf.rsp_buf_semaphore);
|
|
|
|
return 1;
|
|
}
|
|
|
|
if( queue_id == ATSVR_IND_QUEUE_ID ) /* cmd_ind. */
|
|
{
|
|
/* it is called from cmd_dev tx ISR. */
|
|
|
|
if ( (pbuf != cmd_line_buf.cmd_ind_buff) || (blk_id != 0) )
|
|
{
|
|
/* something wrong!!! */
|
|
ATSVRLOGE("FAULT: indication.\r\n");
|
|
}
|
|
|
|
/* indication tx compelete, cmd_ind_buff can be used for next cmd_indication. */
|
|
rtos_set_semaphore(&cmd_line_buf.ind_buf_semaphore);
|
|
|
|
return 1;
|
|
}
|
|
|
|
if( queue_id == ATSVR_FWD_QUEUE_ID ) /* slave buffer. */
|
|
{
|
|
#if defined(FWD_CMD_TO_SLAVE)
|
|
result_fwd(blk_id);
|
|
return 1;
|
|
#endif
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* call from TX ISR. */
|
|
static void atsvr_cmd_tx_complete(u8 *pbuf, u16 buf_tag)
|
|
{
|
|
u32 int_mask = atsvr_task_enter_critical();
|
|
int tx_handled = cmd_tx_complete(pbuf, buf_tag);
|
|
|
|
if(tx_handled == 0) /* not handled. */
|
|
{
|
|
/* FAULT !!!! */
|
|
ATSVRLOGE("FATAL:%x,\r\n", buf_tag);
|
|
}
|
|
|
|
atsvr_task_exit_critical(int_mask);
|
|
}
|
|
|
|
/* call from RX ISR. */
|
|
static void atsvr_rx_indicate(void)
|
|
{
|
|
atsvr_set_event(ATSVR_EVENT_RX_IND);
|
|
|
|
return;
|
|
}
|
|
|
|
static bool_t echo_out(u8 * echo_str, u16 len)
|
|
{
|
|
u16 wr_cnt;
|
|
|
|
if(len == 0)
|
|
return bTRUE;
|
|
|
|
wr_cnt = cmd_dev->dev_drv->write_echo(cmd_dev, echo_str, len);
|
|
|
|
return (wr_cnt == len);
|
|
}
|
|
|
|
static void cmd_info_out(u8 * msg_buf, u16 msg_len, u16 blk_tag)
|
|
{
|
|
u32 int_mask = atsvr_task_enter_critical();
|
|
|
|
/* should have a count semaphore for write_asyn calls for rsp/ind/cmd_hint & slave rsp/ind. *
|
|
* otherwise there will be coupled with driver, drv tx_queue_len MUST be >= 5. */
|
|
cmd_dev->dev_drv->write_async(cmd_dev, msg_buf, msg_len, blk_tag);
|
|
|
|
atsvr_task_exit_critical(int_mask);
|
|
}
|
|
|
|
/* NOTICE: this can only be called by shell task internally (cmd handler). */
|
|
/* it is not a re-enterance function becaue of using rsp_buff. */
|
|
static bool_t cmd_rsp_out(u8 * rsp_msg, u16 msg_len)
|
|
{
|
|
u16 rsp_blk_tag = MAKE_BLOCK_TAG(0, ATSVR_RSP_QUEUE_ID);
|
|
|
|
if(rsp_msg != cmd_line_buf.rsp_buff)
|
|
{
|
|
if(msg_len > sizeof(cmd_line_buf.rsp_buff))
|
|
{
|
|
msg_len = sizeof(cmd_line_buf.rsp_buff);;
|
|
}
|
|
|
|
memcpy(cmd_line_buf.rsp_buff, rsp_msg, msg_len);
|
|
}
|
|
|
|
cmd_info_out(cmd_line_buf.rsp_buff, msg_len, rsp_blk_tag);
|
|
|
|
return bTRUE;
|
|
}
|
|
|
|
/* it is not a re-enterance function, should sync using ind_buf_semaphore. */
|
|
static bool_t cmd_ind_out(u8 * ind_msg, u16 msg_len)
|
|
{
|
|
u16 ind_blk_tag = MAKE_BLOCK_TAG(0, ATSVR_IND_QUEUE_ID);
|
|
|
|
if(ind_msg != cmd_line_buf.cmd_ind_buff)
|
|
{
|
|
if(msg_len > sizeof(cmd_line_buf.cmd_ind_buff))
|
|
{
|
|
msg_len = sizeof(cmd_line_buf.cmd_ind_buff);;
|
|
}
|
|
|
|
memcpy(cmd_line_buf.cmd_ind_buff, ind_msg, msg_len);
|
|
}
|
|
|
|
cmd_info_out(cmd_line_buf.cmd_ind_buff, msg_len, ind_blk_tag);
|
|
|
|
return bTRUE;
|
|
}
|
|
extern int get_data_len(void);
|
|
static void rx_ind_process(void)
|
|
{
|
|
u16 read_cnt, buf_len;
|
|
u8 cmd_rx_done = bFALSE;
|
|
#if CONFIG_SYS_CPU0
|
|
u16 echo_len;
|
|
u16 i = 0;
|
|
u8 need_backspace = bFALSE;
|
|
#if CONFIG_AT_DATA_MODE
|
|
int at_data_len = 0;
|
|
#endif
|
|
#endif
|
|
|
|
if(cmd_dev->dev_type == SHELL_DEV_MAILBOX)
|
|
{
|
|
buf_len = ATSVR_RX_BUF_LEN;
|
|
}
|
|
else /* if(cmd_dev->dev_type == SHELL_DEV_UART) */
|
|
{
|
|
buf_len = 1; /* for UART device, read one by one. */
|
|
}
|
|
|
|
#if CONFIG_AT_DATA_MODE
|
|
if(ATSVR_WK_DATA_HANDLE== get_atsvr_work_state())
|
|
{
|
|
at_data_len = get_data_len();
|
|
}
|
|
#endif
|
|
|
|
|
|
while(bTRUE)
|
|
{
|
|
u8 * rx_temp_buff = &cmd_line_buf.rx_buff[0];
|
|
|
|
read_cnt = cmd_dev->dev_drv->read(cmd_dev, rx_temp_buff, buf_len);
|
|
#if CONFIG_SYS_CPU1
|
|
memcpy(cmd_line_buf.cmd_buff,cmd_line_buf.rx_buff,read_cnt);
|
|
cmd_line_buf.cmd_data_len = read_cnt;
|
|
cmd_line_buf.cur_cmd_type = CMD_TYPE_TEXT;
|
|
cmd_rx_done = 1;
|
|
goto cpu1_handle;
|
|
#endif
|
|
#if CONFIG_SYS_CPU0
|
|
echo_len = 0;
|
|
|
|
for(i = 0; i < read_cnt; i++)
|
|
{
|
|
if(cmd_line_buf.cur_cmd_type == CMD_TYPE_INVALID)
|
|
{
|
|
echo_len++;
|
|
|
|
if((rx_temp_buff[i] >= 0x20) && (rx_temp_buff[i] < 0x7f))
|
|
{
|
|
cmd_line_buf.cur_cmd_type = CMD_TYPE_TEXT;
|
|
|
|
cmd_line_buf.cmd_data_len = 0;
|
|
cmd_line_buf.cmd_buff[cmd_line_buf.cmd_data_len] = rx_temp_buff[i];
|
|
cmd_line_buf.cmd_data_len++;
|
|
|
|
continue;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
if(cmd_line_buf.cur_cmd_type == CMD_TYPE_TEXT)
|
|
{
|
|
echo_len++;
|
|
if(rx_temp_buff[i] == '\b')
|
|
{
|
|
if(cmd_line_buf.cmd_data_len > 0)
|
|
{
|
|
cmd_line_buf.cmd_data_len--;
|
|
|
|
if(cmd_line_buf.cmd_data_len == 0)
|
|
need_backspace = bTRUE;
|
|
}
|
|
}
|
|
else if((rx_temp_buff[i] == '\n') || (rx_temp_buff[i] == '\r'))
|
|
{
|
|
#if CONFIG_AT_DATA_MODE
|
|
if(ATSVR_WK_DATA_HANDLE== get_atsvr_work_state())
|
|
{
|
|
if(cmd_line_buf.cmd_data_len < at_data_len)
|
|
{
|
|
cmd_line_buf.cmd_buff[cmd_line_buf.cmd_data_len] = rx_temp_buff[i];
|
|
cmd_line_buf.cmd_data_len++;
|
|
continue;
|
|
}
|
|
//else
|
|
// cmd_line_buf.cmd_buff[cmd_line_buf.cmd_data_len] = 0; // in case cmd_data_len overflow.
|
|
|
|
cmd_rx_done = bTRUE;
|
|
break;
|
|
}
|
|
#endif
|
|
if(cmd_line_buf.cmd_data_len < sizeof(cmd_line_buf.cmd_buff))
|
|
{
|
|
cmd_line_buf.cmd_buff[cmd_line_buf.cmd_data_len] = 0;
|
|
}
|
|
else
|
|
{
|
|
cmd_line_buf.cmd_buff[cmd_line_buf.cmd_data_len - 1] = 0; // in case cmd_data_len overflow.
|
|
}
|
|
|
|
cmd_rx_done = bTRUE;
|
|
break;
|
|
}
|
|
else if((rx_temp_buff[i] >= 0x20))
|
|
{
|
|
if(cmd_line_buf.cmd_data_len < sizeof(cmd_line_buf.cmd_buff))
|
|
{
|
|
cmd_line_buf.cmd_buff[cmd_line_buf.cmd_data_len] = rx_temp_buff[i];
|
|
cmd_line_buf.cmd_data_len++;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if( cmd_rx_done )
|
|
{
|
|
if(cmd_line_buf.echo_enable)
|
|
{
|
|
echo_out(&rx_temp_buff[0], echo_len);
|
|
echo_out((u8 *)"\r\n", 2);
|
|
}
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if(cmd_line_buf.echo_enable)
|
|
{
|
|
if(echo_len > 0)
|
|
{
|
|
if( (rx_temp_buff[echo_len - 1] == '\b') ||
|
|
(rx_temp_buff[echo_len - 1] == 0x7f) ) /* DEL */
|
|
{
|
|
echo_len--;
|
|
if((cmd_line_buf.cmd_data_len > 0) || need_backspace)
|
|
echo_out((u8 *)"\b \b", 3);
|
|
}
|
|
|
|
u8 cr_lf = 0;
|
|
|
|
if(echo_len == 1)
|
|
{
|
|
if( (rx_temp_buff[echo_len - 1] == '\r') ||
|
|
(rx_temp_buff[echo_len - 1] == '\n') )
|
|
{
|
|
cr_lf = 1;
|
|
}
|
|
}
|
|
else if(echo_len == 2)
|
|
{
|
|
if( (memcmp(rx_temp_buff, "\r\n", 2) == 0) ||
|
|
(memcmp(rx_temp_buff, "\n\r", 2) == 0) )
|
|
{
|
|
cr_lf = 1;
|
|
}
|
|
}
|
|
|
|
if(cr_lf != 0)
|
|
{
|
|
echo_out((u8 *)&atsvr_prompt_str[0], 3);
|
|
echo_len = 0;
|
|
}
|
|
}
|
|
|
|
echo_out(rx_temp_buff, echo_len);
|
|
}
|
|
}
|
|
|
|
if(read_cnt < buf_len) /* all data are read out. */
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
if(read_cnt < buf_len) /* all data are read out. */
|
|
{
|
|
}
|
|
else /* cmd pends in buffer, handle it in new loop cycle. */
|
|
{
|
|
atsvr_set_event(ATSVR_EVENT_RX_IND);
|
|
}
|
|
#if CONFIG_SYS_CPU1
|
|
cpu1_handle:
|
|
#endif
|
|
/* can re-use *buf_len*. */
|
|
if( cmd_rx_done )
|
|
{
|
|
#if CONFIG_SYS_CPU0
|
|
if(cmd_line_buf.cur_cmd_type == CMD_TYPE_TEXT)
|
|
{
|
|
#endif
|
|
u16 rx_ovf = 0;
|
|
cmd_dev->dev_drv->io_ctrl(cmd_dev, SHELL_IO_CTRL_GET_RX_STATUS, &rx_ovf);
|
|
|
|
if(rx_ovf != 0)
|
|
{
|
|
ATSVRLOGE("AT Commands lost!\r\n");
|
|
}
|
|
|
|
rtos_get_semaphore(&cmd_line_buf.rsp_buf_semaphore, ATSVR_WAIT_OUT_TIME);
|
|
|
|
cmd_line_buf.rsp_buff[0] = 0;
|
|
|
|
/* handle command. */
|
|
if( cmd_line_buf.cmd_data_len > 0 )
|
|
//atsvr_handle_shell_input( (char *)cmd_line_buf.cmd_buff, cmd_line_buf.cmd_data_len, (char *)cmd_line_buf.rsp_buff, ATSVR_RSP_BUF_LEN - 4 );
|
|
atsvr_msg_get_input((char *)cmd_line_buf.cmd_buff, cmd_line_buf.cmd_data_len, (char *)cmd_line_buf.rsp_buff, ATSVR_RSP_BUF_LEN - 4);
|
|
|
|
cmd_line_buf.rsp_buff[ATSVR_RSP_BUF_LEN - 4] = 0;
|
|
|
|
buf_len = strlen((char *)cmd_line_buf.rsp_buff);
|
|
if(buf_len > (ATSVR_RSP_BUF_LEN - 4))
|
|
buf_len = (ATSVR_RSP_BUF_LEN - 4);
|
|
buf_len += sprintf((char *)&cmd_line_buf.rsp_buff[buf_len], &atsvr_prompt_str[0]);
|
|
|
|
cmd_rsp_out(cmd_line_buf.rsp_buff, buf_len);
|
|
#if CONFIG_SYS_CPU0
|
|
}
|
|
#endif
|
|
|
|
cmd_line_buf.cur_cmd_type = CMD_TYPE_INVALID; /* reset cmd line to interpret new cmd. */
|
|
cmd_line_buf.cmd_data_len = 0;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
extern gpio_id_t bk_uart_get_rx_gpio(uart_id_t id);
|
|
|
|
static void atsvr_rx_wakeup(int gpio_id);
|
|
|
|
static void atsvr_power_save_enter(void)
|
|
{
|
|
//u32 flush_log = cmd_line_buf.log_flush;
|
|
|
|
cmd_dev->dev_drv->io_ctrl(cmd_dev, SHELL_IO_CTRL_RX_SUSPEND, NULL);
|
|
|
|
if(cmd_dev->dev_type == SHELL_DEV_UART)
|
|
{
|
|
u8 uart_port = UART_ID_MAX;
|
|
|
|
cmd_dev->dev_drv->io_ctrl(cmd_dev, SHELL_IO_CTRL_GET_UART_PORT, &uart_port);
|
|
u32 gpio_id = bk_uart_get_rx_gpio(uart_port);
|
|
|
|
bk_gpio_register_isr(gpio_id, (gpio_isr_t)atsvr_rx_wakeup);
|
|
}
|
|
}
|
|
|
|
static void atsvr_power_save_exit(void)
|
|
{
|
|
cmd_dev->dev_drv->io_ctrl(cmd_dev, SHELL_IO_CTRL_RX_RESUME, NULL);
|
|
}
|
|
|
|
static void wakeup_process(void)
|
|
{
|
|
bk_pm_module_vote_sleep_ctrl(PM_SLEEP_MODULE_NAME_AT, 0, 0);
|
|
atsvr_pm_wake_flag = 1;
|
|
atsvr_pm_wake_time = ATSVR_TASK_WAKE_CYCLE;
|
|
}
|
|
|
|
static void atsvr_rx_wakeup(int gpio_id)
|
|
{
|
|
wakeup_process();
|
|
|
|
ATSVRLOG("ATSVR_wakeup\r\n");
|
|
|
|
if(cmd_dev->dev_type == SHELL_DEV_UART)
|
|
{
|
|
bk_gpio_register_isr(gpio_id, NULL);
|
|
}
|
|
}
|
|
|
|
static void atsvr_task_init(void)
|
|
{
|
|
//u16 i;
|
|
|
|
cmd_line_buf.cur_cmd_type = CMD_TYPE_INVALID;
|
|
cmd_line_buf.cmd_data_len = 0;
|
|
cmd_line_buf.echo_enable = bTRUE;
|
|
|
|
rtos_init_semaphore_ex(&cmd_line_buf.rsp_buf_semaphore, 1, 1); // one buffer for cmd_rsp.
|
|
rtos_init_semaphore_ex(&cmd_line_buf.ind_buf_semaphore, 1, 1); // one buffer for cmd_ind.
|
|
|
|
atsvr_create_event();
|
|
|
|
cmd_dev->dev_drv->init(cmd_dev);
|
|
|
|
cmd_dev->dev_drv->open(cmd_dev, atsvr_cmd_tx_complete, atsvr_rx_indicate); // rx cmd, tx rsp.
|
|
|
|
#if defined(FWD_CMD_TO_SLAVE) || defined(RECV_CMD_LOG_FROM_SLAVE)
|
|
ipc_dev->dev_drv->init(ipc_dev);
|
|
ipc_dev->dev_drv->open(ipc_dev, (shell_ipc_rx_t)atsvr_ipc_rx_indication, NULL); /* register rx-callback to copy log data to buffer. */
|
|
#endif
|
|
|
|
atsvr_init_ok = bTRUE;
|
|
|
|
pm_cb_conf_t enter_config;
|
|
enter_config.cb = (pm_cb)atsvr_power_save_enter;
|
|
enter_config.args = NULL;
|
|
|
|
pm_cb_conf_t exit_config;
|
|
exit_config.cb = (pm_cb)atsvr_power_save_exit;
|
|
exit_config.args = NULL;
|
|
|
|
#if 1
|
|
bk_pm_sleep_register_cb(PM_MODE_LOW_VOLTAGE, PM_DEV_ID_UART2, &enter_config, &exit_config);
|
|
|
|
u8 uart_port = UART_ID_MAX;
|
|
|
|
cmd_dev->dev_drv->io_ctrl(cmd_dev, SHELL_IO_CTRL_GET_UART_PORT, &uart_port);
|
|
|
|
atsvr_rx_wakeup(bk_uart_get_rx_gpio(uart_port));
|
|
#else
|
|
|
|
u8 uart_port = UART_ID_MAX;
|
|
cmd_dev->dev_drv->io_ctrl(cmd_dev, SHELL_IO_CTRL_GET_UART_PORT, &uart_port);
|
|
|
|
u8 pm_uart_port = uart_id_to_pm_uart_id(uart_port);
|
|
bk_pm_sleep_register_cb(PM_MODE_LOW_VOLTAGE, pm_uart_port, &enter_config, &exit_config);
|
|
|
|
atsvr_rx_wakeup(bk_uart_get_rx_gpio(uart_port));
|
|
#endif
|
|
|
|
|
|
}
|
|
|
|
void atsvr_task( void *para )
|
|
{
|
|
u32 Events;
|
|
u32 timeout = ATSVR_TASK_WAIT_TIME;
|
|
|
|
atsvr_task_init();
|
|
|
|
echo_out((u8 *)&atsvr_prompt_str[0], 3);
|
|
|
|
atsvr_notice_ready();
|
|
|
|
while(bTRUE)
|
|
{
|
|
Events = atsvr_wait_any_event(timeout); // WAIT_EVENT;
|
|
|
|
|
|
if(Events & ATSVR_EVENT_RX_IND)
|
|
{
|
|
wakeup_process();
|
|
rx_ind_process();
|
|
}
|
|
|
|
if(Events == 0)
|
|
{
|
|
if(atsvr_pm_wake_time > 0)
|
|
atsvr_pm_wake_time--;
|
|
|
|
if(atsvr_pm_wake_time == 0)
|
|
{
|
|
if(atsvr_pm_wake_flag != 0)
|
|
{
|
|
atsvr_pm_wake_flag = 0;
|
|
bk_pm_module_vote_sleep_ctrl(PM_SLEEP_MODULE_NAME_AT, 1, 0);
|
|
ATSVRLOG("ATSVR sleep\r\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
if(atsvr_pm_wake_flag)
|
|
{
|
|
timeout = ATSVR_TASK_WAIT_TIME;
|
|
}
|
|
else
|
|
{
|
|
timeout = BEKEN_WAIT_FOREVER;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if defined(FWD_CMD_TO_SLAVE) || defined(RECV_CMD_LOG_FROM_SLAVE)
|
|
static int cmd_rsp_fwd(u8 * rsp_msg, u16 msg_len)
|
|
{
|
|
u16 rsp_blk_tag = MAKE_BLOCK_TAG(SLAVE_RSP_BLK_ID, ATSVR_FWD_QUEUE_ID);
|
|
|
|
cmd_info_out(rsp_msg, msg_len, rsp_blk_tag);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int cmd_ind_fwd(u8 * ind_msg, u16 msg_len)
|
|
{
|
|
u16 ind_blk_tag = MAKE_BLOCK_TAG(SLAVE_IND_BLK_ID, ATSVR_FWD_QUEUE_ID);
|
|
|
|
if(0 == strcmp(ATSVR_READY_MSG,(char*)(ind_msg)))
|
|
{
|
|
extern _at_svr_ctrl_env_t _at_svr_env;
|
|
_at_svr_env.cpu1_ready = true;
|
|
ATSVRLOGE("ATSVR:CPU0 Notice CPU1 is ready\r\n");
|
|
}
|
|
cmd_info_out(ind_msg, msg_len, ind_blk_tag);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int result_fwd(int blk_id)
|
|
{
|
|
log_cmd_t * log_cmd;
|
|
|
|
if(blk_id == SLAVE_RSP_BLK_ID)
|
|
{
|
|
log_cmd = &ipc_fwd_data.rsp_buf;
|
|
}
|
|
else if(blk_id == SLAVE_IND_BLK_ID)
|
|
{
|
|
log_cmd = &ipc_fwd_data.ind_buf;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
log_cmd->hdr.data = 0;
|
|
log_cmd->hdr.cmd = MB_CMD_LOG_OUT_OK;
|
|
|
|
return ipc_dev->dev_drv->write_cmd(ipc_dev, (mb_chnl_cmd_t *)log_cmd);
|
|
}
|
|
|
|
static u32 atsvr_ipc_rx_indication(u16 cmd, log_cmd_t *log_cmd, u16 cpu_id)
|
|
{
|
|
u32 result = ACK_STATE_FAIL;
|
|
u8 * data = log_cmd->buf;
|
|
u16 data_len = log_cmd->len;
|
|
if(cmd == MB_CMD_LOG_OUT)
|
|
{
|
|
u8 queue_id = GET_QUEUE_ID(log_cmd->tag);
|
|
|
|
if(queue_id == ATSVR_RSP_QUEUE_ID)
|
|
{
|
|
memcpy(&ipc_fwd_data.rsp_buf, log_cmd, sizeof(ipc_fwd_data.rsp_buf));
|
|
cmd_rsp_fwd(data, data_len);
|
|
|
|
return ACK_STATE_PENDING;
|
|
}
|
|
else if(queue_id == ATSVR_IND_QUEUE_ID)
|
|
{
|
|
memcpy(&ipc_fwd_data.ind_buf, log_cmd, sizeof(ipc_fwd_data.ind_buf));
|
|
cmd_ind_fwd(data, data_len);
|
|
|
|
return ACK_STATE_PENDING;
|
|
}
|
|
}
|
|
|
|
/* no cmd handler. */
|
|
return result;
|
|
}
|
|
|
|
int atsvr_cmd_forward(char *cmd, u16 cmd_len)
|
|
{
|
|
mb_chnl_cmd_t mb_cmd_buf;
|
|
user_cmd_t * user_cmd = (user_cmd_t *)&mb_cmd_buf;
|
|
|
|
user_cmd->hdr.data = 0;
|
|
user_cmd->hdr.cmd = MB_CMD_USER_INPUT;
|
|
user_cmd->buf = (u8 *)cmd;
|
|
user_cmd->len = cmd_len;
|
|
|
|
u32 int_mask = atsvr_task_enter_critical();
|
|
|
|
int ret_code = ipc_dev->dev_drv->write_cmd(ipc_dev, &mb_cmd_buf);
|
|
|
|
atsvr_task_exit_critical(int_mask);
|
|
|
|
return ret_code;
|
|
}
|
|
#endif
|
|
|
|
void atsvr_echo_set(int en_flag)
|
|
{
|
|
if(en_flag != 0)
|
|
cmd_line_buf.echo_enable = bTRUE;
|
|
else
|
|
cmd_line_buf.echo_enable = bFALSE;
|
|
}
|
|
|
|
int atsvr_echo_get(void)
|
|
{
|
|
if(cmd_line_buf.echo_enable)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void atsvr_cmd_ind_out(const char *format, ...)
|
|
{
|
|
u16 data_len, buf_len = ATSVR_IND_BUF_LEN;
|
|
va_list arg_list;
|
|
rtos_get_semaphore(&cmd_line_buf.ind_buf_semaphore, ATSVR_WAIT_OUT_TIME);
|
|
va_start(arg_list, format);
|
|
data_len = vsnprintf( (char *)&cmd_line_buf.cmd_ind_buff[0], buf_len - 1, format, arg_list );
|
|
va_end(arg_list);
|
|
|
|
if(data_len >= buf_len)
|
|
data_len = buf_len - 1;
|
|
|
|
cmd_ind_out(cmd_line_buf.cmd_ind_buff, data_len);
|
|
}
|
|
|
|
int atsvr_get_cpu_id(void)
|
|
{
|
|
#ifdef CONFIG_FREERTOS_SMP
|
|
return rtos_get_core_id();
|
|
#elif (CONFIG_CPU_CNT > 1)
|
|
|
|
if(cmd_dev->dev_type == SHELL_DEV_MAILBOX)
|
|
return SELF_CPU;
|
|
|
|
#endif
|
|
|
|
return -1;
|
|
}
|
|
|
|
|