omapimage.c 5.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251
  1. /*
  2. * (C) Copyright 2010
  3. * Linaro LTD, www.linaro.org
  4. * Author: John Rigby <john.rigby@linaro.org>
  5. * Based on TI's signGP.c
  6. *
  7. * (C) Copyright 2009
  8. * Stefano Babic, DENX Software Engineering, sbabic@denx.de.
  9. *
  10. * (C) Copyright 2008
  11. * Marvell Semiconductor <www.marvell.com>
  12. * Written-by: Prafulla Wadaskar <prafulla@marvell.com>
  13. *
  14. * SPDX-License-Identifier: GPL-2.0+
  15. */
  16. #include "imagetool.h"
  17. #include <image.h>
  18. #include "omapimage.h"
  19. /* Header size is CH header rounded up to 512 bytes plus GP header */
  20. #define OMAP_CH_HDR_SIZE 512
  21. #define OMAP_GP_HDR_SIZE (sizeof(struct gp_header))
  22. #define OMAP_FILE_HDR_SIZE (OMAP_CH_HDR_SIZE+OMAP_GP_HDR_SIZE)
  23. static int do_swap32 = 0;
  24. static uint32_t omapimage_swap32(uint32_t data)
  25. {
  26. uint32_t result = 0;
  27. result = (data & 0xFF000000) >> 24;
  28. result |= (data & 0x00FF0000) >> 8;
  29. result |= (data & 0x0000FF00) << 8;
  30. result |= (data & 0x000000FF) << 24;
  31. return result;
  32. }
  33. static uint8_t omapimage_header[OMAP_FILE_HDR_SIZE];
  34. static int omapimage_check_image_types(uint8_t type)
  35. {
  36. if (type == IH_TYPE_OMAPIMAGE)
  37. return EXIT_SUCCESS;
  38. else {
  39. return EXIT_FAILURE;
  40. }
  41. }
  42. /*
  43. * Only the simplest image type is currently supported:
  44. * TOC pointing to CHSETTINGS
  45. * TOC terminator
  46. * CHSETTINGS
  47. *
  48. * padding to OMAP_CH_HDR_SIZE bytes
  49. *
  50. * gp header
  51. * size
  52. * load_addr
  53. */
  54. static int valid_gph_size(uint32_t size)
  55. {
  56. return size;
  57. }
  58. static int valid_gph_load_addr(uint32_t load_addr)
  59. {
  60. return load_addr;
  61. }
  62. static int omapimage_verify_header(unsigned char *ptr, int image_size,
  63. struct image_tool_params *params)
  64. {
  65. struct ch_toc *toc = (struct ch_toc *)ptr;
  66. struct gp_header *gph = (struct gp_header *)(ptr+OMAP_CH_HDR_SIZE);
  67. uint32_t offset, size, gph_size, gph_load_addr;
  68. while (toc->section_offset != 0xffffffff
  69. && toc->section_size != 0xffffffff) {
  70. if (do_swap32) {
  71. offset = omapimage_swap32(toc->section_offset);
  72. size = omapimage_swap32(toc->section_size);
  73. } else {
  74. offset = toc->section_offset;
  75. size = toc->section_size;
  76. }
  77. if (!offset || !size)
  78. return -1;
  79. if (offset >= OMAP_CH_HDR_SIZE ||
  80. offset+size >= OMAP_CH_HDR_SIZE)
  81. return -1;
  82. toc++;
  83. }
  84. if (do_swap32) {
  85. gph_size = omapimage_swap32(gph->size);
  86. gph_load_addr = omapimage_swap32(gph->load_addr);
  87. } else {
  88. gph_size = gph->size;
  89. gph_load_addr = gph->load_addr;
  90. }
  91. if (!valid_gph_size(gph_size))
  92. return -1;
  93. if (!valid_gph_load_addr(gph_load_addr))
  94. return -1;
  95. return 0;
  96. }
  97. static void omapimage_print_section(struct ch_settings *chs)
  98. {
  99. const char *section_name;
  100. if (chs->section_key)
  101. section_name = "CHSETTINGS";
  102. else
  103. section_name = "UNKNOWNKEY";
  104. printf("%s (%x) "
  105. "valid:%x "
  106. "version:%x "
  107. "reserved:%x "
  108. "flags:%x\n",
  109. section_name,
  110. chs->section_key,
  111. chs->valid,
  112. chs->version,
  113. chs->reserved,
  114. chs->flags);
  115. }
  116. static void omapimage_print_header(const void *ptr)
  117. {
  118. const struct ch_toc *toc = (struct ch_toc *)ptr;
  119. const struct gp_header *gph =
  120. (struct gp_header *)(ptr+OMAP_CH_HDR_SIZE);
  121. uint32_t offset, size, gph_size, gph_load_addr;
  122. while (toc->section_offset != 0xffffffff
  123. && toc->section_size != 0xffffffff) {
  124. if (do_swap32) {
  125. offset = omapimage_swap32(toc->section_offset);
  126. size = omapimage_swap32(toc->section_size);
  127. } else {
  128. offset = toc->section_offset;
  129. size = toc->section_size;
  130. }
  131. if (offset >= OMAP_CH_HDR_SIZE ||
  132. offset+size >= OMAP_CH_HDR_SIZE)
  133. exit(EXIT_FAILURE);
  134. printf("Section %s offset %x length %x\n",
  135. toc->section_name,
  136. toc->section_offset,
  137. toc->section_size);
  138. omapimage_print_section((struct ch_settings *)(ptr+offset));
  139. toc++;
  140. }
  141. if (do_swap32) {
  142. gph_size = omapimage_swap32(gph->size);
  143. gph_load_addr = omapimage_swap32(gph->load_addr);
  144. } else {
  145. gph_size = gph->size;
  146. gph_load_addr = gph->load_addr;
  147. }
  148. if (!valid_gph_size(gph_size)) {
  149. fprintf(stderr, "Error: invalid image size %x\n", gph_size);
  150. exit(EXIT_FAILURE);
  151. }
  152. if (!valid_gph_load_addr(gph_load_addr)) {
  153. fprintf(stderr, "Error: invalid image load address %x\n",
  154. gph_load_addr);
  155. exit(EXIT_FAILURE);
  156. }
  157. printf("GP Header: Size %x LoadAddr %x\n", gph_size, gph_load_addr);
  158. }
  159. static int toc_offset(void *hdr, void *member)
  160. {
  161. return member - hdr;
  162. }
  163. static void omapimage_set_header(void *ptr, struct stat *sbuf, int ifd,
  164. struct image_tool_params *params)
  165. {
  166. struct ch_toc *toc = (struct ch_toc *)ptr;
  167. struct ch_settings *chs = (struct ch_settings *)
  168. (ptr + 2 * sizeof(*toc));
  169. struct gp_header *gph = (struct gp_header *)(ptr + OMAP_CH_HDR_SIZE);
  170. toc->section_offset = toc_offset(ptr, chs);
  171. toc->section_size = sizeof(struct ch_settings);
  172. strcpy((char *)toc->section_name, "CHSETTINGS");
  173. chs->section_key = KEY_CHSETTINGS;
  174. chs->valid = 0;
  175. chs->version = 1;
  176. chs->reserved = 0;
  177. chs->flags = 0;
  178. toc++;
  179. memset(toc, 0xff, sizeof(*toc));
  180. gph->size = sbuf->st_size - OMAP_FILE_HDR_SIZE;
  181. gph->load_addr = params->addr;
  182. if (strncmp(params->imagename, "byteswap", 8) == 0) {
  183. do_swap32 = 1;
  184. int swapped = 0;
  185. uint32_t *data = (uint32_t *)ptr;
  186. while (swapped <= (sbuf->st_size / sizeof(uint32_t))) {
  187. *data = omapimage_swap32(*data);
  188. swapped++;
  189. data++;
  190. }
  191. }
  192. }
  193. int omapimage_check_params(struct image_tool_params *params)
  194. {
  195. return (params->dflag && (params->fflag || params->lflag)) ||
  196. (params->fflag && (params->dflag || params->lflag)) ||
  197. (params->lflag && (params->dflag || params->fflag));
  198. }
  199. /*
  200. * omapimage parameters
  201. */
  202. static struct image_type_params omapimage_params = {
  203. .name = "TI OMAP CH/GP Boot Image support",
  204. .header_size = OMAP_FILE_HDR_SIZE,
  205. .hdr = (void *)&omapimage_header,
  206. .check_image_type = omapimage_check_image_types,
  207. .verify_header = omapimage_verify_header,
  208. .print_header = omapimage_print_header,
  209. .set_header = omapimage_set_header,
  210. .check_params = omapimage_check_params,
  211. };
  212. void init_omap_image_type(void)
  213. {
  214. register_image_type(&omapimage_params);
  215. }