| /* | |
| * Copyright (c) 2011 Sebastian Andrzej Siewior <bigeasy@linutronix.de> | |
| * | |
| * SPDX-License-Identifier: GPL-2.0+ | |
| */ | |
| #include <common.h> | |
| #include <image.h> | |
| #include <android_image.h> | |
| #include <malloc.h> | |
| #include <errno.h> | |
| static const unsigned char lzop_magic[] = { | |
| 0x89, 0x4c, 0x5a, 0x4f, 0x00, 0x0d, 0x0a, 0x1a, 0x0a | |
| }; | |
| static const unsigned char gzip_magic[] = { | |
| 0x1f, 0x8b | |
| }; | |
| static char andr_tmp_str[ANDR_BOOT_ARGS_SIZE + 1]; | |
| #ifdef CONFIG_OF_LIBFDT_OVERLAY | |
| static int save_dtbo_idx(const char *cmdline) | |
| { | |
| char *dtbo_chosen_idx_start = NULL; | |
| char *dtbo_chosen_idx_end = NULL; | |
| char *dtbo_idx = NULL; | |
| if (!getenv("androidboot.dtbo_idx")) { | |
| if (!cmdline) | |
| return -1; | |
| dtbo_chosen_idx_start = strstr(cmdline, "androidboot.dtbo_idx"); | |
| if (!dtbo_chosen_idx_start) { | |
| printf("No androidboot.dtbo_idx configured"); | |
| return -1; | |
| } | |
| dtbo_chosen_idx_end = strchr(dtbo_chosen_idx_start, ' '); | |
| if (dtbo_chosen_idx_end) { | |
| dtbo_idx = malloc(dtbo_chosen_idx_end - | |
| dtbo_chosen_idx_start + 1); | |
| if (!dtbo_idx) { | |
| printf("dtbo out of memory\n"); | |
| return -1; | |
| } | |
| memset(dtbo_idx, 0x00, | |
| dtbo_chosen_idx_end - dtbo_chosen_idx_start + 1); | |
| strncpy(dtbo_idx, dtbo_chosen_idx_start, | |
| dtbo_chosen_idx_end - dtbo_chosen_idx_start); | |
| } else | |
| strncpy(dtbo_idx, dtbo_chosen_idx_start, | |
| strlen(dtbo_chosen_idx_start)); | |
| setenv("androidboot.dtbo_idx", | |
| dtbo_idx + strlen("androidboot.dtbo_idx=")); | |
| } | |
| free(dtbo_idx); | |
| return 0; | |
| } | |
| #endif | |
| /** | |
| * android_image_get_kernel() - processes kernel part of Android boot images | |
| * @hdr: Pointer to image header, which is at the start | |
| * of the image. | |
| * @verify: Checksum verification flag. Currently unimplemented. | |
| * @os_data: Pointer to a ulong variable, will hold os data start | |
| * address. | |
| * @os_len: Pointer to a ulong variable, will hold os data length. | |
| * | |
| * This function returns the os image's start address and length. Also, | |
| * it appends the kernel command line to the bootargs env variable. | |
| * | |
| * Return: Zero, os start address and length on success, | |
| * otherwise on failure. | |
| */ | |
| int android_image_get_kernel(const struct andr_img_hdr *hdr, int verify, | |
| ulong *os_data, ulong *os_len) | |
| { | |
| /* | |
| * Not all Android tools use the id field for signing the image with | |
| * sha1 (or anything) so we don't check it. It is not obvious that the | |
| * string is null terminated so we take care of this. | |
| */ | |
| ulong end; | |
| strncpy(andr_tmp_str, hdr->name, ANDR_BOOT_NAME_SIZE); | |
| andr_tmp_str[ANDR_BOOT_NAME_SIZE] = '\0'; | |
| if (strlen(andr_tmp_str)) | |
| printf("Android's image name: %s\n", andr_tmp_str); | |
| debug("Kernel load addr 0x%08x size %u KiB\n", | |
| hdr->kernel_addr, DIV_ROUND_UP(hdr->kernel_size, 1024)); | |
| int len = 0; | |
| if (*hdr->cmdline) { | |
| printf("Kernel command line: %s\n", hdr->cmdline); | |
| len += strlen(hdr->cmdline); | |
| } | |
| #ifdef CONFIG_OF_LIBFDT_OVERLAY | |
| save_dtbo_idx(hdr->cmdline); | |
| #endif | |
| char *bootargs = getenv("bootargs"); | |
| if (bootargs) | |
| len += strlen(bootargs); | |
| char *newbootargs = malloc(len + 2); | |
| if (!newbootargs) { | |
| puts("Error: malloc in android_image_get_kernel failed!\n"); | |
| return -ENOMEM; | |
| } | |
| *newbootargs = '\0'; | |
| if (bootargs) { | |
| strcpy(newbootargs, bootargs); | |
| strcat(newbootargs, " "); | |
| } | |
| if (*hdr->cmdline) | |
| strcat(newbootargs, hdr->cmdline); | |
| setenv("bootargs", newbootargs); | |
| if (os_data) { | |
| *os_data = (ulong)hdr; | |
| *os_data += hdr->page_size; | |
| } | |
| if (os_len) | |
| *os_len = hdr->kernel_size; | |
| #if defined(CONFIG_ANDROID_IMG) | |
| images.ft_len = (ulong)(hdr->second_size); | |
| end = (ulong)hdr; | |
| end += hdr->page_size; | |
| end += ALIGN(hdr->kernel_size, hdr->page_size); | |
| images.rd_start = end; | |
| end += ALIGN(hdr->ramdisk_size, hdr->page_size); | |
| images.ft_addr = (char *)end; | |
| #endif | |
| return 0; | |
| } | |
| int android_image_check_header(const struct andr_img_hdr *hdr) | |
| { | |
| return memcmp(ANDR_BOOT_MAGIC, hdr->magic, ANDR_BOOT_MAGIC_SIZE); | |
| } | |
| ulong android_image_get_end(const struct andr_img_hdr *hdr) | |
| { | |
| ulong end; | |
| /* | |
| * The header takes a full page, the remaining components are aligned | |
| * on page boundary | |
| */ | |
| end = (ulong)hdr; | |
| end += hdr->page_size; | |
| end += ALIGN(hdr->kernel_size, hdr->page_size); | |
| end += ALIGN(hdr->ramdisk_size, hdr->page_size); | |
| end += ALIGN(hdr->second_size, hdr->page_size); | |
| return end; | |
| } | |
| ulong android_image_get_kload(const struct andr_img_hdr *hdr) | |
| { | |
| return hdr->kernel_addr; | |
| } | |
| int android_image_get_ramdisk(const struct andr_img_hdr *hdr, | |
| ulong *rd_data, ulong *rd_len) | |
| { | |
| if (!hdr->ramdisk_size) | |
| return -1; | |
| debug("RAM disk load addr 0x%08x size %u KiB\n", | |
| hdr->ramdisk_addr, DIV_ROUND_UP(hdr->ramdisk_size, 1024)); | |
| *rd_data = (unsigned long)hdr; | |
| *rd_data += hdr->page_size; | |
| *rd_data += ALIGN(hdr->kernel_size, hdr->page_size); | |
| *rd_len = hdr->ramdisk_size; | |
| return 0; | |
| } | |
| ulong android_image_get_comp(const struct andr_img_hdr *os_hdr) | |
| { | |
| int i; | |
| unsigned char *src = (unsigned char *)os_hdr + os_hdr->page_size; | |
| /* read magic: 9 first bytes */ | |
| for (i = 0; i < ARRAY_SIZE(lzop_magic); i++) { | |
| if (*src++ != lzop_magic[i]) | |
| break; | |
| } | |
| if (i == ARRAY_SIZE(lzop_magic)) | |
| return IH_COMP_LZO; | |
| src = (unsigned char *)os_hdr + os_hdr->page_size; | |
| for (i = 0; i < ARRAY_SIZE(gzip_magic); i++) { | |
| if (*src++ != gzip_magic[i]) | |
| break; | |
| } | |
| if (i == ARRAY_SIZE(gzip_magic)) | |
| return IH_COMP_GZIP; | |
| return IH_COMP_NONE; | |
| } | |
| int android_image_need_move(ulong *img_addr, const struct andr_img_hdr *hdr) | |
| { | |
| ulong kernel_load_addr = android_image_get_kload(hdr); | |
| ulong img_start = *img_addr; | |
| ulong val = 0; | |
| if (kernel_load_addr > img_start) | |
| val = kernel_load_addr - img_start; | |
| else | |
| val = img_start - kernel_load_addr; | |
| if (android_image_get_comp(hdr) == IH_COMP_NONE) | |
| return 0; | |
| if (val < 32*1024*1024) { | |
| ulong total_size = android_image_get_end(hdr)-(ulong)hdr; | |
| void *reloc_addr = malloc(total_size); | |
| if (!reloc_addr) { | |
| puts("Error: malloc in android_image_need_move failed!\n"); | |
| return -ENOMEM; | |
| } | |
| printf("reloc_addr =%lx\n", (ulong)reloc_addr); | |
| memset(reloc_addr, 0, total_size); | |
| memmove(reloc_addr, hdr, total_size); | |
| *img_addr = (ulong)reloc_addr; | |
| printf("copy done\n"); | |
| } | |
| return 0; | |
| } |