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