blob: 2725c352df120a551c9bd6c74baa432be49c25dd [file] [log] [blame] [edit]
/*
* \file cmd_imgread.c
* \brief command to read the actual size of boot.img/recovery.img and logo.img
*
* \version 1.0.0
* \date 2013/10/29
* \author Sam.Wu <yihui.wu@amlgic.com>
*
* Copyright (c) 2013 Amlogic Inc.. All Rights Reserved.
*
*/
#include <config.h>
#include <common.h>
#include <amlogic/storage_if.h>
#include <aml_image.h>
#include <image.h>
#include <android_image.h>
#include <zircon/boot/image.h>
#include <asm/arch/bl31_apis.h>
#include <asm/arch/secure_apb.h>
#include <libfdt.h>
typedef struct andr_img_hdr boot_img_hdr;
#define debugP(fmt...) //printf("[Dbg imgread]L%d:", __LINE__),printf(fmt)
#define errorP(fmt...) printf("Err imgread(L%d):", __LINE__),printf(fmt)
#define wrnP(fmt...) printf("wrn:"fmt)
#define MsgP(fmt...) printf("[imgread]"fmt)
#define IMG_PRELOAD_SZ (1U<<20) //Total read 1M at first to read the image header
#define PIC_PRELOAD_SZ (8U<<10) //Total read 4k at first to read the image header
#define RES_OLD_FMT_READ_SZ (8U<<20)
static int is_secure_boot_enabled(void)
{
const unsigned long cfg10 = readl(AO_SEC_SD_CFG10);
return ( cfg10 & (0x1<< 4) );
}
static int _aml_get_secure_boot_kernel_size(const void* pLoadaddr, unsigned* pTotalEncKernelSz)
{
const int isSecure = is_secure_boot_enabled();
#if (CONFIG_AML_SECURE_BOOT_VERSION < 4)
const AmlSecureBootImgHeader* amlSecureBootImgHead = (const AmlSecureBootImgHeader*)pLoadaddr;
const AmlEncryptBootImgInfo* amlEncrypteBootimgInfo = &amlSecureBootImgHead->encrypteImgInfo;
int rc = 0;
unsigned secureKernelImgSz = 2048;
unsigned int nBlkCnt = amlEncrypteBootimgInfo->nBlkCnt;
const t_aml_enc_blk* pBlkInf = NULL;
*pTotalEncKernelSz = 0;
rc = memcmp(AML_SECU_BOOT_IMG_HDR_MAGIC, amlEncrypteBootimgInfo->magic, AML_SECU_BOOT_IMG_HDR_MAGIC_SIZE);
if (rc) { // img NOT singed
if (isSecure) {
errorP("img NOT signed but secure boot enabled\n");
return __LINE__;
}
*pTotalEncKernelSz = 0;
return 0;
} else { //img signed
if (!isSecure) {
errorP("Img signed but secure boot NOT enabled\n");
return __LINE__;
}
}
if (AML_SECU_BOOT_IMG_HDR_VESRION != amlEncrypteBootimgInfo->version) {
errorP("magic ok but version err, err ver=0x%x\n", amlEncrypteBootimgInfo->version);
return __LINE__;
}
MsgP("szTimeStamp[%s]\n", (char*)&amlEncrypteBootimgInfo->szTimeStamp);
debugP("nBlkCnt=%d\n", nBlkCnt);
for (pBlkInf = &amlEncrypteBootimgInfo->amlKernel;nBlkCnt--; ++pBlkInf)
{
const unsigned int thisBlkLen = pBlkInf->nTotalLength;
debugP("thisBlkLen=0x%x\n", thisBlkLen);
secureKernelImgSz += thisBlkLen;
}
*pTotalEncKernelSz = secureKernelImgSz;
return 0;
#else /* CONFIG_AML_SECURE_BOOT_VERSION */
if (isSecure) {
if (pLoadaddr && pTotalEncKernelSz)
*pTotalEncKernelSz = (((aml_boot_header_t *)pLoadaddr)->img_size);
}
return 0;
#endif /* CONFIG_AML_SECURE_BOOT_VERSION */
}
static int do_image_read_dtb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
boot_img_hdr *hdr_addr = NULL;
const char* const partName = argv[1];
unsigned char* loadaddr = 0;
int nReturn = __LINE__;
uint64_t lflashReadOff = 0;
unsigned int nFlashLoadLen = 0;
unsigned secureKernelImgSz = 0;
const int preloadSz = 2048;
if (2 < argc) {
loadaddr = (unsigned char*)simple_strtoul(argv[2], NULL, 16);
}
else{
loadaddr = (unsigned char*)simple_strtoul(getenv("loadaddr"), NULL, 16);
}
hdr_addr = (boot_img_hdr*)loadaddr;
if (3 < argc) lflashReadOff = simple_strtoull(argv[3], NULL, 0) ;
nFlashLoadLen = preloadSz;//head info is one page size == 2k
debugP("sizeof preloadSz=%u\n", nFlashLoadLen);
nReturn = store_read_ops((unsigned char*)partName, loadaddr, lflashReadOff, nFlashLoadLen );
if (nReturn) {
errorP("Fail to read 0x%xB from part[%s] at offset 0\n", nFlashLoadLen, partName);
return __LINE__;
}
if (IMAGE_FORMAT_ANDROID != genimg_get_format(hdr_addr)) {
errorP("Fmt unsupported! only support 0x%x\n", IMAGE_FORMAT_ANDROID);
return __LINE__;
}
nReturn = _aml_get_secure_boot_kernel_size(loadaddr, &secureKernelImgSz);
if (nReturn) {
errorP("Fail in _aml_get_secure_boot_kernel_size, rc=%d\n", nReturn);
return __LINE__;
}
const int pageSz = hdr_addr->page_size;
/*lflashReadOff += secureKernelImgSz ? sizeof(AmlSecureBootImgHeader) : pageSz;*/
lflashReadOff += pageSz;
lflashReadOff += ALIGN(hdr_addr->kernel_size, pageSz);
lflashReadOff += ALIGN(hdr_addr->ramdisk_size, pageSz);
nFlashLoadLen = ALIGN(hdr_addr->second_size, pageSz);
debugP("lflashReadOff=0x%llx, nFlashLoadLen=0x%x\n", lflashReadOff, nFlashLoadLen);
debugP("page sz %u\n", hdr_addr->page_size);
if (!nFlashLoadLen) {
errorP("NO second part in kernel image\n");
return __LINE__;
}
unsigned char* dtImgAddr = (unsigned char*)loadaddr + lflashReadOff;
nReturn = store_read_ops((unsigned char*)partName, dtImgAddr, lflashReadOff, nFlashLoadLen);
if (nReturn) {
errorP("Fail to read 0x%xB from part[%s] at offset 0x%x\n", nFlashLoadLen, partName, (unsigned int)lflashReadOff);
return __LINE__;
}
if (secureKernelImgSz) {
//because secure boot will use DMA which need disable MMU temp
//here must update the cache, otherwise nand will fail (eMMC is OK)
flush_cache((unsigned long)dtImgAddr,(unsigned long)nFlashLoadLen);
nReturn = aml_sec_boot_check(AML_D_P_IMG_DECRYPT,(unsigned long)loadaddr,GXB_IMG_SIZE,GXB_IMG_DEC_DTB);
if (nReturn) {
errorP("\n[dtb]aml log : Sig Check is %d\n",nReturn);
return __LINE__;
}
MsgP("Enc dtb sz 0x%x\n", nFlashLoadLen);
}
char* dtDestAddr = (char*)loadaddr;//simple_strtoull(getenv("dtb_mem_addr"), NULL, 0);
unsigned long fdtAddr = (unsigned long)dtImgAddr;
#ifdef CONFIG_MULTI_DTB
extern unsigned long get_multi_dt_entry(unsigned long fdt_addr);
fdtAddr = get_multi_dt_entry((unsigned long)dtImgAddr);
if (!fdtAddr) {
errorP("Fail in fdt chk\n");
return __LINE__;
}
#endif// #ifdef CONFIG_MULTI_DTB
nReturn = fdt_check_header((char*)fdtAddr);
if (nReturn) {
errorP("Fail in fdt check header\n");
return CMD_RET_FAILURE;
}
const unsigned fdtsz = fdt_totalsize((char*)fdtAddr);
memmove(dtDestAddr, (char*)fdtAddr, fdtsz);
return nReturn;
}
static int do_image_read_kernel(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
unsigned kernel_size;
unsigned ramdisk_size;
boot_img_hdr *hdr_addr = NULL;
int genFmt = 0;
unsigned actualBootImgSz = 0;
unsigned dtbSz = 0;
const char* const partName = argv[1];
unsigned char* loadaddr = 0;
int rc = 0;
uint64_t flashReadOff = 0;
unsigned secureKernelImgSz = 0;
uint32_t offset = 0;
if (2 < argc) {
loadaddr = (unsigned char*)simple_strtoul(argv[2], NULL, 16);
}
else{
loadaddr = (unsigned char*)simple_strtoul(getenv("loadaddr"), NULL, 16);
}
#if (CONFIG_AML_SECURE_BOOT_VERSION >= 4)
if (is_secure_boot_enabled()) {
offset = sizeof(aml_boot_header_t);
}
#endif /* CONFIG_AML_SECURE_BOOT_VERSION >= 4 */
hdr_addr = (boot_img_hdr*)(loadaddr + offset);
if (3 < argc) flashReadOff = simple_strtoull(argv[3], NULL, 0) ;
rc = store_read_ops((unsigned char*)partName, loadaddr, flashReadOff, IMG_PRELOAD_SZ);
if (rc) {
errorP("Fail to read 0x%xB from part[%s] at offset 0\n", IMG_PRELOAD_SZ, partName);
return __LINE__;
}
flashReadOff += IMG_PRELOAD_SZ;
genFmt = genimg_get_format(hdr_addr);
#if (CONFIG_AML_SECURE_BOOT_VERSION >= 4)
if (!is_secure_boot_enabled()) {
#endif /* CONFIG_AML_SECURE_BOOT_VERSION < 4 */
if (IMAGE_FORMAT_ANDROID != genFmt && IMAGE_FORMAT_ZIRCON != genFmt) {
errorP("Fmt unsupported!genFmt 0x%x != 0x%x or 0x%x\n", genFmt, IMAGE_FORMAT_ANDROID,
IMAGE_FORMAT_ZIRCON);
return __LINE__;
}
#if (CONFIG_AML_SECURE_BOOT_VERSION >= 4)
}
#endif /* CONFIG_AML_SECURE_BOOT_VERSION < 4 */
//Check if encrypted image
rc = _aml_get_secure_boot_kernel_size(loadaddr, &secureKernelImgSz);
if (rc) {
errorP("Fail in _aml_get_secure_boot_kernel_size, rc=%d\n", rc);
return __LINE__;
}
if (secureKernelImgSz)
{
actualBootImgSz = secureKernelImgSz + offset;
MsgP("secureKernelImgSz=0x%x\n", actualBootImgSz);
} else if (genFmt == IMAGE_FORMAT_ZIRCON) {
const zbi_header_t *zbi = (zbi_header_t*)hdr_addr;
actualBootImgSz = zbi->length + sizeof(*zbi);
} else {
kernel_size =(hdr_addr->kernel_size + (hdr_addr->page_size-1)+hdr_addr->page_size)&(~(hdr_addr->page_size -1));
ramdisk_size =(hdr_addr->ramdisk_size + (hdr_addr->page_size-1))&(~(hdr_addr->page_size -1));
dtbSz = hdr_addr->second_size;
actualBootImgSz = kernel_size + ramdisk_size + dtbSz;
debugP("kernel_size 0x%x, page_size 0x%x, totalSz 0x%x\n", hdr_addr->kernel_size, hdr_addr->page_size, kernel_size);
debugP("ramdisk_size 0x%x, totalSz 0x%x\n", hdr_addr->ramdisk_size, ramdisk_size);
debugP("dtbSz 0x%x, Total actualBootImgSz 0x%x\n", dtbSz, actualBootImgSz);
}
#if defined(CONFIG_IMG_SECURE_CHECK_SZ)
// Check if boot image size is larger than the secure boot size limitation.
if (actualBootImgSz > CONFIG_IMG_SECURE_CHECK_SZ) {
errorP("Boot image size(0x%x) is larger than secure size limit(0x%x)\n", actualBootImgSz, CONFIG_IMG_SECURE_CHECK_SZ);
return __LINE__;
}
#endif //CONFIG_IMG_SECURE_CHECK_SZ
if (actualBootImgSz > IMG_PRELOAD_SZ)
{
const unsigned leftSz = actualBootImgSz - IMG_PRELOAD_SZ;
debugP("Left sz 0x%x\n", leftSz);
rc = store_read_ops((unsigned char*)partName, loadaddr + IMG_PRELOAD_SZ, flashReadOff, leftSz);
if (rc) {
errorP("Fail to read 0x%xB from part[%s] at offset 0x%x\n", leftSz, partName, IMG_PRELOAD_SZ);
return __LINE__;
}
}
debugP("totalSz=0x%x\n", actualBootImgSz);
//because secure boot will use DMA which need disable MMU temp
//here must update the cache, otherwise nand will fail (eMMC is OK)
flush_cache((unsigned long)loadaddr,(unsigned long)actualBootImgSz);
return 0;
}
#define AML_RES_IMG_VERSION_V1 (0x01)
#define AML_RES_IMG_VERSION_V2 (0x02)
#define AML_RES_IMG_V1_MAGIC_LEN 8
#define AML_RES_IMG_V1_MAGIC "AML_RES!"//8 chars
#define AML_RES_IMG_ITEM_ALIGN_SZ 16
#define AML_RES_IMG_HEAD_SZ (AML_RES_IMG_ITEM_ALIGN_SZ * 4)//64
#define AML_RES_ITEM_HEAD_SZ (AML_RES_IMG_ITEM_ALIGN_SZ * 4)//64
//typedef for amlogic resource image
#pragma pack(push, 4)
typedef struct {
__u32 crc; //crc32 value for the resouces image
__s32 version;//current version is 0x01
__u8 magic[AML_RES_IMG_V1_MAGIC_LEN]; //resources images magic
__u32 imgSz; //total image size in byte
__u32 imgItemNum;//total item packed in the image
__u32 alignSz;//AML_RES_IMG_ITEM_ALIGN_SZ
__u8 reserv[AML_RES_IMG_HEAD_SZ - 8 * 3 - 4];
}AmlResImgHead_t;
#pragma pack(pop)
#define LOGO_OLD_FMT_READ_SZ (8U<<20)//if logo format old, read 8M
static int img_res_check_log_header(const AmlResImgHead_t* pResImgHead)
{
int rc = 0;
rc = memcmp(pResImgHead->magic, AML_RES_IMG_V1_MAGIC, AML_RES_IMG_V1_MAGIC_LEN);
if (rc) {
debugP("Magic error for res\n");
return 1;
}
if (AML_RES_IMG_VERSION_V2 != pResImgHead->version) {
errorP("res version 0x%x != 0x%x\n", pResImgHead->version, AML_RES_IMG_VERSION_V2);
return 2;
}
return 0;
}
static int do_image_read_res(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
const char* const partName = argv[1];
unsigned char* loadaddr = 0;
int rc = 0;
AmlResImgHead_t* pResImgHead = NULL;
unsigned totalSz = 0;
uint64_t flashReadOff = 0;
if (2 < argc) {
loadaddr = (unsigned char*)simple_strtoul(argv[2], NULL, 16);
}
else{
loadaddr = (unsigned char*)simple_strtoul(getenv("loadaddr"), NULL, 16);
}
pResImgHead = (AmlResImgHead_t*)loadaddr;
rc = store_read_ops((unsigned char*)partName, loadaddr, flashReadOff, IMG_PRELOAD_SZ);
if (rc) {
errorP("Fail to read 0x%xB from part[%s] at offset 0\n", IMG_PRELOAD_SZ, partName);
return __LINE__;
}
flashReadOff = IMG_PRELOAD_SZ;
if (img_res_check_log_header(pResImgHead)) {
errorP("Logo header err.\n");
return __LINE__;
}
//Read the actual size of the new version res imgae
totalSz = pResImgHead->imgSz;
if (totalSz > IMG_PRELOAD_SZ )
{
const unsigned leftSz = totalSz - flashReadOff;
rc = store_read_ops((unsigned char*)partName, loadaddr + (unsigned)flashReadOff,
flashReadOff, leftSz);
if (rc) {
errorP("Fail to read 0x%xB from part[%s] at offset 0x%x\n", leftSz, partName,
IMG_PRELOAD_SZ);
return __LINE__;
}
}
debugP("totalSz=0x%x\n", totalSz);
return 0;
}
#define IH_MAGIC 0x27051956 /* Image Magic Number */
#define IH_NMLEN 32 /* Image Name Length */
#pragma pack(push, 1)
typedef struct pack_header{
unsigned int magic; /* Image Header Magic Number */
unsigned int hcrc; /* Image Header CRC Checksum */
unsigned int size; /* Image Data Size */
unsigned int start; /* item data offset in the image*/
unsigned int end; /* Entry Point Address */
unsigned int next; /* Next item head offset in the image*/
unsigned int dcrc; /* Image Data CRC Checksum */
unsigned char index; /* Operating System */
unsigned char nums; /* CPU architecture */
unsigned char type; /* Image Type */
unsigned char comp; /* Compression Type */
char name[IH_NMLEN]; /* Image Name */
}AmlResItemHead_t;
#pragma pack(pop)
#define CONFIG_MAX_PIC_LEN (12 << 20)
static const unsigned char gzip_magic[] = { 0x1f, 0x8b };
//uncompress known format for 'imgread pic'
static int imgread_uncomp_pic(unsigned char* srcAddr, const unsigned srcSz,
unsigned char* dstAddr, const unsigned dstBufSz, unsigned long* dstDatSz)
{
/*debugP("srcAddr[%x, %x]\n", srcAddr[0], srcAddr[1]);*/
if (!memcmp(srcAddr, gzip_magic, sizeof(gzip_magic)))
{
*dstDatSz = srcSz;
return gunzip(dstAddr, dstBufSz, srcAddr, dstDatSz);
}
return 0;
}
//[imgread pic] logo bootup $loadaddr_misc
static int do_image_read_pic(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
const char* const partName = argv[1];
unsigned char* loadaddr = 0;
int rc = 0;
const AmlResImgHead_t* pResImgHead = NULL;
//unsigned totalSz = 0;
uint64_t flashReadOff = 0;
const unsigned PreloadSz = PIC_PRELOAD_SZ;//preload 8k, 124-1 pic header, If you need pack more than 123 items, fix this
unsigned itemIndex = 0;
const AmlResItemHead_t* pItem = NULL;
const char* picName = argv[2];
loadaddr = (unsigned char*)simple_strtoul(argc > 3 ? argv[3] : getenv("loadaddr_misc"), NULL, 16);
pResImgHead = (AmlResImgHead_t*)loadaddr;
debugP("to read pic (%s)\n", picName);
rc = store_read_ops((unsigned char*)partName, loadaddr, flashReadOff, PreloadSz);
if (rc) {
errorP("Fail to read 0x%xB from part[%s] at offset 0\n", PreloadSz, partName);
return __LINE__;
}
flashReadOff = PreloadSz;
debugP("end read pic sz %d\n", PreloadSz);
if (img_res_check_log_header(pResImgHead)) {
errorP("Logo header err.\n");
return __LINE__;
}
//correct bootup for mbox
while (!strcmp("bootup", picName))
{
char* outputmode = getenv("outputmode");
if (!outputmode)break;//not env outputmode
rc = !strncmp("720", outputmode, 3) || !strncmp("576", outputmode, 3) || !strncmp("480", outputmode, 3);
if (rc) {
picName = "bootup_720";
break;
}
picName = "bootup_1080";
break;
}
pItem = (AmlResItemHead_t*)(pResImgHead + 1);
for (itemIndex = 0; itemIndex < pResImgHead->imgItemNum; ++itemIndex, ++pItem)
{
if (IH_MAGIC != pItem->magic) {
errorP("item magic 0x%x != 0x%x\n", pItem->magic, IH_MAGIC);
return __LINE__;
}
if (!strcmp(picName, pItem->name) || !strcmp(argv[2], pItem->name))
{
char env_name[IH_NMLEN*2];
char env_data[IH_NMLEN*2];
unsigned long picLoadAddr = (unsigned long)loadaddr + (unsigned)pItem->start;
int itemSz = pItem->size;
int uncompSz = 0;
if (pItem->start + itemSz > flashReadOff)
{
unsigned long rdOff = pItem->start;
unsigned long rdOffAlign = (rdOff >> 11) << 11;//align 2k page for mtd nand, 512 for emmc
rc = store_read_ops((unsigned char*)partName, (unsigned char *)((picLoadAddr>>11)<<11),
rdOffAlign, itemSz + (rdOff & 0x7ff) );
if (rc) {
errorP("Fail to read pic at offset 0x%x\n", pItem->start);
return __LINE__;
}
debugP("pic sz 0x%x\n", itemSz);
}
//uncompress supported format
unsigned long uncompLoadaddr = picLoadAddr + itemSz + 7;
uncompLoadaddr &= ~(0x7U);
rc = imgread_uncomp_pic((unsigned char*)picLoadAddr, itemSz, (unsigned char*)uncompLoadaddr,
CONFIG_MAX_PIC_LEN, (unsigned long*)&uncompSz);
if (rc) {
errorP("Fail in uncomp pic,rc[%d]\n", rc);
return __LINE__;
}
if (uncompSz) {
itemSz = uncompSz;
picLoadAddr = uncompLoadaddr;
}
sprintf(env_name, "%s_offset", argv[2]);//be bootup_offset ,not bootup_720_offset
sprintf(env_data, "0x%lx", picLoadAddr);
setenv(env_name, env_data);
sprintf(env_name, "%s_size", argv[2]);
sprintf(env_data, "0x%x", itemSz);
setenv(env_name, env_data);
debugP("end read pic[%s]\n", picName);
return 0;//success
}
}
return __LINE__;//fail
}
static cmd_tbl_t cmd_imgread_sub[] = {
U_BOOT_CMD_MKENT(kernel, 4, 0, do_image_read_kernel, "", ""),
U_BOOT_CMD_MKENT(dtb, 4, 0, do_image_read_dtb, "", ""),
U_BOOT_CMD_MKENT(res, 3, 0, do_image_read_res, "", ""),
U_BOOT_CMD_MKENT(pic, 4, 0, do_image_read_pic, "", ""),
};
static int do_image_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
cmd_tbl_t *c;
/* Strip off leading 'bmp' command argument */
argc--;
argv++;
c = find_cmd_tbl(argv[0], &cmd_imgread_sub[0], ARRAY_SIZE(cmd_imgread_sub));
if (c) {
return c->cmd(cmdtp, flag, argc, argv);
} else {
cmd_usage(cmdtp);
return 1;
}
}
U_BOOT_CMD(
imgread, //command name
5, //maxargs
0, //repeatable
do_image_read, //command function
"Read the image from internal flash with actual size", //description
" argv: <imageType> <part_name> <loadaddr> \n" //usage
" - <image_type> Current support is kernel/res(ource).\n"
"imgread kernel --- Read image in format IMAGE_FORMAT_ANDROID or IMAGE_FORMAT_ZIRCON\n"
"imgread dtb --- Read dtb in format IMAGE_FORMAT_ANDROID\n"
"imgread res --- Read image packed by 'Amlogic resource packer'\n"
"imgread picture --- Read one picture from Amlogic logo"
" - e.g. \n"
" to read boot.img from part boot from flash: <imgread kernel boot loadaddr> \n" //usage
" to read recovery.img from part recovery from flash: <imgread kernel recovery loadaddr $offset> \n" //usage
" to read logo.img from part logo from flash: <imgread res logo loadaddr> \n" //usage
" to read one picture named 'bootup' from logo.img from logo: <imgread pic logo bootup loadaddr> \n" //usage
);
//[imgread pic] logo bootup $loadaddr_misc
static int do_unpackimg(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
unsigned char* loadaddr = 0;
const AmlResImgHead_t* pResImgHead = NULL;
unsigned itemIndex = 0;
const AmlResItemHead_t* pItem = NULL;
loadaddr = (unsigned char*)simple_strtoul(argc > 1 ? argv[1] : getenv("loadaddr_misc"), NULL, 16);
pResImgHead = (AmlResImgHead_t*)loadaddr;
if (img_res_check_log_header(pResImgHead)) {
errorP("Logo header err.\n");
return __LINE__;
}
pItem = (AmlResItemHead_t*)(pResImgHead + 1);
for (itemIndex = 0; itemIndex < pResImgHead->imgItemNum; ++itemIndex, ++pItem)
{
if (IH_MAGIC != pItem->magic) {
errorP("item magic 0x%x != 0x%x\n", pItem->magic, IH_MAGIC);
return __LINE__;
}
char env_name[IH_NMLEN*2];
char env_data[IH_NMLEN*2];
unsigned long picLoadAddr = (unsigned long)loadaddr + (unsigned)pItem->start;
sprintf(env_name, "%s_offset", pItem->name);//be bootup_offset ,not bootup_720_offset
sprintf(env_data, "0x%lx", picLoadAddr);
setenv(env_name, env_data);
sprintf(env_name, "%s_size", pItem->name);
sprintf(env_data, "0x%x", pItem->size);
setenv(env_name, env_data);
}
return 0;//success
}
U_BOOT_CMD(
unpackimg, //command name
2, //maxargs
0, //repeatable
do_unpackimg, //command function
"un pack logo image into pictures", //description
" argv: unpackimg <imgLoadaddr> \n" //usage
" un pack the logo image, which already loaded at <imgLoadaddr>.\n"
);