Kaotings/KT26-0607_AC695n-BTE-SDK312
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
KT26-0607_AC695n-BTE-SDK312/apps/common/update/uart_update_master.c
flym 37c91f0c1f inited
2026-06-07 19:38:16 +08:00

778 lines
20 KiB
C
Raw Permalink Blame History

#include "app_config.h"
#if(USER_UART_UPDATE_ENABLE) && (UART_UPDATE_ROLE == UART_UPDATE_MASTER)
#include "typedef.h"
#include "update_loader_download.h"
#include "os/os_api.h"
#include "system/task.h"
#include "update.h"
#include "gpio.h"
#include "uart_update.h"
#include "asm/uart_dev.h"
#include "asm/clock.h"
#include "timer.h"
#include "system/fs/fs.h"
static volatile u32 uart_to_cnt = 0;
static volatile u32 uart_file_offset = 0;
static volatile u16 rx_cnt; //收数据计数
typedef struct _uart_updte_ctl_t {
OS_SEM sem;
OS_SEM rx_sem;
OS_SEM sd_sem;
volatile u16 timemax;
volatile u16 timeout;
volatile u8 flag;
volatile u8 err_code;
u8 update_sta;
u8 update_percent;
u32 update_total_size;
u32 update_send_size;
u8 rx_cmd[0x30];
u16 cmd_len;
u16 uart_timer_hdl;
u32 offset_addr;
} uart_update_ctl_t;
static uart_update_ctl_t uart_update_ctl;
#define __this (&uart_update_ctl)
#define LOG_TAG "[UART_UPDATE]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
#define LOG_CLI_ENABLE
#include "debug.h"
#define RETRY_TIME 4//重试n次
#define PACKET_TIMEOUT 200//ms
#define FILE_READ_UNIT 512 //
#define UART_DEFAULT_BAUD 9600
#define UART_UPDATE_BAUD (50*10000L)
#define TIME_TICK_UNIT (10) //unit:ms
//命令
#define CMD_UPDATE_START 0x01
#define CMD_UPDATE_READ 0x02
#define CMD_UPDATE_END 0x03
#define CMD_SEND_UPDATE_LEN 0x04
#define CMD_KEEP_ALIVE 0x05
#define UART_DEFALT_SEND_DATA_LEN 256
#define READ_LIT_U16(a) (*((u8*)(a)) + (*((u8*)(a)+1)<<8))
#define READ_LIT_U32(a) (*((u8*)(a)) + (*((u8*)(a)+1)<<8) + (*((u8*)(a)+2)<<16) + (*((u8*)(a)+3)<<24))
#define WRITE_LIT_U16(a,src) {*((u8*)(a)+1) = (u8)(src>>8); *((u8*)(a)+0) = (u8)(src&0xff); }
#define WRITE_LIT_U32(a,src) {*((u8*)(a)+3) = (u8)((src)>>24); *((u8*)(a)+2) = (u8)(((src)>>16)&0xff);*((u8*)(a)+1) = (u8)(((src)>>8)&0xff);*((u8*)(a)+0) = (u8)((src)&0xff);}
#define THIS_TASK_NAME "uart_update"
static protocal_frame_t protocal_frame __attribute__((aligned(4)));
u32 update_baudrate = 9600; //初始波特率
static uart_update_cfg update_cfg;
void *fd = NULL;
u32 uart_dev_receive_data(void *buf, u32 relen, u32 addr);
void uart_set_dir(u8 mode);
void uart_update_write(u8 *data, u32 len);
void uart_update_set_baud(u32 baudrate);
void uart_close_deal(void);
void uart_hw_init(uart_update_cfg update_cfg, void (*cb)(void *, u32));
void uart_data_decode(u8 *buf, u16 len);
/* enum { */
/* SEEK_SET = 0x0, */
/* SEEK_CUR = 0x1, */
/* SEEK_END = 0X2, */
/* }; */
enum {
RX_DATA_READY = 0,
RX_DATA_TIMEOUT,
RX_DATA_SUCC,
};
void uart_update_set_offset_addr(u32 offset)
{
__this->offset_addr = offset;
}
void uart_data_decode(u8 *buf, u16 len)
{
u16 crc, crc0, i, ch;
/* printf("decode_len:%d\n", len); */
/* put_buf(buf, len); */
for (i = 0; i < len; i++) {
ch = buf[i];
__recheck:
if (rx_cnt == 0) {
if (ch == SYNC_MARK0) {
protocal_frame.raw_data[rx_cnt++] = ch;
}
} else if (rx_cnt == 1) {
protocal_frame.raw_data[rx_cnt++] = ch;
if (ch != SYNC_MARK1) {
rx_cnt = 0;
goto __recheck;
}
} else if (rx_cnt < 4) {
protocal_frame.raw_data[rx_cnt++] = ch;
} else {
protocal_frame.raw_data[rx_cnt++] = ch;
if (rx_cnt == (protocal_frame.data.length + SYNC_SIZE)) {
rx_cnt = 0;
extern u16 CRC16(void *ptr, u32 len);
crc = CRC16(protocal_frame.raw_data, protocal_frame.data.length + SYNC_SIZE - 2);
memcpy(&crc0, &protocal_frame.raw_data[protocal_frame.data.length + SYNC_SIZE - 2], 2);
if (crc0 == crc) {
__this->timemax = 0;
if (protocal_frame.data.length <= sizeof(__this->rx_cmd)) {
memcpy(__this->rx_cmd, &(protocal_frame.data.data), protocal_frame.data.length);
__this->flag = RX_DATA_SUCC;
os_sem_post(&__this->rx_sem);
}
}
}
}
}
}
static bool uart_send_packet(u8 *buf, u16 length)
{
bool ret;
u16 crc;
u8 *buffer;
buffer = (u8 *)&protocal_frame;
protocal_frame.data.mark0 = SYNC_MARK0;
protocal_frame.data.mark1 = SYNC_MARK1;
protocal_frame.data.length = length;
memcpy((char *)&buffer[4], buf, length);
crc = CRC16(buffer, length + SYNC_SIZE - 2);
memcpy(buffer + 4 + length, &crc, 2);
uart_set_dir(0);//设为输出
uart_update_write((u8 *)&protocal_frame, length + SYNC_SIZE);
uart_set_dir(1);
return ret;
}
//read file by file operation handle
u32 ufw_data_read_api(u8 *buff, u32 addr, u32 size)
{
//To do...
if (fd) {
addr += __this->offset_addr; //多芯片ufw偏移
fseek(fd, addr, SEEK_SET);
return fread(fd, buff, size);
}
return 0;
}
//open file and get file operation handle
bool ufw_file_op_init(char *update_path)
{
if (fd) {
fclose(fd);
}
//To do
fd = fopen(update_path, "r");
if (!fd) {
return false;
}
return true;
}
//close the file and release resource
void ufw_file_op_close(void)
{
if (fd) {
fclose(fd);
fd = NULL;
}
//To do
}
static u32 update_data_read_from_file(void *p, u32 addr, u32 len)
{
u8 *buffer;
struct file_info *p_file_info;
u32 read_len = 0;
if (len > FILE_READ_UNIT) {
return (u32) - 1;
}
buffer = malloc(len + sizeof(struct file_info));
if (buffer) {
p_file_info = (struct file_info *)buffer;
p_file_info->cmd = CMD_UART_UPDATE_READ;
p_file_info->addr = addr;
p_file_info->len = len;
read_len = ufw_data_read_api(buffer + sizeof(struct file_info), addr, len);
} else {
return (u32) - 2;
}
uart_send_packet(buffer, len + sizeof(struct file_info));
if (buffer) {
free(buffer);
}
return read_len;
}
static u32 update_data_read_and_send(u32 addr, u32 len, u8 wait_ack)
{
u8 *buffer;
struct file_info *p_file_info;
u32 read_len = 0;
if (len > FILE_READ_UNIT) {
return (u32) - 1;
}
buffer = malloc(len + sizeof(struct file_info));
if (buffer) {
p_file_info = (struct file_info *)buffer;
p_file_info->cmd = CMD_UART_SEND_DATA;
p_file_info->addr = addr;
p_file_info->len = len;
read_len = ufw_data_read_api(buffer + sizeof(struct file_info), addr, len);
} else {
return (u32) - 2;
}
uart_send_packet(buffer, len + sizeof(struct file_info));
if (buffer) {
free(buffer);
}
return read_len;
}
enum {
UPDATE_STA_NONE = 0,
UPDATE_STA_READY,
UPDATE_STA_START,
UPDATE_STA_TIMEOUT,
UPDATE_STA_LOADER_DOWNLOAD_FINISH,
UPDATE_STA_SUCC,
UPDATE_STA_FAIL,
};
enum {
UPDATE_ERR_NONE = 0,
UPDATE_ERR_KEY,
UPDATE_ERR_VERIFY,
UPDATE_ERR_LOADER_DOWNLOAD_SUCC = 0x80,
};
static void uart_update_err_code_handle(u8 code)
{
if (code) {
if (UPDATE_ERR_LOADER_DOWNLOAD_SUCC == code) {
__this->update_percent = 100;
__this->update_send_size = 0;
__this->update_total_size = 0;
__this->update_sta = UPDATE_STA_LOADER_DOWNLOAD_FINISH;
log_info("loader dn succ\n");
} else {
__this->update_sta = UPDATE_STA_FAIL;
log_error("update_err:%x\n", code);
}
} else {
__this->update_percent = 100;
__this->update_sta = UPDATE_STA_SUCC;
log_info("update all succ\n");
}
}
static int uart_update_wait_rev_data(timeout)
{
u32 err;
__this->flag = RX_DATA_READY;
__this->timeout = 0;
__this->timemax = (timeout + 1) / TIME_TICK_UNIT;
err = os_sem_pend(&__this->rx_sem, 2000);
if (OS_NO_ERR != err) {
log_info("wait tm out\n");
}
__this->timemax = __this->timeout = 0;
if (__this->flag == RX_DATA_SUCC) {
return TRUE;
}
return FALSE;
}
int uart_update_api_write_then_read(u8 *buf, u8 length, u8 timeout)
{
int ret = FALSE;
uart_send_packet(buf, length);
if (timeout) {
ret = uart_update_wait_rev_data(timeout);
}
return ret;
}
bool uart_update_send_update_ready(char *file_update_path)
{
u8 ut_cmd[1];
ut_cmd[0] = CMD_UART_UPDATE_READY;
if (ufw_file_op_init(file_update_path)) {
__this->update_sta = UPDATE_STA_READY;
uart_send_packet(ut_cmd, sizeof(ut_cmd));
log_info("uart_update_send_update_ready\n");
return TRUE;
}
return FALSE;
}
bool get_uart_update_sta(void)
{
return (__this->update_sta == UPDATE_STA_READY || __this->update_sta == UPDATE_STA_START) ? TRUE : FALSE;
}
static void update_process_run(void)
{
update_baudrate = UART_DEFAULT_BAUD;
uart_update_set_baud(update_baudrate);
__this->update_total_size = 0;
__this->update_percent = 0;
__this->update_send_size = 0;
__this->offset_addr = 0; //多芯片升级ufw偏移
u8 *pbuf = &__this->rx_cmd;
while (1) {
if (OS_NO_ERR != os_sem_pend(&__this->rx_sem, 800)) {
log_info("uart_timeout\n");
__this->update_sta = UPDATE_STA_TIMEOUT;
update_baudrate = 9600;
uart_update_set_baud(update_baudrate);
continue;
}
//os_time_dly(1);
switch (pbuf[0]) {
case CMD_UPDATE_START:
log_info("CMD_UPDATE_START\n");
__this->update_sta = UPDATE_STA_START;
update_baudrate = UART_UPDATE_BAUD;
WRITE_LIT_U32(pbuf + 1, update_baudrate);
uart_send_packet(pbuf, 1 + sizeof(u32));
log_info("use baud:%x\n", update_baudrate);
uart_update_set_baud(update_baudrate);
break;
case CMD_UPDATE_READ: {
u32 addr = READ_LIT_U32(&pbuf[1]);
u32 len = READ_LIT_U32(&pbuf[1 + sizeof(u32)]);
if (__this->update_total_size) {
__this->update_send_size += len;
__this->update_percent = (__this->update_send_size * 100) / __this->update_total_size;
if (__this->update_percent >= 99) {
__this->update_percent = 99;
}
log_info("send data process:%x\n", __this->update_percent);
}
log_info("CMD_UPDATE_READ\n");
update_data_read_from_file(NULL, addr, len);
}
break;
case CMD_UPDATE_END:
log_info("CMD_UPDATE_END\n");
uart_update_err_code_handle(pbuf[1]);
uart_send_packet(pbuf, 1);
break;
case CMD_SEND_UPDATE_LEN:
__this->update_total_size = READ_LIT_U32(&pbuf[1]);
__this->update_percent = 0;
__this->update_send_size = 0;
log_info("update_total_size:%x\n", __this->update_total_size);
uart_send_packet(pbuf, 1);
break;
case CMD_KEEP_ALIVE:
uart_send_packet(pbuf, 1);
break;
case CMD_UART_ACK:
log_info("CMD_UART_ACK -> CMD_UART_SEND_DATA\n");
os_sem_post(&__this->sd_sem);
break;
}
}
}
static void uart_timeout_handler(void *priv)
{
if (__this->timemax) {
__this->timeout++;
if (__this->timeout > __this->timemax) {
__this->timemax = 0;
__this->flag = RX_DATA_TIMEOUT;
os_sem_post(&__this->rx_sem);
}
}
}
static void update_loader_download_task(void *p)
{
log_info("create %s task\n", THIS_TASK_NAME);
os_sem_create(&__this->sem, 0);
os_sem_create(&__this->rx_sem, 0);
os_sem_create(&__this->sd_sem, 0);
while (1) {
update_process_run();
}
}
void uart_update_init(uart_update_cfg *cfg)
{
memcpy(&update_cfg, cfg, sizeof(uart_update_cfg));
task_create(update_loader_download_task, NULL, THIS_TASK_NAME);
uart_hw_init(update_cfg, uart_data_decode);
}
void uart_update_exit(void)
{
log_info("uart update exit\n");
if (__this->uart_timer_hdl) {
sys_timer_del(__this->uart_timer_hdl);
}
os_sem_del(&__this->sem, 0);
os_sem_del(&__this->rx_sem, 0);
ufw_file_op_close();
uart_close_deal();
task_kill(THIS_TASK_NAME);
}
static void clock_critical_enter(void)
{
}
static void clock_critical_exit(void)
{
uart_update_set_baud(update_baudrate);
}
CLOCK_CRITICAL_HANDLE_REG(uart_update, clock_critical_enter, clock_critical_exit)
#endif
#if MUTIL_CPU_UART_UPDATE_ENABLE
#include "app_config.h"
#include "typedef.h"
#include "update_loader_download.h"
#include "os/os_api.h"
#include "system/task.h"
#include "update.h"
#include "gpio.h"
#include "uart_update.h"
#include "asm/uart_dev.h"
#include "system/fs/fs.h"
#include "avctp_user.h"
#define UART_UPDATE_DATA_LEN 256
static uart_bus_t *uart_update_hdl = NULL;
static u8 uart_update_cbuf[UART_UPDATE_DATA_LEN * 2] __attribute__((aligned(4)));
#define UART_UPDATE_TX_PORT IO_PORTA_03
#define UART_UPDATE_RX_PORT IO_PORTA_03
#define UART_UPDATE_BAUDRATE 500 * 1000 //115200
static protocal_frame_t protocal_frame __attribute__((aligned(4)));
static u32 send_len = 0;
static OS_MUTEX uart_mutex;
static u32 ot_time = 100;
static update_op_api_t *uart_op = NULL;
static u8 uart_init_flag = 1;
static u8 uart_init()
{
u8 ret = 0;
struct uart_platform_data_t u_arg = {0};
u_arg.tx_pin = UART_UPDATE_TX_PORT;
u_arg.rx_pin = UART_UPDATE_RX_PORT;
u_arg.rx_cbuf = uart_update_cbuf;
u_arg.rx_cbuf_size = UART_UPDATE_DATA_LEN * 2;
u_arg.frame_length = UART_UPDATE_DATA_LEN * 2;
u_arg.rx_timeout = 5;
/* u_arg.isr_cbfun = uart_isr_hook; */
u_arg.baud = UART_UPDATE_BAUDRATE;
u_arg.is_9bit = 0;
r_printf("uart_dev_open() ...\n");
uart_update_hdl = uart_dev_open(&u_arg);
if (uart_update_hdl != NULL) {
r_printf("success\n");
ret = 0;
} else {
ret = 1;
r_printf("false\n");
}
return ret;
}
static u8 uart_update_packet_data(u8 cmd, u8 *buf, u32 addr, u16 len)
{
u8 ret = 0;
u16 crc;
u8 *buffer;
u8 *data_buffer;
u16 length = len;
struct file_info *p_file_info;
data_buffer = malloc(len + sizeof(struct file_info));
if (data_buffer) {
switch (cmd) {
case CMD_UART_SEND_DATA:
p_file_info = (struct file_info *)data_buffer;
p_file_info->cmd = cmd;
p_file_info->addr = addr;
p_file_info->len = len;
memcpy(data_buffer + sizeof(struct file_info), buf, len);
length = len + sizeof(struct file_info);
break;
case CMD_UART_UPDATE_END:
default:
memcpy(data_buffer, buf, len);
length = len;
break;
}
} else {
ret = 1;
goto __exit;
}
buffer = (u8 *)&protocal_frame;
memset(buffer, 0, sizeof(protocal_frame_t));
protocal_frame.data.mark0 = SYNC_MARK0;
protocal_frame.data.mark1 = SYNC_MARK1;
protocal_frame.data.length = length;
memcpy((char *)&buffer[4], data_buffer, length);
crc = CRC16(buffer, length + SYNC_SIZE - 2);
memcpy(buffer + 4 + length, &crc, 2);
send_len = length + SYNC_SIZE;
__exit:
if (data_buffer) {
free(data_buffer);
data_buffer = NULL;
}
return ret;
}
static u8 uart_update_check_ack(u8 cmd, u8 *buf, u32 rx_len)
{
u16 crc, crc0, i, ch;
u32 ut_rx_cnt = 0;
u8 ret = 0xff;
/* printf("decode_len:%d\n", rx_len); */
/* put_buf(buf, rx_len); */
for (i = 0; i < rx_len; i++) {
ch = buf[i];
__recheck:
if (ut_rx_cnt == 0) {
if (ch == SYNC_MARK0) {
protocal_frame.raw_data[ut_rx_cnt++] = ch;
}
} else if (ut_rx_cnt == 1) {
protocal_frame.raw_data[ut_rx_cnt++] = ch;
if (ch != SYNC_MARK1) {
ut_rx_cnt = 0;
goto __recheck;
}
} else if (ut_rx_cnt < 4) {
protocal_frame.raw_data[ut_rx_cnt++] = ch;
} else {
protocal_frame.raw_data[ut_rx_cnt++] = ch;
if (ut_rx_cnt == (protocal_frame.data.length + SYNC_SIZE)) {
ut_rx_cnt = 0;
crc = CRC16(protocal_frame.raw_data, protocal_frame.data.length + SYNC_SIZE - 2);
memcpy(&crc0, &protocal_frame.raw_data[protocal_frame.data.length + SYNC_SIZE - 2], 2);
if (crc0 == crc) {
u8 *buffer = (u8 *)&protocal_frame;
if (buffer[4] == cmd) {
ret = buffer[5];
break;
}
}
}
}
}
return ret;
}
static u32 uart_update_read(u8 *rx_buf, u32 total_len)
{
u32 start_time = timer_get_ms();
u32 rlen = total_len;
u32 rx_len = 0;
while (1) {
rlen = uart_update_hdl->read(rx_buf, rlen, ot_time);
rx_len += rlen;
if (rx_len == total_len || rx_len >= 9) {
break;
} else {
rx_buf += rlen;
rlen = total_len - rx_len;
}
if ((timer_get_ms() - start_time) >= ot_time) {
break;
}
}
return rx_len;
}
u8 uart_update_tx_packet(u8 cmd, void *data, u32 addr, u16 len, u8 wait_ack)
{
u8 ret = 0;
os_mutex_pend(&uart_mutex, 0);
ret = uart_update_packet_data(cmd, data, addr, len);
if (ret) {
y_printf("\n >>>[test]:func = %s,line= %d\n", __FUNCTION__, __LINE__);
return 1;
}
putchar('W');
uart_update_hdl->write((u8 *)&protocal_frame, send_len);
/* printf(">>>[test]:len = %d\n", send_len); */
/* put_buf((u8 *)&protocal_frame, send_len); */
if (wait_ack) {
u8 *rx_buf = malloc(UART_UPDATE_DATA_LEN);
ASSERT(rx_buf);
u32 rx_len = uart_update_read(rx_buf, UART_UPDATE_DATA_LEN);
ret = uart_update_check_ack(cmd, rx_buf, rx_len);
if (rx_buf) {
free(rx_buf);
rx_buf = NULL;
}
}
/* y_printf(">>>[test]:ret = %d\n", ret); */
os_mutex_post(&uart_mutex);
return ret;
}
u8 uart_update_init_uart_type()
{
u8 ret = 0;
if (uart_init_flag) {
os_mutex_create(&uart_mutex);
ret = uart_init();
uart_init_flag = 0;
}
return ret;
}
void uart_update_change_ot_time(u32 new_time)
{
ot_time = new_time;
}
int uart_update_send_data(void *op_hdl, void *info)
{
/* clk_set("sys", 96000000); */
if (!info || !op_hdl) {
y_printf("\n >>>[test]:func = %s,line= %d\n", __FUNCTION__, __LINE__);
return -1;
}
uart_op = (update_op_api_t *)op_hdl;
int ret = 0;
mutil_ufw_info *p = (mutil_ufw_info *)info;
ot_time = (p->ufw_len + 64 * 1024 - 1) / (64 * 1024) * 500; //AD100那边每64K需要等待时间是300ms。
ot_time += 500;
y_printf(">>>[test]:ot_time = %dms, p->ufw_len = %d\n", ot_time, p->ufw_len);
u32 send_addr = 0;//p->ufw_addr;
u32 send_len = UART_UPDATE_DATA_LEN;
u8 *send_buf = malloc(UART_UPDATE_DATA_LEN);
uart_op->f_seek(NULL, SEEK_SET, send_addr);
uart_op->f_read(NULL, send_buf, send_len);
ret = uart_update_tx_packet(CMD_UART_SEND_DATA, send_buf, send_addr, send_len, 1); //先发一包数据
if (ret) {
y_printf("\n >>>[test]:func = %s,line= %d\n", __FUNCTION__, __LINE__);
goto __exit;
}
#if (LED_LYRICS_ENABLE && TCFG_LRC_LYRICS_ENABLE)
user_send_cmd_prepare(USER_CTRL_DISCONNECTION_HCI, 0, NULL);
#endif
ot_time = 50; //第一次交互之后都比较快
send_addr += send_len;
while (1) {
putchar('a');
if ((send_addr + send_len) > p->ufw_len) {
send_len = p->ufw_len - send_addr;
}
uart_op->f_seek(NULL, SEEK_SET, send_addr);
uart_op->f_read(NULL, send_buf, send_len);
ret = uart_update_tx_packet(CMD_UART_SEND_DATA, send_buf, send_addr, send_len, 1);
if (ret) {
goto __exit;
}
send_addr += send_len;
if (send_addr == p->ufw_len) {
ret = 0;
break;
}
}
__exit:
if (send_buf) {
free(send_buf);
send_buf = NULL;
}
u8 end_buf[2];
end_buf[0] = CMD_UART_UPDATE_END;
end_buf[1] = ret;
ot_time = (p->ufw_len + 64 * 1024 - 1) / (64 * 1024) * 500; //AD100那边每64K需要等待时间是300ms。
ret = uart_update_tx_packet(CMD_UART_UPDATE_END, end_buf, 0, 2, 1);
y_printf(">>>[test]:update over ret = %d\n", ret);
return ret;
}
#endif
Reference in New Issue View Git Blame Copy Permalink