int get_burn_parts_from_img(HIMAGE hImg, ConfigPara_t* pcfgPara)
{
BurnParts_t* pburnPartsCfg = &pcfgPara->burnParts;
int i = 0;
int ret = 0;
int burnNum = 0;
const int totalItemNum = get_total_itemnr(hImg);
for (i = 0; i < totalItemNum; i++)
{
const char* main_type = NULL;
const char* sub_type = NULL;
ret = get_item_name(hImg, i, &main_type, &sub_type);
if (ret) {
DWN_ERR("Exception:fail to get item name!\n");
return __LINE__;
}
if (!strcmp("PARTITION", main_type))
{
char* partName = pburnPartsCfg->burnParts[burnNum];
if (!strcmp("bootloader", sub_type)) continue;
if (!strcmp(AML_SYS_RECOVERY_PART, sub_type))
{
if (OPTIMUS_WORK_MODE_SYS_RECOVERY == optimus_work_mode_get()) continue;
}
strcpy(partName, sub_type);
pburnPartsCfg->bitsMap4BurnParts |= 1U<<burnNum;
burnNum += 1;
}
}
if (burnNum)
{
pburnPartsCfg->burn_num = burnNum;
ret = check_cfg_burn_parts(pcfgPara);
if (ret) {
DWN_ERR("Fail in check burn parts\n");
return __LINE__;
}
print_burn_parts_para(pburnPartsCfg);
}
return OPT_DOWN_OK;
}
int optimus_storage_init(int toErase)
{
int ret = 0;
char* cmd = NULL;
if(_disk_intialed_ok){//To assert only actual disk intialed once
DWN_MSG("Disk inited again.\n");
return 0;
}
if(OPTIMUS_WORK_MODE_USB_PRODUCE != optimus_work_mode_get())//Already inited in other work mode
{
DWN_MSG("Exit before re-init\n");
store_exit();
}
switch(toErase)
{
case 0://NO erase
ret = store_init(1);
break;
case 3://erase all(with key)
{
cmd = "store disprotect key";
DWN_MSG("run cmd [%s]\n", cmd);
ret = run_command(cmd, 0);
if(ret){
DWN_ERR("Fail when run cmd[%s], ret %d\n", cmd, ret);
break;
}
}
case 1://normal erase, store init 3
ret = store_init(3);
break;
case 4://force erase all
{
cmd = "store disprotect key; store disprotect fbbt; store disprotect hynix";
DWN_MSG("run cmd [%s]\n", cmd);
ret = run_command(cmd, 0);
if(ret){
DWN_ERR("Fail when run cmd[%s], ret %d\n", cmd, ret);
break;
}
}
case 2:
ret = store_init(4);
break;
default:
DWN_ERR("Unsupported erase flag %d\n", toErase); ret = -__LINE__;
break;
}
if(!ret)
{
_disk_intialed_ok = 1;
if(OPTIMUS_WORK_MODE_USB_PRODUCE == optimus_work_mode_get())//env not relocated in this case
{
DWN_MSG("usb producing env_relocate\n");
env_relocate();
}
}
return ret;
}
//return value is the data size that actual dealed
static u32 optimus_storage_write(struct ImgBurnInfo* pDownInfo, u64 addrOrOffsetInBy, unsigned dataSz, const u8* data, char* errInfo)
{
u32 burnSz = 0;
const u32 imgType = pDownInfo->imgType;
const int MediaType = pDownInfo->storageMediaType;
addrOrOffsetInBy += pDownInfo->partBaseOffset;
DWN_DBG("[0x]Data %p, addrOrOffsetInBy %llx, dataSzInBy %x\n", data, addrOrOffsetInBy, dataSz);
if(OPTIMUS_IMG_STA_BURN_ING != pDownInfo->imgBurnSta) {
sprintf(errInfo, "Error burn sta %d\n", pDownInfo->imgBurnSta);
DWN_ERR(errInfo);
return 0;
}
switch(MediaType)
{
case OPTIMUS_MEDIA_TYPE_NAND:
case OPTIMUS_MEDIA_TYPE_SDMMC:
case OPTIMUS_MEDIA_TYPE_STORE:
{
switch(imgType)
{
case IMG_TYPE_NORMAL:
burnSz = optimus_download_normal_image(pDownInfo, dataSz, data);
break;
case IMG_TYPE_BOOTLOADER:
burnSz = optimus_download_bootloader_image(pDownInfo, dataSz, data);
break;
case IMG_TYPE_SPARSE:
burnSz = optimus_download_sparse_image(pDownInfo, dataSz, data);
break;
default:
DWN_ERR("error image type %d\n", imgType);
}
}
break;
case OPTIMUS_MEDIA_TYPE_KEY_UNIFY:
{
burnSz = v2_key_burn(pDownInfo->partName, data, dataSz, errInfo);
if(burnSz != dataSz){//return value is write size
DWN_ERR("burn key failed\n");
return 0;
}
}
break;
case OPTIMUS_MEDIA_TYPE_MEM:
{
u8* buf = (u8*)(unsigned)addrOrOffsetInBy;
if(buf != data){
DWN_ERR("buf(%llx) != data(%p)\n", addrOrOffsetInBy, data);
return 0;
}
if(!strcmp("dtb", pDownInfo->partName))//as memory write back size = min[fileSz, 2G], so reach here if downloaded ok!
{
int rc = 0;
char* dtbLoadAddr = (char*)CONFIG_DTB_LOAD_ADDR;
const int DtbMaxSz = (2U<<20);
unsigned fdtSz = 0;
unsigned char* destDtb = (unsigned char*)data;
//Make sure flash already inited before 'run aml_dt'
//old tool will download dtb before 'disk_initial', but new tool will 'disk_initial' first
if(is_optimus_storage_inited() ||
(OPTIMUS_WORK_MODE_USB_PRODUCE != optimus_work_mode_get()))
{
destDtb = (unsigned char*)get_multi_dt_entry((unsigned int)data);
}
rc = fdt_check_header(destDtb);
if(rc){
sprintf(errInfo, "failed at fdt_check_header\n");
DWN_ERR(errInfo);
return 0;
}
fdtSz = fdt_totalsize(destDtb);
if(DtbMaxSz <= fdtSz){
sprintf(errInfo, "failed: fdt header ok but sz 0%x > max 0x%x\n", fdtSz, DtbMaxSz);
DWN_ERR(errInfo);
return 0;
}
DWN_MSG("load dtb to 0x%p\n", dtbLoadAddr);
memcpy(dtbLoadAddr, destDtb, fdtSz);
}
burnSz = dataSz;
}
break;
default:
sprintf(errInfo, "Error MediaType %d\n", MediaType);
DWN_ERR(errInfo);
}
return burnSz;
}
int optimus_burn_with_cfg_file(const char* cfgFile)
{
extern ConfigPara_t g_sdcBurnPara ;
int ret = 0;
HIMAGE hImg = NULL;
ConfigPara_t* pSdcCfgPara = &g_sdcBurnPara;
const char* pkgPath = pSdcCfgPara->burnEx.pkgPath;
__hdle hUiProgress = NULL;
ret = parse_ini_cfg_file(cfgFile);
if (ret) {
DWN_ERR("Fail to parse file %s\n", cfgFile);
ret = __LINE__; goto _finish;
}
if (pSdcCfgPara->custom.eraseBootloader && strcmp("1", getenv("usb_update")))
{
if (is_bootloader_old())
{
DWN_MSG("To erase OLD bootloader !\n");
ret = optimus_erase_bootloader("sdc");
if (ret) {
DWN_ERR("Fail to erase bootloader\n");
ret = __LINE__; goto _finish;
}
#if defined(CONFIG_VIDEO_AMLLCD)
//axp to low power off LCD, no-charging
DWN_MSG("To close LCD\n");
ret = run_command("video dev disable", 0);
if (ret) {
printf("Fail to close back light\n");
/*return __LINE__;*/
}
#endif// #if defined(CONFIG_VIDEO_AMLLCD)
DWN_MSG("Reset to load NEW uboot from ext-mmc!\n");
optimus_reset(OPTIMUS_BURN_COMPLETE__REBOOT_SDC_BURN);
return __LINE__;//should never reach here!!
}
}
if (OPTIMUS_WORK_MODE_SDC_PRODUCE == optimus_work_mode_get()) //led not depend on image res, can init early
{
if (optimus_led_open(LED_TYPE_PWM)) {
DWN_ERR("Fail to open led for sdc_produce\n");
return __LINE__;
}
optimus_led_show_in_process_of_burning();
}
hImg = image_open("mmc", "0", "1", pkgPath);
if (!hImg) {
DWN_ERR("Fail to open image %s\n", pkgPath);
ret = __LINE__; goto _finish;
}
//update dtb for burning drivers
ret = optimus_sdc_burn_dtb_load(hImg);
if (ITEM_NOT_EXIST != ret && ret) {
DWN_ERR("Fail in load dtb for sdc_burn\n");
ret = __LINE__; goto _finish;
}
if (video_res_prepare_for_upgrade(hImg)) {
DWN_ERR("Fail when prepare bm res or init video for upgrade\n");
image_close(hImg);
return __LINE__;
}
show_logo_to_report_burning();
hUiProgress = optimus_progress_ui_request_for_sdc_burn();
if (!hUiProgress) {
DWN_ERR("request progress handle failed!\n");
ret = __LINE__; goto _finish;
}
optimus_progress_ui_direct_update_progress(hUiProgress, UPGRADE_STEPS_AFTER_IMAGE_OPEN_OK);
int hasBootloader = 0;
u64 datapartsSz = optimus_img_decoder_get_data_parts_size(hImg, &hasBootloader);
int eraseFlag = pSdcCfgPara->custom.eraseFlash;
if (!datapartsSz) {
eraseFlag = 0;
DWN_MSG("Disable erase as data parts size is 0\n");
}
ret = optimus_storage_init(eraseFlag);
if (ret) {
DWN_ERR("Fail to init stoarge for sdc burn\n");
return __LINE__;
}
optimus_progress_ui_direct_update_progress(hUiProgress, UPGRADE_STEPS_AFTER_DISK_INIT_OK);
if (datapartsSz)
{
ret = optimus_progress_ui_set_smart_mode(hUiProgress, datapartsSz,
UPGRADE_STEPS_FOR_BURN_DATA_PARTS_IN_PKG(!pSdcCfgPara->burnEx.bitsMap.mediaPath));
if (ret) {
DWN_ERR("Fail to set smart mode\n");
ret = __LINE__; goto _finish;
}
ret = optimus_sdc_burn_partitions(pSdcCfgPara, hImg, hUiProgress, 1);
if (ret) {
DWN_ERR("Fail when burn partitions\n");
ret = __LINE__; goto _finish;
}
}
if (pSdcCfgPara->burnEx.bitsMap.mediaPath) //burn media image
{
const char* mediaPath = pSdcCfgPara->burnEx.mediaPath;
ret = optimus_sdc_burn_media_partition(mediaPath, NULL);//no progress bar info if have partition image not in package
if (ret) {
DWN_ERR("Fail to burn media partition with image %s\n", mediaPath);
optimus_storage_exit();
ret = __LINE__;goto _finish;
}
}
optimus_progress_ui_direct_update_progress(hUiProgress, UPGRADE_STPES_AFTER_BURN_DATA_PARTS_OK);
//TO burn nandkey/securekey/efusekey
ret = sdc_burn_aml_keys(hImg, pSdcCfgPara->custom.keyOverwrite);
if (ret) {
DWN_ERR("Fail in sdc_burn_aml_keys\n");
ret = __LINE__;goto _finish;
}
#if 1
if (hasBootloader)
{//burn bootloader
ret = optimus_burn_bootlader(hImg);
if (ret) {
DWN_ERR("Fail in burn bootloader\n");
goto _finish;
}
else
{//update bootloader ENV only when bootloader image is burned
ret = optimus_set_burn_complete_flag();
if (ret) {
DWN_ERR("Fail in set_burn_complete_flag\n");
ret = __LINE__; goto _finish;
}
}
}
#endif
optimus_progress_ui_direct_update_progress(hUiProgress, UPGRADE_STEPS_AFTER_BURN_BOOTLOADER_OK);
_finish:
image_close(hImg);
optimus_progress_ui_report_upgrade_stat(hUiProgress, !ret);
optimus_report_burn_complete_sta(ret, pSdcCfgPara->custom.rebootAfterBurn);
optimus_progress_ui_release(hUiProgress);
//optimus_storage_exit();//temporary not exit storage driver when failed as may continue burning after burn
return ret;
}
