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/soundbox/smartbox/smartbox_update/smartbox_update_tws.c

754 lines
22 KiB
C
Raw Permalink Normal View History

inited
2024-11-10 10:44:17 +00:00
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include "generic/circular_buf.h"
#include "os/os_api.h"
#include "update_loader_download.h"
#include "system/task.h"
#include "system/timer.h"
#include "init.h"
#include "smartbox_update_tws.h"
#include "dual_bank_updata_api.h"
#include "bt_tws.h"
#include "app_config.h"
#include "btstack/avctp_user.h"
#include "update.h"
#include "app_main.h"
#if (SMART_BOX_EN && OTA_TWS_SAME_TIME_ENABLE)
//#define LOG_TAG_CONST EARPHONE
#define LOG_TAG "[UPDATE_TWS]"
#define log_errorOR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
#define THIS_TASK_NAME "tws_ota"
#define SLAVE_REV_BUF_LEN 1024*2
enum {
TWS_UPDATE_START,
TWS_UPDATE_RESULT_EXCHANGE,
TWS_UPDATE_RESULT_EXCHANGE_RES,
TWS_UPDATE_OVER,
TWS_UPDATE_OVER_CONFIRM,
TWS_UPDATE_OVER_CONFIRM_REQ,
TWS_UPDATE_OVER_CONFIRM_RES,
TWS_UPDATE_VERIFY,
};
extern void sys_enter_soft_poweroff(void *priv);
void db_update_notify_fail_to_phone();
struct __tws_ota_var {
OS_SEM master_sem;
OS_SEM slave_sem;
OS_SEM confirm_sem;
struct __tws_ota_para para;
u8 ota_type;
u8 ota_status;
u8 ota_remote_status;
u8 ota_result;
volatile u32 ota_data_len;
u16 ota_timer_id;
u8 ota_verify_cnt;
volatile u32 ota_confirm;
cbuffer_t cbuffer;
u8 *slave_r_buf;
};
struct __tws_ota_var tws_ota_var;
#define __this (&tws_ota_var)
void tws_ota_event_post(u32 type, u8 event)
{
struct sys_event e;
e.type = SYS_BT_EVENT;
e.arg = (void *)type;
e.u.bt.event = event;
sys_event_notify(&e);
}
u8 tws_ota_control(int type, ...)
{
int ret = 0;
int role = 0;
int value = 0;
va_list argptr;
va_start(argptr, type);
switch (type) {
case OTA_TYPE_SET:
value = va_arg(argptr, int);
__this->ota_type = value;
break;
case OTA_TYPE_GET:
ret = __this->ota_type;
break;
case OTA_STATUS_SET:
value = va_arg(argptr, int);
__this->ota_status = value;
break;
case OTA_STATUS_GET:
ret = __this->ota_status;
break;
case OTA_REMOTE_STATUS_SET:
value = va_arg(argptr, int);
__this->ota_remote_status = value;
break;
case OTA_REMOTE_STATUS_GET:
ret = __this->ota_remote_status;
break;
case OTA_RESULT_SET:
value = va_arg(argptr, int);
role = va_arg(argptr, int);
if (value == 1) {
__this->ota_result |= BIT(role);
} else {
__this->ota_result &= ~BIT(role);
}
break;
case OTA_RESULT_GET:
ret = __this->ota_result;
break;
}
va_end(argptr);
return ret;
}
int tws_ota_init(void)
{
memset((u8 *)__this, 0, sizeof(struct __tws_ota_var));
__this->ota_status = OTA_INIT;
__this->ota_type = OTA_TWS;
if (a2dp_get_status() == BT_MUSIC_STATUS_STARTING) {
/* log_info("try pause a2dp music"); */
user_send_cmd_prepare(USER_CTRL_AVCTP_OPID_PAUSE, 0, NULL);
}
return 0;
}
#define TWS_FUNC_ID_OTA_SYNC TWS_FUNC_ID('O', 'T', 'A', 'S')
static void tws_ota_data_read_s_from_m(void *_data, u16 len, bool rx)
{
if (rx && __this->ota_status == OTA_START && __this->slave_r_buf) {
/* r_log_info("Offset:%x r_len:%d\n",__this->ota_data_len,len); */
/* put_buf(_data, len); */
__this->ota_data_len += len;
if (cbuf_is_write_able(&(__this->cbuffer), len)) {
cbuf_write(&(__this->cbuffer), _data, len);
} else {
log_info("ota cbuf write err\n");
}
os_sem_post(&__this->slave_sem);
}
}
REGISTER_TWS_FUNC_STUB(app_ota_sync_stub) = {
.func_id = TWS_FUNC_ID_OTA_SYNC,
.func = tws_ota_data_read_s_from_m,
};
int tws_ota_data_send_m_to_s(u8 *buf, u16 len)
{
if (!(tws_api_get_tws_state() & TWS_STA_SIBLING_CONNECTED)) {
return 0;
}
if (tws_api_get_role() == TWS_ROLE_SLAVE) {
return 0;
}
int ret = tws_api_send_data_to_slave(buf, len, TWS_FUNC_ID_OTA_SYNC);
return ret;
}
int tws_ota_err_callback(u8 reason)
{
tws_ota_event_post(SYS_BT_OTA_EVENT_TYPE_STATUS, OTA_UPDATE_ERR);
return 0;
}
static void tws_ota_update_loop(void *priv)
{
u32 total_len = 0;
u32 len = 0;
u8 *tmp_buf = NULL;
int ret = 0;
u8 sniff_wait_exit_timeout = 30;//3s
log_info("tws_ota_update_loop\n");
while (1) {
os_sem_pend(&__this->slave_sem, 0);
if (sniff_wait_exit_timeout) {
//wait slave exit sniff
extern u8 btstcak_get_bt_mode(void);
while (btstcak_get_bt_mode() && sniff_wait_exit_timeout--) {
log_info("wait sniff exit \n");
os_time_dly(10);
}
log_info(">>>>>>>sniff timeout:%d \n", sniff_wait_exit_timeout);
if (!sniff_wait_exit_timeout) {
log_info(">>>>>>wait sniff exit timeout !!!! \n");
}
sniff_wait_exit_timeout = 0;
dual_bank_passive_update_init(__this->para.fm_crc16, __this->para.fm_size, __this->para.max_pkt_len, NULL);
ret = dual_bank_update_allow_check(__this->para.fm_size);
if (ret) {
log_info("fm_size:%x can't update\n", __this->para.fm_size);
tws_ota_event_post(SYS_BT_OTA_EVENT_TYPE_STATUS, OTA_UPDATE_ERR);
continue;
}
tws_api_sync_call_by_uuid(0xA2E22223, SYNC_CMD_START_UPDATE, 400);
continue;
}
total_len = cbuf_get_data_size(&(__this->cbuffer));
/* log_info("total_len : %d\n",total_len); */
while (total_len) {
if (total_len > get_dual_bank_passive_update_max_buf()) {
len = get_dual_bank_passive_update_max_buf();
} else {
len = total_len;
}
if (!len) {
continue;
}
tmp_buf = malloc(len);
if (tmp_buf) {
if (cbuf_read(&(__this->cbuffer), tmp_buf, len) == len) {
putchar('D');
dual_bank_update_write(tmp_buf, len, NULL);
} else {
log_error("read err\n");
}
free(tmp_buf);
} else {
log_error("malloc err\n");
}
total_len -= len;
}
}
}
static void ota_finish_confirm(void *priv)
{
log_info("ota_finish_confirm:%d\n", __this->ota_confirm);
if (!__this->ota_confirm) {
//ota tws confirm err,earse boot info
flash_update_clr_boot_info(CLEAR_APP_UPDATE_BANK);
/* ASSERT(0, "ota tws confirm err\n"); */
}
tws_ota_event_post(SYS_BT_OTA_EVENT_TYPE_STATUS, OTA_UPDATE_SUCC);
}
u16 tws_ota_enter_verify(void *priv)
{
if (tws_api_get_tws_state() & TWS_STA_SIBLING_DISCONNECTED) {
log_info("tws_disconn in verify\n");
db_update_notify_fail_to_phone();
return -1;
}
tws_ota_send_data_to_sibling(TWS_UPDATE_VERIFY, NULL, 0);
os_sem_pend(&__this->master_sem, 1000);
//这里pend完，要做超时的准备
if (__this->ota_status == OTA_VERIFY_ING) {
return 0;
} else {
db_update_notify_fail_to_phone();
return -1;
}
}
u16 tws_ota_exit_verify(u8 *res, u8 *up_flg)
{
//not updata boot info in lib
*up_flg = 1;
u8 tws_ota_result[2];
u8 master_result = *res;
u8 result = 0;
tws_ota_control(OTA_STATUS_SET, OTA_VERIFY_END);
tws_ota_control(OTA_RESULT_SET, !master_result, TWS_ROLE_MASTER);
__RESTART:
if (tws_api_get_tws_state() & TWS_STA_SIBLING_DISCONNECTED) {
db_update_notify_fail_to_phone();
return 0;
}
result = tws_ota_control(OTA_RESULT_GET);
tws_ota_result[0] = result;
tws_ota_result[1] = tws_ota_control(OTA_STATUS_GET);
tws_ota_send_data_to_sibling(TWS_UPDATE_RESULT_EXCHANGE, (u8 *)&tws_ota_result, 2);
if ((result & BIT(TWS_ROLE_SLAVE)) && (result & BIT(TWS_ROLE_SLAVE))) {
log_info("tws already ota succ1\n");
os_sem_set(&__this->master_sem, 0);
tws_ota_event_post(SYS_BT_OTA_EVENT_TYPE_STATUS, OTA_UPDATE_OVER);
return 1;
} else if (__this->ota_remote_status == OTA_VERIFY_END || __this->ota_remote_status == OTA_OVER) {
tws_ota_event_post(SYS_BT_OTA_EVENT_TYPE_STATUS, OTA_UPDATE_ERR);
return 0;
} else {
os_sem_pend(&__this->master_sem, 200);
goto __RESTART;
}
return 1;
}
u16 tws_ota_updata_boot_info_over(void *priv)
{
log_info("master update_burn_boot_info succ\n");
if (tws_api_get_tws_state() & TWS_STA_SIBLING_DISCONNECTED) {
log_info("tws_disconn, ota open fail");
db_update_notify_fail_to_phone();
return -1;
}
//等待从机更新完成
log_info("1------pend in");
os_sem_pend(&__this->confirm_sem, 300);
log_info("1------pend out");
log_info("-------mz01");
if (__this->ota_confirm) {
log_info("-------mz02");
os_sem_set(&__this->confirm_sem, 0);
tws_ota_send_data_to_sibling(TWS_UPDATE_OVER_CONFIRM_REQ, NULL, 0);
log_info("2------pend in");
if (OS_TIMEOUT == os_sem_pend(&__this->confirm_sem, 300)) {
__this->ota_confirm = 0;
}
log_info("2------pend out");
}
if (!__this->ota_confirm) {
log_info("-------mz03");
//ota tws confirm err,earse boot info
flash_update_clr_boot_info(CLEAR_APP_UPDATE_BANK);
/* ASSERT(0, "ota tws confirm err\n"); */
return -1;
}
/* tws_ota_event_post(SYS_BT_OTA_EVENT_TYPE_STATUS,OTA_UPDATE_SUCC); //主机等手机发重启命令*/
return 0;
}
int tws_ota_open(struct __tws_ota_para *para)
{
int ret = 0;
log_info("tws_ota_open\n");
if (tws_api_get_tws_state() & TWS_STA_SIBLING_DISCONNECTED) {
log_info("tws_disconn, ota open fail");
db_update_notify_fail_to_phone();
return -1;
}
os_sem_create(&__this->master_sem, 0);
os_sem_create(&__this->slave_sem, 0);
os_sem_create(&__this->confirm_sem, 0);
if (tws_api_get_role() == TWS_ROLE_MASTER) {
extern void bt_check_exit_sniff();
bt_check_exit_sniff();
//master 发命令给slave启动升级
log_info("master updata info: crc16:%x size:%x max_pkt_len:%d\n", para->fm_crc16, para->fm_size, para->max_pkt_len);
if (__this->ota_type == OTA_TWS) {
tws_ota_send_data_to_sibling(TWS_UPDATE_START, (u8 *)para, sizeof(struct __tws_ota_para));
log_info("sem pend in ...");
os_sem_pend(&__this->master_sem, 600);
log_info("sem pend out ...");
//判断对耳状态
if (__this->ota_status == OTA_START) {
log_info("slave has ready");
ret = 0;
} else {
log_info("slave answer timeout");
db_update_notify_fail_to_phone();
ret = -1;
}
}
} else {
log_info("slave updata info: crc16:%x size:%x max_pkt_len:%d\n", para->fm_crc16, para->fm_size, para->max_pkt_len);
/* tws_api_sync_call_by_uuid('T', SYNC_CMD_START_UPDATE, 100); */
tws_ota_event_post(SYS_BT_OTA_EVENT_TYPE_STATUS, OTA_START_UPDATE_READY);
}
return ret;
}
int tws_ota_close(void)
{
int ret = 0;
log_info("%s", __func__);
if (__this->slave_r_buf) {
free(__this->slave_r_buf);
__this->slave_r_buf = 0;
task_kill(THIS_TASK_NAME);
}
return ret;
}
static void ota_verify_timeout(void *priv)
{
log_info("ota_verify_timeout:%x %x\n", __this->para.fm_size, __this->ota_data_len);
if (__this->ota_data_len == __this->para.fm_size) {
/* tws_api_sync_call_by_uuid('T', SYNC_CMD_START_VERIFY, 100); */
tws_ota_event_post(SYS_BT_OTA_EVENT_TYPE_STATUS, OTA_START_VERIFY);
return;
}
if (__this->ota_verify_cnt > 4) {
log_info("code len err\n");
tws_ota_event_post(SYS_BT_OTA_EVENT_TYPE_STATUS, OTA_UPDATE_ERR);
sys_timeout_del(__this->ota_timer_id);
__this->ota_timer_id = 0;
return;
}
__this->ota_verify_cnt ++;
__this->ota_timer_id = 0;
__this->ota_timer_id = sys_timeout_add(NULL, ota_verify_timeout, 500);
}
int tws_ota_get_data_from_sibling(u8 opcode, u8 *data, u8 len)
{
u8 tws_ota_result[2];
switch (opcode) {
//master->slave
case TWS_UPDATE_START:
log_info("TWS_AI_START_UPDATE:%d\n", opcode);
if (tws_api_get_role() == TWS_ROLE_SLAVE) {
if (__this->slave_r_buf) {
tws_ota_close();
}
tws_ota_init();
memcpy((u8 *) & (__this->para), data, len);
tws_ota_open(&(__this->para));
}
break;
//master->slave
case TWS_UPDATE_RESULT_EXCHANGE:
log_info("TWS_UPDATE_RESULT_EXCHANGE:%d %d\n", data[0], data[1]);
__this->ota_remote_status = data[1];
tws_ota_control(OTA_RESULT_SET, (data[0] & BIT(TWS_ROLE_MASTER) ? 1 : 0), TWS_ROLE_MASTER);
tws_ota_result[0] = __this->ota_result;
tws_ota_result[1] = __this->ota_status;
tws_ota_send_data_to_sibling(TWS_UPDATE_RESULT_EXCHANGE_RES, (u8 *)tws_ota_result, 2);
log_info("master ota result:%x %d\n", tws_ota_control(OTA_RESULT_GET), __this->ota_status);
break;
//slave->master
case TWS_UPDATE_RESULT_EXCHANGE_RES:
log_info("TWS_UPDATE_RESULT_EXCHANGE_RES:%d %d\n", data[0], data[1]);
__this->ota_remote_status = data[1];
tws_ota_control(OTA_RESULT_SET, (data[0] & BIT(TWS_ROLE_SLAVE) ? 1 : 0), TWS_ROLE_SLAVE);
log_info("slave ota result:%x %d\n", tws_ota_control(OTA_RESULT_GET), __this->ota_status);
if (tws_ota_control(OTA_RESULT_GET) & BIT(TWS_ROLE_SLAVE)) {
os_sem_post(&__this->master_sem);
}
break;
//master->slave
case TWS_UPDATE_VERIFY:
log_info("TWS_UPDATE_VERIFY\n");
tws_ota_event_post(SYS_BT_OTA_EVENT_TYPE_STATUS, OTA_START_VERIFY);
break;
case TWS_UPDATE_OVER:
log_info("TWS_AI_UPDATE_OVER:%d\n", opcode);
__this->ota_status = OTA_OVER;
break;
//slave to master
case TWS_UPDATE_OVER_CONFIRM:
log_info("TWS_UPDATE_OVER_CONFIRM\n");
__this->ota_confirm = 1;
if (tws_api_get_role() == TWS_ROLE_MASTER) {
log_info("1------post");
os_sem_post(&__this->confirm_sem);
}
break;
//master->slave
case TWS_UPDATE_OVER_CONFIRM_REQ:
log_info("TWS_UPDATE_OVER_CONFIRM_REQ\n");
if (tws_api_get_role() == TWS_ROLE_SLAVE) {
__this->ota_confirm = 1;
tws_ota_send_data_to_sibling(TWS_UPDATE_OVER_CONFIRM_RES, NULL, 0);
log_info("2------post");
os_sem_post(&__this->confirm_sem);
}
break;
//slave->master
case TWS_UPDATE_OVER_CONFIRM_RES:
log_info("TWS_UPDATE_OVER_CONFIRM_RES\n");
if (tws_api_get_role() == TWS_ROLE_MASTER) {
log_info("3------post");
os_sem_post(&__this->confirm_sem);
}
break;
}
return 0;
}
void tws_ota_send_data_to_sibling(u8 opcode, u8 *data, u8 len)
{
extern void tws_data_to_sibling_send(u8 opcode, u8 * data, u8 len);
tws_data_to_sibling_send(opcode, data, len);
}
u8 dual_bank_update_burn_boot_info_callback(u8 ret)
{
if (ret) {
log_info("update_burn_boot_info err\n");
} else {
log_info("slave update_burn_boot_info succ\n");
tws_ota_send_data_to_sibling(TWS_UPDATE_OVER_CONFIRM, NULL, 0);
//not recive master confirm
log_info("3------pend in");
os_sem_pend(&__this->confirm_sem, 300);
log_info("3------pend out");
if (!__this->ota_confirm) {
//ota tws confirm err,earse boot info
flash_update_clr_boot_info(CLEAR_APP_UPDATE_BANK);
/* ASSERT(0, "ota tws confirm err\n"); */
return 0;
}
//确保从机的回复命令送达到主机
os_time_dly(50);
tws_ota_event_post(SYS_BT_OTA_EVENT_TYPE_STATUS, OTA_UPDATE_SUCC);
return 0;
}
return 1;
}
//slave ota result
static sint32_t gma_ota_slave_result(int crc_res)
{
u8 ret = crc_res;
tws_ota_control(OTA_STATUS_SET, OTA_VERIFY_END);
tws_ota_control(OTA_RESULT_SET, crc_res, TWS_ROLE_SLAVE);
log_info("gma_ota_slave_result:%d %d\n", crc_res, tws_ota_control(OTA_STATUS_GET));
return 0;
}
int tws_ota_sync_cmd(int reason)
{
int ret = 1;
switch (reason) {
//slave request
case SYNC_CMD_START_UPDATE:
log_info("SYNC_CMD_START_UPDATE\n");
if (__this->ota_status != OTA_INIT) {
log_info("tws ota no init");
break;
}
__this->ota_status = OTA_START;
__this->ota_data_len = 0;
__this->ota_remote_status = OTA_START;
if (tws_api_get_role() == TWS_ROLE_MASTER) {
os_sem_post(&__this->master_sem);
} else {
}
break;
//slave request
case SYNC_CMD_START_VERIFY:
log_info("SYNC_CMD_START_VERIFY\n");
__this->ota_status = OTA_VERIFY_ING;
__this->ota_remote_status = OTA_VERIFY_ING;
if (tws_api_get_role() == TWS_ROLE_MASTER) {
os_sem_post(&__this->master_sem);
} else {
dual_bank_update_verify(NULL, NULL, gma_ota_slave_result);
}
break;
//master request
case SYNC_CMD_UPDATE_OVER:
log_info("SYNC_CMD_UPDATE_OVER\n");
__this->ota_status = OTA_OVER;
__this->ota_remote_status = OTA_OVER;
if ((__this->ota_result & BIT(TWS_ROLE_MASTER)) && (__this->ota_result & BIT(TWS_ROLE_SLAVE))) {
log_info("OTA SUCCESS\n");
//update boot info
if (tws_api_get_role() == TWS_ROLE_SLAVE) {
dual_bank_update_burn_boot_info(dual_bank_update_burn_boot_info_callback);
}
} else {
log_info("OTA ERR\n");
/* tws_ota_event_post(SYS_BT_OTA_EVENT_TYPE_STATUS,OTA_UPDATE_SUCC); */
}
break;
//slave request
case SYNC_CMD_UPDATE_ERR:
log_info("SYNC_CMD_UPDATE_ERR\n");
if (tws_api_get_role() == TWS_ROLE_MASTER) {
} else {
tws_ota_stop(OTA_STOP_UPDATE_OVER_ERR);
}
break;
default:
ret = 0;
break;
}
return ret;
}
void tws_ota_app_event_deal(u8 evevt)
{
if (__this->ota_status == OTA_OVER) {
return;
}
switch (evevt) {
case TWS_EVENT_CONNECTION_DETACH:
/* case TWS_EVENT_PHONE_LINK_DETACH: */
case TWS_EVENT_REMOVE_PAIRS:
log_info("stop ota : %d --1\n", evevt);
tws_ota_stop(OTA_STOP_LINK_DISCONNECT);
break;
default:
break;
}
}
void tws_ota_stop(u8 reason)
{
log_info("%s", __func__);
if (__this->ota_status != OTA_OVER) {
//reconnect hfp when start err
if (reason == OTA_STOP_APP_DISCONNECT || reason == OTA_STOP_UPDATE_OVER_ERR) {
//在更新信息的时候，手机app断开
/* if(tws_api_get_role() == TWS_ROLE_MASTER) { */
/* extern void user_post_key_msg(u8 user_msg); */
/* user_post_key_msg(USER_TWS_OTA_RESUME); */
/* } */
}
__this->ota_status = OTA_OVER;
if (__this->ota_timer_id) {
sys_timeout_del(__this->ota_timer_id);
__this->ota_timer_id = 0;
}
tws_ota_close();
dual_bank_passive_update_exit(NULL);
extern void rcsp_db_update_fail_deal(); //双备份升级失败处理
rcsp_db_update_fail_deal();
}
}
int bt_ota_event_handler(struct bt_event *bt)
{
int ret = 0;
switch (bt->event) {
case OTA_START_UPDATE:
log_info("OTA_START_UPDATE\n");
tws_api_sync_call_by_uuid(0xA2E22223, SYNC_CMD_START_UPDATE, 400);
break;
case OTA_START_UPDATE_READY:
log_info("OTA_START_UPDATE_READY:%x %x %d\n", __this->para.fm_crc16, __this->para.fm_size, __this->para.max_pkt_len);
extern void rcsp_before_enter_db_update_mode();
rcsp_before_enter_db_update_mode();
if (__this->slave_r_buf) {
ASSERT(0, "tws_ota_update_loop already exit\n");
}
task_create(tws_ota_update_loop, NULL, THIS_TASK_NAME);
__this->slave_r_buf = malloc(SLAVE_REV_BUF_LEN);
ASSERT(__this->slave_r_buf, "slave_r_buf malloc err\n");
cbuf_init(&(__this->cbuffer), __this->slave_r_buf, SLAVE_REV_BUF_LEN);
os_sem_post(&__this->slave_sem);
/* tws_ota_event_post(SYS_BT_OTA_EVENT_TYPE_STATUS,OTA_START_UPDATE); */
break;
case OTA_START_VERIFY:
log_info("OTA_START_VERIFY\n");
if (__this->ota_data_len == __this->para.fm_size) {
tws_api_sync_call_by_uuid(0xA2E22223, SYNC_CMD_START_VERIFY, 1000);
} else {
if (__this->ota_timer_id) {
sys_timeout_del(__this->ota_timer_id);
__this->ota_timer_id = 0;
}
__this->ota_timer_id = sys_timeout_add(NULL, ota_verify_timeout, 500);
}
break;
case OTA_UPDATE_OVER:
log_info("OTA_UPDATE_OVER\n");
tws_api_sync_call_by_uuid(0xA2E22223, SYNC_CMD_UPDATE_OVER, 400);
break;
case OTA_UPDATE_ERR:
log_info("OTA_UPDATE_ERR\n");
tws_api_sync_call_by_uuid(0xA2E22223, SYNC_CMD_UPDATE_ERR, 400);
break;
case OTA_UPDATE_SUCC:
log_info("OTA_UPDATE_SUCC\n");
update_result_set(UPDATA_SUCC);
dual_bank_passive_update_exit(NULL);
/* update_result_set(UPDATA_SUCC); */
/* extern void cpu_reset(); */
/* cpu_reset(); */
//user_ctl.shutdown_need_adv = 0;
sys_enter_soft_poweroff((void *)1);
break;
default:
break;
}
return 0;
}
static void smartbox_tws_ota_sync_handler(int reason, int err)
{
tws_ota_sync_cmd(reason);
}
TWS_SYNC_CALL_REGISTER(smartbox_tws_ota_sync) = {
.uuid = 0xA2E22223,
.task_name = "app_core",
.func = smartbox_tws_ota_sync_handler,
};
#endif
Reference in New Issue Copy Permalink