atf.c 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /**
  3. * (C) Copyright 2014, Cavium Inc.
  4. **/
  5. #include <common.h>
  6. #include <command.h>
  7. #include <asm/cache.h>
  8. #include <asm/io.h>
  9. #include <asm/ptrace.h>
  10. #include <asm/system.h>
  11. #include <cavium/thunderx_svc.h>
  12. #include <cavium/atf.h>
  13. #include <cavium/atf_part.h>
  14. #include <asm/psci.h>
  15. #include <malloc.h>
  16. ssize_t atf_read_mmc(uintptr_t offset, void *buffer, size_t size)
  17. {
  18. struct pt_regs regs;
  19. regs.regs[0] = THUNDERX_MMC_READ;
  20. regs.regs[1] = offset;
  21. regs.regs[2] = size;
  22. regs.regs[3] = (uintptr_t)buffer;
  23. smc_call(&regs);
  24. return regs.regs[0];
  25. }
  26. ssize_t atf_read_nor(uintptr_t offset, void *buffer, size_t size)
  27. {
  28. struct pt_regs regs;
  29. regs.regs[0] = THUNDERX_NOR_READ;
  30. regs.regs[1] = offset;
  31. regs.regs[2] = size;
  32. regs.regs[3] = (uintptr_t)buffer;
  33. smc_call(&regs);
  34. return regs.regs[0];
  35. }
  36. ssize_t atf_get_pcount(void)
  37. {
  38. struct pt_regs regs;
  39. regs.regs[0] = THUNDERX_PART_COUNT;
  40. smc_call(&regs);
  41. return regs.regs[0];
  42. }
  43. ssize_t atf_get_part(struct storage_partition *part, unsigned int index)
  44. {
  45. struct pt_regs regs;
  46. regs.regs[0] = THUNDERX_GET_PART;
  47. regs.regs[1] = (uintptr_t)part;
  48. regs.regs[2] = index;
  49. smc_call(&regs);
  50. return regs.regs[0];
  51. }
  52. ssize_t atf_erase_nor(uintptr_t offset, size_t size)
  53. {
  54. struct pt_regs regs;
  55. regs.regs[0] = THUNDERX_NOR_ERASE;
  56. regs.regs[1] = offset;
  57. smc_call(&regs);
  58. return regs.regs[0];
  59. }
  60. ssize_t atf_write_nor(uintptr_t offset, const void *buffer, size_t size)
  61. {
  62. struct pt_regs regs;
  63. regs.regs[0] = THUNDERX_NOR_WRITE;
  64. regs.regs[1] = offset;
  65. regs.regs[2] = size;
  66. regs.regs[3] = (uintptr_t)buffer;
  67. smc_call(&regs);
  68. return regs.regs[0];
  69. }
  70. ssize_t atf_write_mmc(uintptr_t offset, const void *buffer, size_t size)
  71. {
  72. struct pt_regs regs;
  73. regs.regs[0] = THUNDERX_MMC_WRITE;
  74. regs.regs[1] = offset;
  75. regs.regs[2] = size;
  76. regs.regs[3] = (uintptr_t)buffer;
  77. smc_call(&regs);
  78. return regs.regs[0];
  79. }
  80. ssize_t atf_dram_size(unsigned int node)
  81. {
  82. struct pt_regs regs;
  83. regs.regs[0] = THUNDERX_DRAM_SIZE;
  84. regs.regs[1] = node;
  85. smc_call(&regs);
  86. return regs.regs[0];
  87. }
  88. ssize_t atf_node_count(void)
  89. {
  90. struct pt_regs regs;
  91. regs.regs[0] = THUNDERX_NODE_COUNT;
  92. smc_call(&regs);
  93. return regs.regs[0];
  94. }
  95. ssize_t atf_env_count(void)
  96. {
  97. struct pt_regs regs;
  98. regs.regs[0] = THUNDERX_ENV_COUNT;
  99. smc_call(&regs);
  100. return regs.regs[0];
  101. }
  102. ssize_t atf_env_string(size_t index, char *str)
  103. {
  104. uint64_t *buf = (void *)str;
  105. struct pt_regs regs;
  106. regs.regs[0] = THUNDERX_ENV_STRING;
  107. regs.regs[1] = index;
  108. smc_call(&regs);
  109. if (regs.regs > 0) {
  110. buf[0] = regs.regs[0];
  111. buf[1] = regs.regs[1];
  112. buf[2] = regs.regs[2];
  113. buf[3] = regs.regs[3];
  114. return 1;
  115. } else {
  116. return regs.regs[0];
  117. }
  118. }
  119. #ifdef CONFIG_CMD_ATF
  120. static void atf_print_ver(void)
  121. {
  122. struct pt_regs regs;
  123. regs.regs[0] = ARM_STD_SVC_VERSION;
  124. smc_call(&regs);
  125. printf("ARM Std FW version: %ld.%ld\n", regs.regs[0], regs.regs[1]);
  126. regs.regs[0] = THUNDERX_SVC_VERSION;
  127. smc_call(&regs);
  128. printf("ThunderX OEM ver: %ld.%ld\n", regs.regs[0], regs.regs[1]);
  129. }
  130. static void atf_print_uid(void)
  131. {
  132. }
  133. static void atf_print_part_table(void)
  134. {
  135. size_t pcount;
  136. unsigned long i;
  137. int ret;
  138. char *ptype;
  139. struct storage_partition *part = (void *)CONFIG_SYS_LOWMEM_BASE;
  140. pcount = atf_get_pcount();
  141. printf("Partition count: %lu\n\n", pcount);
  142. printf("%10s %10s %10s\n", "Type", "Size", "Offset");
  143. for (i = 0; i < pcount; i++) {
  144. ret = atf_get_part(part, i);
  145. if (ret < 0) {
  146. printf("Uknown error while reading partition: %d\n",
  147. ret);
  148. return;
  149. }
  150. switch (part->type) {
  151. case PARTITION_NBL1FW_REST:
  152. ptype = "NBL1FW";
  153. break;
  154. case PARTITION_BL2_BL31:
  155. ptype = "BL2_BL31";
  156. break;
  157. case PARTITION_UBOOT:
  158. ptype = "BOOTLDR";
  159. break;
  160. case PARTITION_KERNEL:
  161. ptype = "KERNEL";
  162. break;
  163. case PARTITION_DEVICE_TREE:
  164. ptype = "DEVTREE";
  165. break;
  166. default:
  167. ptype = "UNKNOWN";
  168. }
  169. printf("%10s %10d %10lx\n", ptype, part->size, part->offset);
  170. }
  171. }
  172. int do_atf(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
  173. {
  174. ssize_t ret;
  175. size_t size, offset;
  176. void *buffer = 0;
  177. unsigned int index, node;
  178. char str[4 * sizeof(uint64_t)];
  179. if ((argc == 5) && !strcmp(argv[1], "readmmc")) {
  180. buffer = (void *)hextoul(argv[2], NULL);
  181. offset = dectoul(argv[3], NULL);
  182. size = dectoul(argv[4], NULL);
  183. ret = atf_read_mmc(offset, buffer, size);
  184. } else if ((argc == 5) && !strcmp(argv[1], "readnor")) {
  185. buffer = (void *)hextoul(argv[2], NULL);
  186. offset = dectoul(argv[3], NULL);
  187. size = dectoul(argv[4], NULL);
  188. ret = atf_read_nor(offset, buffer, size);
  189. } else if ((argc == 5) && !strcmp(argv[1], "writemmc")) {
  190. buffer = (void *)hextoul(argv[2], NULL);
  191. offset = dectoul(argv[3], NULL);
  192. size = dectoul(argv[4], NULL);
  193. ret = atf_write_mmc(offset, buffer, size);
  194. } else if ((argc == 5) && !strcmp(argv[1], "writenor")) {
  195. buffer = (void *)hextoul(argv[2], NULL);
  196. offset = dectoul(argv[3], NULL);
  197. size = dectoul(argv[4], NULL);
  198. ret = atf_write_nor(offset, buffer, size);
  199. } else if ((argc == 2) && !strcmp(argv[1], "part")) {
  200. atf_print_part_table();
  201. } else if ((argc == 4) && !strcmp(argv[1], "erasenor")) {
  202. offset = dectoul(argv[2], NULL);
  203. size = dectoul(argv[3], NULL);
  204. ret = atf_erase_nor(offset, size);
  205. } else if ((argc == 2) && !strcmp(argv[1], "envcount")) {
  206. ret = atf_env_count();
  207. printf("Number of environment strings: %zd\n", ret);
  208. } else if ((argc == 3) && !strcmp(argv[1], "envstring")) {
  209. index = dectoul(argv[2], NULL);
  210. ret = atf_env_string(index, str);
  211. if (ret > 0)
  212. printf("Environment string %d: %s\n", index, str);
  213. else
  214. printf("Return code: %zd\n", ret);
  215. } else if ((argc == 3) && !strcmp(argv[1], "dramsize")) {
  216. node = dectoul(argv[2], NULL);
  217. ret = atf_dram_size(node);
  218. printf("DRAM size: %zd Mbytes\n", ret >> 20);
  219. } else if ((argc == 2) && !strcmp(argv[1], "nodes")) {
  220. ret = atf_node_count();
  221. printf("Nodes count: %zd\n", ret);
  222. } else if ((argc == 2) && !strcmp(argv[1], "ver")) {
  223. atf_print_ver();
  224. } else if ((argc == 2) && !strcmp(argv[1], "uid")) {
  225. atf_print_uid();
  226. } else {
  227. return CMD_RET_USAGE;
  228. }
  229. return 0;
  230. }
  231. U_BOOT_CMD(
  232. atf, 10, 1, do_atf,
  233. "issue calls to ATF",
  234. "\t readmmc addr offset size - read MMC card\n"
  235. "\t readnor addr offset size - read NOR flash\n"
  236. "\t writemmc addr offset size - write MMC card\n"
  237. "\t writenor addr offset size - write NOR flash\n"
  238. "\t erasenor offset size - erase NOR flash\n"
  239. "\t nodes - number of nodes\n"
  240. "\t dramsize node - size of DRAM attached to node\n"
  241. "\t envcount - number of environment strings\n"
  242. "\t envstring index - print the environment string\n"
  243. "\t part - print MMC partition table\n"
  244. "\t ver - print ATF call set versions\n"
  245. );
  246. #endif