adtimg.c 5.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * (C) Copyright 2018 Linaro Ltd.
  4. * Sam Protsenko <semen.protsenko@linaro.org>
  5. * Eugeniu Rosca <rosca.eugeniu@gmail.com>
  6. */
  7. #include <command.h>
  8. #include <env.h>
  9. #include <image-android-dt.h>
  10. #include <common.h>
  11. #define OPT_INDEX "--index"
  12. /*
  13. * Current/working DTB/DTBO Android image address.
  14. * Similar to 'working_fdt' variable in 'fdt' command.
  15. */
  16. static ulong working_img;
  17. static int do_adtimg_addr(struct cmd_tbl *cmdtp, int flag, int argc,
  18. char *const argv[])
  19. {
  20. char *endp;
  21. ulong hdr_addr;
  22. if (argc != 2)
  23. return CMD_RET_USAGE;
  24. hdr_addr = hextoul(argv[1], &endp);
  25. if (*endp != '\0') {
  26. printf("Error: Wrong image address '%s'\n", argv[1]);
  27. return CMD_RET_FAILURE;
  28. }
  29. /*
  30. * Allow users to set an address prior to copying the DTB/DTBO
  31. * image to that same address, i.e. skip header verification.
  32. */
  33. working_img = hdr_addr;
  34. return CMD_RET_SUCCESS;
  35. }
  36. static int adtimg_check_working_img(void)
  37. {
  38. if (!working_img) {
  39. printf("Error: Please, call 'adtimg addr <addr>'. Aborting!\n");
  40. return CMD_RET_FAILURE;
  41. }
  42. if (!android_dt_check_header(working_img)) {
  43. printf("Error: Invalid image header at 0x%lx\n", working_img);
  44. return CMD_RET_FAILURE;
  45. }
  46. return CMD_RET_SUCCESS;
  47. }
  48. static int do_adtimg_dump(struct cmd_tbl *cmdtp, int flag, int argc,
  49. char *const argv[])
  50. {
  51. if (argc != 1)
  52. return CMD_RET_USAGE;
  53. if (adtimg_check_working_img() != CMD_RET_SUCCESS)
  54. return CMD_RET_FAILURE;
  55. android_dt_print_contents(working_img);
  56. return CMD_RET_SUCCESS;
  57. }
  58. static int adtimg_getopt_u32(char * const opt, char * const name, u32 *optval)
  59. {
  60. char *endp, *str;
  61. u32 val;
  62. if (!opt || !name || !optval)
  63. return CMD_RET_FAILURE;
  64. str = strchr(opt, '=');
  65. if (!str) {
  66. printf("Error: Option '%s' not followed by '='\n", name);
  67. return CMD_RET_FAILURE;
  68. }
  69. if (*++str == '\0') {
  70. printf("Error: Option '%s=' not followed by value\n", name);
  71. return CMD_RET_FAILURE;
  72. }
  73. val = simple_strtoul(str, &endp, 0);
  74. if (*endp != '\0') {
  75. printf("Error: Wrong integer value '%s=%s'\n", name, str);
  76. return CMD_RET_FAILURE;
  77. }
  78. *optval = val;
  79. return CMD_RET_SUCCESS;
  80. }
  81. static int adtimg_getopt_index(int argc, char *const argv[], u32 *index,
  82. char **avar, char **svar)
  83. {
  84. int ret;
  85. if (!argv || !avar || !svar)
  86. return CMD_RET_FAILURE;
  87. if (argc > 3) {
  88. printf("Error: Unexpected argument '%s'\n", argv[3]);
  89. return CMD_RET_FAILURE;
  90. }
  91. ret = adtimg_getopt_u32(argv[0], OPT_INDEX, index);
  92. if (ret != CMD_RET_SUCCESS)
  93. return ret;
  94. if (argc > 1)
  95. *avar = argv[1];
  96. if (argc > 2)
  97. *svar = argv[2];
  98. return CMD_RET_SUCCESS;
  99. }
  100. static int adtimg_get_dt_by_index(int argc, char *const argv[])
  101. {
  102. ulong addr;
  103. u32 index, size;
  104. int ret;
  105. char *avar = NULL, *svar = NULL;
  106. ret = adtimg_getopt_index(argc, argv, &index, &avar, &svar);
  107. if (ret != CMD_RET_SUCCESS)
  108. return ret;
  109. if (!android_dt_get_fdt_by_index(working_img, index, &addr, &size))
  110. return CMD_RET_FAILURE;
  111. if (avar && svar) {
  112. ret = env_set_hex(avar, addr);
  113. if (ret) {
  114. printf("Error: Can't set '%s' to 0x%lx\n", avar, addr);
  115. return CMD_RET_FAILURE;
  116. }
  117. ret = env_set_hex(svar, size);
  118. if (ret) {
  119. printf("Error: Can't set '%s' to 0x%x\n", svar, size);
  120. return CMD_RET_FAILURE;
  121. }
  122. } else if (avar) {
  123. ret = env_set_hex(avar, addr);
  124. if (ret) {
  125. printf("Error: Can't set '%s' to 0x%lx\n", avar, addr);
  126. return CMD_RET_FAILURE;
  127. }
  128. printf("0x%x (%d)\n", size, size);
  129. } else {
  130. printf("0x%lx, 0x%x (%d)\n", addr, size, size);
  131. }
  132. return CMD_RET_SUCCESS;
  133. }
  134. static int adtimg_get_dt(int argc, char *const argv[])
  135. {
  136. if (argc < 2) {
  137. printf("Error: No options passed to '%s'\n", argv[0]);
  138. return CMD_RET_FAILURE;
  139. }
  140. /* Strip off leading 'dt' command argument */
  141. argc--;
  142. argv++;
  143. if (!strncmp(argv[0], OPT_INDEX, sizeof(OPT_INDEX) - 1))
  144. return adtimg_get_dt_by_index(argc, argv);
  145. printf("Error: Option '%s' not supported\n", argv[0]);
  146. return CMD_RET_FAILURE;
  147. }
  148. static int do_adtimg_get(struct cmd_tbl *cmdtp, int flag, int argc,
  149. char *const argv[])
  150. {
  151. if (argc < 2) {
  152. printf("Error: No arguments passed to '%s'\n", argv[0]);
  153. return CMD_RET_FAILURE;
  154. }
  155. if (adtimg_check_working_img() != CMD_RET_SUCCESS)
  156. return CMD_RET_FAILURE;
  157. /* Strip off leading 'get' command argument */
  158. argc--;
  159. argv++;
  160. if (!strcmp(argv[0], "dt"))
  161. return adtimg_get_dt(argc, argv);
  162. printf("Error: Wrong argument '%s'\n", argv[0]);
  163. return CMD_RET_FAILURE;
  164. }
  165. static struct cmd_tbl cmd_adtimg_sub[] = {
  166. U_BOOT_CMD_MKENT(addr, CONFIG_SYS_MAXARGS, 1, do_adtimg_addr, "", ""),
  167. U_BOOT_CMD_MKENT(dump, CONFIG_SYS_MAXARGS, 1, do_adtimg_dump, "", ""),
  168. U_BOOT_CMD_MKENT(get, CONFIG_SYS_MAXARGS, 1, do_adtimg_get, "", ""),
  169. };
  170. static int do_adtimg(struct cmd_tbl *cmdtp, int flag, int argc,
  171. char *const argv[])
  172. {
  173. struct cmd_tbl *cp;
  174. cp = find_cmd_tbl(argv[1], cmd_adtimg_sub, ARRAY_SIZE(cmd_adtimg_sub));
  175. /* Strip off leading 'adtimg' command argument */
  176. argc--;
  177. argv++;
  178. if (!cp || argc > cp->maxargs)
  179. return CMD_RET_USAGE;
  180. if (flag == CMD_FLAG_REPEAT && !cmd_is_repeatable(cp))
  181. return CMD_RET_SUCCESS;
  182. return cp->cmd(cmdtp, flag, argc, argv);
  183. }
  184. U_BOOT_CMD(
  185. adtimg, CONFIG_SYS_MAXARGS, 0, do_adtimg,
  186. "manipulate dtb/dtbo Android image",
  187. "addr <addr> - Set image location to <addr>\n"
  188. "adtimg dump - Print out image contents\n"
  189. "adtimg get dt --index=<index> [avar [svar]] - Get DT address/size by index\n"
  190. "\n"
  191. "Legend:\n"
  192. " - <addr>: DTB/DTBO image address (hex) in RAM\n"
  193. " - <index>: index (hex/dec) of desired DT in the image\n"
  194. " - <avar>: variable name to contain DT address (hex)\n"
  195. " - <svar>: variable name to contain DT size (hex)"
  196. );