| /* |
| * \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" |
| ); |
| |
