| /* |
| * Copyright (c) 2018 MediaTek Inc. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining |
| * a copy of this software and associated documentation files |
| * (the "Software"), to deal in the Software without restriction, |
| * including without limitation the rights to use, copy, modify, merge, |
| * publish, distribute, sublicense, and/or sell copies of the Software, |
| * and to permit persons to whom the Software is furnished to do so, |
| * subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be |
| * included in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| |
| #include <debug.h> |
| #include <errno.h> |
| #include <fit.h> |
| #include <kernel/vm.h> |
| #include <lib/bio.h> |
| #include <lib/mempool.h> |
| #include <libfdt.h> |
| #include <platform.h> |
| #include <string.h> |
| #include <sys/types.h> |
| #include <trace.h> |
| |
| #include "avb.h" |
| #include "blxboot_ab.h" |
| #include "blxboot_plat.h" |
| #include "imageinfo.h" |
| |
| #if ENABLE_ANDROID_BOOTIMG_SUPPORT |
| #include <lib/android_bootimg.h> |
| #include <lib/boot_info.h> |
| #endif |
| |
| #define LOCAL_TRACE 0 |
| |
| /* BL33 load and entry point address */ |
| #define CFG_BL33_LOAD_EP_ADDR (BL33_ADDR) |
| |
| /* ramdisk args to be appended to kernel command line */ |
| #define MAX_RAMDISK_ARG_LEN (45) |
| #define RAMDISK_ARG_STR_FMT "initrd=0x%lx,0x%x" |
| |
| extern __WEAK paddr_t kvaddr_to_paddr(void *ptr); |
| |
| /* forward declaration */ |
| static int load_avb_image(const char *part_name, |
| struct imageinfo_t *img); |
| static int load_builtin_bl33_image(const char *part_name, |
| struct imageinfo_t *img); |
| static int load_fit_image(const char *part_name, |
| struct imageinfo_t *img); |
| static int load_android_image(const char *part_name, |
| struct imageinfo_t *img); |
| static int load_dtbo_image(const char *part_name, |
| struct imageinfo_t *img); |
| static int load_scpsys_image(const char *part_name, |
| struct imageinfo_t *img); |
| static int load_scpdata_image(const char *part_name, |
| struct imageinfo_t *img); |
| static int load_scpcfg_image(const char *part_name, |
| struct imageinfo_t *img); |
| #if ENABLE_MODEM_LOAD |
| static int load_md_image(const char *part_name, |
| struct imageinfo_t *img); |
| #endif |
| #if ENABLE_HSM_OS_LOAD |
| static int load_hsm_os_image(const char *part_name, |
| struct imageinfo_t *img); |
| #endif |
| |
| struct image_load_data tzimg = { |
| .part_name = TZ_PART_NAME, |
| .recovery_part_name = RECOVERY_TZ_PART_NAME, |
| .membdev_name = "download:tz", |
| .has_slot = (TZ_HAS_SLOT != 0), |
| }; |
| |
| struct image_load_data bl33img = { |
| .part_name = BL33_PART_NAME, |
| .recovery_part_name = RECOVERY_BL33_PART_NAME, |
| .membdev_name = "download:bl33", |
| .has_slot = (BL33_HAS_SLOT != 0), |
| }; |
| |
| #if ENABLE_SLAVE_CPU_LOAD |
| struct image_load_data scpuimg = { |
| .part_name = SLAVE_CPU_PART_NAME, |
| .recovery_part_name = RECOVERY_SLAVE_CPU_PART_NAME, |
| .membdev_name = "download:scpu", |
| .has_slot = (SLAVE_CPU_HAS_SLOT != 0), |
| }; |
| #endif |
| |
| struct image_load_data bootimg = { |
| .part_name = BOOT_PART_NAME, |
| .recovery_part_name = RECOVERY_BOOT_PART_NAME, |
| .membdev_name = "download:boot", |
| .has_slot = (BOOT_HAS_SLOT != 0), |
| }; |
| |
| struct image_load_data dtboimg = { |
| .part_name = DTBO_PART_NAME, |
| .has_slot = (DTBO_HAS_SLOT != 0), |
| }; |
| |
| struct image_load_data vpdimg = { |
| #if defined(VPD_PART_NAME) |
| .part_name = VPD_PART_NAME, |
| #endif |
| #if defined(RECOVERY_VPD_PART_NAME) |
| .recovery_part_name = RECOVERY_VPD_PART_NAME, |
| #endif |
| .membdev_name = "download:vpd", |
| .has_slot = (VPD_HAS_SLOT != 0), |
| }; |
| |
| #if ENABLE_SCP_LOAD |
| struct image_load_data scpsysimg = { |
| .part_name = SCPSYS_PART_NAME, |
| .recovery_part_name = RECOVERY_SCPSYS_PART_NAME, |
| .membdev_name = "download:scpsys", |
| .has_slot = (SCPSYS_HAS_SLOT != 0), |
| }; |
| #endif |
| |
| #if ENABLE_SCP_AUX_LOAD |
| struct image_load_data scpdataimg = { |
| .part_name = SCPDATA_PART_NAME, |
| .recovery_part_name = RECOVERY_SCPDATA_PART_NAME, |
| .membdev_name = "download:scpdata", |
| .has_slot = (SCPDATA_HAS_SLOT != 0), |
| }; |
| |
| struct image_load_data scpcfgimg = { |
| .part_name = SCPCFG_PART_NAME, |
| .recovery_part_name = RECOVERY_SCPCFG_PART_NAME, |
| .buf = (void *)SCP_CFG_VA, |
| .has_slot = (SCPCFG_HAS_SLOT != 0), |
| }; |
| #endif |
| |
| #if ENABLE_SPM_FW_LOAD |
| struct image_load_data spmfwimg = { |
| .part_name = SPM_PART_NAME, |
| .recovery_part_name = SPM_PART_NAME, |
| .membdev_name = "download:spmfw", |
| .has_slot = (SPMFW_HAS_SLOT != 0), |
| }; |
| #endif |
| |
| #if ENABLE_MODEM_LOAD |
| struct image_load_data mdimg = { |
| .part_name = MD_PART_NAME, |
| .membdev_name = "download:md", |
| .buf = (void *)MD_ADDR, |
| .has_slot = (MD_HAS_SLOT != 0), |
| }; |
| #endif |
| |
| #if ENABLE_HSM_OS_LOAD |
| struct image_load_data hsm_os_img = { |
| .part_name = HSM_OS_PART_NAME, |
| .membdev_name = "download:hsmos", |
| .buf = (void *)HSM_OS_ADDR, |
| .has_slot = (HSM_OS_HAS_SLOT != 0), |
| }; |
| #endif |
| |
| struct imageinfo_t imagelist[] = { |
| #if ENABLE_SCP_AUX_LOAD |
| { |
| .type = IMGTYPE_SCPDATA, |
| .load = load_scpdata_image, |
| .imgdata = &scpdataimg, |
| }, |
| { |
| .type = IMGTYPE_SCPCFG, |
| .load = load_scpcfg_image, |
| .imgdata = &scpcfgimg, |
| }, |
| #endif |
| |
| #if ENABLE_SCP_LOAD |
| { |
| .type = IMGTYPE_SCPSYS, |
| .load = load_scpsys_image, |
| .imgdata = &scpsysimg, |
| }, |
| #endif |
| |
| #if ENABLE_TZ_LOAD |
| { |
| .type = IMGTYPE_TZ, |
| .load = load_fit_image, |
| .imgdata = &tzimg, |
| }, |
| #endif /* ENABLE_TZ_LOAD */ |
| |
| #if ENABLE_BL33_LOAD |
| { |
| #if ENABLE_BUILTIN_BL33 |
| .type = IMGTYPE_BUILTIN_BL33, |
| .load = load_builtin_bl33_image, |
| #else |
| .type = IMGTYPE_BL33, |
| .load = load_fit_image, |
| #endif |
| .imgdata = &bl33img, |
| }, |
| #endif /* ENABLE_BL33_LOAD */ |
| |
| #if ENABLE_SLAVE_CPU_LOAD |
| { |
| .type = IMGTYPE_SLAVE_CPU, |
| .load = load_fit_image, |
| .imgdata = &scpuimg, |
| }, |
| #endif /* ENABLE_DSP_LOAD */ |
| |
| #if ENABLE_KERNEL_LOAD |
| { |
| .type = IMGTYPE_KERNEL, |
| #if defined(AVB_VERIFY_KERNEL) |
| .load = load_avb_image, |
| #else |
| #if ENABLE_ANDROID_BOOTIMG_SUPPORT |
| .load = load_android_image, |
| #else |
| .load = load_fit_image, |
| #endif |
| #endif |
| .imgdata = &bootimg, |
| }, |
| { |
| .type = IMGTYPE_VPD, |
| .load = load_dtbo_image, |
| .imgdata = &vpdimg, |
| }, |
| { |
| .type = IMGTYPE_DTBO, |
| .load = load_dtbo_image, |
| .imgdata = &dtboimg, |
| }, |
| #endif /* ENABLE_KERNEL_LOAD */ |
| |
| #if ENABLE_SPM_FW_LOAD |
| { |
| .type = IMGTYPE_SPM, |
| .load = load_fit_image, |
| .imgdata = &spmfwimg, |
| }, |
| #endif /* ENABLE_SPM_FW_LOAD */ |
| |
| #if ENABLE_MODEM_LOAD |
| { |
| .type = IMGTYPE_MODEM, |
| .load = load_md_image, |
| .imgdata = &mdimg, |
| }, |
| #endif |
| |
| #if ENABLE_HSM_OS_LOAD |
| { |
| .type = IMGTYPE_HSM_OS, |
| .load = load_hsm_os_image, |
| .imgdata = &hsm_os_img, |
| }, |
| #endif |
| |
| { .type = IMGTYPE_NONE } /* imagelist end marker */ |
| }; |
| |
| static void append_cmdline_ramdisk_arg(addr_t ramdisk_addr, uint32_t ramdisk_sz) |
| { |
| char ramdisk_arg[MAX_RAMDISK_ARG_LEN]; |
| |
| memset(ramdisk_arg, 0x0, sizeof(ramdisk_arg)); |
| snprintf(ramdisk_arg, MAX_RAMDISK_ARG_LEN, RAMDISK_ARG_STR_FMT, |
| ramdisk_addr, ramdisk_sz); |
| plat_fixup_append(ramdisk_arg); |
| } |
| |
| static int fit_load_images(void *fit, struct image_load_data *fit_data, |
| bool need_verified) |
| { |
| addr_t load; |
| size_t load_size; |
| int ret; |
| |
| /* TODO: decide verify policy with config. */ |
| if (need_verified) { |
| dprintf(ALWAYS, "verify fit conf sig: %s\n", fit_data->part_name); |
| ret = fit_conf_verify_sig(NULL, fit); |
| if (ret < 0) |
| return ret; |
| } |
| |
| ret = fit_load_image(NULL, "kernel", fit, NULL, NULL, |
| (paddr_t *)&fit_data->kernel_entry, need_verified); |
| if (ret && (ret != -ENOENT)) { |
| dprintf(CRITICAL, "%s load kernel failed\n", fit_data->part_name); |
| return ret; |
| } |
| |
| ret = fit_load_image(NULL, "ramdisk", fit, &load, &load_size, NULL, |
| need_verified); |
| if (ret) { |
| if (ret != -ENOENT) { |
| dprintf(CRITICAL, "%s load ramdisk failed\n", fit_data->part_name); |
| return ret; |
| } |
| } else { |
| #if WITH_KERNEL_VM |
| load = kvaddr_to_paddr((void *)load); |
| #endif |
| append_cmdline_ramdisk_arg(load, load_size); |
| } |
| |
| ret = fit_load_image(NULL, "fdt", fit, (addr_t *)&fit_data->dtb_load, NULL, |
| NULL, need_verified); |
| if (ret && (ret != -ENOENT)) { |
| fit_data->dtb_load = ERR_ADDR; /* [TODO] remove or assign it to NULL */ |
| dprintf(CRITICAL, "%s load fdt failed\n", fit_data->part_name); |
| return ret; |
| } |
| |
| ret = fit_load_image(NULL, "tee", fit, NULL, NULL, |
| (paddr_t *)&fit_data->trustedos_entry, need_verified); |
| if (ret && (ret != -ENOENT)) { |
| dprintf(CRITICAL, "%s load trustedos failed\n", fit_data->part_name); |
| return ret; |
| } |
| |
| return 0; |
| } |
| |
| #if ENABLE_ANDROID_BOOTIMG_SUPPORT |
| static int load_android_hdr_images(const void *part_data, |
| struct image_load_data *android_data) |
| { |
| int rc; |
| uint32_t ramdisk_target_addr, kernel_target_addr; |
| uint32_t ramdisk_sz, zimage_sz, dtb_sz; |
| uint64_t dtb_target_addr; |
| vaddr_t ramdisk_addr, kernel_addr, dtb_addr; |
| char android_dtb_param[] = "androidboot.dtb_idx=0"; |
| |
| load_bootinfo_bootimg_hdr((struct bootimg_hdr *)part_data); |
| set_bootimg_loaded((vaddr_t)part_data); |
| |
| ramdisk_target_addr = get_ramdisk_target_addr(); |
| ramdisk_addr = get_ramdisk_addr(); |
| ramdisk_sz = get_ramdisk_real_sz(); |
| |
| kernel_target_addr = get_kernel_target_addr(); |
| kernel_addr = get_kernel_addr(); |
| zimage_sz = get_kernel_real_sz(); |
| |
| dtb_target_addr = get_dtb_target_addr(); |
| dtb_addr = get_dtb_addr(); |
| dtb_sz = get_dtb_size(); |
| |
| assert(ramdisk_target_addr != 0); |
| assert(ramdisk_addr != 0); |
| assert(kernel_target_addr != 0); |
| assert(kernel_addr != 0); |
| assert(dtb_target_addr != 0); |
| assert(dtb_addr != 0); |
| |
| if(get_header_version() < BOOT_HEADER_VERSION_TWO) { |
| LTRACEF_LEVEL(CRITICAL, |
| "Android Image Header version is lower than v2\n"); |
| return -EINVAL; |
| } |
| |
| rc = android_processing_data("ramdisk", ramdisk_addr, |
| ramdisk_target_addr, ramdisk_sz); |
| if (rc != 0) { |
| LTRACEF_LEVEL(CRITICAL, "load %s failed\n", "ramdisk"); |
| return -EINVAL; |
| } |
| append_cmdline_ramdisk_arg((addr_t)ramdisk_target_addr, ramdisk_sz); |
| |
| rc = android_processing_data("kernel", kernel_addr, |
| kernel_target_addr, zimage_sz); |
| if (rc != 0) { |
| LTRACEF_LEVEL(CRITICAL, "load %s failed\n", "kernel"); |
| return -EINVAL; |
| } |
| android_data->kernel_entry = kernel_target_addr; |
| |
| rc = android_processing_data("dtb", dtb_addr, |
| dtb_target_addr, dtb_sz); |
| if (rc != 0) { |
| LTRACEF_LEVEL(CRITICAL, "load %s failed\n", "dtb"); |
| return -EINVAL; |
| } |
| #if WITH_KERNEL_VM |
| dtb_target_addr = (vaddr_t)paddr_to_kvaddr(dtb_target_addr); |
| #endif |
| android_data->dtb_load = dtb_target_addr; |
| |
| plat_fixup_append(android_dtb_param); |
| |
| return 0; |
| } |
| #endif |
| |
| static int load_avb_image(const char *part_name, struct imageinfo_t *img) |
| { |
| int ret; |
| size_t part_name_len; |
| struct image_load_data *imgdata; |
| char *raw_part_name; |
| const char *suffix; |
| AvbSlotVerifyResult verify_result; |
| AvbSlotVerifyData *verify_data; |
| |
| if ((img == NULL) || (img->imgdata == NULL)) |
| return -1; |
| |
| imgdata = img->imgdata; |
| |
| raw_part_name = strdup(part_name); |
| if (raw_part_name == NULL) |
| return -ENOMEM; |
| |
| if (imgdata->has_slot) { |
| /* prepare partition name without ab suffix */ |
| part_name_len = strlen(part_name); |
| suffix = get_suffix(); |
| if (suffix && (part_name_len > strlen(suffix))) { |
| part_name_len -= strlen(suffix); |
| *(raw_part_name + part_name_len) = '\0'; |
| } |
| } |
| |
| ret = 0; |
| verify_result = android_verified_boot_2_0(raw_part_name, &verify_data); |
| if ((verify_result != AVB_SLOT_VERIFY_RESULT_OK) && !is_device_unlocked()) { |
| ret = -10; |
| goto exit; |
| } |
| |
| void *part_data = get_partition_data(raw_part_name, verify_data); |
| if (part_data == NULL) { |
| ret = -11; |
| goto exit; |
| } |
| |
| #if ENABLE_ANDROID_BOOTIMG_SUPPORT |
| if (img->type == IMGTYPE_KERNEL) { |
| ret = load_android_hdr_images(part_data, imgdata); |
| } else { |
| if (android_dtbo_check_header((const void *)part_data) == DTBO_RET_OK) { |
| /* android dtbo image without fit header */ |
| imgdata->dtb_load = (ulong)part_data; |
| } else { |
| /* android dtbo image with fit header */ |
| ret = fit_load_images(part_data, imgdata, false); |
| } |
| } |
| #else |
| ret = fit_load_images(part_data, imgdata, false); |
| #endif |
| |
| if (ret) { |
| LTRACEF_LEVEL(CRITICAL, "load %s image failed\n", part_name); |
| ret = -21; |
| goto exit; |
| } |
| |
| if (img->type == IMGTYPE_KERNEL) |
| plat_fixup_append(verify_data->cmdline); |
| |
| exit: |
| if (raw_part_name) |
| free(raw_part_name); |
| |
| return ret; |
| } |
| |
| static int load_builtin_bl33_image(const char *part_name, |
| struct imageinfo_t *img) |
| { |
| uint32_t bl33[] = { 0xea000005, /* b BL33_32_ENTRY | ands x5, x0, x0 */ |
| 0x58000160, /* .word 0x58000160 | ldr x0, _X0 */ |
| 0x58000181, /* .word 0x58000181 | ldr x1, _X1 */ |
| 0x580001a2, /* .word 0x580001a2 | ldr x2, _X2 */ |
| 0x580001c3, /* .word 0x580001c3 | ldr x3, _X3 */ |
| 0x580001e4, /* .word 0x580001e4 | ldr x4, _X4 */ |
| 0xd61f0080, /* .word 0xd61f0080 | br x4 */ |
| /* BL33_32_ENTRY: | */ |
| 0xe59f0030, /* ldr r0, _R0 | .word 0xe59f0030 */ |
| 0xe59f1030, /* ldr r1, _R1 | .word 0xe59f1030 */ |
| 0xe59f2004, /* ldr r2, _X0 | .word 0xe59f2004 */ |
| 0xe59ff020, /* ldr pc, _X4 | .word 0xe59ff020 */ |
| 0x00000000, /* .word 0x00000000 */ |
| 0x00000000, /* _X0: .word 0x00000000 */ |
| 0x00000000, /* .word 0x00000000 */ |
| 0x00000000, /* _X1: .word 0x00000000 */ |
| 0x00000000, /* .word 0x00000000 */ |
| 0x00000000, /* _X2: .word 0x00000000 */ |
| 0x00000000, /* .word 0x00000000 */ |
| 0x00000000, /* _X3: .word 0x00000000 */ |
| 0x00000000, /* .word 0x00000000 */ |
| 0x00000000, /* _X4: .word 0x00000000 */ |
| 0x00000000, /* _R0: .word 0x00000000 */ |
| 0x00000000, /* _R1: .word 0x00000000 */ |
| 0x00000000 /* .word 0x00000000 */ |
| }; |
| |
| memcpy((void *)CFG_BL33_LOAD_EP_ADDR, bl33, sizeof(bl33)); |
| img->imgdata->kernel_entry = kvaddr_to_paddr ? |
| kvaddr_to_paddr((void *)CFG_BL33_LOAD_EP_ADDR) : CFG_BL33_LOAD_EP_ADDR; |
| |
| return 0; |
| } |
| |
| static int load_fit_image(const char *part_name, struct imageinfo_t *img) |
| { |
| int err; |
| |
| if ((err = fit_get_image(part_name, &img->imgdata->buf)) == 0) { |
| err = fit_load_images(img->imgdata->buf, img->imgdata, true); |
| } |
| |
| return err; |
| } |
| |
| #if ENABLE_ANDROID_BOOTIMG_SUPPORT |
| static int load_android_image(const char *part_name, struct imageinfo_t *img) |
| { |
| int err; |
| |
| if ((err = android_get_image(part_name, &img->imgdata->buf)) == 0) { |
| err = load_android_hdr_images(img->imgdata->buf, img->imgdata); |
| } |
| |
| return err; |
| } |
| #endif |
| |
| static int load_android_dtbo_image(const char *part_name, |
| struct imageinfo_t *img, uint32_t size) |
| { |
| int ret; |
| |
| /* android dtbo format */ |
| LTRACEF("part_name(%s) in pure android dtbo format.\n", part_name); |
| #if defined(AVB_VERIFY_KERNEL) |
| ret = load_avb_image(part_name, img); |
| #else |
| bdev_t *bdev; |
| void *buf; |
| ssize_t read_bytes; |
| |
| bdev = bio_open_by_label(part_name) ? : bio_open(part_name); |
| if (!bdev) |
| return -ENODEV; |
| |
| ret = 0; |
| buf = mempool_alloc(size, MEMPOOL_ANY); |
| if (!buf) { |
| ret = -ENOMEM; |
| goto _err; |
| } |
| |
| read_bytes = bio_read(bdev, buf, 0, size); |
| if (read_bytes < (ssize_t)size) { |
| LTRACEF("Read android dtbo image fail: read(0x%x), got(0x%zx)\n", |
| size, read_bytes); |
| mempool_free(buf); |
| ret = -EIO; |
| goto _err; |
| } |
| |
| img->imgdata->dtb_load = (ulong)buf; |
| |
| _err: |
| if (bdev) |
| bio_close(bdev); |
| #endif |
| |
| return ret; |
| } |
| |
| static int load_fdt_dtbo_image(const char *part_name, struct imageinfo_t *img) |
| { |
| int ret; |
| int noffset; |
| |
| /* legacy fdt format dtbo or android dtbo format with FIT header */ |
| ret = fit_get_image(part_name, &img->imgdata->buf); |
| if (ret != 0) |
| return ret; |
| |
| /* check configuration node to know it's legacy dtbo or not */ |
| noffset = fdt_path_offset(img->imgdata->buf, "/configurations"); |
| if (noffset < 0) { |
| LTRACEF("part_name(%s) in legacy dtbo format\n", part_name); |
| img->imgdata->dtb_load = (ulong)img->imgdata->buf; |
| return 0; |
| } |
| |
| LTRACEF("part_name(%s) in fit android dtbo format.\n", part_name); |
| /* we verifies android dtbo image in the same method with kernel */ |
| #if defined(AVB_VERIFY_KERNEL) |
| if (img->type == IMGTYPE_DTBO) { |
| mempool_free(img->imgdata->buf); |
| img->imgdata->buf = NULL; |
| |
| /* [TODO] load_avb_image() will waste time to load dtbo image again */ |
| ret = load_avb_image(part_name, img); |
| } else { |
| ret = fit_load_images(img->imgdata->buf, img->imgdata, true); |
| } |
| #else |
| /* get android dtbo */ |
| ret = fit_load_images(img->imgdata->buf, img->imgdata, true); |
| #endif |
| |
| return ret; |
| } |
| |
| static int load_dtbo_image(const char *part_name, struct imageinfo_t *img) |
| { |
| int ret; |
| uint32_t total_size; |
| ssize_t read_bytes; |
| void *buf; |
| bdev_t *bdev; |
| |
| bdev = bio_open_by_label(part_name) ? : bio_open(part_name); |
| if (!bdev) { |
| LTRACEF("Partition [%s] is not exist.\n", part_name); |
| return -ENODEV; |
| } |
| |
| ret = 0; |
| /* read 1 block to determine the dtbo image format */ |
| buf = malloc(bdev->block_size); |
| if (!buf) { |
| ret = -ENOMEM; |
| goto _err; |
| } |
| |
| memset(buf, 0, bdev->block_size); |
| read_bytes = bio_read(bdev, buf, 0, bdev->block_size); |
| if (read_bytes < (ssize_t)bdev->block_size) { |
| LTRACEF("bio_read offset: 0, size: %ld, got: %ld\n", |
| bdev->block_size, read_bytes); |
| ret = -EIO; |
| goto _err; |
| } |
| |
| if (android_dtbo_check_header((const void *)buf) == DTBO_RET_OK) { |
| total_size = android_dtbo_total_size((const void *)buf); |
| if (load_android_dtbo_image(part_name, img, total_size) < 0) |
| ret = -EINVAL; |
| } else if (fdt_check_header((const void *)buf) == 0) { |
| if (load_fdt_dtbo_image(part_name, img) < 0) |
| ret = -EINVAL; |
| } else { |
| LTRACEF("Not valid dtbo image.\n"); |
| ret = -ENOTSUP; |
| } |
| |
| _err: |
| if (buf) |
| free(buf); |
| bio_close(bdev); |
| |
| return ret; |
| } |
| |
| static int load_scpsys_image(const char *part_name, struct imageinfo_t *img) |
| { |
| int err; |
| void *fit; |
| |
| err = fit_get_image(part_name, &img->imgdata->buf); |
| if (err) { |
| LTRACEF("fit_get_image %s fail, err=%d\n", part_name, err); |
| return err; |
| } |
| fit = img->imgdata->buf; |
| |
| dprintf(ALWAYS, "verify fit conf sig: %s\n", part_name); |
| err = fit_conf_verify_sig(NULL, fit); |
| if (err < 0) |
| return err; |
| |
| err = fit_load_image(NULL, "kernel", fit, NULL, NULL, NULL, true); |
| if (err) { |
| LTRACEF("fit_load_image %s: sram fw fail, err=%d\n", part_name, err); |
| return err; |
| } |
| |
| /* the dram part of scpsys image is an optional image, could be absent */ |
| err = fit_load_image(NULL, "firmware", fit, NULL, NULL, NULL, true); |
| if (err && err != -ENOENT) { |
| LTRACEF("fit_load_image %s: dram fw fail, err=%d\n", part_name, err); |
| return err; |
| } |
| |
| return 0; |
| } |
| |
| static int load_scpdata_image(const char *part_name, struct imageinfo_t *img) |
| { |
| #define FIT_FASTLOGO_IMG_NODE_NAME "logo" |
| #define FIT_GUIDELINE_IMG_NODE_NAME "guideline" |
| #define FIT_WARNMSG_IMG_NODE_NAME "warnmsg" |
| #define FIT_CVBSIMG_IMG_NODE_NAME "cvbsimg" |
| |
| int err; |
| void *fit; |
| |
| err = fit_get_image(part_name, &img->imgdata->buf); |
| if (err) { |
| LTRACEF("fit_get_image %s fail, err=%d\n", part_name, err); |
| return err; |
| } |
| fit = img->imgdata->buf; |
| |
| err = fit_load_loadable_image(fit, FIT_FASTLOGO_IMG_NODE_NAME, NULL); |
| if (err) { |
| LTRACEF("fit_load_loadable_image %s fail, err=%d\n", |
| FIT_FASTLOGO_IMG_NODE_NAME, err); |
| return err; |
| } |
| |
| err = fit_load_loadable_image(fit, FIT_GUIDELINE_IMG_NODE_NAME, NULL); |
| if (err) { |
| LTRACEF("fit_load_loadable_image %s fail, err=%d\n", |
| FIT_GUIDELINE_IMG_NODE_NAME, err); |
| return err; |
| } |
| |
| err = fit_load_loadable_image(fit, FIT_WARNMSG_IMG_NODE_NAME, NULL); |
| if (err) { |
| LTRACEF("fit_load_loadable_image %s fail, err=%d\n", |
| FIT_WARNMSG_IMG_NODE_NAME, err); |
| return err; |
| } |
| |
| err = fit_load_loadable_image(fit, FIT_CVBSIMG_IMG_NODE_NAME, NULL); |
| if (err) { |
| LTRACEF("fit_load_loadable_image %s fail, err=%d\n", |
| FIT_CVBSIMG_IMG_NODE_NAME, err); |
| return err; |
| } |
| |
| return 0; |
| } |
| |
| /* [TODO] mvoe load_scpcfg_image to mt2712 platform layer to keep SCP_CFG_VA |
| * invisble to others */ |
| static int load_scpcfg_image(const char *part_name, struct imageinfo_t *img) |
| { |
| int err; |
| ssize_t bytes_read; |
| bdev_t *bdev; |
| |
| bdev = bio_open_by_label(part_name) ? : bio_open(part_name); |
| if (!bdev) |
| return -ENODEV; |
| |
| err = 0; |
| bytes_read = bio_read(bdev, img->imgdata->buf, 0, bdev->total_size); |
| if (bytes_read < bdev->total_size) |
| err = -EIO; |
| |
| bio_close(bdev); |
| |
| return err; |
| } |
| |
| #if ENABLE_MODEM_LOAD |
| extern int load_modem_image(const char *part_name); |
| static int load_md_image(const char *part_name, struct imageinfo_t *img) |
| { |
| return load_modem_image(part_name); |
| } |
| #endif |
| |
| #if ENABLE_HSM_OS_LOAD |
| extern int load_hsm_os(const char *part_name); |
| static int load_hsm_os_image(const char *part_name, struct imageinfo_t *img) |
| { |
| return load_hsm_os(part_name); |
| } |
| #endif |