| /* |
| * \file optimus_img_decoder.c |
| * \brief |
| * |
| * \version 1.0.0 |
| * \date 2013-7-8 |
| * \author Sam.Wu <yihui.wu@amlogic.com> |
| * |
| * Copyright (c) 2013 Amlogic. All Rights Reserved. |
| * |
| */ |
| #include "../v2_sdc_burn/optimus_sdc_burn_i.h" |
| |
| //FIMXE: |
| COMPILE_TYPE_CHK(128 == sizeof(ItemInfo_V1), _op_a); |
| COMPILE_TYPE_CHK(576 == sizeof(ItemInfo_V2), __op_a2); |
| COMPILE_TYPE_CHK(64 == sizeof(AmlFirmwareImg_t), __op_b); |
| |
| typedef struct _ImgSrcIf{ |
| unsigned devIf; //mmc/usb/store |
| unsigned devNo; //0/1/2 |
| unsigned devAlignSz; //64K for store |
| unsigned reserv2Align64; |
| uint64_t itemCurSeekOffsetInImg;//fread will auto seek the @readSz, but for STORE we must do it |
| |
| char partName[28]; //partIndex <= 28 (+4 if partIndex not used) |
| unsigned partIndex; //partIndex and part |
| unsigned char resrv[512 - 32 - 24]; |
| }ImgSrcIf_t; |
| |
| COMPILE_TYPE_CHK(512 == sizeof(ImgSrcIf_t), bb); |
| #define MAX_ITEM_NUM 48 |
| |
| typedef struct _ImgInfo_s |
| { |
| ImgSrcIf_t imgSrcIf; |
| AmlFirmwareImg_t imgHead;//Must begin align 512, or store read wiill exception |
| union ItemInfo_u{ |
| ItemInfo_V1 v1[MAX_ITEM_NUM]; |
| ItemInfo_V2 v2[MAX_ITEM_NUM]; |
| }itemInfo; |
| |
| }ImgInfo_t; |
| |
| typedef struct _AmlFirmwareItem0_s |
| { |
| __u32 itemId; |
| __u32 fileType; //image file type, sparse and normal |
| __u64 curoffsetInItem; //current offset in the item |
| __u64 offsetInImage; //item offset in the image |
| __u64 itemSz; //item size in the image |
| const char* itemMainType; |
| const char* itemSubType; |
| }ItemInfo; |
| |
| static int _hFile = -1; |
| |
| //open a Amlogic firmware image |
| //return value is a handle |
| HIMAGE image_open(const char* interface, const char* device, const char* part, const char* imgPath) |
| { |
| const int HeadSz = sizeof(ImgInfo_t) - sizeof(ImgSrcIf_t); |
| ImgInfo_t* hImg = (ImgInfo_t*)OPTIMUS_BURN_PKG_HEAD_BUF_ADDR; |
| int ret = 0; |
| ImgSrcIf_t* pImgSrcIf = NULL; |
| unsigned imgVer = 0; |
| |
| pImgSrcIf = &hImg->imgSrcIf; |
| memset(pImgSrcIf, 0, sizeof(ImgSrcIf_t)); |
| |
| if (!strcmp("store", interface)) |
| { |
| DWN_DBG("imgHead=0x%p, hImg=%p\n", &hImg->imgHead, hImg); |
| ret = store_read(part, IMG_OFFSET_IN_PART, HeadSz, &hImg->imgHead); |
| if (ret) { |
| DWN_ERR("Fail to read image header.\n"); |
| ret = __LINE__; goto _err; |
| } |
| |
| pImgSrcIf->devIf = IMAGE_IF_TYPE_STORE; |
| pImgSrcIf->devAlignSz = 4*1024;//512;//OPTIMUS_DOWNLOAD_SLOT_SZ; |
| strcpy(pImgSrcIf->partName, part); |
| } |
| else |
| { |
| int pFile = do_fat_fopen(imgPath); |
| if (pFile < 0) { |
| DWN_ERR("Fail to open file %s\n", imgPath); |
| goto _err; |
| } |
| _hFile = pFile; |
| |
| ret = do_fat_fread(pFile, (u8*)&hImg->imgHead, HeadSz); |
| if (ret != HeadSz) { |
| DWN_ERR("want to read %d, but %d\n", HeadSz, ret); |
| goto _err; |
| } |
| |
| pImgSrcIf->devAlignSz = do_fat_get_bytesperclust(pFile); |
| } |
| |
| if (IMAGE_MAGIC != hImg->imgHead.magic) { |
| DWN_ERR("error magic 0x%x\n", hImg->imgHead.magic); |
| goto _err; |
| } |
| imgVer = hImg->imgHead.version; |
| if (AML_FRMWRM_VER_V1 != imgVer && AML_FRMWRM_VER_V2 != imgVer) { |
| DWN_ERR("error verison 0x%x\n", hImg->imgHead.version); |
| goto _err; |
| } |
| DWN_MSG("image version [0x%08x]\n", imgVer); |
| if (MAX_ITEM_NUM < hImg->imgHead.itemNum) { |
| DWN_ERR("max itemNum(%d)<actual itemNum (%d)\n", MAX_ITEM_NUM, hImg->imgHead.itemNum); |
| goto _err; |
| } |
| |
| return hImg; |
| _err: |
| return NULL; |
| } |
| |
| |
| //close a Amlogic firmware image |
| int image_close(HIMAGE hImg) |
| { |
| DWN_MSG("to close image\n"); |
| |
| if (_hFile >= 0)do_fat_fclose(_hFile) , _hFile = -1; |
| |
| if (hImg) { |
| hImg = NULL; |
| } |
| return 0; |
| } |
| |
| static const ItemInfo* image_item_get_item_info_byid(HIMAGE hImg, const int itemIndex) |
| { |
| ImgInfo_t* imgInfo = (ImgInfo_t*)hImg; |
| const unsigned imgVer = imgInfo->imgHead.version; |
| static ItemInfo theItem; |
| |
| switch (imgVer) |
| { |
| case AML_FRMWRM_VER_V2: |
| { |
| ItemInfo_V2* pItem = &imgInfo->itemInfo.v2[itemIndex]; |
| theItem.itemMainType = pItem->itemMainType; |
| theItem.itemSubType = pItem->itemSubType; |
| theItem.itemSz = pItem->itemSz; |
| theItem.offsetInImage = pItem->offsetInImage; |
| theItem.curoffsetInItem = pItem->curoffsetInItem; |
| theItem.fileType = pItem->fileType; |
| theItem.itemId = pItem->itemId; |
| } |
| break; |
| |
| case AML_FRMWRM_VER_V1: |
| { |
| ItemInfo_V1* pItem = &imgInfo->itemInfo.v1[itemIndex]; |
| theItem.itemMainType = pItem->itemMainType; |
| theItem.itemSubType = pItem->itemSubType; |
| theItem.itemSz = pItem->itemSz; |
| theItem.offsetInImage = pItem->offsetInImage; |
| theItem.curoffsetInItem = pItem->curoffsetInItem; |
| theItem.fileType = pItem->fileType; |
| theItem.itemId = pItem->itemId; |
| } |
| break; |
| |
| default: |
| DWN_ERR("Exception, imgVer=0x%x\n", imgVer); |
| return NULL; |
| } |
| |
| return &theItem; |
| } |
| |
| //open a item in the image |
| //@hImage: image handle; |
| //@mainType, @subType: main type and subtype to index the item, such as ["IMAGE", "SYSTEM"] |
| HIMAGEITEM image_item_open(HIMAGE hImg, const char* mainType, const char* subType) |
| { |
| ImgInfo_t* imgInfo = (ImgInfo_t*)hImg; |
| const int itemNr = imgInfo->imgHead.itemNum; |
| const ItemInfo* pItem = NULL; |
| int i = 0; |
| |
| for (; i < itemNr ;i++) |
| { |
| pItem = image_item_get_item_info_byid(hImg, i); |
| if (!pItem) { |
| DWN_ERR("Fail to get item at index %d\n", i); |
| return NULL; |
| } |
| |
| if (!strcmp(mainType, pItem->itemMainType) && !strcmp(subType, pItem->itemSubType)) |
| { |
| break; |
| } |
| } |
| if (i >= itemNr) { |
| DWN_WRN("Can't find item [%s, %s]\n", mainType, subType); |
| return NULL; |
| } |
| |
| if (i != pItem->itemId) { |
| DWN_ERR("itemid %d err, should %d\n", pItem->itemId, i); |
| return NULL; |
| } |
| |
| if (IMAGE_IF_TYPE_STORE != imgInfo->imgSrcIf.devIf) |
| { |
| DWN_DBG("Item offset 0x%llx\n", pItem->offsetInImage); |
| i = do_fat_fseek(_hFile, pItem->offsetInImage, 0); |
| if (i) { |
| DWN_ERR("fail to seek, offset is 0x%x\n", (u32)pItem->offsetInImage); |
| return NULL; |
| } |
| } |
| imgInfo->imgSrcIf.itemCurSeekOffsetInImg = pItem->offsetInImage; |
| |
| return (HIMAGEITEM)pItem; |
| } |
| |
| //Need this if item offset in the image file is not aligned to bytesPerCluster of FAT |
| unsigned image_item_get_first_cluster_size(HIMAGE hImg, HIMAGEITEM hItem) |
| { |
| const ImgInfo_t* imgInfo = (ImgInfo_t*)hImg; |
| ItemInfo* pItem = (ItemInfo*)hItem; |
| unsigned itemSizeNotAligned = 0; |
| const unsigned fat_bytesPerCluste = imgInfo->imgSrcIf.devAlignSz; |
| |
| itemSizeNotAligned = pItem->offsetInImage & (fat_bytesPerCluste - 1); |
| itemSizeNotAligned = fat_bytesPerCluste - itemSizeNotAligned; |
| |
| DWN_MSG("itemSizeNotAligned 0x%x\n", itemSizeNotAligned); |
| return itemSizeNotAligned; |
| } |
| |
| unsigned image_get_cluster_size(HIMAGEITEM hImg) |
| { |
| const ImgInfo_t* imgInfo = (ImgInfo_t*)hImg; |
| const unsigned fat_bytesPerCluste = imgInfo->imgSrcIf.devAlignSz; |
| |
| return fat_bytesPerCluste; |
| } |
| |
| //close a item |
| int image_item_close(HIMAGEITEM hItem) |
| { |
| return 0; |
| } |
| |
| __u64 image_item_get_size(HIMAGEITEM hItem) |
| { |
| ItemInfo* pItem = (ItemInfo*)hItem; |
| |
| return pItem->itemSz; |
| } |
| |
| |
| //get image item type, current used type is normal or sparse |
| int image_item_get_type(HIMAGEITEM hItem) |
| { |
| ItemInfo* pItem = (ItemInfo*)hItem; |
| |
| return pItem->fileType; |
| } |
| |
| //read item data, like standard fread |
| int image_item_read(HIMAGE hImg, HIMAGEITEM hItem, void* pBuf, const __u32 wantSz) |
| { |
| ImgInfo_t* imgInfo = (ImgInfo_t*)hImg; |
| unsigned readSz = 0; |
| |
| if (IMAGE_IF_TYPE_STORE == imgInfo->imgSrcIf.devIf) |
| { |
| char* part = imgInfo->imgSrcIf.partName; |
| const uint64_t offsetInPart = imgInfo->imgSrcIf.itemCurSeekOffsetInImg + IMG_OFFSET_IN_PART; |
| int rc = 0; |
| const unsigned storeBlkSz = imgInfo->imgSrcIf.devAlignSz; |
| const unsigned offsetNotAlign = offsetInPart & (storeBlkSz - 1); |
| const unsigned sizeNotAlignInFirstBlk = storeBlkSz - offsetNotAlign;//in the the first block and its offset not aligned |
| |
| //Attention: deal with the align issue in "optimus_burn_one_partition", then not need to modify "do_fat_fread" |
| if (offsetNotAlign) |
| { |
| unsigned char* bufInABlk = NULL; |
| const uint64_t readOffset = offsetInPart - offsetNotAlign; |
| const unsigned bufLen = sizeNotAlignInFirstBlk < wantSz ? sizeNotAlignInFirstBlk : (wantSz); |
| unsigned thisTotalReadSz = wantSz; |
| |
| DWN_MSG("offsetInPart %llx, wantSz=%x\n", offsetInPart, wantSz); |
| bufInABlk = (u8*)malloc(storeBlkSz); |
| rc = store_read(part, readOffset, storeBlkSz, bufInABlk); |
| if (rc) { |
| DWN_ERR("Fail to read: readOffset=%llx, storeBlkSz=%x\n", readOffset, storeBlkSz); |
| free(bufInABlk); |
| return __LINE__; |
| } |
| memcpy(pBuf, bufInABlk + offsetNotAlign, bufLen); |
| thisTotalReadSz -= bufLen; |
| pBuf += bufLen/sizeof(void); |
| free(bufInABlk); |
| |
| if (sizeNotAlignInFirstBlk < wantSz && offsetNotAlign) |
| { |
| rc = store_read(part, (offsetInPart + sizeNotAlignInFirstBlk), thisTotalReadSz, pBuf); |
| if (rc) { |
| DWN_ERR("Fail in store_read_ops to read %u at offset %llx.\n", wantSz, |
| offsetInPart + sizeNotAlignInFirstBlk); |
| return __LINE__; |
| } |
| } |
| } |
| else |
| { |
| rc = store_read(part, offsetInPart, wantSz, pBuf); |
| if (rc) { |
| DWN_ERR("Fail in store_read_ops to read %u at offset %llx.\n", wantSz, offsetInPart); |
| return __LINE__; |
| } |
| } |
| |
| imgInfo->imgSrcIf.itemCurSeekOffsetInImg += wantSz; |
| } |
| else |
| { |
| readSz = do_fat_fread(_hFile, pBuf, wantSz); |
| if (readSz != wantSz) { |
| DWN_ERR("want to read 0x%x, but 0x%x\n", wantSz, readSz); |
| return __LINE__; |
| } |
| } |
| |
| return 0; |
| } |
| |
| int get_total_itemnr(HIMAGE hImg) |
| { |
| ImgInfo_t* imgInfo = (ImgInfo_t*)hImg; |
| |
| return imgInfo->imgHead.itemNum; |
| } |
| |
| HIMAGEITEM get_item(HIMAGE hImg, int itemId) |
| { |
| int ret = 0; |
| ImgInfo_t* imgInfo = (ImgInfo_t*)hImg; |
| const ItemInfo* pItem = NULL; |
| |
| pItem = image_item_get_item_info_byid(hImg, itemId); |
| if (!pItem) { |
| DWN_ERR("Fail to get item at index %d\n", itemId); |
| return NULL; |
| } |
| if (itemId != pItem->itemId) { |
| DWN_ERR("itemid %d err, should %d\n", pItem->itemId, itemId); |
| return NULL; |
| } |
| DWN_MSG("get item [%s, %s] at %d\n", pItem->itemMainType, pItem->itemSubType, itemId); |
| |
| if (IMAGE_IF_TYPE_STORE != imgInfo->imgSrcIf.devIf) |
| { |
| ret = do_fat_fseek(_hFile, pItem->offsetInImage, 0); |
| if (ret) { |
| DWN_ERR("fail to seek, offset is 0x%x, ret=%d\n", (u32)pItem->offsetInImage, ret); |
| return NULL; |
| } |
| } |
| imgInfo->imgSrcIf.itemCurSeekOffsetInImg = pItem->offsetInImage; |
| |
| return (HIMAGEITEM)pItem; |
| } |
| |
| int get_item_name(HIMAGE hImg, int itemId, const char** main_type, const char** sub_type) |
| { |
| const ItemInfo* pItem = NULL; |
| |
| pItem = image_item_get_item_info_byid(hImg, itemId); |
| if (!pItem) { |
| DWN_ERR("Fail to get item at index %d\n", itemId); |
| return __LINE__; |
| } |
| if (itemId != pItem->itemId) { |
| DWN_ERR("itemid %d err, should %d\n", pItem->itemId, itemId); |
| return __LINE__; |
| } |
| DWN_DBG("get item [%s, %s] at %d\n", pItem->itemMainType, pItem->itemSubType, itemId); |
| |
| *main_type = pItem->itemMainType; |
| *sub_type = pItem->itemSubType; |
| |
| return OPT_DOWN_OK; |
| } |
| |
| __u64 image_get_item_size_by_index(HIMAGE hImg, const int itemId) |
| { |
| const ItemInfo* pItem = NULL; |
| |
| pItem = image_item_get_item_info_byid(hImg, itemId); |
| if (!pItem) { |
| DWN_ERR("Fail to get item at index %d\n", itemId); |
| return 0; |
| } |
| if (itemId != pItem->itemId) { |
| DWN_ERR("itemid %d err, should %d\n", pItem->itemId, itemId); |
| return __LINE__; |
| } |
| DWN_DBG("get item [%s, %s] at %d\n", pItem->itemMainType, pItem->itemSubType, itemId); |
| |
| return pItem->itemSz; |
| } |
| |
| u64 optimus_img_decoder_get_data_parts_size(HIMAGE hImg, int* hasBootloader) |
| { |
| int i = 0; |
| int ret = 0; |
| u64 dataPartsSz = 0; |
| const int totalItemNum = get_total_itemnr(hImg); |
| |
| *hasBootloader = 0; |
| 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)) { continue; } |
| if (!strcmp("bootloader", sub_type)) { |
| *hasBootloader = 1; |
| continue; |
| } |
| if (!strcmp(AML_SYS_RECOVERY_PART, sub_type)) |
| { |
| if (OPTIMUS_WORK_MODE_SYS_RECOVERY == optimus_work_mode_get()) continue; |
| } |
| |
| dataPartsSz += image_get_item_size_by_index(hImg, i); |
| } |
| |
| return dataPartsSz; |
| } |
| |
| #define MYDBG 0 |
| #if MYDBG |
| static int test_item(HIMAGE hImg, const char* main_type, const char* sub_type, char* pBuf, const int sz) |
| { |
| HIMAGEITEM hItem = NULL; |
| int ret = 0; |
| |
| hItem = image_item_open(hImg, main_type, sub_type); |
| if (!hItem) { |
| DWN_ERR("fail to open %s, %s\n", main_type, sub_type); |
| return __LINE__; |
| } |
| |
| ret = image_item_read(hImg, hItem, pBuf, sz); |
| if (ret) { |
| DWN_ERR("fail to read\n"); |
| goto _err; |
| } |
| if (64 >= sz)DWN_MSG("%s\n", pBuf) ; |
| |
| _err: |
| image_item_close(hItem); |
| return ret; |
| } |
| |
| static int test_pack(const char* interface, const char* device, const char* part, const char* imgPath) |
| { |
| const int ImagBufLen = OPTIMUS_DOWNLOAD_SLOT_SZ; |
| char* pBuf = (char*)OPTIMUS_DOWNLOAD_TRANSFER_BUF_ADDR + ImagBufLen; |
| int ret = 0; |
| int i = 0; |
| HIMAGEITEM hItem = NULL; |
| |
| if (!strcmp("store", interface)) |
| { |
| ret = run_command("store init 1", 0); |
| if (ret) { |
| DWN_ERR("Fail in init mmc, Does sdcard not plugged in?\n"); |
| return __LINE__; |
| } |
| } |
| else |
| { |
| s64 fileSz = 0; |
| |
| ret = run_command("mmcinfo", 0); |
| if (ret) { |
| DWN_ERR("Fail in init mmc, Does sdcard not plugged in?\n"); |
| return __LINE__; |
| } |
| |
| fileSz = do_fat_get_fileSz(imgPath); |
| if (!fileSz) { |
| DWN_ERR("file %s not exist\n", imgPath); |
| return __LINE__; |
| } |
| } |
| |
| HIMAGE hImg = image_open(interface, device, part, imgPath); |
| if (!hImg) { |
| DWN_ERR("Fail to open image\n"); |
| return __LINE__; |
| } |
| |
| const int itemNr = get_total_itemnr(hImg); |
| for (i = 0; i < itemNr ; i++) |
| { |
| __u64 itemSz = 0; |
| int fileType = 0; |
| |
| hItem = get_item(hImg, i); |
| if (!hItem) { |
| DWN_ERR("Fail to open item at id %d\n", i); |
| break; |
| } |
| |
| itemSz = image_item_get_size(hItem); |
| DWN_MSG("Item Sz is 0x%llx\n", itemSz); |
| |
| unsigned wantSz = ImagBufLen > itemSz ? (unsigned)itemSz : ImagBufLen; |
| unsigned itemSizeNotAligned = 0; |
| char* readBuf = pBuf; |
| unsigned readSz = wantSz; |
| |
| itemSizeNotAligned = image_item_get_first_cluster_size(hImg, hItem); |
| if (itemSizeNotAligned) |
| { |
| ret = image_item_read(hImg, hItem, readBuf, itemSizeNotAligned); |
| readSz = (wantSz > itemSizeNotAligned) ? (wantSz - itemSizeNotAligned) : 0; |
| } |
| |
| if (readSz) |
| { |
| ret = image_item_read(hImg, hItem, readBuf + itemSizeNotAligned, readSz); |
| if (ret) { |
| DWN_ERR("fail to read item data\n"); |
| break; |
| } |
| } |
| |
| fileType = image_item_get_type(hItem); |
| if (IMAGE_ITEM_TYPE_SPARSE == fileType) |
| { |
| DWN_MSG("sparse packet\n"); |
| ret = optimus_simg_probe((const u8*)pBuf, wantSz); |
| if (!ret) { |
| DWN_ERR("item data error, should sparse, but no\n"); |
| break; |
| } |
| } |
| } |
| |
| #if 1 |
| test_item(hImg, "PARTITION", "logo", pBuf, ImagBufLen); |
| test_item(hImg, "VERIFY", "logo", pBuf, 50); |
| #endif |
| |
| image_close(hImg); |
| return 0; |
| } |
| |
| static int do_unpack(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
| { |
| int rcode = 0; |
| const char* imgPath = "a"; |
| |
| #if 1 |
| if (2 > argc) imgPath = "dt.img"; |
| #else |
| if (2 > argc) { |
| cmd_usage(cmdtp); |
| return -1; |
| } |
| #endif//#if MYDBG |
| DWN_MSG("argc %d, %s, %s\n", argc, argv[0], argv[1]); |
| |
| rcode = test_pack("mmc", "0", "aml_sysrecovery", imgPath); |
| |
| DWN_MSG("rcode %d\n", rcode); |
| return rcode; |
| } |
| |
| U_BOOT_CMD( |
| unpack, //command name |
| 5, //maxargs |
| 1, //repeatable |
| do_unpack, //command function |
| "unpack the image in sdmmc ", //description |
| "Usage: unpack imagPath\n" //usage |
| ); |
| #endif//#if MYDBG |
| |
