blob: 32e4efe423d55e3dc9029042eced877807508762 [file] [log] [blame]
Stefano Babic8edcde52010-01-20 18:19:10 +01001/*
2 * (C) Copyright 2009
3 * Stefano Babic, DENX Software Engineering, sbabic@denx.de.
4 *
5 * (C) Copyright 2008
6 * Marvell Semiconductor <www.marvell.com>
7 * Written-by: Prafulla Wadaskar <prafulla@marvell.com>
8 *
Wolfgang Denk1a459662013-07-08 09:37:19 +02009 * SPDX-License-Identifier: GPL-2.0+
Stefano Babic8edcde52010-01-20 18:19:10 +010010 */
11
Stefano Babic8edcde52010-01-20 18:19:10 +010012#include "mkimage.h"
13#include <image.h>
14#include "imximage.h"
15
Stefano Babic0187c982013-06-27 11:42:38 +020016#define UNDEFINED 0xFFFFFFFF
17
Stefano Babic8edcde52010-01-20 18:19:10 +010018/*
19 * Supported commands for configuration file
20 */
21static table_entry_t imximage_cmds[] = {
Liu Hui-R643438a1edd72011-01-19 09:40:26 +000022 {CMD_BOOT_FROM, "BOOT_FROM", "boot command", },
Marek Vasut6cb83822013-04-25 10:16:02 +000023 {CMD_BOOT_OFFSET, "BOOT_OFFSET", "Boot offset", },
Liu Hui-R643438a1edd72011-01-19 09:40:26 +000024 {CMD_DATA, "DATA", "Reg Write Data", },
Stefano Babic0187c982013-06-27 11:42:38 +020025 {CMD_CSF, "CSF", "Command Sequence File", },
Liu Hui-R643438a1edd72011-01-19 09:40:26 +000026 {CMD_IMAGE_VERSION, "IMAGE_VERSION", "image version", },
27 {-1, "", "", },
Stefano Babic8edcde52010-01-20 18:19:10 +010028};
29
30/*
31 * Supported Boot options for configuration file
32 * this is needed to set the correct flash offset
33 */
Stefano Babic377e3672013-06-26 23:50:06 +020034static table_entry_t imximage_boot_offset[] = {
Stefano Babic8edcde52010-01-20 18:19:10 +010035 {FLASH_OFFSET_ONENAND, "onenand", "OneNAND Flash",},
Dirk Behmebd258642012-01-11 23:28:32 +000036 {FLASH_OFFSET_NAND, "nand", "NAND Flash", },
Dirk Behme19b409c2012-01-11 23:28:31 +000037 {FLASH_OFFSET_NOR, "nor", "NOR Flash", },
38 {FLASH_OFFSET_SATA, "sata", "SATA Disk", },
Dirk Behmebd258642012-01-11 23:28:32 +000039 {FLASH_OFFSET_SD, "sd", "SD Card", },
40 {FLASH_OFFSET_SPI, "spi", "SPI Flash", },
Stefano Babic8edcde52010-01-20 18:19:10 +010041 {-1, "", "Invalid", },
42};
43
Liu Hui-R643438a1edd72011-01-19 09:40:26 +000044/*
Stefano Babic377e3672013-06-26 23:50:06 +020045 * Supported Boot options for configuration file
46 * this is needed to determine the initial load size
47 */
48static table_entry_t imximage_boot_loadsize[] = {
49 {FLASH_LOADSIZE_ONENAND, "onenand", "OneNAND Flash",},
50 {FLASH_LOADSIZE_NAND, "nand", "NAND Flash", },
51 {FLASH_LOADSIZE_NOR, "nor", "NOR Flash", },
52 {FLASH_LOADSIZE_SATA, "sata", "SATA Disk", },
53 {FLASH_LOADSIZE_SD, "sd", "SD Card", },
54 {FLASH_LOADSIZE_SPI, "spi", "SPI Flash", },
55 {-1, "", "Invalid", },
56};
57
58/*
Liu Hui-R643438a1edd72011-01-19 09:40:26 +000059 * IMXIMAGE version definition for i.MX chips
60 */
61static table_entry_t imximage_versions[] = {
62 {IMXIMAGE_V1, "", " (i.MX25/35/51 compatible)", },
Dirk Behme19b409c2012-01-11 23:28:31 +000063 {IMXIMAGE_V2, "", " (i.MX53/6 compatible)", },
Liu Hui-R643438a1edd72011-01-19 09:40:26 +000064 {-1, "", " (Invalid)", },
65};
Stefano Babic8edcde52010-01-20 18:19:10 +010066
67static struct imx_header imximage_header;
Liu Hui-R643438a1edd72011-01-19 09:40:26 +000068static uint32_t imximage_version;
Stefano Babic0187c982013-06-27 11:42:38 +020069/*
70 * Image Vector Table Offset
71 * Initialized to a wrong not 4-bytes aligned address to
72 * check if it is was set by the cfg file.
73 */
74static uint32_t imximage_ivt_offset = UNDEFINED;
75static uint32_t imximage_csf_size = UNDEFINED;
Stefano Babic377e3672013-06-26 23:50:06 +020076/* Initial Load Region Size */
77static uint32_t imximage_init_loadsize;
Liu Hui-R643438a1edd72011-01-19 09:40:26 +000078
79static set_dcd_val_t set_dcd_val;
80static set_dcd_rst_t set_dcd_rst;
81static set_imx_hdr_t set_imx_hdr;
Troy Kisky4d5fa982012-10-03 15:47:03 +000082static uint32_t max_dcd_entries;
Troy Kisky24331982012-10-03 15:47:07 +000083static uint32_t *header_size_ptr;
Stefano Babic0187c982013-06-27 11:42:38 +020084static uint32_t *csf_ptr;
Stefano Babic8edcde52010-01-20 18:19:10 +010085
86static uint32_t get_cfg_value(char *token, char *name, int linenr)
87{
88 char *endptr;
89 uint32_t value;
90
91 errno = 0;
92 value = strtoul(token, &endptr, 16);
93 if (errno || (token == endptr)) {
94 fprintf(stderr, "Error: %s[%d] - Invalid hex data(%s)\n",
95 name, linenr, token);
96 exit(EXIT_FAILURE);
97 }
98 return value;
99}
100
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000101static uint32_t detect_imximage_version(struct imx_header *imx_hdr)
Stefano Babic8edcde52010-01-20 18:19:10 +0100102{
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000103 imx_header_v1_t *hdr_v1 = &imx_hdr->header.hdr_v1;
104 imx_header_v2_t *hdr_v2 = &imx_hdr->header.hdr_v2;
105 flash_header_v1_t *fhdr_v1 = &hdr_v1->fhdr;
106 flash_header_v2_t *fhdr_v2 = &hdr_v2->fhdr;
107
108 /* Try to detect V1 */
109 if ((fhdr_v1->app_code_barker == APP_CODE_BARKER) &&
110 (hdr_v1->dcd_table.preamble.barker == DCD_BARKER))
111 return IMXIMAGE_V1;
112
113 /* Try to detect V2 */
114 if ((fhdr_v2->header.tag == IVT_HEADER_TAG) &&
115 (hdr_v2->dcd_table.header.tag == DCD_HEADER_TAG))
116 return IMXIMAGE_V2;
117
118 return IMXIMAGE_VER_INVALID;
Stefano Babic8edcde52010-01-20 18:19:10 +0100119}
120
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000121static void err_imximage_version(int version)
Stefano Babic8edcde52010-01-20 18:19:10 +0100122{
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000123 fprintf(stderr,
124 "Error: Unsupported imximage version:%d\n", version);
Stefano Babic8edcde52010-01-20 18:19:10 +0100125
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000126 exit(EXIT_FAILURE);
Stefano Babic8edcde52010-01-20 18:19:10 +0100127}
128
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000129static void set_dcd_val_v1(struct imx_header *imxhdr, char *name, int lineno,
130 int fld, uint32_t value, uint32_t off)
Stefano Babic8edcde52010-01-20 18:19:10 +0100131{
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000132 dcd_v1_t *dcd_v1 = &imxhdr->header.hdr_v1.dcd_table;
Stefano Babic8edcde52010-01-20 18:19:10 +0100133
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000134 switch (fld) {
135 case CFG_REG_SIZE:
136 /* Byte, halfword, word */
137 if ((value != 1) && (value != 2) && (value != 4)) {
138 fprintf(stderr, "Error: %s[%d] - "
139 "Invalid register size " "(%d)\n",
140 name, lineno, value);
141 exit(EXIT_FAILURE);
142 }
143 dcd_v1->addr_data[off].type = value;
144 break;
145 case CFG_REG_ADDRESS:
146 dcd_v1->addr_data[off].addr = value;
147 break;
148 case CFG_REG_VALUE:
149 dcd_v1->addr_data[off].value = value;
150 break;
151 default:
152 break;
153
154 }
155}
156
157static void set_dcd_val_v2(struct imx_header *imxhdr, char *name, int lineno,
158 int fld, uint32_t value, uint32_t off)
159{
160 dcd_v2_t *dcd_v2 = &imxhdr->header.hdr_v2.dcd_table;
161
162 switch (fld) {
163 case CFG_REG_ADDRESS:
164 dcd_v2->addr_data[off].addr = cpu_to_be32(value);
165 break;
166 case CFG_REG_VALUE:
167 dcd_v2->addr_data[off].value = cpu_to_be32(value);
168 break;
169 default:
170 break;
171
172 }
173}
174
175/*
176 * Complete setting up the rest field of DCD of V1
177 * such as barker code and DCD data length.
178 */
179static void set_dcd_rst_v1(struct imx_header *imxhdr, uint32_t dcd_len,
180 char *name, int lineno)
181{
182 dcd_v1_t *dcd_v1 = &imxhdr->header.hdr_v1.dcd_table;
183
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000184 dcd_v1->preamble.barker = DCD_BARKER;
185 dcd_v1->preamble.length = dcd_len * sizeof(dcd_type_addr_data_t);
Stefano Babic8edcde52010-01-20 18:19:10 +0100186}
187
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000188/*
189 * Complete setting up the reset field of DCD of V2
190 * such as DCD tag, version, length, etc.
191 */
192static void set_dcd_rst_v2(struct imx_header *imxhdr, uint32_t dcd_len,
193 char *name, int lineno)
194{
195 dcd_v2_t *dcd_v2 = &imxhdr->header.hdr_v2.dcd_table;
196
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000197 dcd_v2->header.tag = DCD_HEADER_TAG;
198 dcd_v2->header.length = cpu_to_be16(
199 dcd_len * sizeof(dcd_addr_data_t) + 8);
200 dcd_v2->header.version = DCD_VERSION;
201 dcd_v2->write_dcd_command.tag = DCD_COMMAND_TAG;
202 dcd_v2->write_dcd_command.length = cpu_to_be16(
203 dcd_len * sizeof(dcd_addr_data_t) + 4);
204 dcd_v2->write_dcd_command.param = DCD_COMMAND_PARAM;
205}
206
207static void set_imx_hdr_v1(struct imx_header *imxhdr, uint32_t dcd_len,
Troy Kiskyad0826d2012-10-03 15:47:08 +0000208 uint32_t entry_point, uint32_t flash_offset)
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000209{
210 imx_header_v1_t *hdr_v1 = &imxhdr->header.hdr_v1;
211 flash_header_v1_t *fhdr_v1 = &hdr_v1->fhdr;
212 dcd_v1_t *dcd_v1 = &hdr_v1->dcd_table;
Troy Kiskyab857f22012-10-03 15:47:09 +0000213 uint32_t hdr_base;
Troy Kisky24331982012-10-03 15:47:07 +0000214 uint32_t header_length = (((char *)&dcd_v1->addr_data[dcd_len].addr)
215 - ((char *)imxhdr));
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000216
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000217 /* Set magic number */
218 fhdr_v1->app_code_barker = APP_CODE_BARKER;
219
Stefano Babic377e3672013-06-26 23:50:06 +0200220 /* TODO: check i.MX image V1 handling, for now use 'old' style */
221 hdr_base = entry_point - 4096;
Troy Kiskyab857f22012-10-03 15:47:09 +0000222 fhdr_v1->app_dest_ptr = hdr_base - flash_offset;
Troy Kiskyad0826d2012-10-03 15:47:08 +0000223 fhdr_v1->app_code_jump_vector = entry_point;
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000224
Troy Kiskyab857f22012-10-03 15:47:09 +0000225 fhdr_v1->dcd_ptr_ptr = hdr_base + offsetof(flash_header_v1_t, dcd_ptr);
226 fhdr_v1->dcd_ptr = hdr_base + offsetof(imx_header_v1_t, dcd_table);
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000227
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000228 /* Security feature are not supported */
229 fhdr_v1->app_code_csf = 0;
230 fhdr_v1->super_root_key = 0;
Troy Kisky24331982012-10-03 15:47:07 +0000231 header_size_ptr = (uint32_t *)(((char *)imxhdr) + header_length - 4);
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000232}
233
234static void set_imx_hdr_v2(struct imx_header *imxhdr, uint32_t dcd_len,
Troy Kiskyad0826d2012-10-03 15:47:08 +0000235 uint32_t entry_point, uint32_t flash_offset)
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000236{
237 imx_header_v2_t *hdr_v2 = &imxhdr->header.hdr_v2;
238 flash_header_v2_t *fhdr_v2 = &hdr_v2->fhdr;
Troy Kiskyab857f22012-10-03 15:47:09 +0000239 uint32_t hdr_base;
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000240
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000241 /* Set magic number */
242 fhdr_v2->header.tag = IVT_HEADER_TAG; /* 0xD1 */
243 fhdr_v2->header.length = cpu_to_be16(sizeof(flash_header_v2_t));
244 fhdr_v2->header.version = IVT_VERSION; /* 0x40 */
245
Troy Kiskyad0826d2012-10-03 15:47:08 +0000246 fhdr_v2->entry = entry_point;
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000247 fhdr_v2->reserved1 = fhdr_v2->reserved2 = 0;
Stefano Babic377e3672013-06-26 23:50:06 +0200248 hdr_base = entry_point - imximage_init_loadsize +
249 flash_offset;
250 fhdr_v2->self = hdr_base;
Troy Kiskyab857f22012-10-03 15:47:09 +0000251 fhdr_v2->dcd_ptr = hdr_base + offsetof(imx_header_v2_t, dcd_table);
252 fhdr_v2->boot_data_ptr = hdr_base
253 + offsetof(imx_header_v2_t, boot_data);
Stefano Babic377e3672013-06-26 23:50:06 +0200254 hdr_v2->boot_data.start = entry_point - imximage_init_loadsize;
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000255
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000256 fhdr_v2->csf = 0;
Stefano Babic0187c982013-06-27 11:42:38 +0200257
Troy Kisky24331982012-10-03 15:47:07 +0000258 header_size_ptr = &hdr_v2->boot_data.size;
Stefano Babic0187c982013-06-27 11:42:38 +0200259 csf_ptr = &fhdr_v2->csf;
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000260}
261
York Sun72048bc2013-09-20 12:24:44 -0700262static void set_hdr_func(void)
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000263{
264 switch (imximage_version) {
265 case IMXIMAGE_V1:
266 set_dcd_val = set_dcd_val_v1;
267 set_dcd_rst = set_dcd_rst_v1;
268 set_imx_hdr = set_imx_hdr_v1;
Troy Kisky4d5fa982012-10-03 15:47:03 +0000269 max_dcd_entries = MAX_HW_CFG_SIZE_V1;
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000270 break;
271 case IMXIMAGE_V2:
272 set_dcd_val = set_dcd_val_v2;
273 set_dcd_rst = set_dcd_rst_v2;
274 set_imx_hdr = set_imx_hdr_v2;
Troy Kisky4d5fa982012-10-03 15:47:03 +0000275 max_dcd_entries = MAX_HW_CFG_SIZE_V2;
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000276 break;
277 default:
278 err_imximage_version(imximage_version);
279 break;
280 }
281}
282
283static void print_hdr_v1(struct imx_header *imx_hdr)
284{
285 imx_header_v1_t *hdr_v1 = &imx_hdr->header.hdr_v1;
286 flash_header_v1_t *fhdr_v1 = &hdr_v1->fhdr;
287 dcd_v1_t *dcd_v1 = &hdr_v1->dcd_table;
288 uint32_t size, length, ver;
289
290 size = dcd_v1->preamble.length;
291 if (size > (MAX_HW_CFG_SIZE_V1 * sizeof(dcd_type_addr_data_t))) {
292 fprintf(stderr,
293 "Error: Image corrupt DCD size %d exceed maximum %d\n",
294 (uint32_t)(size / sizeof(dcd_type_addr_data_t)),
295 MAX_HW_CFG_SIZE_V1);
296 exit(EXIT_FAILURE);
297 }
298
299 length = dcd_v1->preamble.length / sizeof(dcd_type_addr_data_t);
300 ver = detect_imximage_version(imx_hdr);
301
302 printf("Image Type: Freescale IMX Boot Image\n");
303 printf("Image Ver: %x", ver);
304 printf("%s\n", get_table_entry_name(imximage_versions, NULL, ver));
305 printf("Data Size: ");
306 genimg_print_size(dcd_v1->addr_data[length].type);
307 printf("Load Address: %08x\n", (uint32_t)fhdr_v1->app_dest_ptr);
308 printf("Entry Point: %08x\n", (uint32_t)fhdr_v1->app_code_jump_vector);
309}
310
311static void print_hdr_v2(struct imx_header *imx_hdr)
312{
313 imx_header_v2_t *hdr_v2 = &imx_hdr->header.hdr_v2;
314 flash_header_v2_t *fhdr_v2 = &hdr_v2->fhdr;
315 dcd_v2_t *dcd_v2 = &hdr_v2->dcd_table;
316 uint32_t size, version;
317
318 size = be16_to_cpu(dcd_v2->header.length) - 8;
319 if (size > (MAX_HW_CFG_SIZE_V2 * sizeof(dcd_addr_data_t))) {
320 fprintf(stderr,
321 "Error: Image corrupt DCD size %d exceed maximum %d\n",
322 (uint32_t)(size / sizeof(dcd_addr_data_t)),
323 MAX_HW_CFG_SIZE_V2);
324 exit(EXIT_FAILURE);
325 }
326
327 version = detect_imximage_version(imx_hdr);
328
329 printf("Image Type: Freescale IMX Boot Image\n");
330 printf("Image Ver: %x", version);
331 printf("%s\n", get_table_entry_name(imximage_versions, NULL, version));
332 printf("Data Size: ");
333 genimg_print_size(hdr_v2->boot_data.size);
334 printf("Load Address: %08x\n", (uint32_t)fhdr_v2->boot_data_ptr);
335 printf("Entry Point: %08x\n", (uint32_t)fhdr_v2->entry);
Stefano Babic0187c982013-06-27 11:42:38 +0200336 if (fhdr_v2->csf && (imximage_ivt_offset != UNDEFINED) &&
337 (imximage_csf_size != UNDEFINED)) {
338 printf("HAB Blocks: %08x %08x %08x\n",
339 (uint32_t)fhdr_v2->self, 0,
340 hdr_v2->boot_data.size - imximage_ivt_offset -
341 imximage_csf_size);
342 }
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000343}
344
345static void parse_cfg_cmd(struct imx_header *imxhdr, int32_t cmd, char *token,
346 char *name, int lineno, int fld, int dcd_len)
347{
348 int value;
349 static int cmd_ver_first = ~0;
350
351 switch (cmd) {
352 case CMD_IMAGE_VERSION:
353 imximage_version = get_cfg_value(token, name, lineno);
354 if (cmd_ver_first == 0) {
355 fprintf(stderr, "Error: %s[%d] - IMAGE_VERSION "
356 "command need be the first before other "
357 "valid command in the file\n", name, lineno);
358 exit(EXIT_FAILURE);
359 }
360 cmd_ver_first = 1;
York Sun72048bc2013-09-20 12:24:44 -0700361 set_hdr_func();
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000362 break;
363 case CMD_BOOT_FROM:
Stefano Babic377e3672013-06-26 23:50:06 +0200364 imximage_ivt_offset = get_table_entry_id(imximage_boot_offset,
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000365 "imximage boot option", token);
Stefano Babic3150f922013-06-26 18:08:37 +0200366 if (imximage_ivt_offset == -1) {
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000367 fprintf(stderr, "Error: %s[%d] -Invalid boot device"
368 "(%s)\n", name, lineno, token);
369 exit(EXIT_FAILURE);
370 }
Stefano Babic377e3672013-06-26 23:50:06 +0200371
372 imximage_init_loadsize =
373 get_table_entry_id(imximage_boot_loadsize,
374 "imximage boot option", token);
375
376 if (imximage_init_loadsize == -1) {
377 fprintf(stderr,
378 "Error: %s[%d] -Invalid boot device(%s)\n",
379 name, lineno, token);
380 exit(EXIT_FAILURE);
381 }
Stefano Babic01390af2013-08-19 19:03:20 +0200382
383 /*
384 * The SOC loads from the storage starting at address 0
385 * then ensures that the load size contains the offset
386 */
387 if (imximage_init_loadsize < imximage_ivt_offset)
388 imximage_init_loadsize = imximage_ivt_offset;
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000389 if (unlikely(cmd_ver_first != 1))
390 cmd_ver_first = 0;
391 break;
Marek Vasut6cb83822013-04-25 10:16:02 +0000392 case CMD_BOOT_OFFSET:
Stefano Babic3150f922013-06-26 18:08:37 +0200393 imximage_ivt_offset = get_cfg_value(token, name, lineno);
Marek Vasut6cb83822013-04-25 10:16:02 +0000394 if (unlikely(cmd_ver_first != 1))
395 cmd_ver_first = 0;
396 break;
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000397 case CMD_DATA:
398 value = get_cfg_value(token, name, lineno);
399 (*set_dcd_val)(imxhdr, name, lineno, fld, value, dcd_len);
400 if (unlikely(cmd_ver_first != 1))
401 cmd_ver_first = 0;
402 break;
Stefano Babic0187c982013-06-27 11:42:38 +0200403 case CMD_CSF:
404 if (imximage_version != 2) {
405 fprintf(stderr,
406 "Error: %s[%d] - CSF only supported for VERSION 2(%s)\n",
407 name, lineno, token);
408 exit(EXIT_FAILURE);
409 }
410 imximage_csf_size = get_cfg_value(token, name, lineno);
411 if (unlikely(cmd_ver_first != 1))
412 cmd_ver_first = 0;
413 break;
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000414 }
415}
416
417static void parse_cfg_fld(struct imx_header *imxhdr, int32_t *cmd,
418 char *token, char *name, int lineno, int fld, int *dcd_len)
419{
420 int value;
421
422 switch (fld) {
423 case CFG_COMMAND:
424 *cmd = get_table_entry_id(imximage_cmds,
425 "imximage commands", token);
426 if (*cmd < 0) {
427 fprintf(stderr, "Error: %s[%d] - Invalid command"
428 "(%s)\n", name, lineno, token);
429 exit(EXIT_FAILURE);
430 }
431 break;
432 case CFG_REG_SIZE:
433 parse_cfg_cmd(imxhdr, *cmd, token, name, lineno, fld, *dcd_len);
434 break;
435 case CFG_REG_ADDRESS:
436 case CFG_REG_VALUE:
437 if (*cmd != CMD_DATA)
438 return;
439
440 value = get_cfg_value(token, name, lineno);
441 (*set_dcd_val)(imxhdr, name, lineno, fld, value, *dcd_len);
442
Troy Kisky4d5fa982012-10-03 15:47:03 +0000443 if (fld == CFG_REG_VALUE) {
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000444 (*dcd_len)++;
Troy Kisky4d5fa982012-10-03 15:47:03 +0000445 if (*dcd_len > max_dcd_entries) {
446 fprintf(stderr, "Error: %s[%d] -"
447 "DCD table exceeds maximum size(%d)\n",
448 name, lineno, max_dcd_entries);
449 exit(EXIT_FAILURE);
450 }
451 }
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000452 break;
453 default:
454 break;
455 }
456}
457static uint32_t parse_cfg_file(struct imx_header *imxhdr, char *name)
Stefano Babic8edcde52010-01-20 18:19:10 +0100458{
459 FILE *fd = NULL;
460 char *line = NULL;
461 char *token, *saveptr1, *saveptr2;
462 int lineno = 0;
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000463 int fld;
Kim Phillips0ad22702010-02-22 19:37:56 -0600464 size_t len;
Stefano Babic8edcde52010-01-20 18:19:10 +0100465 int dcd_len = 0;
Stefano Babic8edcde52010-01-20 18:19:10 +0100466 int32_t cmd;
467
468 fd = fopen(name, "r");
469 if (fd == 0) {
470 fprintf(stderr, "Error: %s - Can't open DCD file\n", name);
471 exit(EXIT_FAILURE);
472 }
473
Stefano Babic01390af2013-08-19 19:03:20 +0200474 /*
475 * Very simple parsing, line starting with # are comments
Stefano Babic8edcde52010-01-20 18:19:10 +0100476 * and are dropped
477 */
478 while ((getline(&line, &len, fd)) > 0) {
479 lineno++;
480
481 token = strtok_r(line, "\r\n", &saveptr1);
482 if (token == NULL)
483 continue;
484
485 /* Check inside the single line */
486 for (fld = CFG_COMMAND, cmd = CMD_INVALID,
487 line = token; ; line = NULL, fld++) {
488 token = strtok_r(line, " \t", &saveptr2);
489 if (token == NULL)
490 break;
491
492 /* Drop all text starting with '#' as comments */
493 if (token[0] == '#')
494 break;
495
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000496 parse_cfg_fld(imxhdr, &cmd, token, name,
497 lineno, fld, &dcd_len);
Stefano Babic8edcde52010-01-20 18:19:10 +0100498 }
499
Stefano Babic8edcde52010-01-20 18:19:10 +0100500 }
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000501
502 (*set_dcd_rst)(imxhdr, dcd_len, name, lineno);
Stefano Babic8edcde52010-01-20 18:19:10 +0100503 fclose(fd);
504
Troy Kisky8d8cc822012-10-03 15:47:05 +0000505 /* Exit if there is no BOOT_FROM field specifying the flash_offset */
Stefano Babic3150f922013-06-26 18:08:37 +0200506 if (imximage_ivt_offset == FLASH_OFFSET_UNDEFINED) {
Troy Kisky8d8cc822012-10-03 15:47:05 +0000507 fprintf(stderr, "Error: No BOOT_FROM tag in %s\n", name);
508 exit(EXIT_FAILURE);
509 }
Stefano Babic5b28e912010-02-05 15:16:02 +0100510 return dcd_len;
Stefano Babic8edcde52010-01-20 18:19:10 +0100511}
512
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000513
514static int imximage_check_image_types(uint8_t type)
515{
516 if (type == IH_TYPE_IMXIMAGE)
517 return EXIT_SUCCESS;
518 else
519 return EXIT_FAILURE;
520}
521
522static int imximage_verify_header(unsigned char *ptr, int image_size,
523 struct mkimage_params *params)
524{
525 struct imx_header *imx_hdr = (struct imx_header *) ptr;
526
527 if (detect_imximage_version(imx_hdr) == IMXIMAGE_VER_INVALID)
528 return -FDT_ERR_BADSTRUCTURE;
529
530 return 0;
531}
532
533static void imximage_print_header(const void *ptr)
534{
535 struct imx_header *imx_hdr = (struct imx_header *) ptr;
536 uint32_t version = detect_imximage_version(imx_hdr);
537
538 switch (version) {
539 case IMXIMAGE_V1:
540 print_hdr_v1(imx_hdr);
541 break;
542 case IMXIMAGE_V2:
543 print_hdr_v2(imx_hdr);
544 break;
545 default:
546 err_imximage_version(version);
547 break;
548 }
549}
550
Stefano Babic8edcde52010-01-20 18:19:10 +0100551static void imximage_set_header(void *ptr, struct stat *sbuf, int ifd,
552 struct mkimage_params *params)
553{
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000554 struct imx_header *imxhdr = (struct imx_header *)ptr;
555 uint32_t dcd_len;
Stefano Babic8edcde52010-01-20 18:19:10 +0100556
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000557 /*
558 * In order to not change the old imx cfg file
559 * by adding VERSION command into it, here need
560 * set up function ptr group to V1 by default.
561 */
562 imximage_version = IMXIMAGE_V1;
Dirk Behme49d3e272012-02-22 22:50:19 +0000563 /* Be able to detect if the cfg file has no BOOT_FROM tag */
Stefano Babic3150f922013-06-26 18:08:37 +0200564 imximage_ivt_offset = FLASH_OFFSET_UNDEFINED;
Stefano Babic0187c982013-06-27 11:42:38 +0200565 imximage_csf_size = 0;
York Sun72048bc2013-09-20 12:24:44 -0700566 set_hdr_func();
Stefano Babic8edcde52010-01-20 18:19:10 +0100567
568 /* Parse dcd configuration file */
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000569 dcd_len = parse_cfg_file(imxhdr, params->imagename);
Stefano Babic8edcde52010-01-20 18:19:10 +0100570
Liu Hui-R643438a1edd72011-01-19 09:40:26 +0000571 /* Set the imx header */
Stefano Babic3150f922013-06-26 18:08:37 +0200572 (*set_imx_hdr)(imxhdr, dcd_len, params->ep, imximage_ivt_offset);
Fabio Estevam1411fb32013-01-03 08:24:33 +0000573
574 /*
575 * ROM bug alert
Marek Vasut895d9962013-04-21 05:52:22 +0000576 *
577 * MX53 only loads 512 byte multiples in case of SD boot.
578 * MX53 only loads NAND page multiples in case of NAND boot and
579 * supports up to 4096 byte large pages, thus align to 4096.
580 *
581 * The remaining fraction of a block bytes would not be loaded!
Fabio Estevam1411fb32013-01-03 08:24:33 +0000582 */
Stefano Babic377e3672013-06-26 23:50:06 +0200583 *header_size_ptr = ROUND(sbuf->st_size, 4096);
Stefano Babic0187c982013-06-27 11:42:38 +0200584
585 if (csf_ptr && imximage_csf_size) {
586 *csf_ptr = params->ep - imximage_init_loadsize +
587 *header_size_ptr;
588 *header_size_ptr += imximage_csf_size;
589 }
Stefano Babic8edcde52010-01-20 18:19:10 +0100590}
591
592int imximage_check_params(struct mkimage_params *params)
593{
594 if (!params)
595 return CFG_INVALID;
596 if (!strlen(params->imagename)) {
597 fprintf(stderr, "Error: %s - Configuration file not specified, "
598 "it is needed for imximage generation\n",
599 params->cmdname);
600 return CFG_INVALID;
601 }
602 /*
603 * Check parameters:
604 * XIP is not allowed and verify that incompatible
605 * parameters are not sent at the same time
606 * For example, if list is required a data image must not be provided
607 */
608 return (params->dflag && (params->fflag || params->lflag)) ||
609 (params->fflag && (params->dflag || params->lflag)) ||
610 (params->lflag && (params->dflag || params->fflag)) ||
611 (params->xflag) || !(strlen(params->imagename));
612}
613
Stefano Babic01390af2013-08-19 19:03:20 +0200614static int imximage_generate(struct mkimage_params *params,
615 struct image_type_params *tparams)
616{
617 struct imx_header *imxhdr;
618 size_t alloc_len;
619 struct stat sbuf;
620 char *datafile = params->datafile;
621 uint32_t pad_len;
622
623 memset(&imximage_header, 0, sizeof(imximage_header));
624
625 /*
626 * In order to not change the old imx cfg file
627 * by adding VERSION command into it, here need
628 * set up function ptr group to V1 by default.
629 */
630 imximage_version = IMXIMAGE_V1;
631 /* Be able to detect if the cfg file has no BOOT_FROM tag */
632 imximage_ivt_offset = FLASH_OFFSET_UNDEFINED;
633 imximage_csf_size = 0;
York Sun72048bc2013-09-20 12:24:44 -0700634 set_hdr_func();
Stefano Babic01390af2013-08-19 19:03:20 +0200635
636 /* Parse dcd configuration file */
637 parse_cfg_file(&imximage_header, params->imagename);
638
639 /* TODO: check i.MX image V1 handling, for now use 'old' style */
640 if (imximage_version == IMXIMAGE_V1) {
641 alloc_len = 4096;
642 } else {
643 if (imximage_init_loadsize < imximage_ivt_offset +
644 sizeof(imx_header_v2_t))
645 imximage_init_loadsize = imximage_ivt_offset +
646 sizeof(imx_header_v2_t);
647 alloc_len = imximage_init_loadsize - imximage_ivt_offset;
648 }
649
650 if (alloc_len < sizeof(struct imx_header)) {
651 fprintf(stderr, "%s: header error\n",
652 params->cmdname);
653 exit(EXIT_FAILURE);
654 }
655
656 imxhdr = malloc(alloc_len);
657
658 if (!imxhdr) {
659 fprintf(stderr, "%s: malloc return failure: %s\n",
660 params->cmdname, strerror(errno));
661 exit(EXIT_FAILURE);
662 }
663
664 memset(imxhdr, 0, alloc_len);
665
666 tparams->header_size = alloc_len;
667 tparams->hdr = imxhdr;
668
669 /* determine data image file length */
670
671 if (stat(datafile, &sbuf) < 0) {
672 fprintf(stderr, "%s: Can't stat %s: %s\n",
673 params->cmdname, datafile, strerror(errno));
674 exit(EXIT_FAILURE);
675 }
676
677 pad_len = ROUND(sbuf.st_size, 4096) - sbuf.st_size;
678
679 /* TODO: check i.MX image V1 handling, for now use 'old' style */
680 if (imximage_version == IMXIMAGE_V1)
681 return 0;
682 else
683 return pad_len;
684}
685
686
Stefano Babic8edcde52010-01-20 18:19:10 +0100687/*
688 * imximage parameters
689 */
690static struct image_type_params imximage_params = {
Fabio Estevam6e083852013-01-02 08:48:34 +0000691 .name = "Freescale i.MX Boot Image support",
Stefano Babic01390af2013-08-19 19:03:20 +0200692 .header_size = 0,
693 .hdr = NULL,
Stefano Babic8edcde52010-01-20 18:19:10 +0100694 .check_image_type = imximage_check_image_types,
695 .verify_header = imximage_verify_header,
696 .print_header = imximage_print_header,
697 .set_header = imximage_set_header,
698 .check_params = imximage_check_params,
Stefano Babic01390af2013-08-19 19:03:20 +0200699 .vrec_header = imximage_generate,
Stefano Babic8edcde52010-01-20 18:19:10 +0100700};
701
702void init_imx_image_type(void)
703{
704 mkimage_register(&imximage_params);
705}