wen/luban-lite-t3e-pro
1
0
Fork 0
mirror of https://gitee.com/Vancouver2017/luban-lite-t3e-pro.git synced 2025-12-14 10:28:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

V1.0.5

Browse Source
This commit is contained in:
刘可亮
2024-06-04 19:00:30 +08:00
parent 990c72f5be
commit 0a13af6a1d
1668 changed files with 342810 additions and 37726 deletions
Download Patch File Download Diff File Expand all files Collapse all files

113
packages/artinchip/ota/absystem.c
View File

@@ -15,18 +15,24 @@
#include <env.h>
#include <absystem.h>
#define HTTP_OTA_FILE_CNT 2
#define HTTP_OTA_FILE_REDUNDAND_CNT HTTP_OTA_FILE_CNT * 2
#define OTA_FILE_CNT 3
#define OTA_FILE_REDUNDAND_CNT OTA_FILE_CNT * 2
char partname[HTTP_OTA_FILE_REDUNDAND_CNT][32] = {
char partname[OTA_FILE_REDUNDAND_CNT][32] = {
"os",
"rodata",
"blk_data",
"os_r",
"rodata_r",
"blk_data_r",
};
#define APPLICATION_PART "blk_rodata"
#define APPLICATION_PART_REDUNDAND "blk_rodata_r"
#define APPLICATION_RO_PART "blk_rodata"
#define APPLICATION_RO_PART_REDUNDAND "blk_rodata_r"
#define APPLICATION_WR_PART "blk_data"
#define APPLICATION_WR_PART_REDUNDAND "blk_data_r"
#define APPLICATION_MMC_RO_PART "mmc0p5"
#define APPLICATION_MMC_RO_PART_REDUNDAND "mmc0p6"
static unsigned char target_offset = 0;
@@ -44,7 +50,7 @@ int aic_upgrade_start(void)
LOG_I("osAB_now = %s", now);
if (strncmp(now, "A", 1) == 0) {
LOG_I("Upgrade B system");
target_offset = HTTP_OTA_FILE_CNT;
target_offset = OTA_FILE_CNT;
} else if (strncmp(now, "B", 1) == 0) {
LOG_I("Upgrade A system");
target_offset = 0;
@@ -108,9 +114,7 @@ aic_upgrade_end_out:
int aic_ota_status_update(void)
{
char *status = NULL;
char *next;
int ret = 0;
char *now = NULL;
if (fw_env_open()) {
pr_err("Open env failed\n");
@@ -122,35 +126,6 @@ int aic_ota_status_update(void)
printf("upgrade_available = %s\n", status);
#endif
if (strncmp(status, "1", 2) == 0) {
next = fw_getenv("osAB_next");
now = fw_getenv("osAB_now");
#ifdef AIC_ENV_DEBUG
printf("osAB_next = %s\n", next);
printf("osAB_now = %s\n", now);
#endif
if (strncmp(next, now, 2) != 0) {
if (strncmp(next, "A", 2) == 0) {
ret = fw_env_write("osAB_now", "A");
} else if (strncmp(next, "B", 2) == 0) {
ret = fw_env_write("osAB_now", "B");
} else {
ret = -1;
pr_err("Invalid osAB_next\n");
goto aic_get_upgrade_status_err;
}
if (ret) {
pr_err("Env write fail\n");
goto aic_get_upgrade_status_err;
}
pr_info("OTA Upgrade success\n");
} else {
pr_info("OTA upgrade failed\n");
ret = -1;
goto aic_get_upgrade_status_err;
}
ret = fw_env_write("upgrade_available", "0");
if (ret) {
@@ -188,10 +163,68 @@ int aic_get_rodata_to_mount(char *target_rodata)
printf("osAB_now = %s\n", now);
#endif
if (strncmp(now, "A", 2) == 0) {
memcpy(target_rodata, APPLICATION_PART, strlen(APPLICATION_PART));
memcpy(target_rodata, APPLICATION_RO_PART, strlen(APPLICATION_RO_PART));
} else if (strncmp(now, "B", 2) == 0) {
memcpy(target_rodata, APPLICATION_PART_REDUNDAND,
strlen(APPLICATION_PART_REDUNDAND));
memcpy(target_rodata, APPLICATION_RO_PART_REDUNDAND,
strlen(APPLICATION_RO_PART_REDUNDAND));
} else {
ret = -1;
pr_err("invalid osAB_now\n");
}
fw_env_close();
return ret;
}
int aic_get_mmc_rodata_to_mount(char *target_rodata)
{
char *now = NULL;
int ret = 0;
if (fw_env_open()) {
pr_err("Open env failed\n");
return -1;
}
now = fw_getenv("osAB_now");
#ifdef AIC_ENV_DEBUG
printf("osAB_now = %s\n", now);
#endif
if (strncmp(now, "A", 2) == 0) {
memcpy(target_rodata, APPLICATION_MMC_RO_PART, strlen(APPLICATION_MMC_RO_PART));
} else if (strncmp(now, "B", 2) == 0) {
memcpy(target_rodata, APPLICATION_MMC_RO_PART_REDUNDAND,
strlen(APPLICATION_MMC_RO_PART_REDUNDAND));
} else {
ret = -1;
pr_err("invalid osAB_now\n");
}
fw_env_close();
return ret;
}
int aic_get_data_to_mount(char *target_data)
{
char *now = NULL;
int ret = 0;
if (fw_env_open()) {
pr_err("Open env failed\n");
return -1;
}
now = fw_getenv("osAB_now");
#ifdef AIC_ENV_DEBUG
printf("osAB_now = %s\n", now);
#endif
if (strncmp(now, "A", 2) == 0) {
memcpy(target_data, APPLICATION_WR_PART, strlen(APPLICATION_WR_PART));
} else if (strncmp(now, "B", 2) == 0) {
memcpy(target_data, APPLICATION_WR_PART_REDUNDAND,
strlen(APPLICATION_WR_PART_REDUNDAND));
} else {
ret = -1;
pr_err("invalid osAB_now\n");

2
packages/artinchip/ota/absystem.h
View File

@@ -18,6 +18,8 @@ char *aic_upgrade_get_partname(unsigned char index);
int aic_upgrade_end(void);
int aic_ota_status_update(void);
int aic_get_rodata_to_mount(char *target_rodata);
int aic_get_mmc_rodata_to_mount(char *target_rodata);
int aic_get_data_to_mount(char *target_data);
#ifdef __cplusplus
}

185
packages/artinchip/ota/burn.c
View File

@@ -30,9 +30,13 @@ const struct fal_partition *dl_part = RT_NULL;
#ifdef AIC_SPINAND_DRV
struct rt_mtd_nand_device *nand_mtd;
u8 g_nftl_flag = 0;
rt_device_t nand_dev;
#endif
rt_device_t mmc_dev;
u32 block_size;
int aic_ota_find_part(char *partname)
{
switch (aic_get_boot_device()) {
@@ -55,9 +59,41 @@ int aic_ota_find_part(char *partname)
return -RT_ERROR;
}
nand_mtd = (struct rt_mtd_nand_device *)nand_dev;
if ((strncmp(partname, "blk_data", 9) == 0) || (strncmp(partname, "blk_data_r", 11) == 0)) {
g_nftl_flag = 1;
} else {
nand_mtd = (struct rt_mtd_nand_device *)nand_dev;
g_nftl_flag = 0;
}
break;
#endif
case BD_SDMC0:
if (!strncmp(partname, "os", 3)) {
mmc_dev = rt_device_find("mmc0p3");
if (mmc_dev == RT_NULL) {
LOG_E("can't find mmc0p3 device!");
return RT_ERROR;
}
} else if (!strncmp(partname, "os_r", 5)) {
mmc_dev =rt_device_find("mmc0p4");
if (mmc_dev == RT_NULL) {
LOG_E("can't find mmc0p4 device!");
return RT_ERROR;
}
} else if (!strncmp(partname, "rodata", 7)) {
mmc_dev =rt_device_find("mmc0p5");
if (mmc_dev == RT_NULL) {
LOG_E("can't find mmc0p5 device!");
return RT_ERROR;
}
} else if (!strncmp(partname, "rodata_r", 9)) {
mmc_dev =rt_device_find("mmc0p6");
if (mmc_dev == RT_NULL) {
LOG_E("can't find mmc0p6 device!");
return RT_ERROR;
}
}
break;
default:
return -RT_ERROR;
break;
@@ -87,6 +123,11 @@ int aic_ota_nand_erase_part(void)
{
unsigned long blk_offset = 0;
if (g_nftl_flag) {
LOG_I("NFTL partition not need to erase!");
return 0;
}
LOG_I("Start erase nand flash partition!");
while (nand_mtd->block_total > blk_offset) {
@@ -108,9 +149,9 @@ int aic_ota_nand_erase_part(void)
int aic_ota_nand_write(uint32_t addr, const uint8_t *buf, size_t size)
{
unsigned long blk = 0, offset = 0, page = 0;
unsigned long blk = 0, offset = 0, page = 0, sector = 0, sector_total = 0;
static unsigned long bad_block_off = 0;
unsigned long blk_size = nand_mtd->pages_per_block * nand_mtd->page_size;
unsigned long blk_size = 0, page_size = 0;
rt_err_t ret = 0;
if (size > 2048) {
@@ -118,39 +159,112 @@ int aic_ota_nand_write(uint32_t addr, const uint8_t *buf, size_t size)
return -RT_ERROR;
}
ret = rt_device_open(nand_dev, RT_DEVICE_OFLAG_RDWR);
if (ret) {
LOG_E("Open MTD device failed.!\n");
if (g_nftl_flag == 0) {
ret = rt_device_open(nand_dev, RT_DEVICE_OFLAG_RDWR);
if (ret) {
LOG_E("Open MTD device failed.!\n");
return ret;
}
blk_size = nand_mtd->pages_per_block * nand_mtd->page_size;
offset = addr + bad_block_off;
/* Search for the first good block after the given offset */
if (offset % blk_size == 0) {
blk = offset / blk_size;
while (rt_mtd_nand_check_block(nand_mtd, blk) != RT_EOK) {
LOG_W("find a bad block(%d), off adjust to the next block\n", blk);
bad_block_off += nand_mtd->pages_per_block;
offset = addr + bad_block_off;
blk = offset / blk_size;
}
}
page = offset / nand_mtd->page_size;
ret = rt_mtd_nand_write(nand_mtd, page, buf, size, RT_NULL, 0);
if (ret) {
LOG_E("Failed to write data to NAND.\n");
ret = -RT_ERROR;
}
rt_device_close(nand_dev);
} else {
ret = rt_device_open(nand_dev, RT_DEVICE_OFLAG_RDWR);
if (ret) {
LOG_E("Open MTD device failed.!\n");
return ret;
}
page_size = 2048;//default size:nand_blk->mtd_device->page_size;
page = addr / page_size;
sector = page * 4;
sector_total = (size / page_size) * 4;
ret = rt_device_write(nand_dev, sector, buf, sector_total);
if (ret < 0) {
LOG_E("Failed to write data to NAND.\n");
ret = -RT_ERROR;
} else {
ret = 0;
}
rt_device_close(nand_dev);
}
return ret;
}
#endif
int aic_ota_mmc_erase_part(void)
{
struct rt_device_blk_geometry get_data;
unsigned long long p[2] = {0};
rt_err_t ret = 0;
LOG_I("Start erase mmc partition!");
rt_device_open(mmc_dev, RT_DEVICE_FLAG_RDWR);
rt_device_control(mmc_dev, RT_DEVICE_CTRL_BLK_GETGEOME, (void *)&get_data);
p[0] = 0;//offset is 0
p[1] = get_data.sector_count;
block_size = get_data.block_size;
ret = rt_device_control(mmc_dev, RT_DEVICE_CTRL_BLK_ERASE, (void *)p);
if (ret != RT_EOK) {
LOG_I("Erase mmc partition failed!");
return ret;
}
offset = addr + bad_block_off;
/* Search for the first good block after the given offset */
if (offset % blk_size == 0) {
blk = offset / blk_size;
while (rt_mtd_nand_check_block(nand_mtd, blk) != RT_EOK) {
LOG_W("find a bad block(%d), off adjust to the next block\n", blk);
bad_block_off += nand_mtd->pages_per_block;
offset = addr + bad_block_off;
blk = offset / blk_size;
}
}
page = offset / nand_mtd->page_size;
ret = rt_mtd_nand_write(nand_mtd, page, buf, size, RT_NULL, 0);
if (ret) {
LOG_E("Failed to write data to NAND.\n");
ret = -RT_ERROR;
goto aic_ota_nand_write_exit;
}
aic_ota_nand_write_exit:
rt_device_close(nand_dev);
LOG_I("Erase mmc partition success!");
return 0;
}
int aic_ota_mmc_write(uint32_t addr, const uint8_t *buf, size_t size)
{
unsigned long blkcnt, blkoffset;
if (size > 2048) {
LOG_E("OTA_BURN_LEN need set 2048! size = %d", size);
return -RT_ERROR;
}
blkcnt = size / block_size;
blkoffset = addr / block_size;
rt_device_open(mmc_dev, RT_DEVICE_FLAG_RDWR);
rt_device_write(mmc_dev, blkoffset, (void *)buf, blkcnt);
rt_device_close(mmc_dev);
return 0;
#endif
}
int aic_ota_erase_part(void)
@@ -167,6 +281,9 @@ int aic_ota_erase_part(void)
case BD_SPINAND:
ret = aic_ota_nand_erase_part();
break;
#endif
case BD_SDMC0:
ret = aic_ota_mmc_erase_part();
break;
default:
break;
@@ -202,6 +319,14 @@ int aic_ota_part_write(uint32_t addr, const uint8_t *buf, size_t size)
return -RT_ERROR;
}
break;
#endif
case BD_SDMC0:
ret = aic_ota_mmc_write(addr, buf, size);
if (ret < 0) {
LOG_E(
"Firmware download failed! mmc partition write data error!");
return -RT_ERROR;
}
break;
default:
return -RT_ERROR;

2
packages/artinchip/ota/ota.c
View File

@@ -510,6 +510,8 @@ int ota_shard_download_fun(char *buffer, int length)
partname = aic_upgrade_get_partname(flag_cpio);
LOG_I("Start upgrade to %s, flag_cpio:%d!", partname, flag_cpio);
ret = aic_ota_find_part(partname);
if (ret)
goto __download_exit;

2
packages/artinchip/ota/ota.h
View File

@@ -23,7 +23,7 @@ extern "C" {
#define OTA_BURN_BUFF_LEN (2048 * 2)
#define OTA_BURN_LEN 2048
#define OTA_HEAD_LEN (2048 * 2)
#define OTA_BUFF_LEN (4096 / 2)
#define OTA_BUFF_LEN 2048
int ota_init(void);
void ota_deinit(void);