| // SPDX-License-Identifier: (GPL-2.0+ OR MIT) |
| /* |
| * Copyright (c) 2019 Amlogic, Inc. All rights reserved. |
| */ |
| |
| #include <config.h> |
| #include <common.h> |
| #include <image.h> |
| #include <linux/libfdt.h> |
| #include <android_image.h> |
| #include <asm/arch/bl31_apis.h> |
| #include <asm/arch/secure_apb.h> |
| #include <amlogic/store_wrapper.h> |
| #include <amlogic/aml_efuse.h> |
| #include <malloc.h> |
| |
| #ifndef IS_FEAT_BOOT_VERIFY |
| #define IS_FEAT_BOOT_VERIFY() 0 |
| #endif// #ifndef IS_FEAT_BOOT_VERIFY |
| int __attribute__((weak)) store_logic_read(const char *name, loff_t off, size_t size, void *buf) |
| { return store_read(name, off, size, buf);} |
| |
| #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) |
| |
| typedef struct __aml_enc_blk{ |
| unsigned int nOffset; |
| unsigned int nRawLength; |
| unsigned int nSigLength; |
| unsigned int nAlignment; |
| unsigned int nTotalLength; |
| unsigned char szPad[12]; |
| unsigned char szSHA2IMG[32]; |
| unsigned char szSHA2KeyID[32]; |
| }t_aml_enc_blk; |
| |
| #define AML_SECU_BOOT_IMG_HDR_MAGIC "AMLSECU!" |
| #define AML_SECU_BOOT_IMG_HDR_MAGIC_SIZE (8) |
| #define AML_SECU_BOOT_IMG_HDR_VESRION (0x0905) |
| |
| typedef struct { |
| |
| unsigned char magic[AML_SECU_BOOT_IMG_HDR_MAGIC_SIZE];//magic to identify whether it is a encrypted boot image |
| |
| unsigned int version; //ersion for this header struct |
| unsigned int nBlkCnt; |
| |
| unsigned char szTimeStamp[16]; |
| |
| t_aml_enc_blk amlKernel; |
| t_aml_enc_blk amlRamdisk; |
| t_aml_enc_blk amlDTB; |
| |
| }AmlEncryptBootImgInfo; |
| |
| typedef struct _boot_img_hdr_secure_boot |
| { |
| unsigned char reserve4ImgHdr[1024]; |
| |
| AmlEncryptBootImgInfo encrypteImgInfo; |
| |
| }AmlSecureBootImgHeader; |
| |
| typedef struct{ |
| unsigned char reserve4ImgHdr[2048]; |
| |
| AmlEncryptBootImgInfo encrypteImgInfo; |
| |
| }AmlSecureBootImg9Header; |
| |
| |
| #define COMPILE_TYPE_ASSERT(expr, t) typedef char t[(expr) ? 1 : -1] |
| COMPILE_TYPE_ASSERT(2048 >= sizeof(AmlSecureBootImgHeader), _cc); |
| |
| static int is_andr_9_image(void* pBuffer) |
| { |
| |
| int nReturn = 0; |
| |
| if (!pBuffer) |
| goto exit; |
| |
| boot_img_hdr_t *pAHdr = (boot_img_hdr_t*)(unsigned long)pBuffer; |
| |
| if (pAHdr->header_version) |
| nReturn = 1; |
| |
| exit: |
| |
| return nReturn; |
| |
| } |
| |
| static int _aml_get_secure_boot_kernel_size(const void* pLoadaddr, unsigned* pTotalEncKernelSz) |
| { |
| const AmlEncryptBootImgInfo* amlEncrypteBootimgInfo = 0; |
| int rc = 0; |
| unsigned secureKernelImgSz = 2048; |
| unsigned int nBlkCnt = 0; |
| const t_aml_enc_blk* pBlkInf = NULL; |
| const int isSecure = IS_FEAT_BOOT_VERIFY(); |
| unsigned char *pAndHead = (unsigned char *)pLoadaddr; |
| |
| if (is_andr_9_image(pAndHead)) |
| { |
| secureKernelImgSz = 4096; |
| } |
| |
| amlEncrypteBootimgInfo = (AmlEncryptBootImgInfo*)(pAndHead + (secureKernelImgSz>>1)); |
| |
| nBlkCnt = amlEncrypteBootimgInfo->nBlkCnt; |
| |
| *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; |
| } |
| |
| static int do_image_read_dtb_from_knl(const char* partName, unsigned char* loadaddr, uint64_t lflashReadOff) |
| { |
| int nReturn = __LINE__; |
| unsigned int nFlashLoadLen = 0; |
| unsigned secureKernelImgSz = 0; |
| const int preloadSz = 4096; |
| int pageSz = 0; |
| boot_img_hdr_t *hdr_addr = (boot_img_hdr_t*)loadaddr; |
| |
| nFlashLoadLen = preloadSz;//head info is one page size == 2k |
| debugP("sizeof preloadSz=%u\n", nFlashLoadLen); |
| nReturn = store_logic_read(partName, lflashReadOff, nFlashLoadLen, loadaddr); |
| 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__; |
| } |
| |
| if (is_android_r_image((void *) hdr_addr)) { |
| const int preloadSz_r = 0x1000; |
| int rc_r = 0; |
| char *slot_name; |
| |
| slot_name = env_get("slot-suffixes"); |
| if (strcmp(slot_name, "0") == 0) { |
| strcpy((char *)partName, "vendor_boot_a"); |
| } else if (strcmp(slot_name, "1") == 0) { |
| strcpy((char *)partName, "vendor_boot_b"); |
| } |
| MsgP("partName = %s \n", partName); |
| |
| nFlashLoadLen = preloadSz_r;//head info is one page size == 4k |
| debugP("sizeof preloadSz=%u\n", nFlashLoadLen); |
| |
| nReturn = store_logic_read(partName,lflashReadOff, nFlashLoadLen, loadaddr); |
| if (nReturn) { |
| errorP("Fail to read 0x%xB from part[%s] at offset 0\n", nFlashLoadLen, partName); |
| return __LINE__; |
| } |
| |
| p_vendor_boot_img_hdr_t pVendorIMGHDR = (p_vendor_boot_img_hdr_t)loadaddr; |
| |
| rc_r = vendor_boot_image_check_header(pVendorIMGHDR); |
| if (!rc_r) { |
| unsigned long ramdisk_size_r,dtb_size_r; |
| pageSz = pVendorIMGHDR->page_size; |
| |
| /* Android R's vendor_boot partition include ramdisk and dtb */ |
| ramdisk_size_r = ALIGN(pVendorIMGHDR->vendor_ramdisk_size, pageSz); |
| dtb_size_r = ALIGN(pVendorIMGHDR->dtb_size, pageSz); |
| nFlashLoadLen = dtb_size_r; |
| lflashReadOff = ramdisk_size_r + 0x1000; |
| debugP("ramdisk_size_r 0x%x, totalSz 0x%lx\n", pVendorIMGHDR->vendor_ramdisk_size, ramdisk_size_r); |
| debugP("dtb_size_r 0x%x, totalSz 0x%lx\n", pVendorIMGHDR->dtb_size, dtb_size_r); |
| debugP("lflashReadOff=0x%llx\n", lflashReadOff); |
| debugP("nFlashLoadLen=0x%x\n", nFlashLoadLen); |
| }else { |
| errorP("check vendor_boot header error\n"); |
| return __LINE__; |
| } |
| |
| } else { |
| 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__; |
| } |
| |
| pageSz = hdr_addr->page_size; |
| 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* secondAddr = (unsigned char*)loadaddr + lflashReadOff; |
| nReturn = store_logic_read(partName, lflashReadOff, nFlashLoadLen, secondAddr); |
| 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)secondAddr,(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("decrypted dtb sz 0x%x\n", nFlashLoadLen); |
| } |
| |
| char* dtDestAddr = (char*)loadaddr;//simple_strtoull(getenv("dtb_mem_addr"), NULL, 0); |
| memmove(dtDestAddr, secondAddr, nFlashLoadLen); |
| |
| return nReturn; |
| } |
| |
| /*uint32_t store_rsv_size(const char *name);*/ |
| static int do_image_read_dtb_from_rsv(unsigned char* loadaddr) |
| { |
| const int dtbMaxSz = store_rsv_size("dtb"); |
| if (dtbMaxSz < 0x400) { |
| errorP("dtbMaxSz(0x%x) invalid\n", dtbMaxSz); |
| return -__LINE__; |
| } |
| int iRet = store_rsv_read("dtb", dtbMaxSz, loadaddr); |
| if (iRet) { |
| errorP("Fail read dtb from rsv with sz 0x%x\n", dtbMaxSz); |
| return -__LINE__; |
| } |
| if (IS_FEAT_BOOT_VERIFY()) { |
| flush_cache((unsigned long)loadaddr, dtbMaxSz); |
| iRet = aml_sec_boot_check(AML_D_P_IMG_DECRYPT, (long)loadaddr, dtbMaxSz, 0); |
| if (iRet) { |
| MsgP("decrypt dtb: Sig Check %d\n",iRet); |
| return -__LINE__; |
| } |
| } |
| |
| return 0; |
| } |
| |
| //imgread dtb boot ${dtb_mem_addr} |
| //imgread dtb rsv ${dtb_mem_addr} |
| static int do_image_read_dtb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
| { |
| int iRet = 0; |
| const char* const partName = argv[1]; |
| unsigned char* loadaddr = 0; |
| uint64_t lflashReadOff = 0; |
| if (2 < argc) { |
| loadaddr = (unsigned char*)simple_strtoul(argv[2], NULL, 16); |
| } else{ |
| loadaddr = (unsigned char*)simple_strtoul(env_get("loadaddr"), NULL, 16); |
| } |
| |
| if (3 < argc) lflashReadOff = simple_strtoull(argv[3], NULL, 0) ; |
| |
| const int fromRsv = !strcmp("_aml_dtb", argv[1]); |
| if ( fromRsv ) { |
| iRet = do_image_read_dtb_from_rsv(loadaddr); |
| } else { |
| iRet = do_image_read_dtb_from_knl(partName, loadaddr, lflashReadOff); |
| } |
| |
| unsigned long fdtAddr = (unsigned long)loadaddr; |
| #ifdef CONFIG_MULTI_DTB |
| extern unsigned long get_multi_dt_entry(unsigned long fdt_addr); |
| fdtAddr = get_multi_dt_entry((unsigned long)fdtAddr); |
| if (!fdtAddr) { |
| errorP("Fail in get_multi_dt_entry\n"); |
| return __LINE__; |
| } |
| #endif// #ifdef CONFIG_MULTI_DTB |
| iRet = fdt_check_header((char*)fdtAddr); |
| if (iRet) { |
| errorP("Fail in fdt check header\n"); |
| return CMD_RET_FAILURE; |
| } |
| const unsigned fdtsz = fdt_totalsize((char*)fdtAddr); |
| memmove(loadaddr, (char*)fdtAddr, fdtsz); |
| |
| return iRet; |
| } |
| |
| 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_t *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; |
| |
| if (2 < argc) { |
| loadaddr = (unsigned char*)simple_strtoul(argv[2], NULL, 16); |
| } |
| else{ |
| loadaddr = (unsigned char*)simple_strtoul(env_get("loadaddr"), NULL, 16); |
| } |
| hdr_addr = (boot_img_hdr_t*)loadaddr; |
| |
| if (3 < argc) flashReadOff = simple_strtoull(argv[3], NULL, 0) ; |
| |
| rc = store_logic_read(partName, flashReadOff, IMG_PRELOAD_SZ, loadaddr); |
| 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 (!is_android_r_image((void *) hdr_addr)) { |
| |
| extern p_vendor_boot_img_t p_vender_boot_img; |
| |
| /*free vendor buffer first*/ |
| if (p_vender_boot_img) { |
| free(p_vender_boot_img); |
| p_vender_boot_img = 0; |
| } |
| genFmt = genimg_get_format(hdr_addr); |
| if (IMAGE_FORMAT_ANDROID != genFmt) { |
| errorP("Fmt unsupported!genFmt 0x%x != 0x%x\n", genFmt, IMAGE_FORMAT_ANDROID); |
| return __LINE__; |
| } |
| |
| //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; |
| MsgP("secureKernelImgSz=0x%x\n", actualBootImgSz); |
| } |
| 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 (actualBootImgSz > IMG_PRELOAD_SZ) { |
| const unsigned leftSz = actualBootImgSz - IMG_PRELOAD_SZ; |
| |
| debugP("Left sz 0x%x\n", leftSz); |
| rc = store_logic_read(partName, flashReadOff, leftSz, loadaddr + IMG_PRELOAD_SZ); |
| 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; |
| } |
| else { |
| extern p_vendor_boot_img_t p_vender_boot_img; |
| |
| /*free vendor buffer first*/ |
| if (p_vender_boot_img) { |
| free(p_vender_boot_img); |
| p_vender_boot_img = 0; |
| } |
| |
| genFmt = genimg_get_format(hdr_addr); |
| if (IMAGE_FORMAT_ANDROID != genFmt) { |
| errorP("Fmt unsupported!genFmt 0x%x != 0x%x\n", genFmt, IMAGE_FORMAT_ANDROID); |
| return __LINE__; |
| } |
| |
| //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; |
| MsgP("secureKernelImgSz=0x%x\n", actualBootImgSz); |
| } |
| else { |
| p_boot_img_hdr_v3_t hdr_addr_v3 = NULL; |
| hdr_addr_v3 = (p_boot_img_hdr_v3_t)hdr_addr; |
| kernel_size = ALIGN(hdr_addr_v3->kernel_size,0x1000); |
| ramdisk_size = ALIGN(hdr_addr_v3->ramdisk_size,0x1000); |
| debugP("kernel_size 0x%x, totalSz 0x%x\n", hdr_addr_v3->kernel_size, kernel_size); |
| debugP("ramdisk_size 0x%x, totalSz 0x%x\n", hdr_addr_v3->ramdisk_size, ramdisk_size); |
| |
| actualBootImgSz = kernel_size + ramdisk_size + 0x1000; |
| |
| if (actualBootImgSz > IMG_PRELOAD_SZ) { |
| const unsigned leftSz = actualBootImgSz - IMG_PRELOAD_SZ; |
| |
| debugP("Left sz 0x%x\n", leftSz); |
| rc = store_logic_read(partName, flashReadOff, leftSz,loadaddr + IMG_PRELOAD_SZ); |
| 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); |
| |
| /* |
| Android R need read vendor_boot partition |
| define Android R variable add suffix xxx_r |
| */ |
| char partName_r[32] = {0}; |
| int nReturn_r = __LINE__; |
| uint64_t lflashReadOff_r = 0; |
| unsigned int nFlashLoadLen_r = 0; |
| const int preloadSz_r = 0x1000; |
| unsigned char * pBuffPreload = 0; |
| int rc_r = 0; |
| char *slot_name; |
| |
| slot_name = env_get("slot-suffixes"); |
| if (strcmp(slot_name, "0") == 0) { |
| strcpy((char *)partName_r, "vendor_boot_a"); |
| } |
| else if (strcmp(slot_name, "1") == 0) { |
| strcpy((char *)partName_r, "vendor_boot_b"); |
| } |
| MsgP("partName_r = %s\n", partName_r); |
| |
| nFlashLoadLen_r = preloadSz_r; //head info is one page size == 4k |
| debugP("sizeof preloadSz=%u\n", nFlashLoadLen_r); |
| |
| pBuffPreload = malloc(preloadSz_r); |
| |
| if (!pBuffPreload) { |
| printf("aml log : system error! Fail to allocate memory for %s!\n",partName_r); |
| return __LINE__; |
| } |
| nReturn_r = store_logic_read(partName_r,lflashReadOff_r, nFlashLoadLen_r, pBuffPreload); |
| |
| if (nReturn_r) { |
| errorP("Fail to read 0x%xB from part[%s] at offset 0\n", nFlashLoadLen_r, partName_r); |
| free(pBuffPreload); |
| pBuffPreload = 0; |
| return __LINE__; |
| } |
| p_vendor_boot_img_hdr_t pVendorIMGHDR = (p_vendor_boot_img_hdr_t)pBuffPreload; |
| |
| rc_r = vendor_boot_image_check_header(pVendorIMGHDR); |
| if (!rc_r) { |
| unsigned long ramdisk_size_r,dtb_size_r; |
| const int pageSz_r = pVendorIMGHDR->page_size; |
| |
| /* Android R's vendor_boot partition include ramdisk and dtb */ |
| ramdisk_size_r = ALIGN(pVendorIMGHDR->vendor_ramdisk_size, pageSz_r); |
| dtb_size_r = ALIGN(pVendorIMGHDR->dtb_size, pageSz_r); |
| nFlashLoadLen_r = ramdisk_size_r + dtb_size_r + 0x1000; |
| debugP("ramdisk_size_r 0x%x, totalSz 0x%x\n", pVendorIMGHDR->vendor_ramdisk_size, ramdisk_size_r); |
| debugP("dtb_size_r 0x%x, totalSz 0x%x\n", pVendorIMGHDR->dtb_size, dtb_size_r); |
| |
| if (nFlashLoadLen_r > preloadSz_r) { |
| free(pBuffPreload); |
| pBuffPreload=malloc(nFlashLoadLen_r); |
| if (!pBuffPreload) |
| return __LINE__; |
| rc_r = store_logic_read(partName_r, lflashReadOff_r, nFlashLoadLen_r, pBuffPreload); |
| if (rc_r) { |
| errorP("Fail to read 0x%xB from part[%s] at offset 0x%x\n", |
| (unsigned int)nFlashLoadLen_r, partName_r, (unsigned int)lflashReadOff_r); |
| free(pBuffPreload); |
| pBuffPreload = 0; |
| return __LINE__; |
| } |
| } |
| |
| debugP("totalSz=0x%x\n", nFlashLoadLen_r); |
| flush_cache((unsigned long)pBuffPreload,nFlashLoadLen_r); |
| |
| p_vender_boot_img = (p_vendor_boot_img_t)pBuffPreload; |
| } |
| else { |
| free(pBuffPreload); |
| pBuffPreload=0; |
| } |
| } /*ANDROID R/S*/ |
| } |
| 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(env_get("loadaddr"), NULL, 16); |
| } |
| pResImgHead = (AmlResImgHead_t*)loadaddr; |
| |
| rc = store_logic_read(partName, flashReadOff, IMG_PRELOAD_SZ, loadaddr); |
| 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_logic_read(partName, flashReadOff, leftSz, loadaddr + (unsigned)flashReadOff); |
| 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] : env_get("loadaddr_misc"), NULL, 16); |
| |
| pResImgHead = (AmlResImgHead_t*)loadaddr; |
| |
| debugP("to read pic (%s)\n", picName); |
| rc = store_logic_read(partName, flashReadOff, PreloadSz, loadaddr); |
| 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 = env_get("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_logic_read(partName, rdOffAlign, itemSz + (rdOff & 0x7ff),(char*)((picLoadAddr>>11)<<11)); |
| 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); |
| env_set(env_name, env_data); |
| |
| sprintf(env_name, "%s_size", argv[2]); |
| sprintf(env_data, "0x%x", itemSz); |
| env_set(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[]) |
| { |
| |
| #ifdef CONFIG_PXP_EMULATOR |
| printf("\naml log : PXP image all use preload\n"); |
| do { (void)cmd_imgread_sub[0]; } while(0); |
| return 0; |
| #else |
| cmd_tbl_t *c; |
| |
| /* Strip off leading 'imgread' 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; |
| } |
| #endif //CONFIG_PXP_EMULATOR |
| } |
| |
| 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 fomart IMAGE_FORMAT_ANDROID\n" |
| "imgread dtb --- Read dtb in fomart 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] : env_get("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); |
| env_set(env_name, env_data); |
| |
| sprintf(env_name, "%s_size", pItem->name); |
| sprintf(env_data, "0x%x", pItem->size); |
| env_set(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" |
| ); |
| |
| #if defined(CONFIG_CMD_AUTOSCR) |
| /* |
| * Keep for now for backward compatibility; |
| * remove later when support for "autoscr" goes away. |
| */ |
| static int |
| do_autoscr (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
| { |
| printf ("\n### WARNING ### " |
| "\"autoscr\" is deprecated, use \"source\" instead ###\n\n"); |
| if (argc < 2) { |
| printf("too few argc %d for %s\n", argc, argv[0]); |
| return CMD_RET_FAILURE; |
| } |
| env_set("_src_addr", argv[1]); |
| return run_command("echo _src_addr ${_src_addr}; source ${_src_addr}; env delete _src_addr", 0); |
| } |
| |
| U_BOOT_CMD_COMPLETE( |
| autoscr, 2, 0, do_autoscr, |
| "DEPRECATED - use \"source\" command instead", |
| " argv: autoscr script_mem_addr", |
| var_complete |
| ); |
| #endif//#if defined(CONFIG_CMD_AUTOSCR) |
| |
