int optimus_sdc_burn_dtb_load(HIMAGE hImg) { s64 itemSz = 0; HIMAGEITEM hImgItem = NULL; int rc = 0; const char* partName = "dtb"; u64 partBaseOffset = OPTIMUS_DOWNLOAD_TRANSFER_BUF_ADDR; unsigned char* dtbTransferBuf = (unsigned char*)partBaseOffset; //meson1.dtb but not meson.dtb for m8 compatible if (_check_if_secureboot_enabled()) { DWN_MSG("SecureEnabled, use meson1_ENC\n"); hImgItem = image_item_open(hImg, partName, "meson1_ENC"); } else { hImgItem = image_item_open(hImg, partName, "meson1"); } if (!hImgItem) { DWN_WRN("Fail to open item [meson1,%s]\n", partName); return ITEM_NOT_EXIST; } itemSz = image_item_get_size(hImgItem); if (!itemSz) { DWN_ERR("Item size 0\n"); image_item_close(hImgItem); return __LINE__; } #if 1 const unsigned itemSzNotAligned = image_item_get_first_cluster_size(hImg, hImgItem); if (itemSzNotAligned /*& 0x7*/) {//Not Aligned 8bytes/64bits, mmc dma read will failed DWN_MSG("align 4 mmc read...\t");//Assert Make 'DDR' buffer addr align 8 dtbTransferBuf += image_get_cluster_size(hImg) - itemSzNotAligned; partBaseOffset += image_get_cluster_size(hImg) - itemSzNotAligned; } #endif rc = image_item_read(hImg, hImgItem, dtbTransferBuf, (unsigned)itemSz); if (rc) { DWN_ERR("Failed at item read, rc = %d\n", rc); image_item_close(hImgItem); return __LINE__; } image_item_close(hImgItem); rc = optimus_parse_img_download_info(partName, itemSz, "normal", "mem", partBaseOffset); if (rc) { DWN_ERR("Failed in init down info\n"); return __LINE__; } { unsigned wrLen = 0; char errInfo[512]; wrLen = optimus_download_img_data(dtbTransferBuf, (unsigned)itemSz, errInfo); rc = (wrLen == itemSz) ? 0 : __LINE__; } return rc; }
//fetch the keys names which need be burned from item[conf, keys] static int sdc_burn_get_user_key_names(HIMAGE hImg, const char* **pKeysName, unsigned* keysNum) { int rc = 0; HIMAGEITEM hImgItem = NULL; unsigned itemSz = 0; unsigned char* thisReadBuf = (unsigned char*)OPTIMUS_SPARSE_IMG_FILL_VAL_BUF;//This buf is not used and not need reuse when burning keys const unsigned thisReadBufSz = (OPTIMUS_SPARSE_IMG_FILL_BUF_SZ >> 1); const char* *keysName = (const char**)(thisReadBuf + thisReadBufSz); hImgItem = image_item_open(hImg, "conf", "keys"); if (!hImgItem) { DWN_ERR("Fail to open keys.conf\n"); return ITEM_NOT_EXIST; } itemSz = (unsigned)image_item_get_size(hImgItem); if (!itemSz) { DWN_ERR("Item size 0\n"); image_item_close(hImgItem); return __LINE__; } const unsigned itemSzNotAligned = image_item_get_first_cluster_size(hImg, hImgItem); if (itemSzNotAligned /*& 0x7*/) {//Not Aligned 8bytes/64bits, mmc dma read will failed DWN_MSG("align 4 mmc read...\t");//Assert Make 'DDR' buffer addr align 8 thisReadBuf += image_get_cluster_size(hImg); thisReadBuf -= itemSzNotAligned; } rc = image_item_read(hImg, hImgItem, thisReadBuf, itemSz); if (rc) { DWN_ERR("Failed at item read, rc = %d\n", rc); image_item_close(hImgItem); return __LINE__; } image_item_close(hImgItem); if (itemSz >= thisReadBufSz) { DWN_ERR("itemSz(0x%x) of keys.conf too large, > max 0x%x.\n", itemSz, thisReadBufSz); return __LINE__; } rc = _optimus_parse_buf_2_lines((char*)thisReadBuf, itemSz, keysName, keysNum, 16); if (rc) { DWN_ERR("Fail in parse buf_2_lines\n"); return __LINE__; } rc = _optimus_abandon_ini_comment_lines((char**)keysName, *keysNum); *pKeysName = keysName; return rc; }
int optimus_verify_partition(const char* partName, HIMAGE hImg, char* _errInfo) { #define MaxSz (64 - 7) //verify file to at most 64B to corresponding to USB burn, strlen("verify ") == 7 char* argv[4]; int ret = 0; HIMAGEITEM hImgItem = NULL; int imgItemSz = 0; char CmdVerify[MaxSz + 7] = {0}; hImgItem = image_item_open(hImg, "VERIFY", partName); if (!hImgItem) { DWN_ERR("Fail to open verify file for part (%s)\n", partName); return ITEM_NOT_EXIST; } imgItemSz = (int)image_item_get_size(hImgItem); if (imgItemSz > MaxSz || !imgItemSz) { DWN_ERR("verify file size %d for part %s invalid, max is %d\n", imgItemSz, partName, MaxSz); ret = __LINE__; goto _finish; } DWN_DBG("item sz %u\n", imgItemSz); ret = image_item_read(hImg, hImgItem, CmdVerify, imgItemSz); if (ret) { DWN_ERR("Fail to read verify item for part %s\n", partName); goto _finish; } CmdVerify[imgItemSz] = 0; DWN_DBG("verify[%s]\n", CmdVerify); argv[0] = "verify"; ret = cli_simple_parse_line(CmdVerify, argv + 1); if (ret != 2) { DWN_ERR("verify cmd argc must be 2, but %d\n", ret); return __LINE__; } ret = optimus_media_download_verify(3, argv, _errInfo); if (ret) { DWN_ERR("Fail when verify\n"); return __LINE__; } _finish: image_item_close(hImgItem); return ret; }
//fetch the keys names which need be burned from item[conf, keys] static int sdc_burn_get_user_key_names(HIMAGE hImg, const char* **pKeysName, unsigned* keysNum) { int rc = 0; HIMAGEITEM hImgItem = NULL; unsigned itemSz = 0; unsigned char* thisReadBuf = (unsigned char*)OPTIMUS_SPARSE_IMG_FILL_VAL_BUF;//This buf is not used and not need reuse when burning keys const unsigned thisReadBufSz = (OPTIMUS_SPARSE_IMG_FILL_BUF_SZ >> 1); const char* *keysName = (const char**)(thisReadBuf + thisReadBufSz); hImgItem = image_item_open(hImg, "conf", "keys"); if(!hImgItem){ DWN_ERR("Fail to open keys.conf\n"); return ITEM_NOT_EXIST; } itemSz = (unsigned)image_item_get_size(hImgItem); if(!itemSz){ DWN_ERR("Item size 0\n"); image_item_close(hImgItem); return __LINE__; } rc = image_item_read(hImg, hImgItem, thisReadBuf, itemSz); if(rc){ DWN_ERR("Failed at item read, rc = %d\n", rc); image_item_close(hImgItem); return __LINE__; } image_item_close(hImgItem); if(itemSz >= thisReadBufSz){ DWN_ERR("itemSz(0x%x) of keys.conf too large, > max 0x%x.\n", itemSz, thisReadBufSz); return __LINE__; } rc = _optimus_parse_buf_2_lines((char*)thisReadBuf, itemSz, keysName, keysNum, 16); if(rc){ DWN_ERR("Fail in parse buf_2_lines\n"); return __LINE__; } rc = _optimus_abandon_ini_comment_lines((char**)keysName, *keysNum); *pKeysName = keysName; return rc; }
static int sdc_burn_dtb_load(HIMAGE hImg) { s64 itemSz = 0; HIMAGEITEM hImgItem = NULL; int rc = 0; const char* partName = "dtb"; const u64 partBaseOffset = OPTIMUS_DOWNLOAD_TRANSFER_BUF_ADDR; unsigned char* dtbTransferBuf = (unsigned char*)(unsigned)partBaseOffset; hImgItem = image_item_open(hImg, partName, "meson"); if(!hImgItem){ DWN_ERR("Fail to open verify file for part (%s)\n", partName); return ITEM_NOT_EXIST; } itemSz = image_item_get_size(hImgItem); if(!itemSz){ DWN_ERR("Item size 0\n"); image_item_close(hImgItem); return __LINE__; } rc = image_item_read(hImg, hImgItem, dtbTransferBuf, (unsigned)itemSz); if(rc){ DWN_ERR("Failed at item read, rc = %d\n", rc); image_item_close(hImgItem); return __LINE__; } image_item_close(hImgItem); rc = optimus_parse_img_download_info(partName, itemSz, "normal", "mem", partBaseOffset); if(rc){ DWN_ERR("Failed in init down info\n"); return __LINE__; } { unsigned wrLen = 0; char errInfo[512]; wrLen = optimus_download_img_data(dtbTransferBuf, (unsigned)itemSz, errInfo); rc = (wrLen == itemSz) ? 0 : wrLen; } return rc; }
//.NeedVerify: Try to get verify file if .NeedVerify == 1 static int optimus_burn_one_partition(const char* partName, HIMAGE hImg, __hdle hUiProgress, int NeedVerify) { int rcode = 0; s64 imgItemSz = 0; s64 leftItemSz = 0; u32 thisReadLen = 0; __hdle hImgItem = NULL; char* downTransBuf = NULL;//get buffer from optimus_buffer_manager const unsigned ItemReadBufSz = OPTIMUS_DOWNLOAD_SLOT_SZ;//read this size from image item each time unsigned sequenceNo = 0; const char* fileFmt = NULL; /*static */char _errInfo[512]; unsigned itemSizeNotAligned = 0; printf("\n"); DWN_MSG("=====>To burn part [%s]\n", partName); optimus_progress_ui_printf("Burning part[%s]\n", partName); hImgItem = image_item_open(hImg, "PARTITION", partName); if (!hImgItem) { DWN_ERR("Fail to open item for part (%s)\n", partName); return __LINE__; } imgItemSz = leftItemSz = image_item_get_size(hImgItem); if (!imgItemSz) { DWN_ERR("image size is 0 , image of part (%s) not exist ?\n", partName); return __LINE__; } fileFmt = (IMAGE_ITEM_TYPE_SPARSE == image_item_get_type(hImgItem)) ? "sparse" : "normal"; itemSizeNotAligned = image_item_get_first_cluster_size(hImg, hImgItem); leftItemSz -= itemSizeNotAligned; rcode = sdc_burn_buf_manager_init(partName, imgItemSz, fileFmt, itemSizeNotAligned); if (rcode) { DWN_ERR("fail in sdc_burn_buf_manager_init, rcode %d\n", rcode); return __LINE__; } //for each loop: //1, get buffer from buffer_manager, //2, read item data to buffer, //3, report data ready to buffer_manager for (; leftItemSz > 0; leftItemSz -= thisReadLen, sequenceNo++) { thisReadLen = leftItemSz > ItemReadBufSz ? ItemReadBufSz: (u32)leftItemSz; rcode = optimus_buf_manager_get_buf_for_bulk_transfer(&downTransBuf, thisReadLen, sequenceNo, _errInfo); if (rcode) { DWN_ERR("fail in get buf, msg[%s]\n", _errInfo); goto _finish; } //If the item head is not alinged to FAT cluster, Read it firstly to speed up mmc read if (itemSizeNotAligned && !sequenceNo) { DWN_MSG("itemSizeNotAligned 0x%x\n", itemSizeNotAligned); rcode = image_item_read(hImg, hImgItem, downTransBuf - itemSizeNotAligned, itemSizeNotAligned); if (rcode) { DWN_ERR("fail in read data from item,rcode %d, len 0x%x, sequenceNo %d\n", rcode, itemSizeNotAligned, sequenceNo); goto _finish; } } rcode = image_item_read(hImg, hImgItem, downTransBuf, thisReadLen); if (rcode) { DWN_ERR("fail in read data from item,rcode %d\n", rcode); goto _finish; } rcode = optimus_buf_manager_report_transfer_complete(thisReadLen, _errInfo); if (rcode) { DWN_ERR("fail in report data ready, rcode %d\n", rcode); goto _finish; } if (hUiProgress)optimus_progress_ui_update_by_bytes(hUiProgress, thisReadLen) ; } DWN_DBG("BURN part %s %s!\n", partName, leftItemSz ? "FAILED" : "SUCCESS"); _finish: image_item_close(hImgItem); if (rcode) { DWN_ERR("Fail to burn part(%s) with in format (%s) before verify\n", partName, fileFmt); optimus_progress_ui_printf("Failed at burn part[%s] befor VERIFY\n", partName); return rcode; } #if 1 if (!NeedVerify) { return rcode; } rcode = optimus_verify_partition(partName, hImg, _errInfo); if (ITEM_NOT_EXIST == rcode) { printf("WRN:part(%s) NOT verified\n", partName); return 0; } if (rcode) { printf("Fail in verify part(%s)\n", partName); optimus_progress_ui_printf("Failed at VERIFY part[%s]\n", partName); return __LINE__; } #endif//#fi 0 return rcode; }