zhangzhaopeng/fusion
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
张兆鹏
2025-08-05 15:53:44 +08:00
commit 09dc02ae52
553 changed files with 137665 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

631
app/app_ota/app_ota.c Executable file
View File

@@ -0,0 +1,631 @@
#include <stdlib.h>
#include "app_ota.h"
#include "httpclient.h"
#include "makeimage.h"
#include "crc32.h"
#include "hlog.h"
#define TAG "TAG_APPOTA"
struct RangeUpgardeParam
{
int32_t offset;
int32_t totallen; //ota file length
int32_t progress;
int32_t retry;
};
enum upgradeStage
{
STAGE_HEADER = 0,
STAGE_AW831,
STAGE_SOUND,
STAGE_MT7682,
STAGE_DONE,
};
enum upgradeRet
{
RET_FW_NOT_ENOUGH_DATA = -3,
RET_FW_MAGIC_ERROR = -2,
RET_FW_CRC_ERROR = -1,
RET_FW_OK,
RET_FW_NEED_MORE_DATA,
RET_FW_NO_NEED_UPGRADE,
};
typedef struct {
char *url;
onDownloadImageProgress listener;
}Upgrade_config;
//format: version,length,crc
//setenv mt7682_ota_info 1,552996,1652930298
#define DEV_OTA_PARTITION "/dev/OTA"
#define DOWNLOAD_TRY_TIMES 5
static enum upgradeStage sUpgradeStage = STAGE_HEADER;
static iobuffer sDataBuffer = {NULL, 0, 0};
static struct FWPackHeader sFWHeader;
static int32_t sUpgrading;
//EKEN format
typedef enum {
PAYLOAD_TYPE_SET_WOW = 1,
PAYLOAD_TYPE_KEEPALIVE,
PAYLOAD_TYPE_GET_WIFI_DATA,
PAYLOAD_TYPE_CHANGE_WIFI_CONNECT,//4
PAYLOAD_TYPE_SET_PIR,
PAYLOAD_TYPE_REBOOT_T31,
PAYLOAD_TYPE_GET_SOME_DATA,
PAYLOAD_TYPE_OTA_START,//8
PAYLOAD_TYPE_OTA_ERASE,
PAYLOAD_TYPE_OTA_ERASE_RET,
PAYLOAD_TYPE_OTA_WRITE,
PAYLOAD_TYPE_OTA_CRC_RET,//12
PAYLOAD_TYPE_OTA_STOP,
PAYLOAD_TYPE_SET_DATETIME_TS,
PAYLOAD_TYPE_SET_AP_SCAN,
PAYLOAD_TYPE_GET_AP_SCAN_LIST,//16
PAYLOAD_TYPE_SET_AP_MODE,
PAYLOAD_TYPE_SET_REBOOT_SYS,
PAYLOAD_TYPE_SET_LED_STATE,
PAYLOAD_TYPE_DHCP_OK,//20
PAYLOAD_TYPE_RING_KEY,
PAYLOAD_TYPE_LOG_DATA,
PAYLOAD_TYPE_SET_REG_DATA,
PAYLOAD_TYPE_GET_REG_DATA,
PAYLOAD_TYPE_TEST = 999,
}_SPI_PAYLOAD_TYPE;
typedef struct {
uint32_t payload_type;
uint32_t payload_len;
} _SPI_DATA_HEADER;
int32_t startOTAFromiobuffer(onDownloadImageProgress listener);
static int32_t writeDatato7682(int32_t type, uint8_t *payload, uint32_t payloadsize)
{
_SPI_DATA_HEADER header = {type, payloadsize};
char *send_buf = (char *)hv_malloc(sizeof(header) + payloadsize);
memcpy(send_buf, (unsigned char *)&header, sizeof(header));
if (payload)
{
memcpy(send_buf + sizeof(header), payload, payloadsize);
}
int32_t length = sizeof(header) + payloadsize;
/*if (t31_device_transfer_mt7682(send_buf, length, NULL, 0) != 0)
{
hv_free(send_buf);
hlogd("%s: t31_device_transfer_mt7682 failed", __FUNCTION__);
return -1;
}*/
hv_free(send_buf);
return 0;
}
//VIA format
static int32_t writeRAWSDIODatato7672(const char* data, int32_t len)
{
#if 0
SdioPacket* packet = PacketCreate();
putCmd(packet, UPGRADE_REQ);
putData(packet, data, len);
int32_t ret = sdio_writePacket(packet);
hv_free(packet);
return ret;
#endif
return 0;
}
void requestMT7682RebootandUpgrade()
{
hlogd("request MT7682 reboot to upgrade");
for (int32_t i = 0; i < 10; i++)
{
int32_t magic = 0x20207682;
if (writeDatato7682(PAYLOAD_TYPE_OTA_START, (uint8_t*)&magic, sizeof(magic)) != 0)
{
sleep(1);
}
else
{
break;
}
}
hlogd("FIXME: should not be here, 7682 should already reboot us");
}
void dump(struct chipFWInfo *chipInfo)
{
hlogd("dump chipinfo: magic 0x%x chipid %d version %d offset %d length %d crc 0x%x",
chipInfo->magic, chipInfo->chipID, chipInfo->version, chipInfo->offset,
chipInfo->length, chipInfo->crc);
}
enum upgradeRet verifyFirmware(int32_t id)
{
struct chipFWInfo *chipInfo = &sFWHeader.FWInfo[id];
int32_t fwLen = chipInfo->length;
if (chipInfo->magic == 0 && fwLen == 0)
{
hlogd("id %d no need upgrade", id);
return RET_FW_NO_NEED_UPGRADE;
}
if (sDataBuffer.size < fwLen)
{
return RET_FW_NOT_ENOUGH_DATA;
// return RET_FW_NEED_MORE_DATA;
}
if (chipInfo->magic != IMG_MAGIC || chipInfo->chipID != id)
{
dump(chipInfo);
hlogd("verifyChipInfo: check id %d failed", id);
return RET_FW_MAGIC_ERROR;
}
uint32_t crc = crc32(0, (const void *)sDataBuffer.iodata, fwLen);
if (crc != chipInfo->crc)
{
int32_t *data = (int32_t *)sDataBuffer.iodata;
hlogd("id %d fw crc error: 0x%x VS 0x%x, fwLen %d, fw data 0x%x 0x%x 0x%x 0x%x",
id, crc, chipInfo->crc, fwLen, *(data), *(data + 1), *(data + 2), *(data + 3));
return RET_FW_CRC_ERROR;
}
hlogd("verifyChipInfo: id:%d check crc:0x%x", id, crc);
return RET_FW_OK;
}
static int32_t parseHeader()
{
if (sDataBuffer.size < sizeof(struct FWPackHeader))
{
return -1;
}
iobuffer_read(&sDataBuffer, &sFWHeader, sizeof(struct FWPackHeader));
sUpgradeStage++;
hlogd("parse OTA package header OK");
for (int32_t i = 0; i < CHIP_MAX; i++)
{
struct chipFWInfo *info = &sFWHeader.FWInfo[i];
if (info->magic == IMG_MAGIC)
{
hlogd("FW id: %d version %d length %d offset %d crc 0x%x",
i, info->version, info->length, info->offset, info->crc);
}
}
return 0;
}
static int32_t upgradeModule(int32_t id, onDownloadImageProgress listener)
{
enum upgradeRet ret = verifyFirmware(id);
if (ret < 0)
return -2;
if (ret == RET_FW_NO_NEED_UPGRADE)
goto end;
int32_t length = sFWHeader.FWInfo[id].length;
if (id == MAIN)
{
hlogd("AW831 Firmware verify OK, start upgrade");
#if 0
if (aw_upgrade_slice("rtos", sDataBuffer.iodata, 0, length, 1))
{
hloge("upgradeAW831 aw_upgrade_slice failed");
return -1;
}
if (aw_upgrade_end(0))
{
hloge("upgradeAW831 aw_upgrade_end failed");
return -1;
}
#endif
hlogd("upgradeModule V831 OK");
}
else if (id == SOUND)
{
hlogd("SOUND Firmware verify OK, start upgrade");
#if 0
if (aw_upgrade_slice("/dev/SOUND", sDataBuffer.iodata, 0, length, 1))
{
hloge("aw_upgrade_slice SOUND failed");
return -1;
}
#endif
hlogd("SOUND Firmware upgrade done");
}
else if (id == WIFI)
{
hlogd("MT7682 Firmware verify OK, start upgrade");
//hexdump -n 1024 /dev/OTA
#if 0
if (aw_upgrade_slice(DEV_OTA_PARTITION, sDataBuffer.iodata, 0, length, 1))
{
hloge("store7682Image aw_upgrade_slice failed");
return -1;
}
#endif
hlogd("upgradeModule store MT7682 firmware OK");
}
iobuffer_erase(&sDataBuffer, 0, length);
end:
sUpgradeStage++;
return 0;
}
static int32_t rangeUpgrade(Upgrade_config *downcfg, struct RangeUpgardeParam *upgradeParam, onDownloadImageProgress listener){
httpclient_data_t client_data = {0};
httpclient_t client = {0};
static int32_t left_data = 0;
int32_t ret = UPGRADING;
sUpgradeStage = STAGE_HEADER;
int32_t header_size = 1024;
int32_t body_size = 32001; //one byte more for httpclient
char *response_header = (char *)hv_malloc(header_size);
char *response_body = (char *)hv_malloc(body_size);
hlogd("%s: url %s", __FUNCTION__, downcfg->url);
HTTPCLIENT_RESULT result = httpclient_connect(&client, downcfg->url);
if (result != HTTPCLIENT_OK)
{
hlogd("httpclient_connect %s failed result %d", downcfg->url, result);
listener(UPGRADING, 0);
ret = UPGRADING;
goto exit;
}
else
{
hlogd("httpclient_connect %s OK fd %d", downcfg->url, client.socket);
}
memset(&client_data, 0, sizeof(client_data));
client_data.header_buf = response_header;
client_data.header_buf_len = header_size;
client_data.response_buf = response_body;
client_data.response_buf_len = body_size;
client_data.range_enable = 1;
client_data.range_begin = sDataBuffer.size;
client_data.range_end = 0;
listener(UPGRADING, 0);
result = httpclient_send_request(&client, downcfg->url, HTTPCLIENT_GET, &client_data);
if (result != HTTPCLIENT_OK)
{
hlogd("httpclient_send_request %s failed result %d", downcfg->url, result);
listener(UPGRADING, 0);
ret = UPGRADING;
goto exit;
}
while (result >= HTTPCLIENT_OK)
{
result = httpclient_recv_response(&client, &client_data);
if (result < 0)
{
hlogd("httpclient_recv_response %s failed result %d", downcfg->url, result);
listener(UPGRADING, 0);
ret = UPGRADING;
goto exit;
}
if(upgradeParam->offset == 0)
upgradeParam->retry = 0;
if (upgradeParam->totallen == 0)
{
left_data = upgradeParam->totallen = client_data.response_content_len;
hlogd("url %s size %d", downcfg->url, upgradeParam->totallen);
}
uint32_t data_len = left_data - client_data.retrieve_len;
upgradeParam->offset += data_len;
left_data -= data_len;
hlogd("upgradeParam totallen %d offset %d leftLen %d",
upgradeParam->totallen, upgradeParam->offset, client_data.retrieve_len);
int32_t curProgress = upgradeParam->offset * 100 / upgradeParam->totallen;
if(curProgress > upgradeParam->progress && curProgress != 100)
{
upgradeParam->progress = curProgress;
listener(UPGRADING, curProgress);
ret = UPGRADING;
}
if (data_len != 0)
{
iobuffer_appendData(&sDataBuffer, client_data.response_buf, data_len);
}
if (upgradeParam->offset == upgradeParam->totallen)
{
hlogd("firmware download done");
listener(UPGRADING, 100);
listener(DOWNLOAD_OK, 0);
ret = DOWNLOAD_OK;
break;
}
}
exit:
hlogd("httpclient_close fd %d", client.socket);
httpclient_close(&client);
if (response_header)
hv_free(response_header);
if (response_body)
hv_free(response_body);
/* for compile
if(ret == UPGRADING)
rt_thread_mdelay(2000);*/
return ret;
}
static void upgradeTask(void *arg)
{
sUpgrading = 1;
Upgrade_config *downcfg =(Upgrade_config *)arg;
onDownloadImageProgress listener = downcfg->listener;
//RT_ASSERT(listener);
struct RangeUpgardeParam upgradeParam;
memset(&upgradeParam, 0, sizeof(upgradeParam));
int32_t upgradeStatus = UPGRADING;
//add_suspend(SUSPEND_UPGRADE, 8*60);
iobuffer_init(&sDataBuffer);
iobuffer_reserve(&sDataBuffer, 4*1024*1024);
listener(READY, 0);
while(strlen(downcfg->url) > 0){
hlogd("retried %d times rangeUpgrade", upgradeParam.retry);
upgradeStatus = rangeUpgrade(downcfg, &upgradeParam, listener);
if(upgradeStatus == DOWNLOAD_OK){
hlogd("rangeUpgrade download ok");
break;
}else if(++upgradeParam.retry > DOWNLOAD_TRY_TIMES){
hlogd("retried %d times and still download fail !!!", upgradeParam.retry);
upgradeStatus = DOWNLOAD_FAIL;
listener(DOWNLOAD_FAIL, 0);
break;
}
}
if(upgradeStatus == DOWNLOAD_OK)
startOTAFromiobuffer(listener);
exit:
sUpgrading = 0;
if (STAGE_DONE != sUpgradeStage)
{
hlogd("upgradeTask error, current stage %d", sUpgradeStage);
#if 0
goWow(__func__);
#endif
}
else
{
hlogd("upgradeTask OK");
}
hv_free(downcfg->url);
hv_free(downcfg);
return;
}
iobuffer* getOTAiobuffer()
{
return &sDataBuffer;
}
int32_t startOTAFromiobuffer(onDownloadImageProgress listener)
{
int32_t ret;
int32_t upgraded7682 = 0;
if(sDataBuffer.size == 0) {
hlogd("sDataBuffer size is 0");
return -1;
}
listener(INSTALL_ING, 0);
ret = parseHeader();
if(ret < 0)
goto end;
listener(UPGRADING, 10);
ret = upgradeModule(MAIN, listener);
if(ret < 0)
goto end;
listener(UPGRADING, 50);
ret = upgradeModule(SOUND, listener);
if(ret < 0)
goto end;
listener(UPGRADING, 80);
ret = upgradeModule(WIFI, listener);
if(ret < 0)
goto end;
else if(ret == RET_FW_OK){
upgraded7682 = 1;
}
listener(UPGRADING, 100);
end:
switch(ret){
case RET_FW_NOT_ENOUGH_DATA:
case RET_FW_MAGIC_ERROR:
listener(INSTALL_FAIL, 0);
break;
case RET_FW_CRC_ERROR:
listener(CRC_FAIL, 0);
break;
default:// RET_FW_OK or RET_FW_NO_NEED_UPGRADE
listener(UPGRADE_KERNEL, 0);
listener(INSTALL_OK, 0);
listener(UPGRADE_ALL, 0);
break;
}
/*env_mutex_lock();
if(upgraded7682){
char info[32] = {0};
snprint32_tf(info, sizeof(info), "%d,%d,%d", sFWHeader.FWInfo[WIFI].version, sFWHeader.FWInfo[WIFI].length, sFWHeader.FWInfo[WIFI].crc);
env_set_string(env_ota_info, info);
}
if(!is_adb_online()){//do not report version when update throught adb
env_set_int32_t(env_need_report_version, 1);
}
env_save();
env_mutex_unlock();*/
if(upgraded7682){
requestMT7682RebootandUpgrade();
}
return 0;
}
void createUpgradeTask(char *otaURL, onDownloadImageProgress listener)
{
if(sUpgrading){
hlogd("%s sUpgrading return",__func__);
return;
}
hlogd("createUpgradeTask : %s", otaURL);
Upgrade_config *p = (Upgrade_config*)hv_malloc(sizeof(Upgrade_config));
//RT_ASSERT(p);
p->url = strdup(otaURL);
p->listener = listener;
/*
rt_thread_t task_t = rt_thread_create("upgradeTask", upgradeTask, p, 10*1024, CONFIG_FINSH_THREAD_PRIORITY, 20);
if(task_t == RT_NULL){
listener(READY_FAIL, 0);
}else{
rt_thread_startup(task_t);
}*/
}
typedef struct
{
uint32_t m_magic;
/* version of app */
uint32_t m_ver;
/* app len*/
uint32_t m_body_len;
uint32_t m_checkcrc;
uint32_t m_bin_start_addr;
uint32_t reserve[3];
} bl_sota_update_info_t; //32bytes
int32_t isUpgrading(void){
return sUpgrading;
}
int32_t upgradeMT7682(void)
{
hlogd("%s start", __FUNCTION__);
sUpgrading = 1;
char *info = NULL;//env_get_string(env_ota_info, NULL);
if (info == NULL)
{
hlogd("%s: can't find env env_ota_info", __FUNCTION__);
return -1;
}
int32_t ret = -1;
int32_t max_block_size = 1024;
int32_t block_size = max_block_size;
int32_t fwVersion = -1, fwSize = 0, fwCrc = 0;
if (3 != sscanf(info, "%d,%d,%d", &fwVersion, &fwSize, &fwCrc))
{
hlogd("%s: firmware info error: %s", __FUNCTION__, info);
return -1;
}
int32_t otaFD = open(DEV_OTA_PARTITION, O_RDONLY);
if (otaFD < 0)
{
hlogd("%s: open %s failed", __FUNCTION__, DEV_OTA_PARTITION);
return -1;
}
char *buf = hv_malloc(block_size);
if (!buf)
{
hlogd("%s: hv_malloc upgrade buffer %d error", __FUNCTION__, block_size);
goto __ota_exit;
}
{
//先发送一包数据表示固件的相关信息
bl_sota_update_info_t sota_header;
sota_header.m_magic = 0x08317682;
sota_header.m_ver = fwVersion;
sota_header.m_body_len = fwSize;
sota_header.m_checkcrc = fwCrc;
hlogd("%s: start upgrade version %d length %d crc 0x%x",
__FUNCTION__, sota_header.m_ver, sota_header.m_body_len, sota_header.m_checkcrc);
if (writeRAWSDIODatato7672((const char *)&sota_header, sizeof(sota_header)))
{
hlogd("%s: write sota_header failed", __FUNCTION__);
return -1;
}
hlogd("%s: write sota_header ok", __FUNCTION__);
}
int32_t leftSize = fwSize;
do
{
block_size = leftSize > max_block_size ? max_block_size : leftSize;
int32_t avail = read(otaFD, buf, block_size);
if (avail == -1)
{
hlogd("read source failed");
goto __ota_exit;
}
leftSize -= avail;
if (writeRAWSDIODatato7672((const char *)buf, avail) != 0)
{
hlogd("%s: write sota data failed", __FUNCTION__);
goto __ota_exit;
}
hlogd("%s: write data %d ok", __FUNCTION__, avail);
} while (leftSize);
ret = 0;
__ota_exit:
if (buf)
{
hv_free(buf);
}
if (otaFD)
{
close(otaFD);
}
if (ret == 0)
{
hlogd("%s: done", __FUNCTION__);
}
else
{
hlogd("%s: failed", __FUNCTION__);
}
return ret;
}

47
app/app_ota/app_ota.h Executable file
View File

@@ -0,0 +1,47 @@
#ifndef _EKEN_UPRAGDE_H_
#define _EKEN_UPRAGDE_H_
#include "iobuffer.h"
typedef enum{
READY=1,
READY_FAIL = 2,
UPGRADING = 3,//for progress
DOWNLOAD_OK = 4,
DOWNLOAD_FAIL = 5,
CRC_FAIL = 11,
INSTALL_ING= 12,
INSTALL_OK= 13,
INSTALL_FAIL= 14,
UPGRADE_KERNEL = 16,
UPGRADE_ALL = 18,
BATTERY_LOW = 19,
MCU_FAIL = 20,
}UPGRADE_STATUS;
typedef void (*onDownloadImageProgress)(UPGRADE_STATUS status, int progress);
//How to use:
// 1 ./build.sh 3
// 2 generate the OTA package in V831\source\workspace\suniv\beetles\mkimage\DBV7PRO_MAIN_WIFI_001.ota
// 3 upload the ota to http server
// 4 eken_test OTA http://mysafelock.com/test/DBV7PRO_MAIN_WIFI_001.ota
//create task to download OTA package from http url
//1 after verify, upgrade 831 through aw_upgrade API aw_upgrade_slice
// after upgrade, aw_upgrade_end switch the BOOTA/BOOTB partition
//2 store the 7682 image in new 1MB USER partition in source/projects/defconfig/eken/aw_eken/sys_partition.fex
// after verify, notify MT7682 to upgrade(bl_sota_write_update_info) and reboot
//3 after 7682 and 831 reboot, the first handshake packet should notify 831 to upgrade 7682
//4 831 send 7682 image through SDIO interface in upgradeMT7682
void createUpgradeTask(char *otaURL, onDownloadImageProgress listener);
// send MT7682 image through SDIO interface
int upgradeMT7682(void);
int isUpgrading(void);
iobuffer* getOTAIOBuffer();
int startOTAFromIOBuffer(onDownloadImageProgress listener);
#endif

2
app/app_ota/config.mk Executable file
View File

@@ -0,0 +1,2 @@
SRC += $(wildcard $(APP_DIR)/app_ota/*.c)
CFLAGS += -I$(APP_DIR)/app_ota

306
app/app_ota/makeimage.c Executable file
View File

@@ -0,0 +1,306 @@
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <dirent.h>
#include <stdbool.h>
#include "makeimage.h"
static const unsigned int sf_crc_table[256] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
0x2d02ef8d
};
#define DO1(buf) crc = sf_crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8);
#define DO2(buf) do {DO1(buf); DO1(buf); } while (0)
#define DO4(buf) do {DO2(buf); DO2(buf); } while (0)
#define DO8(buf) do {DO4(buf); DO4(buf); } while (0)
static unsigned long crc32(unsigned int crc, unsigned char const *buf, size_t len)
{
crc = crc ^ 0xffffffff;
while (len >= 8) {
DO8(buf);
len -= 8;
}
if (len) {
do {
DO1(buf);
} while (--len);
}
return crc ^ 0xffffffff;
}
static int fw_offset = 0;
static char *readFileLenAndCrc(struct chipFWInfo* chipInfo, const char * file, int chipid)
{
FILE * f = fopen(file, "rb");
int version = 0;
int len = 0;
char* v = strrchr(file, '_');
if(!v) {
printf("file %s name is not correct\n", file);
return NULL;
}
sscanf(v+1, "%d.bin", &version);
chipInfo->magic = IMG_MAGIC;
chipInfo->chipID = chipid;
chipInfo->version = version;
if(version <=0){
printf("%s version:%dis not correct\n", __func__, version);
}
if(!f) {
printf("Can not open file:%s!\n", file);
return NULL;
}
fseek(f, 0, SEEK_END);
len = ftell(f);
fseek(f, 0, SEEK_SET);
char* data = (char *)hv_malloc(len);
if(fread(data, 1, len, f) != len) {
printf("Can not read file:%s!\n", file);
fclose(f);
hv_free(data);
return NULL;
}
fclose(f);
chipInfo->offset = fw_offset;
chipInfo->length = len;
chipInfo->crc = crc32(0, (unsigned char*)data, len);
fw_offset += len;
printf("file %s: magic 0x%x, chipID %d, version %d, offset %d, length %d, crc 0x%x\n\n",
file, chipInfo->magic, chipInfo->chipID, chipInfo->version, chipInfo->offset, chipInfo->length, chipInfo->crc);
return data;
}
#define SOC_PREFIX "SOC"
#define SOUND_PREFIX "SOUND"
static char *WIFI_PREFIX = "WIFI";
#define MCU2_PREFIX "MCU2"
bool findFile(const char*path, const char* prefix, char *bufName){
struct dirent *dp;
DIR *dfd;
if((dfd = opendir(path)) == NULL)
{
printf("open dir failed! dir: %s", path);
return false;
}
for(dp = readdir(dfd); NULL!=dp; dp = readdir(dfd))
{
if(strstr(dp->d_name, prefix)!=NULL)
{
strcpy(bufName, dp->d_name);
printf("%s: %s\n",__func__, dp->d_name);
closedir(dfd);
return true;
}
}
closedir(dfd);
return false;
}
int getVersion(char *filename){
int version = 0;
if(filename){
const char *start = strrchr(filename, '_');
if(start){
sscanf(start+1, "%d.bin", &version);
//printf("%s filename:%s, version:%d\n",__func__, filename, version);
}else{
printf("%s error filename:%s\n",__func__, filename);
}
}
return version;
}
#define SUFFIX "OTA.bin"
int main(int argc, char *argv[])
{
FILE* fpOutput = NULL;
int CHIP_version[CHIP_MAX]={0};
char *CHIP_data[CHIP_MAX]={NULL};
WIFI_PREFIX = argc > 1 ? argv[1] : WIFI_PREFIX;
char output[256]={0};//such as: T8w_MAIN_WIFI_001.ota
struct FWPackHeader header;
memset(&header, 0, sizeof(struct FWPackHeader));
fw_offset = sizeof(struct FWPackHeader);
FILE* fpVersion = NULL;
char versionBuf[1024]={0};
const char* versionFile = "version.info";
if((fpVersion = fopen(versionFile, "rt+")) == NULL) {
if((fpVersion = fopen(versionFile, "wt+")) == NULL) {
printf("Can not create versionFile:%s! LINE:%d\n", versionFile, __LINE__);
return -1;
}
}
const char *path = "./";
int i;
char filename[256];
int readCnt = fread(versionBuf, 1, sizeof(versionBuf), fpVersion);
if(readCnt == 0){
printf("%s fread readCnt == 0!\n", versionFile);
sprintf(versionBuf,"%d\n%d\n%d\n%d\n", CHIP_version[0], CHIP_version[1], CHIP_version[2], CHIP_version[3]);
readCnt = strlen(versionBuf);
}
fclose(fpVersion);
fpVersion = NULL;
bool changed;
if(readCnt > 0){
char *start = versionBuf;
char *next = versionBuf;
for(i=0; i<CHIP_MAX; i++){
next = strchr(start, '\n');
if(next){
*next = '\0';
CHIP_version[i] = atoi(start);
start = next + 1;
int newVersion;
char *prefix = NULL;
switch(i){
case MAIN:
prefix = SOC_PREFIX;
break;
case WIFI:
prefix = WIFI_PREFIX;
break;
case SOUND:
prefix = SOUND_PREFIX;
break;
case MCU2:
prefix = MCU2_PREFIX;
break;
}
if(prefix && findFile(path, prefix, filename) && (newVersion=getVersion(filename)) > 0){
if(1 || newVersion > CHIP_version[i]){
char filenam_no_ext[128];
strcpy(filenam_no_ext, filename);
char *ext_pos = strrchr(filenam_no_ext, '.');
if(ext_pos){
*ext_pos = '\0';
}
strcat(output, filenam_no_ext);
strcat(output, "_");
CHIP_version[i] = newVersion;
CHIP_data[i] = readFileLenAndCrc(&header.FWInfo[i], filename, i);
changed = true;
}else{
printf("warning: file(%s) not be packed coz newVersion:%d <= %d(oldVersion)\n", filename, newVersion, CHIP_version[i]);
}
}
}else{
break;
}
}
sprintf(versionBuf,"%d\n%d\n%d\n%d\n", CHIP_version[0], CHIP_version[1], CHIP_version[2], CHIP_version[3]);
if(changed){
if((fpVersion = fopen(versionFile, "wt+")) != NULL) {
fwrite(versionBuf, strlen(versionBuf), 1, fpVersion);
}else{
printf("Can not create versionFile:%s! LINE:%d\n", versionFile, __LINE__);
}
} else {
printf("=========================================\n");
printf("no firmware changed, not pack OTA package\n");
printf("=========================================\n");
return 0;
}
}
strcat(output, SUFFIX);
printf("=========================================\n");
printf("OTA Image:%s\n", output);
printf("=========================================\n");
if ((fpOutput = fopen(output, "wb+")) == NULL) {
printf("Can not create new image:%s!\n", output);
}else{
fwrite(&header, 1, sizeof(struct FWPackHeader),fpOutput);
for(i=0; i<CHIP_MAX; i++){
if(CHIP_data[i]){
fwrite(CHIP_data[i], header.FWInfo[i].length, 1, fpOutput);
hv_free(CHIP_data[i]);
CHIP_data[i] = NULL;
}
}
fclose(fpOutput);
strcpy(filename, "release/");
strcat(filename, output);
int ret = rename(output, filename);
if(ret != 0)
printf("error rename ret:%d, %s to %s\n", ret, output, filename);
}
if(fpVersion)
fclose(fpVersion);
return 0;
}

40
app/app_ota/makeimage.h Executable file
View File

@@ -0,0 +1,40 @@
#ifndef _FIRMWARE_PACK_H_
#define _FIRMWARE_PACK_H_
/*
* 功能:
* 因为固件都在V831这边，所以由V831来做升级的总管，控制升级流程
* 1 从MT7682接收固件包, 写到V831的flash上面
* 2 接收完毕，CRC正确，设置升级标志位，各个芯片要支持单独升级/单独设置升级标志/版本号
* 3 触发V831的升级，升级完成，版本号与升级版本一致，清除V831的升级标志
* 4 触发MT7682升级，升级完获取版本号，版本号与升级版本一致，清除MT7682升级标志
* 5 类似方式触发BYD/华大升级
*/
/*
* 每一个模块升级完都要单独更新升级标志
*/
enum FIRMWARE_ID {
MAIN=0,
SOUND,
WIFI, //必须放在最后面, 因为写到flash以后, 就触发重启升级机制
MCU2,
CHIP_MAX
};
#define IMG_MAGIC 0x20A3BF9D
struct chipFWInfo {
unsigned int magic;
unsigned short chipID; //FIRMWARE_ID
unsigned short version; //待升级的版本号
unsigned int offset; //在固件包当中的偏移地址
unsigned int length; //固件大小
unsigned int crc; //crc32
};
struct FWPackHeader{
struct chipFWInfo FWInfo[CHIP_MAX];
unsigned char reserved[128 - sizeof(struct chipFWInfo) * CHIP_MAX];
};
#endif

1
app/app_ota/readme.txt Executable file
View File

@@ -0,0 +1 @@
none