1 /* 2 * (C) Copyright 2015 Google, Inc 3 * Written by Simon Glass <sjg@chromium.org> 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 * 7 * Helper functions for Rockchip images 8 */ 9 10 #include "imagetool.h" 11 #include <image.h> 12 #include <rc4.h> 13 #include "mkimage.h" 14 #include "rkcommon.h" 15 16 enum { 17 RK_SIGNATURE = 0x0ff0aa55, 18 }; 19 20 /** 21 * struct header0_info - header block for boot ROM 22 * 23 * This is stored at SD card block 64 (where each block is 512 bytes, or at 24 * the start of SPI flash. It is encoded with RC4. 25 * 26 * @signature: Signature (must be RKSD_SIGNATURE) 27 * @disable_rc4: 0 to use rc4 for boot image, 1 to use plain binary 28 * @init_offset: Offset in blocks of the SPL code from this header 29 * block. E.g. 4 means 2KB after the start of this header. 30 * Other fields are not used by U-Boot 31 */ 32 struct header0_info { 33 uint32_t signature; 34 uint8_t reserved[4]; 35 uint32_t disable_rc4; 36 uint16_t init_offset; 37 uint8_t reserved1[492]; 38 uint16_t init_size; 39 uint16_t init_boot_size; 40 uint8_t reserved2[2]; 41 }; 42 43 /** 44 * struct header1_info 45 */ 46 struct header1_info { 47 uint32_t magic; 48 }; 49 50 /** 51 * struct spl_info - spl info for each chip 52 * 53 * @imagename: Image name(passed by "mkimage -n") 54 * @spl_hdr: Boot ROM requires a 4-bytes spl header 55 * @spl_size: Spl size(include extra 4-bytes spl header) 56 * @spl_rc4: RC4 encode the SPL binary (same key as header) 57 * @spl_boot0: A new-style (ARM_SOC_BOOT0_HOOK) image that should 58 * have the boot magic (e.g. 'RK33') written to its first 59 * word. 60 */ 61 62 struct spl_info { 63 const char *imagename; 64 const char *spl_hdr; 65 const uint32_t spl_size; 66 const bool spl_rc4; 67 const bool spl_boot0; 68 }; 69 70 static struct spl_info spl_infos[] = { 71 { "rk3036", "RK30", 0x1000, false, false }, 72 { "rk3188", "RK31", 0x8000 - 0x800, true, false }, 73 { "rk3288", "RK32", 0x8000, false, false }, 74 { "rk3399", "RK33", 0x20000, false, true }, 75 }; 76 77 static unsigned char rc4_key[16] = { 78 124, 78, 3, 4, 85, 5, 9, 7, 79 45, 44, 123, 56, 23, 13, 23, 17 80 }; 81 82 static struct spl_info *rkcommon_get_spl_info(char *imagename) 83 { 84 int i; 85 86 for (i = 0; i < ARRAY_SIZE(spl_infos); i++) 87 if (!strncmp(imagename, spl_infos[i].imagename, 6)) 88 return spl_infos + i; 89 90 return NULL; 91 } 92 93 int rkcommon_check_params(struct image_tool_params *params) 94 { 95 int i; 96 97 if (rkcommon_get_spl_info(params->imagename) != NULL) 98 return 0; 99 100 fprintf(stderr, "ERROR: imagename (%s) is not supported!\n", 101 strlen(params->imagename) > 0 ? params->imagename : "NULL"); 102 103 fprintf(stderr, "Available imagename:"); 104 for (i = 0; i < ARRAY_SIZE(spl_infos); i++) 105 fprintf(stderr, "\t%s", spl_infos[i].imagename); 106 fprintf(stderr, "\n"); 107 108 return -1; 109 } 110 111 const char *rkcommon_get_spl_hdr(struct image_tool_params *params) 112 { 113 struct spl_info *info = rkcommon_get_spl_info(params->imagename); 114 115 /* 116 * info would not be NULL, because of we checked params before. 117 */ 118 return info->spl_hdr; 119 } 120 121 122 int rkcommon_get_spl_size(struct image_tool_params *params) 123 { 124 struct spl_info *info = rkcommon_get_spl_info(params->imagename); 125 126 /* 127 * info would not be NULL, because of we checked params before. 128 */ 129 return info->spl_size; 130 } 131 132 bool rkcommon_need_rc4_spl(struct image_tool_params *params) 133 { 134 struct spl_info *info = rkcommon_get_spl_info(params->imagename); 135 136 /* 137 * info would not be NULL, because of we checked params before. 138 */ 139 return info->spl_rc4; 140 } 141 142 bool rkcommon_spl_is_boot0(struct image_tool_params *params) 143 { 144 struct spl_info *info = rkcommon_get_spl_info(params->imagename); 145 146 /* 147 * info would not be NULL, because of we checked params before. 148 */ 149 return info->spl_boot0; 150 } 151 152 static void rkcommon_set_header0(void *buf, uint file_size, 153 struct image_tool_params *params) 154 { 155 struct header0_info *hdr = buf; 156 157 memset(buf, '\0', RK_INIT_OFFSET * RK_BLK_SIZE); 158 hdr->signature = RK_SIGNATURE; 159 hdr->disable_rc4 = !rkcommon_need_rc4_spl(params); 160 hdr->init_offset = RK_INIT_OFFSET; 161 162 hdr->init_size = (file_size + RK_BLK_SIZE - 1) / RK_BLK_SIZE; 163 hdr->init_size = (hdr->init_size + 3) & ~3; 164 hdr->init_boot_size = hdr->init_size + RK_MAX_BOOT_SIZE / RK_BLK_SIZE; 165 166 rc4_encode(buf, RK_BLK_SIZE, rc4_key); 167 } 168 169 int rkcommon_set_header(void *buf, uint file_size, 170 struct image_tool_params *params) 171 { 172 struct header1_info *hdr = buf + RK_SPL_HDR_START; 173 174 if (file_size > rkcommon_get_spl_size(params)) 175 return -ENOSPC; 176 177 rkcommon_set_header0(buf, file_size, params); 178 179 /* Set up the SPL name and add the AArch64 'nop' padding, if needed */ 180 memcpy(&hdr->magic, rkcommon_get_spl_hdr(params), RK_SPL_HDR_SIZE); 181 182 if (rkcommon_need_rc4_spl(params)) 183 rkcommon_rc4_encode_spl(buf, RK_SPL_HDR_START, 184 params->file_size - RK_SPL_HDR_START); 185 186 return 0; 187 } 188 189 void rkcommon_rc4_encode_spl(void *buf, unsigned int offset, unsigned int size) 190 { 191 unsigned int remaining = size; 192 193 while (remaining > 0) { 194 int step = (remaining > RK_BLK_SIZE) ? RK_BLK_SIZE : remaining; 195 196 rc4_encode(buf + offset, step, rc4_key); 197 offset += RK_BLK_SIZE; 198 remaining -= step; 199 } 200 } 201 202 void rkcommon_vrec_header(struct image_tool_params *params, 203 struct image_type_params *tparams) 204 { 205 /* 206 * The SPL image looks as follows: 207 * 208 * 0x0 header0 (see rkcommon.c) 209 * 0x800 spl_name ('RK30', ..., 'RK33') 210 * 0x804 first instruction to be executed 211 * (image start for AArch32, 'nop' for AArch64)) 212 * 0x808 second instruction to be executed 213 * (image start for AArch64) 214 * 215 * For AArch64 (ARMv8) payloads, we receive an input file that 216 * needs to start on an 8-byte boundary (natural alignment), so 217 * we need to put a NOP at 0x804. 218 * 219 * Depending on this, the header is either 0x804 or 0x808 bytes 220 * in length. 221 */ 222 if (rkcommon_spl_is_boot0(params)) 223 tparams->header_size = RK_SPL_HDR_START; 224 else 225 tparams->header_size = RK_SPL_HDR_START + 4; 226 227 /* Allocate, clear and install the header */ 228 tparams->hdr = malloc(tparams->header_size); 229 memset(tparams->hdr, 0, tparams->header_size); 230 tparams->header_size = tparams->header_size; 231 } 232