imximage.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574
  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. * See file CREDITS for list of people who contributed to this
  10. * project.
  11. *
  12. * This program is free software; you can redistribute it and/or
  13. * modify it under the terms of the GNU General Public License as
  14. * published by the Free Software Foundation; either version 2 of
  15. * the License, or (at your option) any later version.
  16. *
  17. * This program is distributed in the hope that it will be useful,
  18. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20. * GNU General Public License for more details.
  21. *
  22. * You should have received a copy of the GNU General Public License
  23. * along with this program; if not, write to the Free Software
  24. * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  25. * MA 02111-1307 USA
  26. */
  27. /* Required to obtain the getline prototype from stdio.h */
  28. #define _GNU_SOURCE
  29. #include "mkimage.h"
  30. #include <image.h>
  31. #include "imximage.h"
  32. /*
  33. * Supported commands for configuration file
  34. */
  35. static table_entry_t imximage_cmds[] = {
  36. {CMD_BOOT_FROM, "BOOT_FROM", "boot command", },
  37. {CMD_DATA, "DATA", "Reg Write Data", },
  38. {CMD_IMAGE_VERSION, "IMAGE_VERSION", "image version", },
  39. {-1, "", "", },
  40. };
  41. /*
  42. * Supported Boot options for configuration file
  43. * this is needed to set the correct flash offset
  44. */
  45. static table_entry_t imximage_bootops[] = {
  46. {FLASH_OFFSET_SPI, "spi", "SPI Flash", },
  47. {FLASH_OFFSET_NAND, "nand", "NAND Flash", },
  48. {FLASH_OFFSET_SD, "sd", "SD Card", },
  49. {FLASH_OFFSET_ONENAND, "onenand", "OneNAND 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 compatible)", },
  58. {-1, "", " (Invalid)", },
  59. };
  60. static struct imx_header imximage_header;
  61. static uint32_t imximage_version;
  62. static set_dcd_val_t set_dcd_val;
  63. static set_dcd_rst_t set_dcd_rst;
  64. static set_imx_hdr_t set_imx_hdr;
  65. static uint32_t get_cfg_value(char *token, char *name, int linenr)
  66. {
  67. char *endptr;
  68. uint32_t value;
  69. errno = 0;
  70. value = strtoul(token, &endptr, 16);
  71. if (errno || (token == endptr)) {
  72. fprintf(stderr, "Error: %s[%d] - Invalid hex data(%s)\n",
  73. name, linenr, token);
  74. exit(EXIT_FAILURE);
  75. }
  76. return value;
  77. }
  78. static uint32_t detect_imximage_version(struct imx_header *imx_hdr)
  79. {
  80. imx_header_v1_t *hdr_v1 = &imx_hdr->header.hdr_v1;
  81. imx_header_v2_t *hdr_v2 = &imx_hdr->header.hdr_v2;
  82. flash_header_v1_t *fhdr_v1 = &hdr_v1->fhdr;
  83. flash_header_v2_t *fhdr_v2 = &hdr_v2->fhdr;
  84. /* Try to detect V1 */
  85. if ((fhdr_v1->app_code_barker == APP_CODE_BARKER) &&
  86. (hdr_v1->dcd_table.preamble.barker == DCD_BARKER))
  87. return IMXIMAGE_V1;
  88. /* Try to detect V2 */
  89. if ((fhdr_v2->header.tag == IVT_HEADER_TAG) &&
  90. (hdr_v2->dcd_table.header.tag == DCD_HEADER_TAG))
  91. return IMXIMAGE_V2;
  92. return IMXIMAGE_VER_INVALID;
  93. }
  94. static void err_imximage_version(int version)
  95. {
  96. fprintf(stderr,
  97. "Error: Unsupported imximage version:%d\n", version);
  98. exit(EXIT_FAILURE);
  99. }
  100. static void set_dcd_val_v1(struct imx_header *imxhdr, char *name, int lineno,
  101. int fld, uint32_t value, uint32_t off)
  102. {
  103. dcd_v1_t *dcd_v1 = &imxhdr->header.hdr_v1.dcd_table;
  104. switch (fld) {
  105. case CFG_REG_SIZE:
  106. /* Byte, halfword, word */
  107. if ((value != 1) && (value != 2) && (value != 4)) {
  108. fprintf(stderr, "Error: %s[%d] - "
  109. "Invalid register size " "(%d)\n",
  110. name, lineno, value);
  111. exit(EXIT_FAILURE);
  112. }
  113. dcd_v1->addr_data[off].type = value;
  114. break;
  115. case CFG_REG_ADDRESS:
  116. dcd_v1->addr_data[off].addr = value;
  117. break;
  118. case CFG_REG_VALUE:
  119. dcd_v1->addr_data[off].value = value;
  120. break;
  121. default:
  122. break;
  123. }
  124. }
  125. static void set_dcd_val_v2(struct imx_header *imxhdr, char *name, int lineno,
  126. int fld, uint32_t value, uint32_t off)
  127. {
  128. dcd_v2_t *dcd_v2 = &imxhdr->header.hdr_v2.dcd_table;
  129. switch (fld) {
  130. case CFG_REG_ADDRESS:
  131. dcd_v2->addr_data[off].addr = cpu_to_be32(value);
  132. break;
  133. case CFG_REG_VALUE:
  134. dcd_v2->addr_data[off].value = cpu_to_be32(value);
  135. break;
  136. default:
  137. break;
  138. }
  139. }
  140. /*
  141. * Complete setting up the rest field of DCD of V1
  142. * such as barker code and DCD data length.
  143. */
  144. static void set_dcd_rst_v1(struct imx_header *imxhdr, uint32_t dcd_len,
  145. char *name, int lineno)
  146. {
  147. dcd_v1_t *dcd_v1 = &imxhdr->header.hdr_v1.dcd_table;
  148. if (dcd_len > MAX_HW_CFG_SIZE_V1) {
  149. fprintf(stderr, "Error: %s[%d] -"
  150. "DCD table exceeds maximum size(%d)\n",
  151. name, lineno, MAX_HW_CFG_SIZE_V1);
  152. exit(EXIT_FAILURE);
  153. }
  154. dcd_v1->preamble.barker = DCD_BARKER;
  155. dcd_v1->preamble.length = dcd_len * sizeof(dcd_type_addr_data_t);
  156. }
  157. /*
  158. * Complete setting up the reset field of DCD of V2
  159. * such as DCD tag, version, length, etc.
  160. */
  161. static void set_dcd_rst_v2(struct imx_header *imxhdr, uint32_t dcd_len,
  162. char *name, int lineno)
  163. {
  164. dcd_v2_t *dcd_v2 = &imxhdr->header.hdr_v2.dcd_table;
  165. if (dcd_len > MAX_HW_CFG_SIZE_V2) {
  166. fprintf(stderr, "Error: %s[%d] -"
  167. "DCD table exceeds maximum size(%d)\n",
  168. name, lineno, MAX_HW_CFG_SIZE_V2);
  169. exit(EXIT_FAILURE);
  170. }
  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. struct stat *sbuf,
  182. struct mkimage_params *params)
  183. {
  184. imx_header_v1_t *hdr_v1 = &imxhdr->header.hdr_v1;
  185. flash_header_v1_t *fhdr_v1 = &hdr_v1->fhdr;
  186. dcd_v1_t *dcd_v1 = &hdr_v1->dcd_table;
  187. uint32_t base_offset;
  188. /* Set default offset */
  189. imxhdr->flash_offset = FLASH_OFFSET_STANDARD;
  190. /* Set magic number */
  191. fhdr_v1->app_code_barker = APP_CODE_BARKER;
  192. fhdr_v1->app_dest_ptr = params->addr;
  193. fhdr_v1->app_dest_ptr = params->ep - imxhdr->flash_offset -
  194. sizeof(struct imx_header);
  195. fhdr_v1->app_code_jump_vector = params->ep;
  196. base_offset = fhdr_v1->app_dest_ptr + imxhdr->flash_offset ;
  197. fhdr_v1->dcd_ptr_ptr =
  198. (uint32_t) (offsetof(flash_header_v1_t, dcd_ptr) -
  199. offsetof(flash_header_v1_t, app_code_jump_vector) +
  200. base_offset);
  201. fhdr_v1->dcd_ptr = base_offset +
  202. offsetof(imx_header_v1_t, dcd_table);
  203. /* The external flash header must be at the end of the DCD table */
  204. dcd_v1->addr_data[dcd_len].type = sbuf->st_size +
  205. imxhdr->flash_offset +
  206. sizeof(struct imx_header);
  207. /* Security feature are not supported */
  208. fhdr_v1->app_code_csf = 0;
  209. fhdr_v1->super_root_key = 0;
  210. }
  211. static void set_imx_hdr_v2(struct imx_header *imxhdr, uint32_t dcd_len,
  212. struct stat *sbuf,
  213. struct mkimage_params *params)
  214. {
  215. imx_header_v2_t *hdr_v2 = &imxhdr->header.hdr_v2;
  216. flash_header_v2_t *fhdr_v2 = &hdr_v2->fhdr;
  217. /* Set default offset */
  218. imxhdr->flash_offset = FLASH_OFFSET_STANDARD;
  219. /* Set magic number */
  220. fhdr_v2->header.tag = IVT_HEADER_TAG; /* 0xD1 */
  221. fhdr_v2->header.length = cpu_to_be16(sizeof(flash_header_v2_t));
  222. fhdr_v2->header.version = IVT_VERSION; /* 0x40 */
  223. fhdr_v2->entry = params->ep;
  224. fhdr_v2->reserved1 = fhdr_v2->reserved2 = 0;
  225. fhdr_v2->self = params->ep - sizeof(struct imx_header);
  226. fhdr_v2->dcd_ptr = fhdr_v2->self +
  227. offsetof(imx_header_v2_t, dcd_table);
  228. fhdr_v2->boot_data_ptr = fhdr_v2->self +
  229. offsetof(imx_header_v2_t, boot_data);
  230. hdr_v2->boot_data.start = fhdr_v2->self - imxhdr->flash_offset;
  231. hdr_v2->boot_data.size = sbuf->st_size +
  232. imxhdr->flash_offset +
  233. sizeof(struct imx_header);
  234. /* Security feature are not supported */
  235. fhdr_v2->csf = 0;
  236. }
  237. static void set_hdr_func(struct imx_header *imxhdr)
  238. {
  239. switch (imximage_version) {
  240. case IMXIMAGE_V1:
  241. set_dcd_val = set_dcd_val_v1;
  242. set_dcd_rst = set_dcd_rst_v1;
  243. set_imx_hdr = set_imx_hdr_v1;
  244. break;
  245. case IMXIMAGE_V2:
  246. set_dcd_val = set_dcd_val_v2;
  247. set_dcd_rst = set_dcd_rst_v2;
  248. set_imx_hdr = set_imx_hdr_v2;
  249. break;
  250. default:
  251. err_imximage_version(imximage_version);
  252. break;
  253. }
  254. }
  255. static void print_hdr_v1(struct imx_header *imx_hdr)
  256. {
  257. imx_header_v1_t *hdr_v1 = &imx_hdr->header.hdr_v1;
  258. flash_header_v1_t *fhdr_v1 = &hdr_v1->fhdr;
  259. dcd_v1_t *dcd_v1 = &hdr_v1->dcd_table;
  260. uint32_t size, length, ver;
  261. size = dcd_v1->preamble.length;
  262. if (size > (MAX_HW_CFG_SIZE_V1 * sizeof(dcd_type_addr_data_t))) {
  263. fprintf(stderr,
  264. "Error: Image corrupt DCD size %d exceed maximum %d\n",
  265. (uint32_t)(size / sizeof(dcd_type_addr_data_t)),
  266. MAX_HW_CFG_SIZE_V1);
  267. exit(EXIT_FAILURE);
  268. }
  269. length = dcd_v1->preamble.length / sizeof(dcd_type_addr_data_t);
  270. ver = detect_imximage_version(imx_hdr);
  271. printf("Image Type: Freescale IMX Boot Image\n");
  272. printf("Image Ver: %x", ver);
  273. printf("%s\n", get_table_entry_name(imximage_versions, NULL, ver));
  274. printf("Data Size: ");
  275. genimg_print_size(dcd_v1->addr_data[length].type);
  276. printf("Load Address: %08x\n", (uint32_t)fhdr_v1->app_dest_ptr);
  277. printf("Entry Point: %08x\n", (uint32_t)fhdr_v1->app_code_jump_vector);
  278. }
  279. static void print_hdr_v2(struct imx_header *imx_hdr)
  280. {
  281. imx_header_v2_t *hdr_v2 = &imx_hdr->header.hdr_v2;
  282. flash_header_v2_t *fhdr_v2 = &hdr_v2->fhdr;
  283. dcd_v2_t *dcd_v2 = &hdr_v2->dcd_table;
  284. uint32_t size, version;
  285. size = be16_to_cpu(dcd_v2->header.length) - 8;
  286. if (size > (MAX_HW_CFG_SIZE_V2 * sizeof(dcd_addr_data_t))) {
  287. fprintf(stderr,
  288. "Error: Image corrupt DCD size %d exceed maximum %d\n",
  289. (uint32_t)(size / sizeof(dcd_addr_data_t)),
  290. MAX_HW_CFG_SIZE_V2);
  291. exit(EXIT_FAILURE);
  292. }
  293. version = detect_imximage_version(imx_hdr);
  294. printf("Image Type: Freescale IMX Boot Image\n");
  295. printf("Image Ver: %x", version);
  296. printf("%s\n", get_table_entry_name(imximage_versions, NULL, version));
  297. printf("Data Size: ");
  298. genimg_print_size(hdr_v2->boot_data.size);
  299. printf("Load Address: %08x\n", (uint32_t)fhdr_v2->boot_data_ptr);
  300. printf("Entry Point: %08x\n", (uint32_t)fhdr_v2->entry);
  301. }
  302. static void parse_cfg_cmd(struct imx_header *imxhdr, int32_t cmd, char *token,
  303. char *name, int lineno, int fld, int dcd_len)
  304. {
  305. int value;
  306. static int cmd_ver_first = ~0;
  307. switch (cmd) {
  308. case CMD_IMAGE_VERSION:
  309. imximage_version = get_cfg_value(token, name, lineno);
  310. if (cmd_ver_first == 0) {
  311. fprintf(stderr, "Error: %s[%d] - IMAGE_VERSION "
  312. "command need be the first before other "
  313. "valid command in the file\n", name, lineno);
  314. exit(EXIT_FAILURE);
  315. }
  316. cmd_ver_first = 1;
  317. set_hdr_func(imxhdr);
  318. break;
  319. case CMD_BOOT_FROM:
  320. imxhdr->flash_offset = get_table_entry_id(imximage_bootops,
  321. "imximage boot option", token);
  322. if (imxhdr->flash_offset == -1) {
  323. fprintf(stderr, "Error: %s[%d] -Invalid boot device"
  324. "(%s)\n", name, lineno, token);
  325. exit(EXIT_FAILURE);
  326. }
  327. if (unlikely(cmd_ver_first != 1))
  328. cmd_ver_first = 0;
  329. break;
  330. case CMD_DATA:
  331. value = get_cfg_value(token, name, lineno);
  332. (*set_dcd_val)(imxhdr, name, lineno, fld, value, dcd_len);
  333. if (unlikely(cmd_ver_first != 1))
  334. cmd_ver_first = 0;
  335. break;
  336. }
  337. }
  338. static void parse_cfg_fld(struct imx_header *imxhdr, int32_t *cmd,
  339. char *token, char *name, int lineno, int fld, int *dcd_len)
  340. {
  341. int value;
  342. switch (fld) {
  343. case CFG_COMMAND:
  344. *cmd = get_table_entry_id(imximage_cmds,
  345. "imximage commands", token);
  346. if (*cmd < 0) {
  347. fprintf(stderr, "Error: %s[%d] - Invalid command"
  348. "(%s)\n", name, lineno, token);
  349. exit(EXIT_FAILURE);
  350. }
  351. break;
  352. case CFG_REG_SIZE:
  353. parse_cfg_cmd(imxhdr, *cmd, token, name, lineno, fld, *dcd_len);
  354. break;
  355. case CFG_REG_ADDRESS:
  356. case CFG_REG_VALUE:
  357. if (*cmd != CMD_DATA)
  358. return;
  359. value = get_cfg_value(token, name, lineno);
  360. (*set_dcd_val)(imxhdr, name, lineno, fld, value, *dcd_len);
  361. if (fld == CFG_REG_VALUE)
  362. (*dcd_len)++;
  363. break;
  364. default:
  365. break;
  366. }
  367. }
  368. static uint32_t parse_cfg_file(struct imx_header *imxhdr, char *name)
  369. {
  370. FILE *fd = NULL;
  371. char *line = NULL;
  372. char *token, *saveptr1, *saveptr2;
  373. int lineno = 0;
  374. int fld;
  375. size_t len;
  376. int dcd_len = 0;
  377. int32_t cmd;
  378. fd = fopen(name, "r");
  379. if (fd == 0) {
  380. fprintf(stderr, "Error: %s - Can't open DCD file\n", name);
  381. exit(EXIT_FAILURE);
  382. }
  383. /* Very simple parsing, line starting with # are comments
  384. * and are dropped
  385. */
  386. while ((getline(&line, &len, fd)) > 0) {
  387. lineno++;
  388. token = strtok_r(line, "\r\n", &saveptr1);
  389. if (token == NULL)
  390. continue;
  391. /* Check inside the single line */
  392. for (fld = CFG_COMMAND, cmd = CMD_INVALID,
  393. line = token; ; line = NULL, fld++) {
  394. token = strtok_r(line, " \t", &saveptr2);
  395. if (token == NULL)
  396. break;
  397. /* Drop all text starting with '#' as comments */
  398. if (token[0] == '#')
  399. break;
  400. parse_cfg_fld(imxhdr, &cmd, token, name,
  401. lineno, fld, &dcd_len);
  402. }
  403. }
  404. (*set_dcd_rst)(imxhdr, dcd_len, name, lineno);
  405. fclose(fd);
  406. return dcd_len;
  407. }
  408. static int imximage_check_image_types(uint8_t type)
  409. {
  410. if (type == IH_TYPE_IMXIMAGE)
  411. return EXIT_SUCCESS;
  412. else
  413. return EXIT_FAILURE;
  414. }
  415. static int imximage_verify_header(unsigned char *ptr, int image_size,
  416. struct mkimage_params *params)
  417. {
  418. struct imx_header *imx_hdr = (struct imx_header *) ptr;
  419. if (detect_imximage_version(imx_hdr) == IMXIMAGE_VER_INVALID)
  420. return -FDT_ERR_BADSTRUCTURE;
  421. return 0;
  422. }
  423. static void imximage_print_header(const void *ptr)
  424. {
  425. struct imx_header *imx_hdr = (struct imx_header *) ptr;
  426. uint32_t version = detect_imximage_version(imx_hdr);
  427. switch (version) {
  428. case IMXIMAGE_V1:
  429. print_hdr_v1(imx_hdr);
  430. break;
  431. case IMXIMAGE_V2:
  432. print_hdr_v2(imx_hdr);
  433. break;
  434. default:
  435. err_imximage_version(version);
  436. break;
  437. }
  438. }
  439. static void imximage_set_header(void *ptr, struct stat *sbuf, int ifd,
  440. struct mkimage_params *params)
  441. {
  442. struct imx_header *imxhdr = (struct imx_header *)ptr;
  443. uint32_t dcd_len;
  444. /*
  445. * In order to not change the old imx cfg file
  446. * by adding VERSION command into it, here need
  447. * set up function ptr group to V1 by default.
  448. */
  449. imximage_version = IMXIMAGE_V1;
  450. set_hdr_func(imxhdr);
  451. /* Parse dcd configuration file */
  452. dcd_len = parse_cfg_file(imxhdr, params->imagename);
  453. /* Set the imx header */
  454. (*set_imx_hdr)(imxhdr, dcd_len, sbuf, params);
  455. }
  456. int imximage_check_params(struct mkimage_params *params)
  457. {
  458. if (!params)
  459. return CFG_INVALID;
  460. if (!strlen(params->imagename)) {
  461. fprintf(stderr, "Error: %s - Configuration file not specified, "
  462. "it is needed for imximage generation\n",
  463. params->cmdname);
  464. return CFG_INVALID;
  465. }
  466. /*
  467. * Check parameters:
  468. * XIP is not allowed and verify that incompatible
  469. * parameters are not sent at the same time
  470. * For example, if list is required a data image must not be provided
  471. */
  472. return (params->dflag && (params->fflag || params->lflag)) ||
  473. (params->fflag && (params->dflag || params->lflag)) ||
  474. (params->lflag && (params->dflag || params->fflag)) ||
  475. (params->xflag) || !(strlen(params->imagename));
  476. }
  477. /*
  478. * imximage parameters
  479. */
  480. static struct image_type_params imximage_params = {
  481. .name = "Freescale i.MX 5x Boot Image support",
  482. .header_size = sizeof(struct imx_header),
  483. .hdr = (void *)&imximage_header,
  484. .check_image_type = imximage_check_image_types,
  485. .verify_header = imximage_verify_header,
  486. .print_header = imximage_print_header,
  487. .set_header = imximage_set_header,
  488. .check_params = imximage_check_params,
  489. };
  490. void init_imx_image_type(void)
  491. {
  492. mkimage_register(&imximage_params);
  493. }