atf.c 6.7 KB

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