Uahpet/AC707N
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
36e62db3a4021223d74c8a4df5ff2e97b6a2921a
AC707N/SDK/apps/common/config/new_cfg_tool.c
T
huxi bc195654bf 初版
2025-12-03 11:12:34 +08:00

749 lines
24 KiB
C
Raw Blame History

#ifdef SUPPORT_MS_EXTENSIONS
#pragma bss_seg(".new_cfg_tool.data.bss")
#pragma data_seg(".new_cfg_tool.data")
#pragma const_seg(".new_cfg_tool.text.const")
#pragma code_seg(".new_cfg_tool.text")
#endif
#include "cfg_tool.h"
#include "boot.h"
#include "ioctl_cmds.h"
#include "app_online_cfg.h"
#include "asm/crc16.h"
#include "asm/cpu.h"
#include "app_config.h"
#include "online_db_deal.h"
#include "init.h"
#include "usb/device/cdc.h"
#include "app_msg.h"
#include "classic/tws_api.h"
#include "bt_tws.h"
#include "timer.h"
#include "sniff.h"
#if CFG_TOOL_VER == CFG_TOOL_VER_VISUAL
#include "system/malloc.h"
#include "system/task.h"
#include "cfg_tool_statistics.h"
#include "cfg_tool_cdc.h"
#endif
#define LOG_TAG_CONST APP_CFG_TOOL
#define LOG_TAG "[APP_CFG_TOOL]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
#if TCFG_CFG_TOOL_ENABLE
#if (TCFG_COMM_TYPE == TCFG_UART_COMM) && (TCFG_ONLINE_TX_PORT == IO_PORT_DP || TCFG_ONLINE_RX_PORT == IO_PORT_DM) && \
(TCFG_USB_HOST_ENABLE || TCFG_PC_ENABLE)
#error "online config tool select DP/DM but usb module is enable"
#endif
struct cfg_tool_info {
R_QUERY_BASIC_INFO r_basic_info;
R_QUERY_FILE_SIZE r_file_size;
R_QUERY_FILE_CONTENT r_file_content;
R_PREPARE_WRITE_FILE r_prepare_write_file;
R_READ_ADDR_RANGE r_read_addr_range;
R_ERASE_ADDR_RANGE r_erase_addr_range;
R_WRITE_ADDR_RANGE r_write_addr_range;
R_ENTER_UPGRADE_MODE r_enter_upgrade_mode;
S_QUERY_BASIC_INFO s_basic_info;
S_QUERY_FILE_SIZE s_file_size;
S_PREPARE_WRITE_FILE s_prepare_write_file;
};
static struct cfg_tool_info info = {
.s_basic_info.protocolVer = PROTOCOL_VER_AT_OLD,
};
#define __this (&info)
#if (TCFG_USER_TWS_ENABLE || (TCFG_COMM_TYPE == TCFG_USB_COMM) || (TCFG_COMM_TYPE == TCFG_UART_COMM))
static u8 *local_packet = NULL;
u8 *local_packet_malloc(u16 size)
{
if ((local_packet == NULL) && (size > 0)) {
local_packet = (u8 *)malloc(size);
if (local_packet == NULL) {
ASSERT(0, "local_packet malloc err!");
}
} else {
ASSERT(0, "local_packet already allocated!");
}
return local_packet;
}
void local_packet_free()
{
if (local_packet != NULL) {
free(local_packet);
local_packet = NULL;
}
/* mem_stats(); */
}
#endif
extern const char *sdk_version_info_get(void);
extern u8 *sdfile_get_burn_code(u8 *len);
extern int sfc_norflash_erase(u32 cmd, u32 addr);
extern void doe(u16 k, void *pBuf, u32 lenIn, u32 addr);
extern void go_mask_usb_updata();
static void tws_sync_cfg_tool_data(struct cfg_tool_event *cfg_tool_dev);
#if (CFG_TOOL_VER == CFG_TOOL_VER_VISUAL)
const char fa_return[] = "ER"; //失败
#else
const char fa_return[] = "FA"; //失败
#endif
const char ok_return[] = "OK"; //成功
const char er_return[] = "ER"; //不能识别的命令
static u32 size_total_write = 0;
static u8 parse_seq = 0;
struct cfg_tool_event cfg_packet;
#define TWS_FUNC_ID_CFGTOOL_SYNC TWS_FUNC_ID('C', 'F', 'G', 'S')
#ifdef ALIGN
#undef ALIGN
#endif
#define ALIGN(a, b) \
({ \
int m = (u32)(a) & ((b)-1); \
int ret = (u32)(a) + (m?((b)-m):0); \
ret;\
})
static u32 encode_data_by_user_key(u16 key, u8 *buff, u16 size, u32 dec_addr, u8 dec_len)
{
u16 key_addr;
u16 r_len;
while (size) {
r_len = (size > dec_len) ? dec_len : size;
key_addr = (dec_addr >> 2)^key;
doe(key_addr, buff, r_len, 0);
buff += r_len;
dec_addr += r_len;
size -= r_len;
}
return dec_addr;
}
void hex2text(u8 *buf, u8 *out)
{
//sprintf(out, "%02x%02x-%02x%02x%02x%02x", buf[5], buf[4], buf[3], buf[2], buf[1], buf[0]);
}
u32 packet_combined(u8 *packet, u8 num)
{
u32 _packet = 0;
_packet = (packet[num] | (packet[num + 1] << 8) | (packet[num + 2] << 16) | (packet[num + 3] << 24));
return _packet;
}
/*延时复位防止工具升级进度条显示错误*/
static void delay_cpu_reset(void *priv)
{
cpu_reset();
}
RESFILE *cfg_open_file(u32 file_id)
{
RESFILE *cfg_fp = NULL;
if (file_id == CFG_TOOL_FILEID) {
cfg_fp = resfile_open(CFG_TOOL_FILE);
#if (CFG_TOOL_VER != CFG_TOOL_VER_VISUAL)
} else if (file_id == CFG_OLD_EQ_FILEID) {
cfg_fp = resfile_open(CFG_OLD_EQ_FILE);
} else if (file_id == CFG_OLD_EFFECT_FILEID) {
cfg_fp = resfile_open(CFG_OLD_EFFECT_FILE);
} else if (file_id == CFG_EQ_FILEID) {
cfg_fp = resfile_open(CFG_EQ_FILE);
#else
} else if (file_id == CFG_STREAM_FILEID) {
cfg_fp = resfile_open(CFG_STREAM_FILE);
} else if (file_id == CFG_EFFECT_CFG_FILEID) {
cfg_fp = resfile_open(CFG_EFFECT_CFG_FILE);
#endif
}
return cfg_fp;
}
void all_assemble_package_send_to_pc(u8 id, u8 sq, u8 *buf, u32 len)
{
u8 *send_buf = NULL;
u16 crc16_data;
send_buf = (u8 *)dma_malloc(len + 9); // 串口发数据需要使用dma_malloc
if (send_buf == NULL) {
log_error("send_buf malloc err!");
return;
}
send_buf[0] = 0x5A;
send_buf[1] = 0xAA;
send_buf[2] = 0xA5;
CFG_TOOL_WRITE_LIT_U16(send_buf + 5, (2 + len)); /*L*/
send_buf[7] = id;/*T*/
send_buf[8] = sq;/*SQ*/
memcpy(send_buf + 9, buf, len);
crc16_data = CRC16(&send_buf[5], len + 4);
send_buf[3] = crc16_data & 0xff;
send_buf[4] = (crc16_data >> 8) & 0xff;
/* printf("cfg_tool tx:\n"); */
/* printf_buf(send_buf, len + 9); */
#if (TCFG_COMM_TYPE == TCFG_UART_COMM)
ci_uart_write(send_buf, len + 9);
#elif (TCFG_COMM_TYPE == TCFG_USB_COMM)
cdc_write_data(0, send_buf, len + 9);
#elif (TCFG_COMM_TYPE == TCFG_SPP_COMM)
#if SPP_DATA_USED_LVT
app_online_db_ack(parse_seq, buf, len);
#else
app_online_db_ack(0xff, send_buf, len + 9);
#endif
#endif
dma_free(send_buf);
}
void app_cfg_tool_event_handler(struct cfg_tool_event *cfg_tool_dev)
{
u8 *buf = NULL;
buf = (u8 *)malloc(cfg_tool_dev->size);
if (buf == NULL) {
ASSERT(0, "buf malloc err!");
return;
}
buf = (u8 *)ALIGN(buf, 4);
memset(buf, 0, cfg_tool_dev->size);
/* printf_buf(cfg_tool_dev->packet, cfg_tool_dev->size); */
memcpy(buf, cfg_tool_dev->packet, cfg_tool_dev->size);
const struct tool_interface *p;
list_for_each_tool_interface(p) {
if (p->id == cfg_tool_dev->packet[2]) {
p->tool_message_deal(buf + 2, cfg_tool_dev->size - 2);
}
}
free(buf);
}
u8 online_cfg_tool_data_deal(void *buf, u32 len)
{
u8 *data_buf = (u8 *)buf;
u16 crc16_data;
/* printf("cfg_tool rx:\n"); */
/* printf_buf(buf, len); */
if ((data_buf[0] != 0x5a) || (data_buf[1] != 0xaa) || (data_buf[2] != 0xa5)) {
/* log_error("Header check error, receive an invalid message!\n"); */
return 1;
}
crc16_data = (data_buf[4] << 8) | data_buf[3];
if (crc16_data != CRC16(data_buf + 5, len - 5)) {
log_error("CRC16 check error, receive an invalid message!\n");
return 1;
}
device_online_timeout_check();
u32 cmd = packet_combined(data_buf, 9);
cfg_packet.event = cmd;
cfg_packet.size = CFG_TOOL_READ_LIT_U16(data_buf + 5) + 2;
#if ((TCFG_COMM_TYPE == TCFG_UART_COMM) || (TCFG_COMM_TYPE == TCFG_SPP_COMM))
cfg_packet.packet = &data_buf[5];
#if (TCFG_USER_TWS_ENABLE && (TCFG_COMM_TYPE == TCFG_UART_COMM))
tws_sync_cfg_tool_data(&cfg_packet);
#endif
app_cfg_tool_event_handler(&cfg_packet);
#elif (TCFG_COMM_TYPE == TCFG_USB_COMM)//in irq
if (local_packet != NULL) {
local_packet_free();
}
local_packet = local_packet_malloc(cfg_packet.size);
if (local_packet == NULL) {
return 1;
}
cfg_packet.packet = local_packet;
memcpy(cfg_packet.packet, &data_buf[5], cfg_packet.size);
if (OS_NO_ERR != os_taskq_post_type("app_core", MSG_FROM_CDC, 0, NULL)) {
local_packet_free();
}
#endif
return 0;
}
#if (TCFG_COMM_TYPE == TCFG_SPP_COMM && SPP_DATA_USED_LVT)
int cfg_tool_spp_rx_data(u8 *packet, u8 size, u8 *ext_data, u16 ext_size)
{
u8 *rx_buf = NULL;
rx_buf = (u8 *)malloc(size + ext_size + 1);
if (rx_buf == NULL) {
log_error("rx_buf malloc err!");
return -1;
}
rx_buf[0] = size + 1;
memcpy(rx_buf + 1, ext_data, ext_size);
memcpy(rx_buf + 1 + ext_size, packet, size);
parse_seq = rx_buf[2];
u32 event = (rx_buf[3] | (rx_buf[4] << 8) | (rx_buf[5] << 16) | (rx_buf[6] << 24));
cfg_packet.event = event;
cfg_packet.packet = rx_buf;
cfg_packet.size = size + ext_size + 1;
app_cfg_tool_event_handler(&cfg_packet);
free(rx_buf);
return 0;
}
static int cfg_tool_spp_init(void)
{
app_online_db_register_handle(SPP_NEW_EQ_CH, cfg_tool_spp_rx_data);
app_online_db_register_handle(SPP_OLD_EQ_CH, cfg_tool_spp_rx_data);
app_online_db_register_handle(SPP_CFG_CH, cfg_tool_spp_rx_data);
return 0;
}
early_initcall(cfg_tool_spp_init);
#endif //#if (TCFG_COMM_TYPE == TCFG_SPP_COMM && SPP_DATA_USED_LVT)
#if (TCFG_COMM_TYPE == TCFG_USB_COMM)
static int cfg_tool_cdc_rx_data(int *msg)
{
#if TCFG_USER_TWS_ENABLE
tws_sync_cfg_tool_data(&cfg_packet);
#endif
app_cfg_tool_event_handler(&cfg_packet);
return 0;
}
APP_MSG_HANDLER(cdc_msg_entry) = {
.owner = 0xff,
.from = MSG_FROM_CDC,
.handler = cfg_tool_cdc_rx_data,
};
#endif//#if (TCFG_COMM_TYPE == TCFG_USB_COMM)
#if TCFG_USER_TWS_ENABLE
static void tws_sync_cfg_tool_data(struct cfg_tool_event *cfg_tool_dev)
{
if (cfg_tool_dev != NULL) {
tws_api_send_data_to_sibling(cfg_tool_dev->packet, cfg_tool_dev->size, TWS_FUNC_ID_CFGTOOL_SYNC);
}
}
static void online_cfg_tool_tws_sibling_data_deal(void *_data, u16 len, bool rx)
{
if (rx) {
cfg_packet.event = DEFAULT_ACTION;
cfg_packet.size = len;
if (local_packet != NULL) {
local_packet_free();
}
local_packet = local_packet_malloc(cfg_packet.size);
if (local_packet == NULL) {
return;
}
cfg_packet.packet = local_packet;
memcpy(cfg_packet.packet, (u8 *)_data, cfg_packet.size);
if (OS_NO_ERR != os_taskq_post_type("app_core", MSG_FROM_CFGTOOL_TWS_SYNC, 0, NULL)) {
local_packet_free();
}
}
}
static int cfg_tool_tws_sync_rx_data(int *msg)
{
app_cfg_tool_event_handler(&cfg_packet);
return 0;
}
REGISTER_TWS_FUNC_STUB(cfg_tool_stub) = {
.func_id = TWS_FUNC_ID_CFGTOOL_SYNC,
.func = online_cfg_tool_tws_sibling_data_deal,
};
APP_MSG_HANDLER(tws_msg_entry) = {
.owner = 0xff,
.from = MSG_FROM_CFGTOOL_TWS_SYNC,
.handler = cfg_tool_tws_sync_rx_data,
};
#endif//#if TCFG_USER_TWS_ENABLE
#if CFG_TOOL_VER == CFG_TOOL_VER_VISUAL
// 在线检测设备
static u32 _device_online_timeout = 0;
static u16 _timer_id = 0;
static CFG_TOOL_ONLINE_STATUS _cfg_tool_online_status = CFG_TOOL_ONLINE_STATUS_OFFLINE;
static void device_online_timeout_task(void *priv)
{
_device_online_timeout++;
if (_device_online_timeout >= 3) {
if (_timer_id) {
sys_timer_del(_timer_id);
_timer_id = 0;
#if (TCFG_COMM_TYPE == TCFG_SPP_COMM)
bt_sniff_enable();
#endif
}
_cfg_tool_online_status = CFG_TOOL_ONLINE_STATUS_OFFLINE;
// 清理任务统计的资源
cfg_tool_statistics_resource_release();
/* log_info("cfg tool is offline!\n"); */
}
}
void device_online_timeout_check()
{
_device_online_timeout = 0;
_cfg_tool_online_status = CFG_TOOL_ONLINE_STATUS_ONLINE;
#if (TCFG_COMM_TYPE == TCFG_SPP_COMM)
bt_sniff_disable();
#endif
if (!_timer_id) {
/* log_info("cfg tool online sys timer add!\n"); */
_timer_id = sys_timer_add(NULL, device_online_timeout_task, 1000);
}
}
CFG_TOOL_ONLINE_STATUS cfg_tool_online_status()
{
return _cfg_tool_online_status;
}
#else
CFG_TOOL_ONLINE_STATUS cfg_tool_online_status()
{
return CFG_TOOL_ONLINE_STATUS_ONLINE;
}
#endif
// 发送buf malloc
u8 *send_buf_malloc(u32 send_buf_size)
{
u8 *buf = (u8 *)malloc(send_buf_size);
if (buf == NULL) {
ASSERT(0, "send buf malloc err!");
}
return buf;
}
static void cfg_tool_callback(u8 *packet, u32 size)
{
u32 erase_cmd = 0;
u32 write_len = 0;
u32 send_len = 0;
u8 crc_temp_len, sdkname_temp_len;
u8 *buf = NULL;
u8 *buf_temp = NULL;
struct resfile_attrs attr;
RESFILE *cfg_fp = NULL;
switch (cfg_packet.event) {
case ONLINE_SUB_OP_QUERY_BASIC_INFO:
memset(&__this->s_basic_info, 0, sizeof(__this->s_basic_info));
u8 *p = sdfile_get_burn_code(&crc_temp_len);
if (p != NULL) {
memcpy(__this->s_basic_info.progCrc, p + 8, 6);
hex2text(__this->s_basic_info.progCrc, __this->s_basic_info.progCrc);
sdkname_temp_len = strlen(sdk_version_info_get());
memcpy(__this->s_basic_info.sdkName, sdk_version_info_get(), sdkname_temp_len);
struct flash_head flash_head_for_pid_vid;
for (u8 i = 0; i < 5; i++) {
tzflash_read((u8 *)&flash_head_for_pid_vid, 32, 0x1000 * i);
doe(0xffff, (u8 *)&flash_head_for_pid_vid, 32, 0);
if (flash_head_for_pid_vid.crc == 0xffff) {
continue;
} else {
log_info("flash head addr = 0x%x\n", 0x1000 * i);
break;
}
}
if (flash_head_for_pid_vid.crc == 0xffff) {
log_error("Can't find flash head addr");
break;
}
memcpy(__this->s_basic_info.pid, &(flash_head_for_pid_vid.pid), sizeof(flash_head_for_pid_vid.pid));
memcpy(__this->s_basic_info.vid, &(flash_head_for_pid_vid.vid), sizeof(flash_head_for_pid_vid.vid));
for (u8 i = 0; i < sizeof(__this->s_basic_info.pid); i++) {
if (__this->s_basic_info.pid[i] == 0xff) {
__this->s_basic_info.pid[i] = 0x00;
}
}
#if (CFG_TOOL_VER == CFG_TOOL_VER_VISUAL)
#if TCFG_COMM_TYPE == TCFG_USB_COMM
__this->s_basic_info.max_buffer_size = cfg_tool_cdc_rx_max_mtu();
#elif TCFG_COMM_TYPE == TCFG_UART_COMM
extern u16 get_ci_rx_size();
__this->s_basic_info.max_buffer_size = get_ci_rx_size();
#else
extern u16 l2cap_max_mtu(void);
__this->s_basic_info.max_buffer_size = 256;//l2cap_max_mtu();
#endif
printf("cfg_tool max_buffer_size:%d\n", __this->s_basic_info.max_buffer_size);
#endif
send_len = sizeof(__this->s_basic_info);
buf = send_buf_malloc(send_len);
memcpy(buf, &(__this->s_basic_info), send_len);
}
break;
case ONLINE_SUB_OP_CPU_RESET:
send_len = 2;
u8 cpu_reset_ret[] = "OK";
buf = send_buf_malloc(send_len);
memcpy(buf, cpu_reset_ret, send_len);
sys_timeout_add(NULL, delay_cpu_reset, 500);
break;
case ONLINE_SUB_OP_QUERY_FILE_SIZE:
__this->r_file_size.file_id = packet_combined(cfg_packet.packet, 8);
cfg_fp = cfg_open_file(__this->r_file_size.file_id);
if (cfg_fp == NULL) {
log_error("file open error!\n");
goto _exit_;
}
resfile_get_attrs(cfg_fp, &attr);
__this->s_file_size.file_size = attr.fsize;
send_len = sizeof(__this->s_file_size.file_size);//长度
buf = send_buf_malloc(send_len);
memcpy(buf, &(__this->s_file_size.file_size), send_len);
resfile_close(cfg_fp);
break;
case ONLINE_SUB_OP_QUERY_FILE_CONTENT:
__this->r_file_content.file_id = packet_combined(cfg_packet.packet, 8);
__this->r_file_content.offset = packet_combined(cfg_packet.packet, 12);
__this->r_file_content.size = packet_combined(cfg_packet.packet, 16);
cfg_fp = cfg_open_file(__this->r_file_content.file_id);
if (cfg_fp == NULL) {
log_error("file open error!\n");
goto _exit_;
}
resfile_get_attrs(cfg_fp, &attr);
if (__this->r_file_content.size > attr.fsize) {
resfile_close(cfg_fp);
log_error("reading size more than actual size!\n");
break;
}
u32 flash_addr = sdfile_cpu_addr2flash_addr(attr.sclust);
buf_temp = (u8 *)malloc(__this->r_file_content.size);
if (buf_temp == NULL) {
log_error("buf_temp malloc err!");
goto _exit_;
}
tzflash_read((void *)buf_temp, __this->r_file_content.size, flash_addr + __this->r_file_content.offset);
send_len = __this->r_file_content.size;
buf = send_buf_malloc(send_len);
memcpy(buf, buf_temp, __this->r_file_content.size);
free(buf_temp);
resfile_close(cfg_fp);
break;
case ONLINE_SUB_OP_PREPARE_WRITE_FILE:
__this->r_prepare_write_file.file_id = packet_combined(cfg_packet.packet, 8);
__this->r_prepare_write_file.size = packet_combined(cfg_packet.packet, 12);
cfg_fp = cfg_open_file(__this->r_prepare_write_file.file_id);
if (cfg_fp == NULL) {
log_error("file open error!\n");
break;
}
resfile_get_attrs(cfg_fp, &attr);
__this->s_prepare_write_file.file_size = attr.fsize;
__this->s_prepare_write_file.file_addr = sdfile_cpu_addr2flash_addr(attr.sclust);
__this->s_prepare_write_file.earse_unit = boot_info.vm.align * 256;
send_len = sizeof(__this->s_prepare_write_file);
buf = send_buf_malloc(send_len);
memcpy(buf, &(__this->s_prepare_write_file), send_len);
resfile_close(cfg_fp);
if (__this->r_prepare_write_file.file_id == CFG_STREAM_FILEID) {
app_send_message(APP_MSG_WRITE_RESFILE_START, (int)"stream.bin");
}
break;
case ONLINE_SUB_OP_READ_ADDR_RANGE:
__this->r_read_addr_range.addr = packet_combined(cfg_packet.packet, 8);
__this->r_read_addr_range.size = packet_combined(cfg_packet.packet, 12);
buf_temp = (u8 *)malloc(__this->r_read_addr_range.size);
if (buf_temp == NULL) {
log_error("buf_temp malloc err!");
goto _exit_;
}
tzflash_read((void *)buf_temp, __this->r_read_addr_range.size, __this->r_read_addr_range.addr);
send_len = __this->r_read_addr_range.size;
buf = send_buf_malloc(send_len);
memcpy(buf, buf_temp, __this->r_read_addr_range.size);
free(buf_temp);
break;
case ONLINE_SUB_OP_ERASE_ADDR_RANGE:
__this->r_erase_addr_range.addr = packet_combined(cfg_packet.packet, 8);
__this->r_erase_addr_range.size = packet_combined(cfg_packet.packet, 12);
switch (__this->s_prepare_write_file.earse_unit) {
case 256:
erase_cmd = IOCTL_ERASE_PAGE;
break;
case (4*1024):
erase_cmd = IOCTL_ERASE_SECTOR;
break;
case (64*1024):
erase_cmd = IOCTL_ERASE_BLOCK;
break;
default:
send_len = sizeof(fa_return);
buf = send_buf_malloc(send_len);
memcpy(buf, fa_return, send_len);
log_error("erase error!");
break;
}
for (u8 i = 0; i < (__this->r_erase_addr_range.size / __this->s_prepare_write_file.earse_unit); i ++) {
/* u8 ret = sfc_norflash_erase(erase_cmd, __this->r_erase_addr_range.addr + (i * __this->s_prepare_write_file.earse_unit)); */
int ret = tzflash_ioctl(erase_cmd, __this->r_erase_addr_range.addr + (i * __this->s_prepare_write_file.earse_unit));
if (ret) {
send_len = sizeof(fa_return);
buf = send_buf_malloc(send_len);
memcpy(buf, fa_return, send_len);
log_error("erase error!");
break;
} else {
send_len = sizeof(ok_return);
buf = send_buf_malloc(send_len);
memcpy(buf, ok_return, send_len);
}
}
break;
case ONLINE_SUB_OP_WRITE_ADDR_RANGE:
__this->r_write_addr_range.addr = packet_combined(cfg_packet.packet, 8);
__this->r_write_addr_range.size = packet_combined(cfg_packet.packet, 12);
buf_temp = (u8 *)malloc(__this->r_write_addr_range.size);
if (buf_temp == NULL) {
log_error("buf_temp malloc err!");
goto _exit_;
}
memcpy(buf_temp, cfg_packet.packet + 16, __this->r_write_addr_range.size);
encode_data_by_user_key(boot_info.chip_id, buf_temp, __this->r_write_addr_range.size, __this->r_write_addr_range.addr - boot_info.sfc.sfc_base_addr, 0x20);
write_len = tzflash_write(buf_temp, __this->r_write_addr_range.size, __this->r_write_addr_range.addr);
if (write_len != __this->r_write_addr_range.size) {
send_len = sizeof(fa_return);
buf = send_buf_malloc(send_len);
memcpy(buf, fa_return, send_len);
log_error("write error!");
} else {
send_len = sizeof(ok_return);
buf = send_buf_malloc(send_len);
memcpy(buf, ok_return, send_len);
}
if (buf_temp) {
free(buf_temp);
}
#if (CFG_TOOL_VER != CFG_TOOL_VER_VISUAL)
if (__this->r_prepare_write_file.file_id == CFG_TOOL_FILEID) {
size_total_write += __this->r_write_addr_range.size;
if (size_total_write >= __this->r_erase_addr_range.size) {
size_total_write = 0;
log_info("cpu_reset\n");
sys_timeout_add(NULL, delay_cpu_reset, 500);
}
}
#endif
int a = __this->r_write_addr_range.addr + __this->r_write_addr_range.size;
int b = __this->s_prepare_write_file.file_addr + __this->s_prepare_write_file.file_size;
if (__this->r_prepare_write_file.file_id == CFG_STREAM_FILEID) {
if (a >= b) {
app_send_message(APP_MSG_WRITE_RESFILE_STOP, (int)"stream.bin");
}
}
break;
#if TCFG_COMM_TYPE == TCFG_USB_COMM
case ONLINE_SUB_OP_ENTER_UPGRADE_MODE:
log_info("event_ONLINE_SUB_OP_ENTER_UPGRADE_MODE\n");
go_mask_usb_updata();
break;
#endif
case ONLINE_SUB_OP_ONLINE_INSPECTION:
R_QUERY_SYS_INFO upload_param = {0};
upload_param.use_mem = memory_get_size(P_MEMORY_USED);//使用的mem;
upload_param.total_mem = memory_get_size(P_MEMORY_TOTAL);//总的mem
int cpu_use[2] = {0};
os_cpu_usage(NULL, cpu_use);
int cpu_usage = (cpu_use[0] + cpu_use[1]) / CPU_CORE_NUM;
upload_param.cpu_use_ratio = cpu_usage;
upload_param.task_num = get_task_info_list_num();
send_len = sizeof(upload_param);
buf = send_buf_malloc(send_len);
memcpy(buf, &upload_param, send_len);
break;
default: // DEFAULT_ACTION
#if (CFG_TOOL_VER == CFG_TOOL_VER_VISUAL)
if (buf) {
free(buf);
buf = NULL;
}
return;
#else
log_error("invalid data\n");
send_len = sizeof(er_return);
buf = send_buf_malloc(send_len);
memcpy(buf, er_return, sizeof(er_return));//不认识的命令返回ER
#endif
break;
_exit_:
send_len = sizeof(fa_return);
buf = send_buf_malloc(send_len);
memcpy(buf, fa_return, sizeof(fa_return));//文件打开失败返回FA
break;
}
all_assemble_package_send_to_pc(REPLY_STYLE, cfg_packet.packet[3], buf, send_len);
if (buf) {
free(buf);
buf = NULL;
}
}
#if (CFG_TOOL_VER == CFG_TOOL_VER_VISUAL)
REGISTER_DETECT_TARGET(cfg_tool_target) = {
.id = VISUAL_CFG_TOOL_CHANNEL_STYLE,
.tool_message_deal = cfg_tool_callback,
};
#else
REGISTER_DETECT_TARGET(cfg_tool_target) = {
.id = INITIATIVE_STYLE,
.tool_message_deal = cfg_tool_callback,
};
#endif
//在线调试不进power down
static u8 cfg_tool_idle_query(void)
{
return !cfg_tool_online_status();
}
REGISTER_LP_TARGET(cfg_tool_lp_target) = {
.name = "new_cfg_tool",
.is_idle = cfg_tool_idle_query,
};
#endif // TCFG_CFG_TOOL_ENABLE
Reference in New Issue View Git Blame Copy Permalink