1 /* 2 * Copyright (c) 2011 Sebastian Andrzej Siewior <bigeasy@linutronix.de> 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 #include <common.h> 8 #include <image.h> 9 #include <android_image.h> 10 #include <malloc.h> 11 #include <errno.h> 12 13 #define ANDROID_IMAGE_DEFAULT_KERNEL_ADDR 0x10008000 14 15 static char andr_tmp_str[ANDR_BOOT_ARGS_SIZE + 1]; 16 17 static ulong android_image_get_kernel_addr(const struct andr_img_hdr *hdr) 18 { 19 /* 20 * All the Android tools that generate a boot.img use this 21 * address as the default. 22 * 23 * Even though it doesn't really make a lot of sense, and it 24 * might be valid on some platforms, we treat that adress as 25 * the default value for this field, and try to execute the 26 * kernel in place in such a case. 27 * 28 * Otherwise, we will return the actual value set by the user. 29 */ 30 if (hdr->kernel_addr == ANDROID_IMAGE_DEFAULT_KERNEL_ADDR) 31 return (ulong)hdr + hdr->page_size; 32 33 return hdr->kernel_addr; 34 } 35 36 /** 37 * android_image_get_kernel() - processes kernel part of Android boot images 38 * @hdr: Pointer to image header, which is at the start 39 * of the image. 40 * @verify: Checksum verification flag. Currently unimplemented. 41 * @os_data: Pointer to a ulong variable, will hold os data start 42 * address. 43 * @os_len: Pointer to a ulong variable, will hold os data length. 44 * 45 * This function returns the os image's start address and length. Also, 46 * it appends the kernel command line to the bootargs env variable. 47 * 48 * Return: Zero, os start address and length on success, 49 * otherwise on failure. 50 */ 51 int android_image_get_kernel(const struct andr_img_hdr *hdr, int verify, 52 ulong *os_data, ulong *os_len) 53 { 54 u32 kernel_addr = android_image_get_kernel_addr(hdr); 55 56 /* 57 * Not all Android tools use the id field for signing the image with 58 * sha1 (or anything) so we don't check it. It is not obvious that the 59 * string is null terminated so we take care of this. 60 */ 61 strncpy(andr_tmp_str, hdr->name, ANDR_BOOT_NAME_SIZE); 62 andr_tmp_str[ANDR_BOOT_NAME_SIZE] = '\0'; 63 if (strlen(andr_tmp_str)) 64 printf("Android's image name: %s\n", andr_tmp_str); 65 66 printf("Kernel load addr 0x%08x size %u KiB\n", 67 kernel_addr, DIV_ROUND_UP(hdr->kernel_size, 1024)); 68 69 int len = 0; 70 if (*hdr->cmdline) { 71 printf("Kernel command line: %s\n", hdr->cmdline); 72 len += strlen(hdr->cmdline); 73 } 74 75 char *bootargs = env_get("bootargs"); 76 if (bootargs) 77 len += strlen(bootargs); 78 79 char *newbootargs = malloc(len + 2); 80 if (!newbootargs) { 81 puts("Error: malloc in android_image_get_kernel failed!\n"); 82 return -ENOMEM; 83 } 84 *newbootargs = '\0'; 85 86 if (bootargs) { 87 strcpy(newbootargs, bootargs); 88 strcat(newbootargs, " "); 89 } 90 if (*hdr->cmdline) 91 strcat(newbootargs, hdr->cmdline); 92 93 env_set("bootargs", newbootargs); 94 95 if (os_data) { 96 *os_data = (ulong)hdr; 97 *os_data += hdr->page_size; 98 } 99 if (os_len) 100 *os_len = hdr->kernel_size; 101 return 0; 102 } 103 104 int android_image_check_header(const struct andr_img_hdr *hdr) 105 { 106 return memcmp(ANDR_BOOT_MAGIC, hdr->magic, ANDR_BOOT_MAGIC_SIZE); 107 } 108 109 ulong android_image_get_end(const struct andr_img_hdr *hdr) 110 { 111 ulong end; 112 /* 113 * The header takes a full page, the remaining components are aligned 114 * on page boundary 115 */ 116 end = (ulong)hdr; 117 end += hdr->page_size; 118 end += ALIGN(hdr->kernel_size, hdr->page_size); 119 end += ALIGN(hdr->ramdisk_size, hdr->page_size); 120 end += ALIGN(hdr->second_size, hdr->page_size); 121 122 return end; 123 } 124 125 ulong android_image_get_kload(const struct andr_img_hdr *hdr) 126 { 127 return android_image_get_kernel_addr(hdr); 128 } 129 130 int android_image_get_ramdisk(const struct andr_img_hdr *hdr, 131 ulong *rd_data, ulong *rd_len) 132 { 133 if (!hdr->ramdisk_size) { 134 *rd_data = *rd_len = 0; 135 return -1; 136 } 137 138 printf("RAM disk load addr 0x%08x size %u KiB\n", 139 hdr->ramdisk_addr, DIV_ROUND_UP(hdr->ramdisk_size, 1024)); 140 141 *rd_data = (unsigned long)hdr; 142 *rd_data += hdr->page_size; 143 *rd_data += ALIGN(hdr->kernel_size, hdr->page_size); 144 145 *rd_len = hdr->ramdisk_size; 146 return 0; 147 } 148 149 int android_image_get_second(const struct andr_img_hdr *hdr, 150 ulong *second_data, ulong *second_len) 151 { 152 if (!hdr->second_size) { 153 *second_data = *second_len = 0; 154 return -1; 155 } 156 157 *second_data = (unsigned long)hdr; 158 *second_data += hdr->page_size; 159 *second_data += ALIGN(hdr->kernel_size, hdr->page_size); 160 *second_data += ALIGN(hdr->ramdisk_size, hdr->page_size); 161 162 printf("second address is 0x%lx\n",*second_data); 163 164 *second_len = hdr->second_size; 165 return 0; 166 } 167 168 #if !defined(CONFIG_SPL_BUILD) 169 /** 170 * android_print_contents - prints out the contents of the Android format image 171 * @hdr: pointer to the Android format image header 172 * 173 * android_print_contents() formats a multi line Android image contents 174 * description. 175 * The routine prints out Android image properties 176 * 177 * returns: 178 * no returned results 179 */ 180 void android_print_contents(const struct andr_img_hdr *hdr) 181 { 182 const char * const p = IMAGE_INDENT_STRING; 183 /* os_version = ver << 11 | lvl */ 184 u32 os_ver = hdr->os_version >> 11; 185 u32 os_lvl = hdr->os_version & ((1U << 11) - 1); 186 187 printf("%skernel size: %x\n", p, hdr->kernel_size); 188 printf("%skernel address: %x\n", p, hdr->kernel_addr); 189 printf("%sramdisk size: %x\n", p, hdr->ramdisk_size); 190 printf("%sramdisk addrress: %x\n", p, hdr->ramdisk_addr); 191 printf("%ssecond size: %x\n", p, hdr->second_size); 192 printf("%ssecond address: %x\n", p, hdr->second_addr); 193 printf("%stags address: %x\n", p, hdr->tags_addr); 194 printf("%spage size: %x\n", p, hdr->page_size); 195 /* ver = A << 14 | B << 7 | C (7 bits for each of A, B, C) 196 * lvl = ((Y - 2000) & 127) << 4 | M (7 bits for Y, 4 bits for M) */ 197 printf("%sos_version: %x (ver: %u.%u.%u, level: %u.%u)\n", 198 p, hdr->os_version, 199 (os_ver >> 7) & 0x7F, (os_ver >> 14) & 0x7F, os_ver & 0x7F, 200 (os_lvl >> 4) + 2000, os_lvl & 0x0F); 201 printf("%sname: %s\n", p, hdr->name); 202 printf("%scmdline: %s\n", p, hdr->cmdline); 203 } 204 #endif 205