imximage.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705
  1. /*
  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. *
  9. * SPDX-License-Identifier: GPL-2.0+
  10. */
  11. #include "imagetool.h"
  12. #include <image.h>
  13. #include "imximage.h"
  14. #define UNDEFINED 0xFFFFFFFF
  15. /*
  16. * Supported commands for configuration file
  17. */
  18. static table_entry_t imximage_cmds[] = {
  19. {CMD_BOOT_FROM, "BOOT_FROM", "boot command", },
  20. {CMD_BOOT_OFFSET, "BOOT_OFFSET", "Boot offset", },
  21. {CMD_DATA, "DATA", "Reg Write Data", },
  22. {CMD_CSF, "CSF", "Command Sequence File", },
  23. {CMD_IMAGE_VERSION, "IMAGE_VERSION", "image version", },
  24. {-1, "", "", },
  25. };
  26. /*
  27. * Supported Boot options for configuration file
  28. * this is needed to set the correct flash offset
  29. */
  30. static table_entry_t imximage_boot_offset[] = {
  31. {FLASH_OFFSET_ONENAND, "onenand", "OneNAND Flash",},
  32. {FLASH_OFFSET_NAND, "nand", "NAND Flash", },
  33. {FLASH_OFFSET_NOR, "nor", "NOR Flash", },
  34. {FLASH_OFFSET_SATA, "sata", "SATA Disk", },
  35. {FLASH_OFFSET_SD, "sd", "SD Card", },
  36. {FLASH_OFFSET_SPI, "spi", "SPI Flash", },
  37. {-1, "", "Invalid", },
  38. };
  39. /*
  40. * Supported Boot options for configuration file
  41. * this is needed to determine the initial load size
  42. */
  43. static table_entry_t imximage_boot_loadsize[] = {
  44. {FLASH_LOADSIZE_ONENAND, "onenand", "OneNAND Flash",},
  45. {FLASH_LOADSIZE_NAND, "nand", "NAND Flash", },
  46. {FLASH_LOADSIZE_NOR, "nor", "NOR Flash", },
  47. {FLASH_LOADSIZE_SATA, "sata", "SATA Disk", },
  48. {FLASH_LOADSIZE_SD, "sd", "SD Card", },
  49. {FLASH_LOADSIZE_SPI, "spi", "SPI Flash", },
  50. {-1, "", "Invalid", },
  51. };
  52. /*
  53. * IMXIMAGE version definition for i.MX chips
  54. */
  55. static table_entry_t imximage_versions[] = {
  56. {IMXIMAGE_V1, "", " (i.MX25/35/51 compatible)", },
  57. {IMXIMAGE_V2, "", " (i.MX53/6 compatible)", },
  58. {-1, "", " (Invalid)", },
  59. };
  60. static struct imx_header imximage_header;
  61. static uint32_t imximage_version;
  62. /*
  63. * Image Vector Table Offset
  64. * Initialized to a wrong not 4-bytes aligned address to
  65. * check if it is was set by the cfg file.
  66. */
  67. static uint32_t imximage_ivt_offset = UNDEFINED;
  68. static uint32_t imximage_csf_size = UNDEFINED;
  69. /* Initial Load Region Size */
  70. static uint32_t imximage_init_loadsize;
  71. static set_dcd_val_t set_dcd_val;
  72. static set_dcd_rst_t set_dcd_rst;
  73. static set_imx_hdr_t set_imx_hdr;
  74. static uint32_t max_dcd_entries;
  75. static uint32_t *header_size_ptr;
  76. static uint32_t *csf_ptr;
  77. static uint32_t get_cfg_value(char *token, char *name, int linenr)
  78. {
  79. char *endptr;
  80. uint32_t value;
  81. errno = 0;
  82. value = strtoul(token, &endptr, 16);
  83. if (errno || (token == endptr)) {
  84. fprintf(stderr, "Error: %s[%d] - Invalid hex data(%s)\n",
  85. name, linenr, token);
  86. exit(EXIT_FAILURE);
  87. }
  88. return value;
  89. }
  90. static uint32_t detect_imximage_version(struct imx_header *imx_hdr)
  91. {
  92. imx_header_v1_t *hdr_v1 = &imx_hdr->header.hdr_v1;
  93. imx_header_v2_t *hdr_v2 = &imx_hdr->header.hdr_v2;
  94. flash_header_v1_t *fhdr_v1 = &hdr_v1->fhdr;
  95. flash_header_v2_t *fhdr_v2 = &hdr_v2->fhdr;
  96. /* Try to detect V1 */
  97. if ((fhdr_v1->app_code_barker == APP_CODE_BARKER) &&
  98. (hdr_v1->dcd_table.preamble.barker == DCD_BARKER))
  99. return IMXIMAGE_V1;
  100. /* Try to detect V2 */
  101. if ((fhdr_v2->header.tag == IVT_HEADER_TAG) &&
  102. (hdr_v2->dcd_table.header.tag == DCD_HEADER_TAG))
  103. return IMXIMAGE_V2;
  104. return IMXIMAGE_VER_INVALID;
  105. }
  106. static void err_imximage_version(int version)
  107. {
  108. fprintf(stderr,
  109. "Error: Unsupported imximage version:%d\n", version);
  110. exit(EXIT_FAILURE);
  111. }
  112. static void set_dcd_val_v1(struct imx_header *imxhdr, char *name, int lineno,
  113. int fld, uint32_t value, uint32_t off)
  114. {
  115. dcd_v1_t *dcd_v1 = &imxhdr->header.hdr_v1.dcd_table;
  116. switch (fld) {
  117. case CFG_REG_SIZE:
  118. /* Byte, halfword, word */
  119. if ((value != 1) && (value != 2) && (value != 4)) {
  120. fprintf(stderr, "Error: %s[%d] - "
  121. "Invalid register size " "(%d)\n",
  122. name, lineno, value);
  123. exit(EXIT_FAILURE);
  124. }
  125. dcd_v1->addr_data[off].type = value;
  126. break;
  127. case CFG_REG_ADDRESS:
  128. dcd_v1->addr_data[off].addr = value;
  129. break;
  130. case CFG_REG_VALUE:
  131. dcd_v1->addr_data[off].value = value;
  132. break;
  133. default:
  134. break;
  135. }
  136. }
  137. static void set_dcd_val_v2(struct imx_header *imxhdr, char *name, int lineno,
  138. int fld, uint32_t value, uint32_t off)
  139. {
  140. dcd_v2_t *dcd_v2 = &imxhdr->header.hdr_v2.dcd_table;
  141. switch (fld) {
  142. case CFG_REG_ADDRESS:
  143. dcd_v2->addr_data[off].addr = cpu_to_be32(value);
  144. break;
  145. case CFG_REG_VALUE:
  146. dcd_v2->addr_data[off].value = cpu_to_be32(value);
  147. break;
  148. default:
  149. break;
  150. }
  151. }
  152. /*
  153. * Complete setting up the rest field of DCD of V1
  154. * such as barker code and DCD data length.
  155. */
  156. static void set_dcd_rst_v1(struct imx_header *imxhdr, uint32_t dcd_len,
  157. char *name, int lineno)
  158. {
  159. dcd_v1_t *dcd_v1 = &imxhdr->header.hdr_v1.dcd_table;
  160. dcd_v1->preamble.barker = DCD_BARKER;
  161. dcd_v1->preamble.length = dcd_len * sizeof(dcd_type_addr_data_t);
  162. }
  163. /*
  164. * Complete setting up the reset field of DCD of V2
  165. * such as DCD tag, version, length, etc.
  166. */
  167. static void set_dcd_rst_v2(struct imx_header *imxhdr, uint32_t dcd_len,
  168. char *name, int lineno)
  169. {
  170. dcd_v2_t *dcd_v2 = &imxhdr->header.hdr_v2.dcd_table;
  171. dcd_v2->header.tag = DCD_HEADER_TAG;
  172. dcd_v2->header.length = cpu_to_be16(
  173. dcd_len * sizeof(dcd_addr_data_t) + 8);
  174. dcd_v2->header.version = DCD_VERSION;
  175. dcd_v2->write_dcd_command.tag = DCD_COMMAND_TAG;
  176. dcd_v2->write_dcd_command.length = cpu_to_be16(
  177. dcd_len * sizeof(dcd_addr_data_t) + 4);
  178. dcd_v2->write_dcd_command.param = DCD_COMMAND_PARAM;
  179. }
  180. static void set_imx_hdr_v1(struct imx_header *imxhdr, uint32_t dcd_len,
  181. uint32_t entry_point, uint32_t flash_offset)
  182. {
  183. imx_header_v1_t *hdr_v1 = &imxhdr->header.hdr_v1;
  184. flash_header_v1_t *fhdr_v1 = &hdr_v1->fhdr;
  185. dcd_v1_t *dcd_v1 = &hdr_v1->dcd_table;
  186. uint32_t hdr_base;
  187. uint32_t header_length = (((char *)&dcd_v1->addr_data[dcd_len].addr)
  188. - ((char *)imxhdr));
  189. /* Set magic number */
  190. fhdr_v1->app_code_barker = APP_CODE_BARKER;
  191. /* TODO: check i.MX image V1 handling, for now use 'old' style */
  192. hdr_base = entry_point - 4096;
  193. fhdr_v1->app_dest_ptr = hdr_base - flash_offset;
  194. fhdr_v1->app_code_jump_vector = entry_point;
  195. fhdr_v1->dcd_ptr_ptr = hdr_base + offsetof(flash_header_v1_t, dcd_ptr);
  196. fhdr_v1->dcd_ptr = hdr_base + offsetof(imx_header_v1_t, dcd_table);
  197. /* Security feature are not supported */
  198. fhdr_v1->app_code_csf = 0;
  199. fhdr_v1->super_root_key = 0;
  200. header_size_ptr = (uint32_t *)(((char *)imxhdr) + header_length - 4);
  201. }
  202. static void set_imx_hdr_v2(struct imx_header *imxhdr, uint32_t dcd_len,
  203. uint32_t entry_point, uint32_t flash_offset)
  204. {
  205. imx_header_v2_t *hdr_v2 = &imxhdr->header.hdr_v2;
  206. flash_header_v2_t *fhdr_v2 = &hdr_v2->fhdr;
  207. uint32_t hdr_base;
  208. /* Set magic number */
  209. fhdr_v2->header.tag = IVT_HEADER_TAG; /* 0xD1 */
  210. fhdr_v2->header.length = cpu_to_be16(sizeof(flash_header_v2_t));
  211. fhdr_v2->header.version = IVT_VERSION; /* 0x40 */
  212. fhdr_v2->entry = entry_point;
  213. fhdr_v2->reserved1 = fhdr_v2->reserved2 = 0;
  214. hdr_base = entry_point - imximage_init_loadsize +
  215. flash_offset;
  216. fhdr_v2->self = hdr_base;
  217. fhdr_v2->dcd_ptr = hdr_base + offsetof(imx_header_v2_t, dcd_table);
  218. fhdr_v2->boot_data_ptr = hdr_base
  219. + offsetof(imx_header_v2_t, boot_data);
  220. hdr_v2->boot_data.start = entry_point - imximage_init_loadsize;
  221. fhdr_v2->csf = 0;
  222. header_size_ptr = &hdr_v2->boot_data.size;
  223. csf_ptr = &fhdr_v2->csf;
  224. }
  225. static void set_hdr_func(void)
  226. {
  227. switch (imximage_version) {
  228. case IMXIMAGE_V1:
  229. set_dcd_val = set_dcd_val_v1;
  230. set_dcd_rst = set_dcd_rst_v1;
  231. set_imx_hdr = set_imx_hdr_v1;
  232. max_dcd_entries = MAX_HW_CFG_SIZE_V1;
  233. break;
  234. case IMXIMAGE_V2:
  235. set_dcd_val = set_dcd_val_v2;
  236. set_dcd_rst = set_dcd_rst_v2;
  237. set_imx_hdr = set_imx_hdr_v2;
  238. max_dcd_entries = MAX_HW_CFG_SIZE_V2;
  239. break;
  240. default:
  241. err_imximage_version(imximage_version);
  242. break;
  243. }
  244. }
  245. static void print_hdr_v1(struct imx_header *imx_hdr)
  246. {
  247. imx_header_v1_t *hdr_v1 = &imx_hdr->header.hdr_v1;
  248. flash_header_v1_t *fhdr_v1 = &hdr_v1->fhdr;
  249. dcd_v1_t *dcd_v1 = &hdr_v1->dcd_table;
  250. uint32_t size, length, ver;
  251. size = dcd_v1->preamble.length;
  252. if (size > (MAX_HW_CFG_SIZE_V1 * sizeof(dcd_type_addr_data_t))) {
  253. fprintf(stderr,
  254. "Error: Image corrupt DCD size %d exceed maximum %d\n",
  255. (uint32_t)(size / sizeof(dcd_type_addr_data_t)),
  256. MAX_HW_CFG_SIZE_V1);
  257. exit(EXIT_FAILURE);
  258. }
  259. length = dcd_v1->preamble.length / sizeof(dcd_type_addr_data_t);
  260. ver = detect_imximage_version(imx_hdr);
  261. printf("Image Type: Freescale IMX Boot Image\n");
  262. printf("Image Ver: %x", ver);
  263. printf("%s\n", get_table_entry_name(imximage_versions, NULL, ver));
  264. printf("Data Size: ");
  265. genimg_print_size(dcd_v1->addr_data[length].type);
  266. printf("Load Address: %08x\n", (uint32_t)fhdr_v1->app_dest_ptr);
  267. printf("Entry Point: %08x\n", (uint32_t)fhdr_v1->app_code_jump_vector);
  268. }
  269. static void print_hdr_v2(struct imx_header *imx_hdr)
  270. {
  271. imx_header_v2_t *hdr_v2 = &imx_hdr->header.hdr_v2;
  272. flash_header_v2_t *fhdr_v2 = &hdr_v2->fhdr;
  273. dcd_v2_t *dcd_v2 = &hdr_v2->dcd_table;
  274. uint32_t size, version;
  275. size = be16_to_cpu(dcd_v2->header.length) - 8;
  276. if (size > (MAX_HW_CFG_SIZE_V2 * sizeof(dcd_addr_data_t))) {
  277. fprintf(stderr,
  278. "Error: Image corrupt DCD size %d exceed maximum %d\n",
  279. (uint32_t)(size / sizeof(dcd_addr_data_t)),
  280. MAX_HW_CFG_SIZE_V2);
  281. exit(EXIT_FAILURE);
  282. }
  283. version = detect_imximage_version(imx_hdr);
  284. printf("Image Type: Freescale IMX Boot Image\n");
  285. printf("Image Ver: %x", version);
  286. printf("%s\n", get_table_entry_name(imximage_versions, NULL, version));
  287. printf("Data Size: ");
  288. genimg_print_size(hdr_v2->boot_data.size);
  289. printf("Load Address: %08x\n", (uint32_t)fhdr_v2->boot_data_ptr);
  290. printf("Entry Point: %08x\n", (uint32_t)fhdr_v2->entry);
  291. if (fhdr_v2->csf && (imximage_ivt_offset != UNDEFINED) &&
  292. (imximage_csf_size != UNDEFINED)) {
  293. printf("HAB Blocks: %08x %08x %08x\n",
  294. (uint32_t)fhdr_v2->self, 0,
  295. hdr_v2->boot_data.size - imximage_ivt_offset -
  296. imximage_csf_size);
  297. }
  298. }
  299. static void parse_cfg_cmd(struct imx_header *imxhdr, int32_t cmd, char *token,
  300. char *name, int lineno, int fld, int dcd_len)
  301. {
  302. int value;
  303. static int cmd_ver_first = ~0;
  304. switch (cmd) {
  305. case CMD_IMAGE_VERSION:
  306. imximage_version = get_cfg_value(token, name, lineno);
  307. if (cmd_ver_first == 0) {
  308. fprintf(stderr, "Error: %s[%d] - IMAGE_VERSION "
  309. "command need be the first before other "
  310. "valid command in the file\n", name, lineno);
  311. exit(EXIT_FAILURE);
  312. }
  313. cmd_ver_first = 1;
  314. set_hdr_func();
  315. break;
  316. case CMD_BOOT_FROM:
  317. imximage_ivt_offset = get_table_entry_id(imximage_boot_offset,
  318. "imximage boot option", token);
  319. if (imximage_ivt_offset == -1) {
  320. fprintf(stderr, "Error: %s[%d] -Invalid boot device"
  321. "(%s)\n", name, lineno, token);
  322. exit(EXIT_FAILURE);
  323. }
  324. imximage_init_loadsize =
  325. get_table_entry_id(imximage_boot_loadsize,
  326. "imximage boot option", token);
  327. if (imximage_init_loadsize == -1) {
  328. fprintf(stderr,
  329. "Error: %s[%d] -Invalid boot device(%s)\n",
  330. name, lineno, token);
  331. exit(EXIT_FAILURE);
  332. }
  333. /*
  334. * The SOC loads from the storage starting at address 0
  335. * then ensures that the load size contains the offset
  336. */
  337. if (imximage_init_loadsize < imximage_ivt_offset)
  338. imximage_init_loadsize = imximage_ivt_offset;
  339. if (unlikely(cmd_ver_first != 1))
  340. cmd_ver_first = 0;
  341. break;
  342. case CMD_BOOT_OFFSET:
  343. imximage_ivt_offset = get_cfg_value(token, name, lineno);
  344. if (unlikely(cmd_ver_first != 1))
  345. cmd_ver_first = 0;
  346. break;
  347. case CMD_DATA:
  348. value = get_cfg_value(token, name, lineno);
  349. (*set_dcd_val)(imxhdr, name, lineno, fld, value, dcd_len);
  350. if (unlikely(cmd_ver_first != 1))
  351. cmd_ver_first = 0;
  352. break;
  353. case CMD_CSF:
  354. if (imximage_version != 2) {
  355. fprintf(stderr,
  356. "Error: %s[%d] - CSF only supported for VERSION 2(%s)\n",
  357. name, lineno, token);
  358. exit(EXIT_FAILURE);
  359. }
  360. imximage_csf_size = get_cfg_value(token, name, lineno);
  361. if (unlikely(cmd_ver_first != 1))
  362. cmd_ver_first = 0;
  363. break;
  364. }
  365. }
  366. static void parse_cfg_fld(struct imx_header *imxhdr, int32_t *cmd,
  367. char *token, char *name, int lineno, int fld, int *dcd_len)
  368. {
  369. int value;
  370. switch (fld) {
  371. case CFG_COMMAND:
  372. *cmd = get_table_entry_id(imximage_cmds,
  373. "imximage commands", token);
  374. if (*cmd < 0) {
  375. fprintf(stderr, "Error: %s[%d] - Invalid command"
  376. "(%s)\n", name, lineno, token);
  377. exit(EXIT_FAILURE);
  378. }
  379. break;
  380. case CFG_REG_SIZE:
  381. parse_cfg_cmd(imxhdr, *cmd, token, name, lineno, fld, *dcd_len);
  382. break;
  383. case CFG_REG_ADDRESS:
  384. case CFG_REG_VALUE:
  385. if (*cmd != CMD_DATA)
  386. return;
  387. value = get_cfg_value(token, name, lineno);
  388. (*set_dcd_val)(imxhdr, name, lineno, fld, value, *dcd_len);
  389. if (fld == CFG_REG_VALUE) {
  390. (*dcd_len)++;
  391. if (*dcd_len > max_dcd_entries) {
  392. fprintf(stderr, "Error: %s[%d] -"
  393. "DCD table exceeds maximum size(%d)\n",
  394. name, lineno, max_dcd_entries);
  395. exit(EXIT_FAILURE);
  396. }
  397. }
  398. break;
  399. default:
  400. break;
  401. }
  402. }
  403. static uint32_t parse_cfg_file(struct imx_header *imxhdr, char *name)
  404. {
  405. FILE *fd = NULL;
  406. char *line = NULL;
  407. char *token, *saveptr1, *saveptr2;
  408. int lineno = 0;
  409. int fld;
  410. size_t len;
  411. int dcd_len = 0;
  412. int32_t cmd;
  413. fd = fopen(name, "r");
  414. if (fd == 0) {
  415. fprintf(stderr, "Error: %s - Can't open DCD file\n", name);
  416. exit(EXIT_FAILURE);
  417. }
  418. /*
  419. * Very simple parsing, line starting with # are comments
  420. * and are dropped
  421. */
  422. while ((getline(&line, &len, fd)) > 0) {
  423. lineno++;
  424. token = strtok_r(line, "\r\n", &saveptr1);
  425. if (token == NULL)
  426. continue;
  427. /* Check inside the single line */
  428. for (fld = CFG_COMMAND, cmd = CMD_INVALID,
  429. line = token; ; line = NULL, fld++) {
  430. token = strtok_r(line, " \t", &saveptr2);
  431. if (token == NULL)
  432. break;
  433. /* Drop all text starting with '#' as comments */
  434. if (token[0] == '#')
  435. break;
  436. parse_cfg_fld(imxhdr, &cmd, token, name,
  437. lineno, fld, &dcd_len);
  438. }
  439. }
  440. (*set_dcd_rst)(imxhdr, dcd_len, name, lineno);
  441. fclose(fd);
  442. /* Exit if there is no BOOT_FROM field specifying the flash_offset */
  443. if (imximage_ivt_offset == FLASH_OFFSET_UNDEFINED) {
  444. fprintf(stderr, "Error: No BOOT_FROM tag in %s\n", name);
  445. exit(EXIT_FAILURE);
  446. }
  447. return dcd_len;
  448. }
  449. static int imximage_check_image_types(uint8_t type)
  450. {
  451. if (type == IH_TYPE_IMXIMAGE)
  452. return EXIT_SUCCESS;
  453. else
  454. return EXIT_FAILURE;
  455. }
  456. static int imximage_verify_header(unsigned char *ptr, int image_size,
  457. struct image_tool_params *params)
  458. {
  459. struct imx_header *imx_hdr = (struct imx_header *) ptr;
  460. if (detect_imximage_version(imx_hdr) == IMXIMAGE_VER_INVALID)
  461. return -FDT_ERR_BADSTRUCTURE;
  462. return 0;
  463. }
  464. static void imximage_print_header(const void *ptr)
  465. {
  466. struct imx_header *imx_hdr = (struct imx_header *) ptr;
  467. uint32_t version = detect_imximage_version(imx_hdr);
  468. switch (version) {
  469. case IMXIMAGE_V1:
  470. print_hdr_v1(imx_hdr);
  471. break;
  472. case IMXIMAGE_V2:
  473. print_hdr_v2(imx_hdr);
  474. break;
  475. default:
  476. err_imximage_version(version);
  477. break;
  478. }
  479. }
  480. static void imximage_set_header(void *ptr, struct stat *sbuf, int ifd,
  481. struct image_tool_params *params)
  482. {
  483. struct imx_header *imxhdr = (struct imx_header *)ptr;
  484. uint32_t dcd_len;
  485. /*
  486. * In order to not change the old imx cfg file
  487. * by adding VERSION command into it, here need
  488. * set up function ptr group to V1 by default.
  489. */
  490. imximage_version = IMXIMAGE_V1;
  491. /* Be able to detect if the cfg file has no BOOT_FROM tag */
  492. imximage_ivt_offset = FLASH_OFFSET_UNDEFINED;
  493. imximage_csf_size = 0;
  494. set_hdr_func();
  495. /* Parse dcd configuration file */
  496. dcd_len = parse_cfg_file(imxhdr, params->imagename);
  497. /* Set the imx header */
  498. (*set_imx_hdr)(imxhdr, dcd_len, params->ep, imximage_ivt_offset);
  499. /*
  500. * ROM bug alert
  501. *
  502. * MX53 only loads 512 byte multiples in case of SD boot.
  503. * MX53 only loads NAND page multiples in case of NAND boot and
  504. * supports up to 4096 byte large pages, thus align to 4096.
  505. *
  506. * The remaining fraction of a block bytes would not be loaded!
  507. */
  508. *header_size_ptr = ROUND(sbuf->st_size, 4096);
  509. if (csf_ptr && imximage_csf_size) {
  510. *csf_ptr = params->ep - imximage_init_loadsize +
  511. *header_size_ptr;
  512. *header_size_ptr += imximage_csf_size;
  513. }
  514. }
  515. int imximage_check_params(struct image_tool_params *params)
  516. {
  517. if (!params)
  518. return CFG_INVALID;
  519. if (!strlen(params->imagename)) {
  520. fprintf(stderr, "Error: %s - Configuration file not specified, "
  521. "it is needed for imximage generation\n",
  522. params->cmdname);
  523. return CFG_INVALID;
  524. }
  525. /*
  526. * Check parameters:
  527. * XIP is not allowed and verify that incompatible
  528. * parameters are not sent at the same time
  529. * For example, if list is required a data image must not be provided
  530. */
  531. return (params->dflag && (params->fflag || params->lflag)) ||
  532. (params->fflag && (params->dflag || params->lflag)) ||
  533. (params->lflag && (params->dflag || params->fflag)) ||
  534. (params->xflag) || !(strlen(params->imagename));
  535. }
  536. static int imximage_generate(struct image_tool_params *params,
  537. struct image_type_params *tparams)
  538. {
  539. struct imx_header *imxhdr;
  540. size_t alloc_len;
  541. struct stat sbuf;
  542. char *datafile = params->datafile;
  543. uint32_t pad_len;
  544. memset(&imximage_header, 0, sizeof(imximage_header));
  545. /*
  546. * In order to not change the old imx cfg file
  547. * by adding VERSION command into it, here need
  548. * set up function ptr group to V1 by default.
  549. */
  550. imximage_version = IMXIMAGE_V1;
  551. /* Be able to detect if the cfg file has no BOOT_FROM tag */
  552. imximage_ivt_offset = FLASH_OFFSET_UNDEFINED;
  553. imximage_csf_size = 0;
  554. set_hdr_func();
  555. /* Parse dcd configuration file */
  556. parse_cfg_file(&imximage_header, params->imagename);
  557. /* TODO: check i.MX image V1 handling, for now use 'old' style */
  558. if (imximage_version == IMXIMAGE_V1) {
  559. alloc_len = 4096;
  560. } else {
  561. if (imximage_init_loadsize < imximage_ivt_offset +
  562. sizeof(imx_header_v2_t))
  563. imximage_init_loadsize = imximage_ivt_offset +
  564. sizeof(imx_header_v2_t);
  565. alloc_len = imximage_init_loadsize - imximage_ivt_offset;
  566. }
  567. if (alloc_len < sizeof(struct imx_header)) {
  568. fprintf(stderr, "%s: header error\n",
  569. params->cmdname);
  570. exit(EXIT_FAILURE);
  571. }
  572. imxhdr = malloc(alloc_len);
  573. if (!imxhdr) {
  574. fprintf(stderr, "%s: malloc return failure: %s\n",
  575. params->cmdname, strerror(errno));
  576. exit(EXIT_FAILURE);
  577. }
  578. memset(imxhdr, 0, alloc_len);
  579. tparams->header_size = alloc_len;
  580. tparams->hdr = imxhdr;
  581. /* determine data image file length */
  582. if (stat(datafile, &sbuf) < 0) {
  583. fprintf(stderr, "%s: Can't stat %s: %s\n",
  584. params->cmdname, datafile, strerror(errno));
  585. exit(EXIT_FAILURE);
  586. }
  587. pad_len = ROUND(sbuf.st_size, 4096) - sbuf.st_size;
  588. /* TODO: check i.MX image V1 handling, for now use 'old' style */
  589. if (imximage_version == IMXIMAGE_V1)
  590. return 0;
  591. else
  592. return pad_len;
  593. }
  594. /*
  595. * imximage parameters
  596. */
  597. static struct image_type_params imximage_params = {
  598. .name = "Freescale i.MX Boot Image support",
  599. .header_size = 0,
  600. .hdr = NULL,
  601. .check_image_type = imximage_check_image_types,
  602. .verify_header = imximage_verify_header,
  603. .print_header = imximage_print_header,
  604. .set_header = imximage_set_header,
  605. .check_params = imximage_check_params,
  606. .vrec_header = imximage_generate,
  607. };
  608. void init_imx_image_type(void)
  609. {
  610. register_image_type(&imximage_params);
  611. }