Kaotings/KT24-1110_65E-HA-651B
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
KT24-1110_65E-HA-651B/apps/common/update/uart_update_master.c
flym 9fd47355c9 inited
2024-11-10 18:44:17 +08:00

458 lines
12 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;
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;
} 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 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 {
CMD_UART_UPDATE_START = 0x1,
CMD_UART_UPDATE_READ,
CMD_UART_UPDATE_END,
CMD_UART_UPDATE_UPDATE_LEN,
CMD_UART_JEEP_ALIVE,
CMD_UART_UPDATE_READY,
};
enum {
RX_DATA_READY = 0,
RX_DATA_TIMEOUT,
RX_DATA_SUCC,
};
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) {
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;
}
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;
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;
}
}
}
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);
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
Reference in New Issue View Git Blame Copy Permalink