diff options
| -rw-r--r-- | common/aboot.c | 2643 |
1 files changed, 2643 insertions, 0 deletions
diff --git a/common/aboot.c b/common/aboot.c new file mode 100644 index 0000000..3b5092d --- /dev/null +++ b/common/aboot.c @@ -0,0 +1,2643 @@ +/* + * Copyright (c) 2009, Google Inc. + * All rights reserved. + * + * Copyright (c) 2009-2014, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of The Linux Foundation nor + * the names of its contributors may be used to endorse or promote + * products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include <app.h> +#include <debug.h> +#include <arch/arm.h> +#include <string.h> +#include <stdlib.h> +#include <limits.h> +#include <kernel/thread.h> +#include <arch/ops.h> + +#include <dev/flash.h> +#include <lib/ptable.h> +#include <dev/keys.h> +#include <dev/fbcon.h> +#include <baseband.h> +#include <target.h> +#include <mmc.h> +#include <partition_parser.h> +#include <platform.h> +#include <crypto_hash.h> +#include <malloc.h> +#include <boot_stats.h> +#include <sha.h> +#include <platform/iomap.h> +#include <boot_device.h> + +#if DEVICE_TREE +#include <libfdt.h> +#include <dev_tree.h> +#endif + +#include "image_verify.h" +#include "recovery.h" +#include "bootimg.h" +#include "fastboot.h" +#include "sparse_format.h" +#include "mmc.h" +#include "devinfo.h" +#include "board.h" +#include "scm.h" + +extern bool target_use_signed_kernel(void); +extern void platform_uninit(void); +extern void target_uninit(void); +extern int get_target_boot_params(const char *cmdline, const char *part, + char *buf, int buflen); + +void write_device_info_mmc(device_info *dev); +void write_device_info_flash(device_info *dev); + +#define EXPAND(NAME) #NAME +#define TARGET(NAME) EXPAND(NAME) + +#ifdef MEMBASE +#define EMMC_BOOT_IMG_HEADER_ADDR (0xFF000+(MEMBASE)) +#else +#define EMMC_BOOT_IMG_HEADER_ADDR 0xFF000 +#endif + +#ifndef MEMSIZE +#define MEMSIZE 1024*1024 +#endif + +#define MAX_TAGS_SIZE 1024 + +#define RECOVERY_MODE 0x77665502 +#define FASTBOOT_MODE 0x77665500 + +/* make 4096 as default size to ensure EFS,EXT4's erasing */ +#define DEFAULT_ERASE_SIZE 4096 +#define MAX_PANEL_BUF_SIZE 128 + +#define UBI_MAGIC "UBI#" +#define DISPLAY_DEFAULT_PREFIX "mdss_mdp" +#define UBI_MAGIC_SIZE 0x04 +#define BOOT_DEV_MAX_LEN 64 + +#define IS_ARM64(ptr) (ptr->magic_64 == KERNEL64_HDR_MAGIC) ? true : false + +#define ADD_OF(a, b) (UINT_MAX - b > a) ? (a + b) : UINT_MAX + +#if UFS_SUPPORT +static const char *emmc_cmdline = " androidboot.bootdevice="; +#else +static const char *emmc_cmdline = " androidboot.emmc=true"; +#endif +static const char *usb_sn_cmdline = " androidboot.serialno="; +static const char *androidboot_mode = " androidboot.mode="; +static const char *loglevel = " quiet"; +static const char *battchg_pause = " androidboot.mode=charger"; +static const char *auth_kernel = " androidboot.authorized_kernel=true"; +static const char *secondary_gpt_enable = " gpt"; + +static const char *baseband_apq = " androidboot.baseband=apq"; +static const char *baseband_msm = " androidboot.baseband=msm"; +static const char *baseband_csfb = " androidboot.baseband=csfb"; +static const char *baseband_svlte2a = " androidboot.baseband=svlte2a"; +static const char *baseband_mdm = " androidboot.baseband=mdm"; +static const char *baseband_mdm2 = " androidboot.baseband=mdm2"; +static const char *baseband_sglte = " androidboot.baseband=sglte"; +static const char *baseband_dsda = " androidboot.baseband=dsda"; +static const char *baseband_dsda2 = " androidboot.baseband=dsda2"; +static const char *baseband_sglte2 = " androidboot.baseband=sglte2"; +static const char *warmboot_cmdline = " qpnp-power-on.warm_boot=1"; + +static unsigned page_size = 0; +static unsigned page_mask = 0; +static char ffbm_mode_string[FFBM_MODE_BUF_SIZE]; +static bool boot_into_ffbm; +static char target_boot_params[64]; + +/* Assuming unauthorized kernel image by default */ +static int auth_kernel_img = 0; + +static device_info device = {DEVICE_MAGIC, 0, 0, 0, 0}; + +struct atag_ptbl_entry +{ + char name[16]; + unsigned offset; + unsigned size; + unsigned flags; +}; + +/* + * Partition info, required to be published + * for fastboot + */ +struct getvar_partition_info { + const char part_name[MAX_GPT_NAME_SIZE]; /* Partition name */ + char getvar_size[MAX_GET_VAR_NAME_SIZE]; /* fastboot get var name for size */ + char getvar_type[MAX_GET_VAR_NAME_SIZE]; /* fastboot get var name for type */ + char size_response[MAX_RSP_SIZE]; /* fastboot response for size */ + char type_response[MAX_RSP_SIZE]; /* fastboot response for type */ +}; + +/* + * Right now, we are publishing the info for only + * three partitions + */ +struct getvar_partition_info part_info[] = +{ + { "system" , "partition-size:", "partition-type:", "", "ext4" }, + { "userdata", "partition-size:", "partition-type:", "", "ext4" }, + { "cache" , "partition-size:", "partition-type:", "", "ext4" }, +}; + +char max_download_size[MAX_RSP_SIZE]; +char charger_screen_enabled[MAX_RSP_SIZE]; +char sn_buf[13]; +char display_panel_buf[MAX_PANEL_BUF_SIZE]; +char panel_display_mode[MAX_RSP_SIZE]; + +extern int emmc_recovery_init(void); + +#if NO_KEYPAD_DRIVER +extern int fastboot_trigger(void); +#endif + +static void update_ker_tags_rdisk_addr(struct boot_img_hdr *hdr, bool is_arm64) +{ + /* overwrite the destination of specified for the project */ +#ifdef ABOOT_IGNORE_BOOT_HEADER_ADDRS + if (is_arm64) + hdr->kernel_addr = ABOOT_FORCE_KERNEL64_ADDR; + else + hdr->kernel_addr = ABOOT_FORCE_KERNEL_ADDR; + hdr->ramdisk_addr = ABOOT_FORCE_RAMDISK_ADDR; + hdr->tags_addr = ABOOT_FORCE_TAGS_ADDR; +#endif +} + +static void ptentry_to_tag(unsigned **ptr, struct ptentry *ptn) +{ + struct atag_ptbl_entry atag_ptn; + + memcpy(atag_ptn.name, ptn->name, 16); + atag_ptn.name[15] = '\0'; + atag_ptn.offset = ptn->start; + atag_ptn.size = ptn->length; + atag_ptn.flags = ptn->flags; + memcpy(*ptr, &atag_ptn, sizeof(struct atag_ptbl_entry)); + *ptr += sizeof(struct atag_ptbl_entry) / sizeof(unsigned); +} + +unsigned char *update_cmdline(const char * cmdline) +{ + int cmdline_len = 0; + int have_cmdline = 0; + unsigned char *cmdline_final = NULL; + int pause_at_bootup = 0; + bool warm_boot = false; + bool gpt_exists = partition_gpt_exists(); + int have_target_boot_params = 0; + char *boot_dev_buf = NULL; + + if (cmdline && cmdline[0]) { + cmdline_len = strlen(cmdline); + have_cmdline = 1; + } + if (target_is_emmc_boot()) { + cmdline_len += strlen(emmc_cmdline); +#if UFS_SUPPORT + boot_dev_buf = (char *) malloc(sizeof(char) * BOOT_DEV_MAX_LEN); + ASSERT(boot_dev_buf); + platform_boot_dev_cmdline(boot_dev_buf); + cmdline_len += strlen(boot_dev_buf); +#endif + } + + cmdline_len += strlen(usb_sn_cmdline); + cmdline_len += strlen(sn_buf); + + if (boot_into_recovery && gpt_exists) + cmdline_len += strlen(secondary_gpt_enable); + + if (boot_into_ffbm) { + cmdline_len += strlen(androidboot_mode); + cmdline_len += strlen(ffbm_mode_string); + /* reduce kernel console messages to speed-up boot */ + cmdline_len += strlen(loglevel); + } else if (device.charger_screen_enabled && + target_pause_for_battery_charge()) { + pause_at_bootup = 1; + cmdline_len += strlen(battchg_pause); + } + + if(target_use_signed_kernel() && auth_kernel_img) { + cmdline_len += strlen(auth_kernel); + } + + if (get_target_boot_params(cmdline, boot_into_recovery ? "recoveryfs" : + "system", + target_boot_params, + sizeof(target_boot_params)) == 0) { + have_target_boot_params = 1; + cmdline_len += strlen(target_boot_params); + } + + /* Determine correct androidboot.baseband to use */ + switch(target_baseband()) + { + case BASEBAND_APQ: + cmdline_len += strlen(baseband_apq); + break; + + case BASEBAND_MSM: + cmdline_len += strlen(baseband_msm); + break; + + case BASEBAND_CSFB: + cmdline_len += strlen(baseband_csfb); + break; + + case BASEBAND_SVLTE2A: + cmdline_len += strlen(baseband_svlte2a); + break; + + case BASEBAND_MDM: + cmdline_len += strlen(baseband_mdm); + break; + + case BASEBAND_MDM2: + cmdline_len += strlen(baseband_mdm2); + break; + + case BASEBAND_SGLTE: + cmdline_len += strlen(baseband_sglte); + break; + + case BASEBAND_SGLTE2: + cmdline_len += strlen(baseband_sglte2); + break; + + case BASEBAND_DSDA: + cmdline_len += strlen(baseband_dsda); + break; + + case BASEBAND_DSDA2: + cmdline_len += strlen(baseband_dsda2); + break; + } + + if (cmdline) { + if ((strstr(cmdline, DISPLAY_DEFAULT_PREFIX) == NULL) && + target_display_panel_node(device.display_panel, + display_panel_buf, MAX_PANEL_BUF_SIZE) && + strlen(display_panel_buf)) { + cmdline_len += strlen(display_panel_buf); + } + } + + if (target_warm_boot()) { + warm_boot = true; + cmdline_len += strlen(warmboot_cmdline); + } + + if (cmdline_len > 0) { + const char *src; + unsigned char *dst = (unsigned char*) malloc((cmdline_len + 4) & (~3)); + ASSERT(dst != NULL); + + /* Save start ptr for debug print */ + cmdline_final = dst; + if (have_cmdline) { + src = cmdline; + while ((*dst++ = *src++)); + } + if (target_is_emmc_boot()) { + src = emmc_cmdline; + if (have_cmdline) --dst; + have_cmdline = 1; + while ((*dst++ = *src++)); +#if UFS_SUPPORT + src = boot_dev_buf; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); +#endif + } + + src = usb_sn_cmdline; + if (have_cmdline) --dst; + have_cmdline = 1; + while ((*dst++ = *src++)); + src = sn_buf; + if (have_cmdline) --dst; + have_cmdline = 1; + while ((*dst++ = *src++)); + if (warm_boot) { + if (have_cmdline) --dst; + src = warmboot_cmdline; + while ((*dst++ = *src++)); + } + + if (boot_into_recovery && gpt_exists) { + src = secondary_gpt_enable; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + } + + if (boot_into_ffbm) { + src = androidboot_mode; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + src = ffbm_mode_string; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + src = loglevel; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + } else if (pause_at_bootup) { + src = battchg_pause; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + } + + if(target_use_signed_kernel() && auth_kernel_img) { + src = auth_kernel; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + } + + switch(target_baseband()) + { + case BASEBAND_APQ: + src = baseband_apq; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + break; + + case BASEBAND_MSM: + src = baseband_msm; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + break; + + case BASEBAND_CSFB: + src = baseband_csfb; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + break; + + case BASEBAND_SVLTE2A: + src = baseband_svlte2a; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + break; + + case BASEBAND_MDM: + src = baseband_mdm; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + break; + + case BASEBAND_MDM2: + src = baseband_mdm2; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + break; + + case BASEBAND_SGLTE: + src = baseband_sglte; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + break; + + case BASEBAND_SGLTE2: + src = baseband_sglte2; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + break; + + case BASEBAND_DSDA: + src = baseband_dsda; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + break; + + case BASEBAND_DSDA2: + src = baseband_dsda2; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + break; + } + + if (strlen(display_panel_buf)) { + src = display_panel_buf; + if (have_cmdline) --dst; + while ((*dst++ = *src++)); + } + + if (have_target_boot_params) { + if (have_cmdline) --dst; + src = target_boot_params; + while ((*dst++ = *src++)); + } + } + + + if (boot_dev_buf) + free(boot_dev_buf); + + dprintf(INFO, "cmdline: %s\n", cmdline_final); + return cmdline_final; +} + +unsigned *atag_core(unsigned *ptr) +{ + /* CORE */ + *ptr++ = 2; + *ptr++ = 0x54410001; + + return ptr; + +} + +unsigned *atag_ramdisk(unsigned *ptr, void *ramdisk, + unsigned ramdisk_size) +{ + if (ramdisk_size) { + *ptr++ = 4; + *ptr++ = 0x54420005; + *ptr++ = (unsigned)ramdisk; + *ptr++ = ramdisk_size; + } + + return ptr; +} + +unsigned *atag_ptable(unsigned **ptr_addr) +{ + int i; + struct ptable *ptable; + + if ((ptable = flash_get_ptable()) && (ptable->count != 0)) { + *(*ptr_addr)++ = 2 + (ptable->count * (sizeof(struct atag_ptbl_entry) / + sizeof(unsigned))); + *(*ptr_addr)++ = 0x4d534d70; + for (i = 0; i < ptable->count; ++i) + ptentry_to_tag(ptr_addr, ptable_get(ptable, i)); + } + + return (*ptr_addr); +} + +unsigned *atag_cmdline(unsigned *ptr, const char *cmdline) +{ + int cmdline_length = 0; + int n; + char *dest; + + cmdline_length = strlen((const char*)cmdline); + n = (cmdline_length + 4) & (~3); + + *ptr++ = (n / 4) + 2; + *ptr++ = 0x54410009; + dest = (char *) ptr; + while ((*dest++ = *cmdline++)); + ptr += (n / 4); + + return ptr; +} + +unsigned *atag_end(unsigned *ptr) +{ + /* END */ + *ptr++ = 0; + *ptr++ = 0; + + return ptr; +} + +void generate_atags(unsigned *ptr, const char *cmdline, + void *ramdisk, unsigned ramdisk_size) +{ + + ptr = atag_core(ptr); + ptr = atag_ramdisk(ptr, ramdisk, ramdisk_size); + ptr = target_atag_mem(ptr); + + /* Skip NAND partition ATAGS for eMMC boot */ + if (!target_is_emmc_boot()){ + ptr = atag_ptable(&ptr); + } + + ptr = atag_cmdline(ptr, cmdline); + ptr = atag_end(ptr); +} + +typedef void entry_func_ptr(unsigned, unsigned, unsigned*); +void boot_linux(void *kernel, unsigned *tags, + const char *cmdline, unsigned machtype, + void *ramdisk, unsigned ramdisk_size) +{ + unsigned char *final_cmdline; +#if DEVICE_TREE + int ret = 0; +#endif + + void (*entry)(unsigned, unsigned, unsigned*) = (entry_func_ptr*)(PA((addr_t)kernel)); + uint32_t tags_phys = PA((addr_t)tags); + struct kernel64_hdr *kptr = (struct kernel64_hdr*)kernel; + + ramdisk = PA(ramdisk); + + final_cmdline = update_cmdline((const char*)cmdline); + +#if DEVICE_TREE + dprintf(INFO, "Updating device tree: start\n"); + + /* Update the Device Tree */ + ret = update_device_tree((void *)tags, final_cmdline, ramdisk, ramdisk_size); + if(ret) + { + dprintf(CRITICAL, "ERROR: Updating Device Tree Failed \n"); + ASSERT(0); + } + dprintf(INFO, "Updating device tree: done\n"); +#else + /* Generating the Atags */ + generate_atags(tags, final_cmdline, ramdisk, ramdisk_size); +#endif + + /* Perform target specific cleanup */ + target_uninit(); + + /* Turn off splash screen if enabled */ +#if DISPLAY_SPLASH_SCREEN + target_display_shutdown(); +#endif + + + dprintf(INFO, "booting linux @ %p, ramdisk @ %p (%d), tags/device tree @ %p\n", + entry, ramdisk, ramdisk_size, tags_phys); + + enter_critical_section(); + + /* do any platform specific cleanup before kernel entry */ + platform_uninit(); + + arch_disable_cache(UCACHE); + +#if ARM_WITH_MMU + arch_disable_mmu(); +#endif + bs_set_timestamp(BS_KERNEL_ENTRY); + + if (IS_ARM64(kptr)) + /* Jump to a 64bit kernel */ + scm_elexec_call((paddr_t)kernel, tags_phys); + else + /* Jump to a 32bit kernel */ + entry(0, machtype, (unsigned*)tags_phys); +} + +/* Function to check if the memory address range falls within the aboot + * boundaries. + * start: Start of the memory region + * size: Size of the memory region + */ +int check_aboot_addr_range_overlap(uint32_t start, uint32_t size) +{ + /* Check for boundary conditions. */ + if ((UINT_MAX - start) < size) + return -1; + + /* Check for memory overlap. */ + if ((start < MEMBASE) && ((start + size) <= MEMBASE)) + return 0; + else if (start >= (MEMBASE + MEMSIZE)) + return 0; + else + return -1; +} + +#define ROUND_TO_PAGE(x,y) (((x) + (y)) & (~(y))) + +BUF_DMA_ALIGN(buf, BOOT_IMG_MAX_PAGE_SIZE); //Equal to max-supported pagesize +#if DEVICE_TREE +BUF_DMA_ALIGN(dt_buf, BOOT_IMG_MAX_PAGE_SIZE); +#endif + +static void verify_signed_bootimg(uint32_t bootimg_addr, uint32_t bootimg_size) +{ + int ret; +#if IMAGE_VERIF_ALGO_SHA1 + uint32_t auth_algo = CRYPTO_AUTH_ALG_SHA1; +#else + uint32_t auth_algo = CRYPTO_AUTH_ALG_SHA256; +#endif + + /* Assume device is rooted at this time. */ + device.is_tampered = 1; + + dprintf(INFO, "Authenticating boot image (%d): start\n", bootimg_size); + + ret = image_verify((unsigned char *)bootimg_addr, + (unsigned char *)(bootimg_addr + bootimg_size), + bootimg_size, + auth_algo); + + dprintf(INFO, "Authenticating boot image: done return value = %d\n", ret); + + if (ret) + { + /* Authorized kernel */ + device.is_tampered = 0; + auth_kernel_img = 1; + } + +#if USE_PCOM_SECBOOT + set_tamper_flag(device.is_tampered); +#endif + + if(device.is_tampered) + { + write_device_info_mmc(&device); + #ifdef TZ_TAMPER_FUSE + set_tamper_fuse_cmd(); + #endif + #ifdef ASSERT_ON_TAMPER + dprintf(CRITICAL, "Device is tampered. Asserting..\n"); + ASSERT(0); + #endif + } +} + +static bool check_format_bit() +{ + bool ret = false; + int index; + uint64_t offset; + struct boot_selection_info *in = NULL; + char *buf = NULL; + + index = partition_get_index("bootselect"); + if (index == INVALID_PTN) + { + dprintf(INFO, "Unable to locate /bootselect partition\n"); + return ret; + } + offset = partition_get_offset(index); + if(!offset) + { + dprintf(INFO, "partition /bootselect doesn't exist\n"); + return ret; + } + buf = (char *) memalign(CACHE_LINE, ROUNDUP(page_size, CACHE_LINE)); + ASSERT(buf); + if (mmc_read(offset, (unsigned int *)buf, page_size)) + { + dprintf(INFO, "mmc read failure /bootselect %d\n", page_size); + free(buf); + return ret; + } + in = (struct boot_selection_info *) buf; + if ((in->signature == BOOTSELECT_SIGNATURE) && + (in->version == BOOTSELECT_VERSION)) { + if ((in->state_info & BOOTSELECT_FORMAT) && + !(in->state_info & BOOTSELECT_FACTORY)) + ret = true; + } else { + dprintf(CRITICAL, "Signature: 0x%08x or version: 0x%08x mismatched of /bootselect\n", + in->signature, in->version); + ASSERT(0); + } + free(buf); + return ret; +} + +int boot_linux_from_mmc(void) +{ + struct boot_img_hdr *hdr = (void*) buf; + struct boot_img_hdr *uhdr; + unsigned offset = 0; + int rcode; + unsigned long long ptn = 0; + int index = INVALID_PTN; + + unsigned char *image_addr = 0; + unsigned kernel_actual; + unsigned ramdisk_actual; + unsigned imagesize_actual; + unsigned second_actual = 0; + +#if DEVICE_TREE + struct dt_table *table; + struct dt_entry dt_entry; + unsigned dt_table_offset; + uint32_t dt_actual; + uint32_t dt_hdr_size; +#endif + BUF_DMA_ALIGN(kbuf, BOOT_IMG_MAX_PAGE_SIZE); + struct kernel64_hdr *kptr = (void*) kbuf; + + if (check_format_bit()) + boot_into_recovery = 1; + + if (!boot_into_recovery) { + memset(ffbm_mode_string, '\0', sizeof(ffbm_mode_string)); + rcode = get_ffbm(ffbm_mode_string, sizeof(ffbm_mode_string)); + if (rcode <= 0) { + boot_into_ffbm = false; + if (rcode < 0) + dprintf(CRITICAL,"failed to get ffbm cookie"); + } else + boot_into_ffbm = true; + } else + boot_into_ffbm = false; + uhdr = (struct boot_img_hdr *)EMMC_BOOT_IMG_HEADER_ADDR; + if (!memcmp(uhdr->magic, BOOT_MAGIC, BOOT_MAGIC_SIZE)) { + dprintf(INFO, "Unified boot method!\n"); + hdr = uhdr; + goto unified_boot; + } + if (!boot_into_recovery) { + index = partition_get_index("boot"); + ptn = partition_get_offset(index); + if(ptn == 0) { + dprintf(CRITICAL, "ERROR: No boot partition found\n"); + return -1; + } + } + else { + index = partition_get_index("recovery"); + ptn = partition_get_offset(index); + if(ptn == 0) { + dprintf(CRITICAL, "ERROR: No recovery partition found\n"); + return -1; + } + } + + if (mmc_read(ptn + offset, (unsigned int *) buf, page_size)) { + dprintf(CRITICAL, "ERROR: Cannot read boot image header\n"); + return -1; + } + + if (memcmp(hdr->magic, BOOT_MAGIC, BOOT_MAGIC_SIZE)) { + dprintf(CRITICAL, "ERROR: Invalid boot image header\n"); + return -1; + } + + if (hdr->page_size && (hdr->page_size != page_size)) { + + if (hdr->page_size > BOOT_IMG_MAX_PAGE_SIZE) { + dprintf(CRITICAL, "ERROR: Invalid page size\n"); + return -1; + } + page_size = hdr->page_size; + page_mask = page_size - 1; + } + + /* Read the next page to get kernel Image header + * which lives in the second page for arm64 targets. + */ + + if (mmc_read(ptn + page_size, (unsigned int *) kbuf, page_size)) { + dprintf(CRITICAL, "ERROR: Cannot read boot image header\n"); + return -1; + } + + /* + * Update the kernel/ramdisk/tags address if the boot image header + * has default values, these default values come from mkbootimg when + * the boot image is flashed using fastboot flash:raw + */ + update_ker_tags_rdisk_addr(hdr, IS_ARM64(kptr)); + + /* Get virtual addresses since the hdr saves physical addresses. */ + hdr->kernel_addr = VA((addr_t)(hdr->kernel_addr)); + hdr->ramdisk_addr = VA((addr_t)(hdr->ramdisk_addr)); + hdr->tags_addr = VA((addr_t)(hdr->tags_addr)); + + kernel_actual = ROUND_TO_PAGE(hdr->kernel_size, page_mask); + ramdisk_actual = ROUND_TO_PAGE(hdr->ramdisk_size, page_mask); + + /* Check if the addresses in the header are valid. */ + if (check_aboot_addr_range_overlap(hdr->kernel_addr, kernel_actual) || + check_aboot_addr_range_overlap(hdr->ramdisk_addr, ramdisk_actual)) + { + dprintf(CRITICAL, "kernel/ramdisk addresses overlap with aboot addresses.\n"); + return -1; + } + +#ifndef DEVICE_TREE + if (check_aboot_addr_range_overlap(hdr->tags_addr, MAX_TAGS_SIZE)) + { + dprintf(CRITICAL, "Tags addresses overlap with aboot addresses.\n"); + return -1; + } +#endif + + /* Authenticate Kernel */ + dprintf(INFO, "use_signed_kernel=%d, is_unlocked=%d, is_tampered=%d.\n", + (int) target_use_signed_kernel(), + device.is_unlocked, + device.is_tampered); + + if(target_use_signed_kernel() && (!device.is_unlocked)) + { + offset = 0; + + image_addr = (unsigned char *)target_get_scratch_address(); + +#if DEVICE_TREE + dt_actual = ROUND_TO_PAGE(hdr->dt_size, page_mask); + imagesize_actual = (page_size + kernel_actual + ramdisk_actual + dt_actual); + + if (check_aboot_addr_range_overlap(hdr->tags_addr, dt_actual)) + { + dprintf(CRITICAL, "Device tree addresses overlap with aboot addresses.\n"); + return -1; + } +#else + imagesize_actual = (page_size + kernel_actual + ramdisk_actual); + +#endif + + dprintf(INFO, "Loading boot image (%d): start\n", imagesize_actual); + bs_set_timestamp(BS_KERNEL_LOAD_START); + + if (check_aboot_addr_range_overlap(image_addr, imagesize_actual)) + { + dprintf(CRITICAL, "Boot image buffer address overlaps with aboot addresses.\n"); + return -1; + } + + /* Read image without signature */ + if (mmc_read(ptn + offset, (void *)image_addr, imagesize_actual)) + { + dprintf(CRITICAL, "ERROR: Cannot read boot image\n"); + return -1; + } + + dprintf(INFO, "Loading boot image (%d): done\n", imagesize_actual); + bs_set_timestamp(BS_KERNEL_LOAD_DONE); + + offset = imagesize_actual; + + if (check_aboot_addr_range_overlap(image_addr + offset, page_size)) + { + dprintf(CRITICAL, "Signature read buffer address overlaps with aboot addresses.\n"); + return -1; + } + + /* Read signature */ + if(mmc_read(ptn + offset, (void *)(image_addr + offset), page_size)) + { + dprintf(CRITICAL, "ERROR: Cannot read boot image signature\n"); + return -1; + } + + verify_signed_bootimg(image_addr, imagesize_actual); + + /* Move kernel, ramdisk and device tree to correct address */ + memmove((void*) hdr->kernel_addr, (char *)(image_addr + page_size), hdr->kernel_size); + memmove((void*) hdr->ramdisk_addr, (char *)(image_addr + page_size + kernel_actual), hdr->ramdisk_size); + + #if DEVICE_TREE + if(hdr->dt_size) { + dt_table_offset = ((uint32_t)image_addr + page_size + kernel_actual + ramdisk_actual + second_actual); + table = (struct dt_table*) dt_table_offset; + + if (dev_tree_validate(table, hdr->page_size, &dt_hdr_size) != 0) { + dprintf(CRITICAL, "ERROR: Cannot validate Device Tree Table \n"); + return -1; + } + + /* Find index of device tree within device tree table */ + if(dev_tree_get_entry_info(table, &dt_entry) != 0){ + dprintf(CRITICAL, "ERROR: Device Tree Blob cannot be found\n"); + return -1; + } + + /* Validate and Read device device tree in the "tags_add */ + if (check_aboot_addr_range_overlap(hdr->tags_addr, dt_entry.size)) + { + dprintf(CRITICAL, "Device tree addresses overlap with aboot addresses.\n"); + return -1; + } + + memmove((void *)hdr->tags_addr, (char *)dt_table_offset + dt_entry.offset, dt_entry.size); + } else { + /* + * If appended dev tree is found, update the atags with + * memory address to the DTB appended location on RAM. + * Else update with the atags address in the kernel header + */ + void *dtb; + dtb = dev_tree_appended((void*) hdr->kernel_addr, + hdr->kernel_size, + (void *)hdr->tags_addr); + if (!dtb) { + dprintf(CRITICAL, "ERROR: Appended Device Tree Blob not found\n"); + return -1; + } + } + #endif + } + else + { + second_actual = ROUND_TO_PAGE(hdr->second_size, page_mask); + + dprintf(INFO, "Loading boot image (%d): start\n", + kernel_actual + ramdisk_actual); + bs_set_timestamp(BS_KERNEL_LOAD_START); + + offset = page_size; + + /* Load kernel */ + if (mmc_read(ptn + offset, (void *)hdr->kernel_addr, kernel_actual)) { + dprintf(CRITICAL, "ERROR: Cannot read kernel image\n"); + return -1; + } + offset += kernel_actual; + + /* Load ramdisk */ + if(ramdisk_actual != 0) + { + if (mmc_read(ptn + offset, (void *)hdr->ramdisk_addr, ramdisk_actual)) { + dprintf(CRITICAL, "ERROR: Cannot read ramdisk image\n"); + return -1; + } + } + offset += ramdisk_actual; + + dprintf(INFO, "Loading boot image (%d): done\n", + kernel_actual + ramdisk_actual); + bs_set_timestamp(BS_KERNEL_LOAD_DONE); + + if(hdr->second_size != 0) { + offset += second_actual; + /* Second image loading not implemented. */ + ASSERT(0); + } + + #if DEVICE_TREE + if(hdr->dt_size != 0) { + /* Read the first page of device tree table into buffer */ + if(mmc_read(ptn + offset,(unsigned int *) dt_buf, page_size)) { + dprintf(CRITICAL, "ERROR: Cannot read the Device Tree Table\n"); + return -1; + } + table = (struct dt_table*) dt_buf; + + if (dev_tree_validate(table, hdr->page_size, &dt_hdr_size) != 0) { + dprintf(CRITICAL, "ERROR: Cannot validate Device Tree Table \n"); + return -1; + } + + table = (struct dt_table*) memalign(CACHE_LINE, dt_hdr_size); + if (!table) + return -1; + + /* Read the entire device tree table into buffer */ + if(mmc_read(ptn + offset,(unsigned int *) table, dt_hdr_size)) { + dprintf(CRITICAL, "ERROR: Cannot read the Device Tree Table\n"); + return -1; + } + + /* Find index of device tree within device tree table */ + if(dev_tree_get_entry_info(table, &dt_entry) != 0){ + dprintf(CRITICAL, "ERROR: Getting device tree address failed\n"); + return -1; + } + + /* Validate and Read device device tree in the "tags_add */ + if (check_aboot_addr_range_overlap(hdr->tags_addr, dt_entry.size)) + { + dprintf(CRITICAL, "Device tree addresses overlap with aboot addresses.\n"); + return -1; + } + + if(mmc_read(ptn + offset + dt_entry.offset, + (void *)hdr->tags_addr, dt_entry.size)) { + dprintf(CRITICAL, "ERROR: Cannot read device tree\n"); + return -1; + } + #ifdef TZ_SAVE_KERNEL_HASH + aboot_save_boot_hash_mmc(hdr->kernel_addr, kernel_actual, + hdr->ramdisk_addr, ramdisk_actual, + ptn, offset, hdr->dt_size); + #endif /* TZ_SAVE_KERNEL_HASH */ + + } else { + + /* Validate the tags_addr */ + if (check_aboot_addr_range_overlap(hdr->tags_addr, kernel_actual)) + { + dprintf(CRITICAL, "Device tree addresses overlap with aboot addresses.\n"); + return -1; + } + /* + * If appended dev tree is found, update the atags with + * memory address to the DTB appended location on RAM. + * Else update with the atags address in the kernel header + */ + void *dtb; + dtb = dev_tree_appended((void*) hdr->kernel_addr, + kernel_actual, + (void *)hdr->tags_addr); + if (!dtb) { + dprintf(CRITICAL, "ERROR: Appended Device Tree Blob not found\n"); + return -1; + } + } + #endif + } + + if (boot_into_recovery && !device.is_unlocked && !device.is_tampered) + target_load_ssd_keystore(); + +unified_boot: + + boot_linux((void *)hdr->kernel_addr, (void *)hdr->tags_addr, + (const char *)hdr->cmdline, board_machtype(), + (void *)hdr->ramdisk_addr, hdr->ramdisk_size); + + return 0; +} + +int boot_linux_from_flash(void) +{ + struct boot_img_hdr *hdr = (void*) buf; + struct ptentry *ptn; + struct ptable *ptable; + unsigned offset = 0; + + unsigned char *image_addr = 0; + unsigned kernel_actual; + unsigned ramdisk_actual; + unsigned imagesize_actual; + unsigned second_actual; + +#if DEVICE_TREE + struct dt_table *table; + struct dt_entry dt_entry; + uint32_t dt_actual; + uint32_t dt_hdr_size; +#endif + + if (target_is_emmc_boot()) { + hdr = (struct boot_img_hdr *)EMMC_BOOT_IMG_HEADER_ADDR; + if (memcmp(hdr->magic, BOOT_MAGIC, BOOT_MAGIC_SIZE)) { + dprintf(CRITICAL, "ERROR: Invalid boot image header\n"); + return -1; + } + goto continue_boot; + } + + ptable = flash_get_ptable(); + if (ptable == NULL) { + dprintf(CRITICAL, "ERROR: Partition table not found\n"); + return -1; + } + + if(!boot_into_recovery) + { + ptn = ptable_find(ptable, "boot"); + + if (ptn == NULL) { + dprintf(CRITICAL, "ERROR: No boot partition found\n"); + return -1; + } + } + else + { + ptn = ptable_find(ptable, "recovery"); + if (ptn == NULL) { + dprintf(CRITICAL, "ERROR: No recovery partition found\n"); + return -1; + } + } + + if (flash_read(ptn, offset, buf, page_size)) { + dprintf(CRITICAL, "ERROR: Cannot read boot image header\n"); + return -1; + } + + if (memcmp(hdr->magic, BOOT_MAGIC, BOOT_MAGIC_SIZE)) { + dprintf(CRITICAL, "ERROR: Invalid boot image header\n"); + return -1; + } + + if (hdr->page_size != page_size) { + dprintf(CRITICAL, "ERROR: Invalid boot image pagesize. Device pagesize: %d, Image pagesize: %d\n",page_size,hdr->page_size); + return -1; + } + + /* + * Update the kernel/ramdisk/tags address if the boot image header + * has default values, these default values come from mkbootimg when + * the boot image is flashed using fastboot flash:raw + */ + update_ker_tags_rdisk_addr(hdr, false); + + /* Get virtual addresses since the hdr saves physical addresses. */ + hdr->kernel_addr = VA((addr_t)(hdr->kernel_addr)); + hdr->ramdisk_addr = VA((addr_t)(hdr->ramdisk_addr)); + hdr->tags_addr = VA((addr_t)(hdr->tags_addr)); + + kernel_actual = ROUND_TO_PAGE(hdr->kernel_size, page_mask); + ramdisk_actual = ROUND_TO_PAGE(hdr->ramdisk_size, page_mask); + + /* Check if the addresses in the header are valid. */ + if (check_aboot_addr_range_overlap(hdr->kernel_addr, kernel_actual) || + check_aboot_addr_range_overlap(hdr->ramdisk_addr, ramdisk_actual)) + { + dprintf(CRITICAL, "kernel/ramdisk addresses overlap with aboot addresses.\n"); + return -1; + } + +#ifndef DEVICE_TREE + if (check_aboot_addr_range_overlap(hdr->tags_addr, MAX_TAGS_SIZE)) + { + dprintf(CRITICAL, "Tags addresses overlap with aboot addresses.\n"); + return -1; + } +#endif + + /* Authenticate Kernel */ + if(target_use_signed_kernel() && (!device.is_unlocked)) + { + image_addr = (unsigned char *)target_get_scratch_address(); + offset = 0; + +#if DEVICE_TREE + dt_actual = ROUND_TO_PAGE(hdr->dt_size, page_mask); + imagesize_actual = (page_size + kernel_actual + ramdisk_actual + dt_actual); + + if (check_aboot_addr_range_overlap(hdr->tags_addr, hdr->dt_size)) + { + dprintf(CRITICAL, "Device tree addresses overlap with aboot addresses.\n"); + return -1; + } +#else + imagesize_actual = (page_size + kernel_actual + ramdisk_actual); +#endif + + dprintf(INFO, "Loading boot image (%d): start\n", imagesize_actual); + bs_set_timestamp(BS_KERNEL_LOAD_START); + + /* Read image without signature */ + if (flash_read(ptn, offset, (void *)image_addr, imagesize_actual)) + { + dprintf(CRITICAL, "ERROR: Cannot read boot image\n"); + return -1; + } + + dprintf(INFO, "Loading boot image (%d): done\n", imagesize_actual); + bs_set_timestamp(BS_KERNEL_LOAD_DONE); + + offset = imagesize_actual; + /* Read signature */ + if (flash_read(ptn, offset, (void *)(image_addr + offset), page_size)) + { + dprintf(CRITICAL, "ERROR: Cannot read boot image signature\n"); + return -1; + } + + verify_signed_bootimg(image_addr, imagesize_actual); + + /* Move kernel and ramdisk to correct address */ + memmove((void*) hdr->kernel_addr, (char *)(image_addr + page_size), hdr->kernel_size); + memmove((void*) hdr->ramdisk_addr, (char *)(image_addr + page_size + kernel_actual), hdr->ramdisk_size); +#if DEVICE_TREE + /* Validate and Read device device tree in the "tags_add */ + if (check_aboot_addr_range_overlap(hdr->tags_addr, dt_entry.size)) + { + dprintf(CRITICAL, "Device tree addresses overlap with aboot addresses.\n"); + return -1; + } + + memmove((void*) hdr->tags_addr, (char *)(image_addr + page_size + kernel_actual + ramdisk_actual), hdr->dt_size); +#endif + + /* Make sure everything from scratch address is read before next step!*/ + if(device.is_tampered) + { + write_device_info_flash(&device); + } +#if USE_PCOM_SECBOOT + set_tamper_flag(device.is_tampered); +#endif + } + else + { + offset = page_size; + + kernel_actual = ROUND_TO_PAGE(hdr->kernel_size, page_mask); + ramdisk_actual = ROUND_TO_PAGE(hdr->ramdisk_size, page_mask); + second_actual = ROUND_TO_PAGE(hdr->second_size, page_mask); + + dprintf(INFO, "Loading boot image (%d): start\n", + kernel_actual + ramdisk_actual); + bs_set_timestamp(BS_KERNEL_LOAD_START); + + if (flash_read(ptn, offset, (void *)hdr->kernel_addr, kernel_actual)) { + dprintf(CRITICAL, "ERROR: Cannot read kernel image\n"); + return -1; + } + offset += kernel_actual; + + if (flash_read(ptn, offset, (void *)hdr->ramdisk_addr, ramdisk_actual)) { + dprintf(CRITICAL, "ERROR: Cannot read ramdisk image\n"); + return -1; + } + offset += ramdisk_actual; + + dprintf(INFO, "Loading boot image (%d): done\n", + kernel_actual + ramdisk_actual); + bs_set_timestamp(BS_KERNEL_LOAD_DONE); + + if(hdr->second_size != 0) { + offset += second_actual; + /* Second image loading not implemented. */ + ASSERT(0); + } + +#if DEVICE_TREE + if(hdr->dt_size != 0) { + + /* Read the device tree table into buffer */ + if(flash_read(ptn, offset, (void *) dt_buf, page_size)) { + dprintf(CRITICAL, "ERROR: Cannot read the Device Tree Table\n"); + return -1; + } + + table = (struct dt_table*) dt_buf; + + if (dev_tree_validate(table, hdr->page_size, &dt_hdr_size) != 0) { + dprintf(CRITICAL, "ERROR: Cannot validate Device Tree Table \n"); + return -1; + } + + table = (struct dt_table*) memalign(CACHE_LINE, dt_hdr_size); + if (!table) + return -1; + + /* Read the entire device tree table into buffer */ + if(flash_read(ptn, offset, (void *)table, dt_hdr_size)) { + dprintf(CRITICAL, "ERROR: Cannot read the Device Tree Table\n"); + return -1; + } + + + /* Find index of device tree within device tree table */ + if(dev_tree_get_entry_info(table, &dt_entry) != 0){ + dprintf(CRITICAL, "ERROR: Getting device tree address failed\n"); + return -1; + } + + /* Validate and Read device device tree in the "tags_add */ + if (check_aboot_addr_range_overlap(hdr->tags_addr, dt_entry.size)) + { + dprintf(CRITICAL, "Device tree addresses overlap with aboot addresses.\n"); + return -1; + } + + /* Read device device tree in the "tags_add */ + if(flash_read(ptn, offset + dt_entry.offset, + (void *)hdr->tags_addr, dt_entry.size)) { + dprintf(CRITICAL, "ERROR: Cannot read device tree\n"); + return -1; + } + } +#endif + + } +continue_boot: + + /* TODO: create/pass atags to kernel */ + + boot_linux((void *)hdr->kernel_addr, (void *)hdr->tags_addr, + (const char *)hdr->cmdline, board_machtype(), + (void *)hdr->ramdisk_addr, hdr->ramdisk_size); + + return 0; +} + +BUF_DMA_ALIGN(info_buf, BOOT_IMG_MAX_PAGE_SIZE); +void write_device_info_mmc(device_info *dev) +{ + struct device_info *info = (void*) info_buf; + unsigned long long ptn = 0; + unsigned long long size; + int index = INVALID_PTN; + uint32_t blocksize; + uint8_t lun = 0; + + index = partition_get_index("aboot"); + ptn = partition_get_offset(index); + if(ptn == 0) + { + return; + } + + lun = partition_get_lun(index); + mmc_set_lun(lun); + + size = partition_get_size(index); + + memcpy(info, dev, sizeof(device_info)); + + blocksize = mmc_get_device_blocksize(); + + if(mmc_write((ptn + size - blocksize), blocksize, (void *)info_buf)) + { + dprintf(CRITICAL, "ERROR: Cannot write device info\n"); + return; + } +} + +void read_device_info_mmc(device_info *dev) +{ + struct device_info *info = (void*) info_buf; + unsigned long long ptn = 0; + unsigned long long size; + int index = INVALID_PTN; + uint32_t blocksize; + + index = partition_get_index("aboot"); + ptn = partition_get_offset(index); + if(ptn == 0) + { + return; + } + + size = partition_get_size(index); + + blocksize = mmc_get_device_blocksize(); + + if(mmc_read((ptn + size - blocksize), (void *)info_buf, blocksize)) + { + dprintf(CRITICAL, "ERROR: Cannot read device info\n"); + return; + } + + if (memcmp(info->magic, DEVICE_MAGIC, DEVICE_MAGIC_SIZE)) + { + memcpy(info->magic, DEVICE_MAGIC, DEVICE_MAGIC_SIZE); + info->is_unlocked = 0; + info->is_tampered = 0; + info->charger_screen_enabled = 0; + + write_device_info_mmc(info); + } + memcpy(dev, info, sizeof(device_info)); +} + +void write_device_info_flash(device_info *dev) +{ + struct device_info *info = (void *) info_buf; + struct ptentry *ptn; + struct ptable *ptable; + + ptable = flash_get_ptable(); + if (ptable == NULL) + { + dprintf(CRITICAL, "ERROR: Partition table not found\n"); + return; + } + + ptn = ptable_find(ptable, "devinfo"); + if (ptn == NULL) + { + dprintf(CRITICAL, "ERROR: No boot partition found\n"); + return; + } + + memcpy(info, dev, sizeof(device_info)); + + if (flash_write(ptn, 0, (void *)info_buf, page_size)) + { + dprintf(CRITICAL, "ERROR: Cannot write device info\n"); + return; + } +} + +void read_device_info_flash(device_info *dev) +{ + struct device_info *info = (void*) info_buf; + struct ptentry *ptn; + struct ptable *ptable; + + ptable = flash_get_ptable(); + if (ptable == NULL) + { + dprintf(CRITICAL, "ERROR: Partition table not found\n"); + return; + } + + ptn = ptable_find(ptable, "devinfo"); + if (ptn == NULL) + { + dprintf(CRITICAL, "ERROR: No boot partition found\n"); + return; + } + + if (flash_read(ptn, 0, (void *)info_buf, page_size)) + { + dprintf(CRITICAL, "ERROR: Cannot write device info\n"); + return; + } + + if (memcmp(info->magic, DEVICE_MAGIC, DEVICE_MAGIC_SIZE)) + { + memcpy(info->magic, DEVICE_MAGIC, DEVICE_MAGIC_SIZE); + info->is_unlocked = 0; + info->is_tampered = 0; + write_device_info_flash(info); + } + memcpy(dev, info, sizeof(device_info)); +} + +void write_device_info(device_info *dev) +{ + if(target_is_emmc_boot()) + { + write_device_info_mmc(dev); + } + else + { + write_device_info_flash(dev); + } +} + +void read_device_info(device_info *dev) +{ + if(target_is_emmc_boot()) + { + read_device_info_mmc(dev); + } + else + { + read_device_info_flash(dev); + } +} + +void reset_device_info() +{ + dprintf(ALWAYS, "reset_device_info called."); + device.is_tampered = 0; + write_device_info(&device); +} + +void set_device_root() +{ + dprintf(ALWAYS, "set_device_root called."); + device.is_tampered = 1; + write_device_info(&device); +} + +#if DEVICE_TREE +int copy_dtb(uint8_t *boot_image_start) +{ + uint32 dt_image_offset = 0; + uint32_t n; + struct dt_table *table; + struct dt_entry dt_entry; + uint32_t dt_hdr_size; + + struct boot_img_hdr *hdr = (struct boot_img_hdr *) (boot_image_start); + + if(hdr->dt_size != 0) { + + /* add kernel offset */ + dt_image_offset += page_size; + n = ROUND_TO_PAGE(hdr->kernel_size, page_mask); + dt_image_offset += n; + + /* add ramdisk offset */ + n = ROUND_TO_PAGE(hdr->ramdisk_size, page_mask); + dt_image_offset += n; + + /* add second offset */ + if(hdr->second_size != 0) { + n = ROUND_TO_PAGE(hdr->second_size, page_mask); + dt_image_offset += n; + } + + /* offset now point to start of dt.img */ + table = (struct dt_table*)(boot_image_start + dt_image_offset); + + if (dev_tree_validate(table, hdr->page_size, &dt_hdr_size) != 0) { + dprintf(CRITICAL, "ERROR: Cannot validate Device Tree Table \n"); + return -1; + } + /* Find index of device tree within device tree table */ + if(dev_tree_get_entry_info(table, &dt_entry) != 0){ + dprintf(CRITICAL, "ERROR: Getting device tree address failed\n"); + return -1; + } + + /* Validate and Read device device tree in the "tags_add */ + if (check_aboot_addr_range_overlap(hdr->tags_addr, dt_entry.size)) + { + dprintf(CRITICAL, "Device tree addresses overlap with aboot addresses.\n"); + return -1; + } + + /* Read device device tree in the "tags_add */ + memmove((void*) hdr->tags_addr, + boot_image_start + dt_image_offset + dt_entry.offset, + dt_entry.size); + } else + return -1; + + /* Everything looks fine. Return success. */ + return 0; +} +#endif + +void cmd_boot(const char *arg, void *data, unsigned sz) +{ + unsigned kernel_actual; + unsigned ramdisk_actual; + uint32_t image_actual; + uint32_t dt_actual = 0; + uint32_t sig_actual = SIGNATURE_SIZE; + struct boot_img_hdr *hdr; + struct kernel64_hdr *kptr; + char *ptr = ((char*) data); + int ret = 0; + uint8_t dtb_copied = 0; + + if (sz < sizeof(hdr)) { + fastboot_fail("invalid bootimage header"); + return; + } + + hdr = (struct boot_img_hdr *)data; + + /* ensure commandline is terminated */ + hdr->cmdline[BOOT_ARGS_SIZE-1] = 0; + + if(target_is_emmc_boot() && hdr->page_size) { + page_size = hdr->page_size; + page_mask = page_size - 1; + } + + kernel_actual = ROUND_TO_PAGE(hdr->kernel_size, page_mask); + ramdisk_actual = ROUND_TO_PAGE(hdr->ramdisk_size, page_mask); +#if DEVICE_TREE + dt_actual = ROUND_TO_PAGE(hdr->dt_size, page_mask); +#endif + + image_actual = ADD_OF(page_size, kernel_actual); + image_actual = ADD_OF(image_actual, ramdisk_actual); + image_actual = ADD_OF(image_actual, dt_actual); + + if (target_use_signed_kernel() && (!device.is_unlocked)) + image_actual = ADD_OF(image_actual, sig_actual); + + /* sz should have atleast raw boot image */ + if (image_actual > sz) { + fastboot_fail("bootimage: incomplete or not signed"); + return; + } + + /* Verify the boot image + * device & page_size are initialized in aboot_init + */ + if (target_use_signed_kernel() && (!device.is_unlocked)) + /* Pass size excluding signature size, otherwise we would try to + * access signature beyond its length + */ + verify_signed_bootimg((uint32_t)data, (image_actual - sig_actual)); + + /* + * Update the kernel/ramdisk/tags address if the boot image header + * has default values, these default values come from mkbootimg when + * the boot image is flashed using fastboot flash:raw + */ + kptr = (struct kernel64_hdr*)((char*) data + page_size); + update_ker_tags_rdisk_addr(hdr, IS_ARM64(kptr)); + + /* Get virtual addresses since the hdr saves physical addresses. */ + hdr->kernel_addr = VA(hdr->kernel_addr); + hdr->ramdisk_addr = VA(hdr->ramdisk_addr); + hdr->tags_addr = VA(hdr->tags_addr); + + /* Check if the addresses in the header are valid. */ + if (check_aboot_addr_range_overlap(hdr->kernel_addr, kernel_actual) || + check_aboot_addr_range_overlap(hdr->ramdisk_addr, ramdisk_actual)) + { + dprintf(CRITICAL, "kernel/ramdisk addresses overlap with aboot addresses.\n"); + return; + } + +#if DEVICE_TREE + /* find correct dtb and copy it to right location */ + ret = copy_dtb(data); + + dtb_copied = !ret ? 1 : 0; +#else + if (check_aboot_addr_range_overlap(hdr->tags_addr, MAX_TAGS_SIZE)) + { + dprintf(CRITICAL, "Tags addresses overlap with aboot addresses.\n"); + return; + } +#endif + + /* Load ramdisk & kernel */ + memmove((void*) hdr->ramdisk_addr, ptr + page_size + kernel_actual, hdr->ramdisk_size); + memmove((void*) hdr->kernel_addr, ptr + page_size, hdr->kernel_size); + +#if DEVICE_TREE + /* + * If dtb is not found look for appended DTB in the kernel. + * If appended dev tree is found, update the atags with + * memory address to the DTB appended location on RAM. + * Else update with the atags address in the kernel header + */ + if (!dtb_copied) { + void *dtb; + dtb = dev_tree_appended((void *)hdr->kernel_addr, hdr->kernel_size, + (void *)hdr->tags_addr); + if (!dtb) { + fastboot_fail("dtb not found"); + return; + } + } +#endif + +#ifndef DEVICE_TREE + if (check_aboot_addr_range_overlap(hdr->tags_addr, MAX_TAGS_SIZE)) + { + dprintf(CRITICAL, "Tags addresses overlap with aboot addresses.\n"); + return; + } +#endif + + fastboot_okay(""); + fastboot_stop(); + + boot_linux((void*) hdr->kernel_addr, (void*) hdr->tags_addr, + (const char*) hdr->cmdline, board_machtype(), + (void*) hdr->ramdisk_addr, hdr->ramdisk_size); +} + +void cmd_erase(const char *arg, void *data, unsigned sz) +{ + struct ptentry *ptn; + struct ptable *ptable; + + ptable = flash_get_ptable(); + if (ptable == NULL) { + fastboot_fail("partition table doesn't exist"); + return; + } + + ptn = ptable_find(ptable, arg); + if (ptn == NULL) { + fastboot_fail("unknown partition name"); + return; + } + + if (flash_erase(ptn)) { + fastboot_fail("failed to erase partition"); + return; + } + fastboot_okay(""); +} + + +void cmd_erase_mmc(const char *arg, void *data, unsigned sz) +{ + BUF_DMA_ALIGN(out, DEFAULT_ERASE_SIZE); + unsigned long long ptn = 0; + unsigned long long size = 0; + int index = INVALID_PTN; + uint8_t lun = 0; + + index = partition_get_index(arg); + ptn = partition_get_offset(index); + size = partition_get_size(index); + + if(ptn == 0) { + fastboot_fail("Partition table doesn't exist\n"); + return; + } + + lun = partition_get_lun(index); + mmc_set_lun(lun); + +#if MMC_SDHCI_SUPPORT + if (mmc_erase_card(ptn, size)) { + fastboot_fail("failed to erase partition\n"); + return; + } +#else + size = partition_get_size(index); + if (size > DEFAULT_ERASE_SIZE) + size = DEFAULT_ERASE_SIZE; + + /* Simple inefficient version of erase. Just writing + 0 in first several blocks */ + if (mmc_write(ptn , size, (unsigned int *)out)) { + fastboot_fail("failed to erase partition"); + return; + } +#endif + fastboot_okay(""); +} + + +void cmd_flash_mmc_img(const char *arg, void *data, unsigned sz) +{ + unsigned long long ptn = 0; + unsigned long long size = 0; + int index = INVALID_PTN; + char *token = NULL; + char *pname = NULL; + uint8_t lun = 0; + bool lun_set = false; + + token = strtok(arg, ":"); + pname = token; + token = strtok(NULL, ":"); + if(token) + { + lun = atoi(token); + mmc_set_lun(lun); + lun_set = true; + } + + if (pname) + { + if (!strcmp(pname, "partition")) + { + dprintf(INFO, "Attempt to write partition image.\n"); + if (write_partition(sz, (unsigned char *) data)) { + fastboot_fail("failed to write partition"); + return; + } + } + else + { + index = partition_get_index(pname); + ptn = partition_get_offset(index); + if(ptn == 0) { + fastboot_fail("partition table doesn't exist"); + return; + } + + if (!strcmp(pname, "boot") || !strcmp(pname, "recovery")) { + if (memcmp((void *)data, BOOT_MAGIC, BOOT_MAGIC_SIZE)) { + fastboot_fail("image is not a boot image"); + return; + } + } + + if(!lun_set) + { + lun = partition_get_lun(index); + mmc_set_lun(lun); + } + + size = partition_get_size(index); + if (ROUND_TO_PAGE(sz,511) > size) { + fastboot_fail("size too large"); + return; + } + else if (mmc_write(ptn , sz, (unsigned int *)data)) { + fastboot_fail("flash write failure"); + return; + } + } + } + fastboot_okay(""); + return; +} + +void cmd_flash_mmc_sparse_img(const char *arg, void *data, unsigned sz) +{ + unsigned int chunk; + unsigned int chunk_data_sz; + uint32_t *fill_buf = NULL; + uint32_t fill_val; + uint32_t chunk_blk_cnt = 0; + sparse_header_t *sparse_header; + chunk_header_t *chunk_header; + uint32_t total_blocks = 0; + unsigned long long ptn = 0; + unsigned long long size = 0; + int index = INVALID_PTN; + int i; + uint8_t lun = 0; + + index = partition_get_index(arg); + ptn = partition_get_offset(index); + if(ptn == 0) { + fastboot_fail("partition table doesn't exist"); + return; + } + + size = partition_get_size(index); + if (ROUND_TO_PAGE(sz,511) > size) { + fastboot_fail("size too large"); + return; + } + + lun = partition_get_lun(index); + mmc_set_lun(lun); + + /* Read and skip over sparse image header */ + sparse_header = (sparse_header_t *) data; + if ((sparse_header->total_blks * sparse_header->blk_sz) > size) { + fastboot_fail("size too large"); + return; + } + + data += sparse_header->file_hdr_sz; + if(sparse_header->file_hdr_sz > sizeof(sparse_header_t)) + { + /* Skip the remaining bytes in a header that is longer than + * we expected. + */ + data += (sparse_header->file_hdr_sz - sizeof(sparse_header_t)); + } + + dprintf (SPEW, "=== Sparse Image Header ===\n"); + dprintf (SPEW, "magic: 0x%x\n", sparse_header->magic); + dprintf (SPEW, "major_version: 0x%x\n", sparse_header->major_version); + dprintf (SPEW, "minor_version: 0x%x\n", sparse_header->minor_version); + dprintf (SPEW, "file_hdr_sz: %d\n", sparse_header->file_hdr_sz); + dprintf (SPEW, "chunk_hdr_sz: %d\n", sparse_header->chunk_hdr_sz); + dprintf (SPEW, "blk_sz: %d\n", sparse_header->blk_sz); + dprintf (SPEW, "total_blks: %d\n", sparse_header->total_blks); + dprintf (SPEW, "total_chunks: %d\n", sparse_header->total_chunks); + + /* Start processing chunks */ + for (chunk=0; chunk<sparse_header->total_chunks; chunk++) + { + /* Read and skip over chunk header */ + chunk_header = (chunk_header_t *) data; + data += sizeof(chunk_header_t); + + dprintf (SPEW, "=== Chunk Header ===\n"); + dprintf (SPEW, "chunk_type: 0x%x\n", chunk_header->chunk_type); + dprintf (SPEW, "chunk_data_sz: 0x%x\n", chunk_header->chunk_sz); + dprintf (SPEW, "total_size: 0x%x\n", chunk_header->total_sz); + + if(sparse_header->chunk_hdr_sz > sizeof(chunk_header_t)) + { + /* Skip the remaining bytes in a header that is longer than + * we expected. + */ + data += (sparse_header->chunk_hdr_sz - sizeof(chunk_header_t)); + } + + chunk_data_sz = sparse_header->blk_sz * chunk_header->chunk_sz; + switch (chunk_header->chunk_type) + { + case CHUNK_TYPE_RAW: + if(chunk_header->total_sz != (sparse_header->chunk_hdr_sz + + chunk_data_sz)) + { + fastboot_fail("Bogus chunk size for chunk type Raw"); + return; + } + + if(mmc_write(ptn + ((uint64_t)total_blocks*sparse_header->blk_sz), + chunk_data_sz, + (unsigned int*)data)) + { + fastboot_fail("flash write failure"); + return; + } + total_blocks += chunk_header->chunk_sz; + data += chunk_data_sz; + break; + + case CHUNK_TYPE_FILL: + if(chunk_header->total_sz != (sparse_header->chunk_hdr_sz + + sizeof(uint32_t))) + { + fastboot_fail("Bogus chunk size for chunk type FILL"); + return; + } + + fill_buf = (uint32_t *)memalign(CACHE_LINE, ROUNDUP(sparse_header->blk_sz, CACHE_LINE)); + if (!fill_buf) + { + fastboot_fail("Malloc failed for: CHUNK_TYPE_FILL"); + return; + } + + fill_val = *(uint32_t *)data; + data = (char *) data + sizeof(uint32_t); + chunk_blk_cnt = chunk_data_sz / sparse_header->blk_sz; + + for (i = 0; i < (sparse_header->blk_sz / sizeof(fill_val)); i++) + { + fill_buf[i] = fill_val; + } + + for (i = 0; i < chunk_blk_cnt; i++) + { + if(mmc_write(ptn + ((uint64_t)total_blocks*sparse_header->blk_sz), + sparse_header->blk_sz, + fill_buf)) + { + fastboot_fail("flash write failure"); + free(fill_buf); + return; + } + + total_blocks++; + } + + free(fill_buf); + break; + + case CHUNK_TYPE_DONT_CARE: + total_blocks += chunk_header->chunk_sz; + break; + + case CHUNK_TYPE_CRC: + if(chunk_header->total_sz != sparse_header->chunk_hdr_sz) + { + fastboot_fail("Bogus chunk size for chunk type Dont Care"); + return; + } + total_blocks += chunk_header->chunk_sz; + data += chunk_data_sz; + break; + + default: + dprintf(CRITICAL, "Unkown chunk type: %x\n",chunk_header->chunk_type); + fastboot_fail("Unknown chunk type"); + return; + } + } + + dprintf(INFO, "Wrote %d blocks, expected to write %d blocks\n", + total_blocks, sparse_header->total_blks); + + if(total_blocks != sparse_header->total_blks) + { + fastboot_fail("sparse image write failure"); + } + + fastboot_okay(""); + return; +} + +void cmd_flash_mmc(const char *arg, void *data, unsigned sz) +{ + sparse_header_t *sparse_header; + /* 8 Byte Magic + 2048 Byte xml + Encrypted Data */ + unsigned int *magic_number = (unsigned int *) data; + +#ifdef SSD_ENABLE + int ret=0; + uint32 major_version=0; + uint32 minor_version=0; + + ret = scm_svc_version(&major_version,&minor_version); + if(!ret) + { + if(major_version >= 2) + { + if( !strcmp(arg, "ssd") || !strcmp(arg, "tqs") ) + { + ret = encrypt_scm((uint32 **) &data, &sz); + if (ret != 0) { + dprintf(CRITICAL, "ERROR: Encryption Failure\n"); + return; + } + + /* Protect only for SSD */ + if (!strcmp(arg, "ssd")) { + ret = scm_protect_keystore((uint32 *) data, sz); + if (ret != 0) { + dprintf(CRITICAL, "ERROR: scm_protect_keystore Failed\n"); + return; + } + } + } + else + { + ret = decrypt_scm_v2((uint32 **) &data, &sz); + if(ret != 0) + { + dprintf(CRITICAL,"ERROR: Decryption Failure\n"); + return; + } + } + } + else + { + if (magic_number[0] == DECRYPT_MAGIC_0 && + magic_number[1] == DECRYPT_MAGIC_1) + { + ret = decrypt_scm((uint32 **) &data, &sz); + if (ret != 0) { + dprintf(CRITICAL, "ERROR: Invalid secure image\n"); + return; + } + } + else if (magic_number[0] == ENCRYPT_MAGIC_0 && + magic_number[1] == ENCRYPT_MAGIC_1) + { + ret = encrypt_scm((uint32 **) &data, &sz); + if (ret != 0) { + dprintf(CRITICAL, "ERROR: Encryption Failure\n"); + return; + } + } + } + } + else + { + dprintf(CRITICAL,"INVALID SVC Version\n"); + return; + } +#endif /* SSD_ENABLE */ + + sparse_header = (sparse_header_t *) data; + if (sparse_header->magic != SPARSE_HEADER_MAGIC) + cmd_flash_mmc_img(arg, data, sz); + else + cmd_flash_mmc_sparse_img(arg, data, sz); + return; +} + +void cmd_flash(const char *arg, void *data, unsigned sz) +{ + struct ptentry *ptn; + struct ptable *ptable; + unsigned extra = 0; + + ptable = flash_get_ptable(); + if (ptable == NULL) { + fastboot_fail("partition table doesn't exist"); + return; + } + + ptn = ptable_find(ptable, arg); + if (ptn == NULL) { + fastboot_fail("unknown partition name"); + return; + } + + if (!strcmp(ptn->name, "boot") || !strcmp(ptn->name, "recovery")) { + if (memcmp((void *)data, BOOT_MAGIC, BOOT_MAGIC_SIZE)) { + fastboot_fail("image is not a boot image"); + return; + } + } + + if (!strcmp(ptn->name, "system") + || !strcmp(ptn->name, "userdata") + || !strcmp(ptn->name, "persist") + || !strcmp(ptn->name, "recoveryfs") + || !strcmp(ptn->name, "modem")) + { + if (memcmp((void *)data, UBI_MAGIC, UBI_MAGIC_SIZE)) + extra = 1; + else + extra = 0; + } + else + sz = ROUND_TO_PAGE(sz, page_mask); + + dprintf(INFO, "writing %d bytes to '%s'\n", sz, ptn->name); + if (flash_write(ptn, extra, data, sz)) { + fastboot_fail("flash write failure"); + return; + } + dprintf(INFO, "partition '%s' updated\n", ptn->name); + fastboot_okay(""); +} + +void cmd_continue(const char *arg, void *data, unsigned sz) +{ + fastboot_okay(""); + fastboot_stop(); + if (target_is_emmc_boot()) + { + boot_linux_from_mmc(); + } + else + { + boot_linux_from_flash(); + } +} + +void cmd_reboot(const char *arg, void *data, unsigned sz) +{ + dprintf(INFO, "rebooting the device\n"); + fastboot_okay(""); + reboot_device(0); +} + +void cmd_reboot_bootloader(const char *arg, void *data, unsigned sz) +{ + dprintf(INFO, "rebooting the device\n"); + fastboot_okay(""); + reboot_device(FASTBOOT_MODE); +} + +void cmd_oem_enable_charger_screen(const char *arg, void *data, unsigned size) +{ + dprintf(INFO, "Enabling charger screen check\n"); + device.charger_screen_enabled = 1; + write_device_info(&device); + fastboot_okay(""); +} + +void cmd_oem_disable_charger_screen(const char *arg, void *data, unsigned size) +{ + dprintf(INFO, "Disabling charger screen check\n"); + device.charger_screen_enabled = 0; + write_device_info(&device); + fastboot_okay(""); +} + +void cmd_oem_select_display_panel(const char *arg, void *data, unsigned size) +{ + dprintf(INFO, "Selecting display panel %s\n", arg); + if (arg) + strlcpy(device.display_panel, arg, + sizeof(device.display_panel)); + write_device_info(&device); + fastboot_okay(""); +} + +void cmd_oem_unlock(const char *arg, void *data, unsigned sz) +{ + if(!device.is_unlocked) + { + device.is_unlocked = 1; + write_device_info(&device); + } + fastboot_okay(""); +} + +void cmd_oem_devinfo(const char *arg, void *data, unsigned sz) +{ + char response[128]; + snprintf(response, sizeof(response), "\tDevice tampered: %s", (device.is_tampered ? "true" : "false")); + fastboot_info(response); + snprintf(response, sizeof(response), "\tDevice unlocked: %s", (device.is_unlocked ? "true" : "false")); + fastboot_info(response); + snprintf(response, sizeof(response), "\tCharger screen enabled: %s", (device.charger_screen_enabled ? "true" : "false")); + fastboot_info(response); + snprintf(response, sizeof(response), "\tDisplay panel: %s", (device.display_panel)); + fastboot_info(response); + fastboot_okay(""); +} + +void cmd_preflash(const char *arg, void *data, unsigned sz) +{ + fastboot_okay(""); +} + +static struct fbimage logo_header = {0}; +struct fbimage* splash_screen_flash(); + +int splash_screen_check_header(struct fbimage *logo) +{ + if (memcmp(logo->header.magic, LOGO_IMG_MAGIC, 8)) + return -1; + if (logo->header.width == 0 || logo->header.height == 0) + return -1; + return 0; +} + +struct fbimage* splash_screen_flash() +{ + struct ptentry *ptn; + struct ptable *ptable; + struct fbcon_config *fb_display = NULL; + struct fbimage *logo = &logo_header; + + + ptable = flash_get_ptable(); + if (ptable == NULL) { + dprintf(CRITICAL, "ERROR: Partition table not found\n"); + return NULL; + } + ptn = ptable_find(ptable, "splash"); + if (ptn == NULL) { + dprintf(CRITICAL, "ERROR: splash Partition not found\n"); + return NULL; + } + + if (flash_read(ptn, 0,(unsigned int *) logo, sizeof(logo->header))) { + dprintf(CRITICAL, "ERROR: Cannot read boot image header\n"); + return NULL; + } + + if (splash_screen_check_header(logo)) { + dprintf(CRITICAL, "ERROR: Boot image header invalid\n"); + return NULL; + } + + fb_display = fbcon_display(); + if (fb_display) { + uint8_t *base = (uint8_t *) fb_display->base; + if (logo->header.width != fb_display->width || logo->header.height != fb_display->height) { + base += LOGO_IMG_OFFSET; + } + + if (flash_read(ptn + sizeof(logo->header), 0, + base, + ((((logo->header.width * logo->header.height * fb_display->bpp/8) + 511) >> 9) << 9))) { + fbcon_clear(); + dprintf(CRITICAL, "ERROR: Cannot read splash image\n"); + return NULL; + } + logo->image = base; + } + + return logo; +} + +struct fbimage* splash_screen_mmc() +{ + int index = INVALID_PTN; + unsigned long long ptn = 0; + struct fbcon_config *fb_display = NULL; + struct fbimage *logo = &logo_header; + + index = partition_get_index("splash"); + if (index == 0) { + dprintf(CRITICAL, "ERROR: splash Partition table not found\n"); + return NULL; + } + + ptn = partition_get_offset(index); + if (ptn == 0) { + dprintf(CRITICAL, "ERROR: splash Partition invalid\n"); + return NULL; + } + + if (mmc_read(ptn, (unsigned int *) logo, sizeof(logo->header))) { + dprintf(CRITICAL, "ERROR: Cannot read splash image header\n"); + return NULL; + } + + if (splash_screen_check_header(logo)) { + dprintf(CRITICAL, "ERROR: Splash image header invalid\n"); + return NULL; + } + + fb_display = fbcon_display(); + if (fb_display) { + uint8_t *base = (uint8_t *) fb_display->base; + if (logo->header.width != fb_display->width || logo->header.height != fb_display->height) + base += LOGO_IMG_OFFSET; + + if (mmc_read(ptn + sizeof(logo->header), + base, + ((((logo->header.width * logo->header.height * fb_display->bpp/8) + 511) >> 9) << 9))) { + fbcon_clear(); + dprintf(CRITICAL, "ERROR: Cannot read splash image\n"); + return NULL; + } + + logo->image = base; + } + + return logo; +} + + +struct fbimage* fetch_image_from_partition() +{ + if (target_is_emmc_boot()) { + return splash_screen_mmc(); + } else { + return splash_screen_flash(); + } +} + +/* Get the size from partiton name */ +static void get_partition_size(const char *arg, char *response) +{ + uint64_t ptn = 0; + uint64_t size; + int index = INVALID_PTN; + + index = partition_get_index(arg); + + if (index == INVALID_PTN) + { + dprintf(CRITICAL, "Invalid partition index\n"); + return; + } + + ptn = partition_get_offset(index); + + if(!ptn) + { + dprintf(CRITICAL, "Invalid partition name %s\n", arg); + return; + } + + size = partition_get_size(index); + + snprintf(response, MAX_RSP_SIZE, "\t 0x%llx", size); + return; +} + +/* + * Publish the partition type & size info + * fastboot getvar will publish the required information. + * fastboot getvar partition_size:<partition_name>: partition size in hex + * fastboot getvar partition_type:<partition_name>: partition type (ext/fat) + */ +static void publish_getvar_partition_info(struct getvar_partition_info *info, uint8_t num_parts) +{ + uint8_t i; + + for (i = 0; i < num_parts; i++) { + get_partition_size(info[i].part_name, info[i].size_response); + + if (strlcat(info[i].getvar_size, info[i].part_name, MAX_GET_VAR_NAME_SIZE) >= MAX_GET_VAR_NAME_SIZE) + { + dprintf(CRITICAL, "partition size name truncated\n"); + return; + } + if (strlcat(info[i].getvar_type, info[i].part_name, MAX_GET_VAR_NAME_SIZE) >= MAX_GET_VAR_NAME_SIZE) + { + dprintf(CRITICAL, "partition type name truncated\n"); + return; + } + + /* publish partition size & type info */ + fastboot_publish((const char *) info[i].getvar_size, (const char *) info[i].size_response); + fastboot_publish((const char *) info[i].getvar_type, (const char *) info[i].type_response); + } +} + +/* register commands and variables for fastboot */ +void aboot_fastboot_register_commands(void) +{ + if (target_is_emmc_boot()) + { + fastboot_register("flash:", cmd_flash_mmc); + fastboot_register("erase:", cmd_erase_mmc); + } + else + { + fastboot_register("flash:", cmd_flash); + fastboot_register("erase:", cmd_erase); + } + + fastboot_register("boot", cmd_boot); + fastboot_register("continue", cmd_continue); + fastboot_register("reboot", cmd_reboot); + fastboot_register("reboot-bootloader", cmd_reboot_bootloader); + fastboot_register("oem unlock", cmd_oem_unlock); + fastboot_register("oem device-info", cmd_oem_devinfo); + fastboot_register("preflash", cmd_preflash); + fastboot_register("oem enable-charger-screen", + cmd_oem_enable_charger_screen); + fastboot_register("oem disable-charger-screen", + cmd_oem_disable_charger_screen); + fastboot_register("oem select-display-panel", + cmd_oem_select_display_panel); + /* publish variables and their values */ + fastboot_publish("product", TARGET(BOARD)); + fastboot_publish("kernel", "lk"); + fastboot_publish("serialno", sn_buf); + + /* + * partition info is supported only for emmc partitions + * Calling this for NAND prints some error messages which + * is harmless but misleading. Avoid calling this for NAND + * devices. + */ + if (target_is_emmc_boot()) + publish_getvar_partition_info(part_info, ARRAY_SIZE(part_info)); + + /* Max download size supported */ + snprintf(max_download_size, MAX_RSP_SIZE, "\t0x%x", + target_get_max_flash_size()); + fastboot_publish("max-download-size", (const char *) max_download_size); + /* Is the charger screen check enabled */ + snprintf(charger_screen_enabled, MAX_RSP_SIZE, "%d", + device.charger_screen_enabled); + fastboot_publish("charger-screen-enabled", + (const char *) charger_screen_enabled); + snprintf(panel_display_mode, MAX_RSP_SIZE, "%s", + device.display_panel); + fastboot_publish("display-panel", + (const char *) panel_display_mode); +} + +void aboot_init(const struct app_descriptor *app) +{ + unsigned reboot_mode = 0; + bool boot_into_fastboot = false; + + /* Setup page size information for nv storage */ + if (target_is_emmc_boot()) + { + page_size = mmc_page_size(); + page_mask = page_size - 1; + } + else + { + page_size = flash_page_size(); + page_mask = page_size - 1; + } + + ASSERT((MEMBASE + MEMSIZE) > MEMBASE); + + read_device_info(&device); + + /* Display splash screen if enabled */ +#if DISPLAY_SPLASH_SCREEN + dprintf(SPEW, "Display Init: Start\n"); + target_display_init(device.display_panel); + dprintf(SPEW, "Display Init: Done\n"); +#endif + + + target_serialno((unsigned char *) sn_buf); + dprintf(SPEW,"serial number: %s\n",sn_buf); + + memset(display_panel_buf, '\0', MAX_PANEL_BUF_SIZE); + + /* Check if we should do something other than booting up */ + if (keys_get_state(KEY_VOLUMEUP) && keys_get_state(KEY_VOLUMEDOWN)) + { + dprintf(ALWAYS,"dload mode key sequence detected\n"); + if (set_download_mode(EMERGENCY_DLOAD)) + { + dprintf(CRITICAL,"dload mode not supported by target\n"); + } + else + { + reboot_device(DLOAD); + dprintf(CRITICAL,"Failed to reboot into dload mode\n"); + } + boot_into_fastboot = true; + } + if (!boot_into_fastboot) + { + if (keys_get_state(KEY_HOME) || keys_get_state(KEY_VOLUMEUP)) + boot_into_recovery = 1; + if (!boot_into_recovery && + (keys_get_state(KEY_BACK) || keys_get_state(KEY_VOLUMEDOWN))) + boot_into_fastboot = true; + } + #if NO_KEYPAD_DRIVER + if (fastboot_trigger()) + boot_into_fastboot = true; + #endif + + reboot_mode = check_reboot_mode(); + if (reboot_mode == RECOVERY_MODE) { + boot_into_recovery = 1; + } else if(reboot_mode == FASTBOOT_MODE) { + boot_into_fastboot = true; + } + + if (!boot_into_fastboot) + { + if (target_is_emmc_boot()) + { + if(emmc_recovery_init()) + dprintf(ALWAYS,"error in emmc_recovery_init\n"); + if(target_use_signed_kernel()) + { + if((device.is_unlocked) || (device.is_tampered)) + { + #ifdef TZ_TAMPER_FUSE + set_tamper_fuse_cmd(); + #endif + #if USE_PCOM_SECBOOT + set_tamper_flag(device.is_tampered); + #endif + } + } + boot_linux_from_mmc(); + } + else + { + recovery_init(); + #if USE_PCOM_SECBOOT + if((device.is_unlocked) || (device.is_tampered)) + set_tamper_flag(device.is_tampered); + #endif + boot_linux_from_flash(); + } + dprintf(CRITICAL, "ERROR: Could not do normal boot. Reverting " + "to fastboot mode.\n"); + } + + /* We are here means regular boot did not happen. Start fastboot. */ + + /* register aboot specific fastboot commands */ + aboot_fastboot_register_commands(); + + /* dump partition table for debug info */ + partition_dump(); + + /* initialize and start fastboot */ + fastboot_init(target_get_scratch_address(), target_get_max_flash_size()); +} + +uint32_t get_page_size() +{ + return page_size; +} + +/* + * Calculated and save hash (SHA256) for non-signed boot image. + * + * Hash the same data that is checked on the signed boot image. + * Kernel and Ramdisk are already read to memory buffers. + * Need to read the entire device-tree from mmc + * since non-signed image only read the DT tags of the relevant platform. + * + * @param kernel_addr - kernel bufer + * @param kernel_actual - kernel size in bytes + * @param ramdisk_addr - ramdisk buffer + * @param ramdisk_actual - ramdisk size + * @param ptn - partition + * @param dt_offset - device tree offset on mmc partition + * @param dt_size + * + * @return int - 0 on success, negative value on failure. + */ +int aboot_save_boot_hash_mmc(void *kernel_addr, unsigned kernel_actual, + void *ramdisk_addr, unsigned ramdisk_actual, + unsigned long long ptn, + unsigned dt_offset, unsigned dt_size) +{ + SHA256_CTX sha256_ctx; + char digest[32]={0}; + char *buf = (char *)target_get_scratch_address(); + unsigned dt_actual = ROUND_TO_PAGE(dt_size, page_mask); + unsigned imagesize_actual = page_size + kernel_actual + ramdisk_actual + dt_actual; + + SHA256_Init(&sha256_ctx); + + /* Read Boot Header */ + if (mmc_read(ptn, buf, page_size)) + { + dprintf(CRITICAL, "ERROR: mmc_read() fail.\n"); + return -1; + } + /* Read entire Device Tree */ + if (mmc_read(ptn + dt_offset, buf+page_size, dt_actual)) + { + dprintf(CRITICAL, "ERROR: mmc_read() fail.\n"); + return -1; + } + SHA256_Update(&sha256_ctx, buf, page_size); // Boot Header + SHA256_Update(&sha256_ctx, kernel_addr, kernel_actual); + SHA256_Update(&sha256_ctx, ramdisk_addr, ramdisk_actual); + SHA256_Update(&sha256_ctx, buf+page_size, dt_actual); // Device Tree + + SHA256_Final(digest, &sha256_ctx); + + save_kernel_hash_cmd(digest); + dprintf(INFO, "aboot_save_boot_hash_mmc: imagesize_actual size %d bytes.\n", (int) imagesize_actual); + + return 0; +} + +APP_START(aboot) + .init = aboot_init, +APP_END |