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; }