light-efuse-test.c 9.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482
  1. #include <assert.h>
  2. #include <errno.h>
  3. #include <fcntl.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #include <unistd.h>
  8. #include <sys/types.h>
  9. #include "efuse-api.h"
  10. void csi_efuse_offset_test()
  11. {
  12. int ret, i;
  13. unsigned char data[32] = {0xff, 0xef, 0xdf, 0xcf, 0xbf, 0xaf, 0x9f, 0x8f, 0x7f, 0x6f, 0x5f, 0x4f, 0x3f, 0x2f, 0x1f, 0x0f, 0xfe, 0xee, 0xde, 0xce, 0xbe, 0xae, 0x9e, 0x8e, 0x7e, 0x6e, 0x5e, 0x4e, 0x3e, 0x2e, 0x3f, 0xff};
  14. unsigned int addr = 50;
  15. printf("data before set:\n");
  16. for (i = 0; i < 32; i++)
  17. printf("0x%x ", data[i]);
  18. printf("\n");
  19. #if 1
  20. ret = csi_efuse_write(addr, &data, sizeof(data));
  21. if (ret < 0)
  22. return;
  23. memset(data, 0, 32);
  24. #endif
  25. ret = csi_efuse_read(addr, &data, sizeof(data));
  26. if (ret < 0)
  27. return;
  28. printf("data after set:\n");
  29. for (i = 0; i < 32; i++)
  30. printf("0x%x ", data[i]);
  31. printf("\n");
  32. }
  33. void csi_efuse_userdata_group_test()
  34. {
  35. unsigned char group[16] = {0};
  36. int ret, i;
  37. for (i = 0; i < 16; i++)
  38. group[i] = i;
  39. ret = csi_efuse_set_userdata_group(group, 12);
  40. if (ret < 0)
  41. return;
  42. memset(group, 0, sizeof(group));
  43. ret = csi_efuse_get_userdata_group(group, 12);
  44. if (ret < 0)
  45. return;
  46. #if 0
  47. for (i = 0; i < 16; i++)
  48. printf("%x", group[i]);
  49. ret = csi_efuse_set_userdata_group(group, 44);
  50. if (ret < 0)
  51. return;
  52. #endif
  53. memset(group, 0, sizeof(group));
  54. ret = csi_efuse_get_userdata_group(group, 44);
  55. if (ret < 0)
  56. return;
  57. for (i = 0; i < 16; i++)
  58. printf("%x", group[i]);
  59. printf("\n");
  60. }
  61. void csi_efuse_get_hash_challenge_test()
  62. {
  63. unsigned char hash[32] = {0};
  64. int ret, i;
  65. ret =csi_efuse_get_hash_challenge(&hash);
  66. if (ret < 0)
  67. return;
  68. printf("hash challenge: 0x");
  69. for (i = 31; i >=0; i--)
  70. printf("%x", hash[i]);
  71. printf("\n");
  72. }
  73. void csi_efuse_get_secure_boot_st_test()
  74. {
  75. sboot_st_t flag;
  76. int ret;
  77. ret =csi_efuse_get_secure_boot_st(&flag);
  78. if (ret < 0)
  79. return;
  80. printf("secure boot flag: 0x%x\n", flag);
  81. if (flag != SECURE_BOOT_DIS && flag != SECURE_BOOT_EN)
  82. printf("incorrect secure boot flag\n");
  83. }
  84. void csi_efuse_get_bl2_version_test()
  85. {
  86. unsigned long long version;
  87. int ret;
  88. ret = csi_efuse_get_bl2_version(&version);
  89. if (ret < 0)
  90. return;
  91. printf("before setting bl2 version = 0x%llx\n", version);
  92. version = 0xabcdef123456789a;
  93. ret = csi_efuse_set_bl2_version(version);
  94. if (ret < 0)
  95. return;
  96. ret = csi_efuse_get_bl2_version(&version);
  97. if (ret < 0)
  98. return;
  99. printf("after setting bl2 version = 0x%llx\n", version);
  100. }
  101. void csi_efuse_get_bl1_version_test()
  102. {
  103. unsigned long long version;
  104. int ret;
  105. ret = csi_efuse_get_bl1_version(&version);
  106. if (ret < 0)
  107. return;
  108. printf("before setting bl1 version = 0x%llx\n", version);
  109. version = 0xabcdef123456789a;
  110. ret = csi_efuse_set_bl1_version(version);
  111. if (ret < 0)
  112. return;
  113. ret = csi_efuse_get_bl1_version(&version);
  114. if (ret < 0)
  115. return;
  116. printf("after setting bl1 version = 0x%llx\n", version);
  117. }
  118. void csi_efuse_bl4_img_encrypt_test()
  119. {
  120. img_encrypt_st_t flag;
  121. int ret;
  122. ret = csi_efuse_get_bl4_img_encrypt_st(&flag);
  123. if (ret < 0)
  124. return;
  125. printf("before setting bl4 img flg: 0x%x\n", flag);
  126. flag = IMAGE_ENCRYPT_EN;
  127. ret = csi_efuse_set_bl4_img_encrypt_st(flag);
  128. if (ret < 0)
  129. return;
  130. ret = csi_efuse_get_bl4_img_encrypt_st(&flag);
  131. if (ret < 0)
  132. return;
  133. printf("after setting bl4 img flg: 0x%x\n", flag);
  134. }
  135. void csi_efuse_bl3_img_encrypt_test()
  136. {
  137. img_encrypt_st_t flag;
  138. int ret;
  139. ret = csi_efuse_get_bl3_img_encrypt_st(&flag);
  140. if (ret < 0)
  141. return;
  142. printf("before setting bl3 img flg: 0x%x\n", flag);
  143. flag = IMAGE_ENCRYPT_EN;
  144. ret = csi_efuse_set_bl3_img_encrypt_st(flag);
  145. if (ret < 0)
  146. return;
  147. ret = csi_efuse_get_bl3_img_encrypt_st(&flag);
  148. if (ret < 0)
  149. return;
  150. printf("after setting bl3 img flg: 0x%x\n", flag);
  151. }
  152. void csi_efuse_bl2_img_encrypt_test()
  153. {
  154. img_encrypt_st_t flag;
  155. int ret;
  156. ret = csi_efuse_get_bl2_img_encrypt_st(&flag);
  157. if (ret < 0)
  158. return;
  159. printf("before setting bl2 img flg: 0x%x\n", flag);
  160. flag = IMAGE_ENCRYPT_EN;
  161. ret = csi_efuse_set_bl2_img_encrypt_st(flag);
  162. if (ret < 0)
  163. return;
  164. ret = csi_efuse_get_bl2_img_encrypt_st(&flag);
  165. if (ret < 0)
  166. return;
  167. printf("after setting bl2 img flg: 0x%x\n", flag);
  168. }
  169. void csi_efuse_usr_brom_cct_test()
  170. {
  171. brom_cct_st_t status;
  172. int ret;
  173. printf("csi_efuse_usr_brom_cct_test....\n");
  174. ret = csi_efuse_get_usr_brom_cct_st(&status);
  175. if (ret < 0)
  176. return;
  177. printf("before setting cct status: 0x%x\n", status);
  178. ret = csi_efuse_dis_usr_brom_cct();
  179. if (ret < 0)
  180. return;
  181. ret = csi_efuse_get_usr_brom_cct_st(&status);
  182. if (ret < 0)
  183. return;
  184. printf("after setting cct status: 0x%x\n", status);
  185. }
  186. void csi_efuse_usr_brom_usb_fastboot_test()
  187. {
  188. brom_usbboot_st_t status;
  189. int ret;
  190. ret = csi_efuse_get_usr_brom_usb_fastboot_st(&status);
  191. if (ret < 0)
  192. return;
  193. printf("before setting fastboot status: 0x%x\n", status);
  194. ret = csi_efuse_dis_usr_brom_usb_fastboot();
  195. if (ret < 0)
  196. return;
  197. ret = csi_efuse_get_usr_brom_usb_fastboot_st(&status);
  198. if (ret < 0)
  199. return;
  200. printf("after setting fastboot status: 0x%x\n", status);
  201. }
  202. void csi_efuse_bak_boot_index_test()
  203. {
  204. int ret;
  205. unsigned char index;
  206. ret = csi_efuse_get_bak_boot_index(&index);
  207. if (ret < 0)
  208. return;
  209. printf("\nbefore write bak boot index = %d\n", index);
  210. index = 50;
  211. ret = csi_efuse_set_bak_boot_index(index);
  212. if (ret < 0)
  213. return;
  214. ret = csi_efuse_get_bak_boot_index(&index);
  215. if (ret < 0)
  216. return;
  217. printf("\nafter write bak boot index = %d\n", index);
  218. }
  219. void csi_efuse_bak_boot_offset_test()
  220. {
  221. int ret;
  222. unsigned int offset;
  223. ret = csi_efuse_get_bak_boot_offset(&offset);
  224. if (ret < 0)
  225. return;
  226. printf("\nbefore write bak boot offset = %d\n", offset);
  227. offset = 122;
  228. ret = csi_efuse_set_bak_boot_offset(offset);
  229. if (ret < 0)
  230. return;
  231. ret = csi_efuse_get_bak_boot_offset(&offset);
  232. if (ret < 0)
  233. return;
  234. printf("\nafter write bak boot offset = %d\n", offset);
  235. }
  236. void csi_efuse_boot_index_test()
  237. {
  238. unsigned char index;
  239. int ret;
  240. #if 1
  241. ret = csi_efuse_set_boot_index(244);
  242. if (ret < 0)
  243. return;
  244. #endif
  245. ret = csi_efuse_get_boot_index(&index);
  246. if (ret < 0)
  247. return;
  248. printf("\nboot index = %d\n", index);
  249. }
  250. void csi_efuse_boot_offset_test()
  251. {
  252. int ret;
  253. unsigned int offset = 56;
  254. #if 1
  255. ret = csi_efuse_set_boot_offset(offset);
  256. if (ret < 0)
  257. return;
  258. #endif
  259. ret = csi_efuse_get_boot_offset(&offset);
  260. if (ret < 0)
  261. return;
  262. printf("\noffset = 0x%x\n", offset);
  263. }
  264. void csi_efuse_user_dbg_mode_test()
  265. {
  266. int ret;
  267. efuse_dbg_type_t type = USR_CHIP_DBG;
  268. efuse_dbg_mode_t mode = DBG_MODE_PWD_PROTECT;
  269. ret = csi_efuse_set_user_dbg_mode(type, mode);
  270. if (ret < 0)
  271. return;
  272. ret = csi_efuse_get_user_dbg_mode(type, &mode);
  273. if (ret < 0)
  274. return;
  275. if (mode != DBG_MODE_ENABLE && mode != DBG_MODE_PWD_PROTECT &&
  276. mode != DBG_MODE_DISABLE) {
  277. printf("invalid debug mode in efuse\n");
  278. return;
  279. }
  280. printf("\ndebug mode:%d\n", mode);
  281. }
  282. void efuse_chip_id_get_test()
  283. {
  284. int ret;
  285. unsigned char uid[20] = {};
  286. #if 0
  287. ret = csi_efuse_write(0x50, &rw_uid, sizeof(unsigned int));
  288. if (ret < 0)
  289. return;
  290. #endif
  291. ret = csi_efuse_get_chipid(&uid);
  292. if (ret < 0)
  293. printf("failed to read uid\n");
  294. printf("\nuid: ");
  295. for (int i = 0; i < 20; i++)
  296. printf("%x", uid[i]);
  297. printf("\n");
  298. }
  299. void csi_efuse_update_lc_rma_test()
  300. {
  301. csi_efuse_update_lc_rma();
  302. }
  303. void csi_efuse_update_lc_rip_test()
  304. {
  305. csi_efuse_update_lc_rip();
  306. }
  307. void csi_efuse_gmac_macaddr_test()
  308. {
  309. int ret;
  310. unsigned char mac0[6] = {0x00, 0x22, 0x33, 0x44, 0x55, 0x00};
  311. unsigned char mac1[6] = {0x00, 0x22, 0x33, 0x44, 0x66, 0x00};
  312. unsigned char r_mac0[6] = {};
  313. unsigned char r_mac1[6] = {};
  314. ret = csi_efuse_set_gmac_macaddr(0, mac0);
  315. if (ret < 0)
  316. return;
  317. ret = csi_efuse_get_gmac_macaddr(0, r_mac0);
  318. if (ret < 0)
  319. return;
  320. printf("gmac mac0 address: %2x:%2x:%2x:%2x:%2x:%2x\n", r_mac0[0], r_mac0[1], r_mac0[2], r_mac0[3], r_mac0[4], r_mac0[5]);
  321. ret = csi_efuse_set_gmac_macaddr(1, mac1);
  322. if (ret < 0)
  323. return;
  324. ret = csi_efuse_get_gmac_macaddr(1, r_mac1);
  325. if (ret < 0)
  326. return;
  327. printf("gmac mac0 address: %2x:%2x:%2x:%2x:%2x:%2x\n", r_mac1[0], r_mac1[1], r_mac1[2], r_mac1[3], r_mac1[4], r_mac1[5]);
  328. }
  329. void csi_efuse_get_lc_preld_test()
  330. {
  331. char life_cycle[12] = {0};
  332. int ret;
  333. ret = csi_efuse_get_lc_preld(life_cycle);
  334. if (ret) {
  335. printf("ret = %d\n", ret);
  336. return;
  337. }
  338. printf("lc_preld: %s\n", life_cycle);
  339. }
  340. void csi_efuse_update_lc_test()
  341. {
  342. csi_efuse_update_lc(LC_DEV);
  343. csi_efuse_update_lc(LC_RMA);
  344. }
  345. int main()
  346. {
  347. printf("efuse testing....\n");
  348. csi_efuse_update_lc_test();
  349. #if 0
  350. csi_efuse_get_lc_preld_test();
  351. csi_efuse_bl4_img_encrypt_test();
  352. csi_efuse_bl2_img_encrypt_test();
  353. csi_efuse_bl3_img_encrypt_test();
  354. csi_efuse_get_bl1_version_test();
  355. csi_efuse_get_hash_challenge_test();
  356. csi_efuse_get_secure_boot_st_test();
  357. csi_efuse_offset_test();
  358. csi_efuse_usr_brom_cct_test();
  359. csi_efuse_usr_brom_usb_fastboot_test();
  360. csi_efuse_boot_index_test();
  361. csi_efuse_boot_offset_test();
  362. efuse_chip_id_get_test();
  363. csi_efuse_get_bl1_version_test();
  364. csi_efuse_get_bl2_version_test();
  365. csi_efuse_get_secure_boot_st_test();
  366. csi_efuse_get_hash_challenge_test();
  367. csi_efuse_userdata_group_test();
  368. efuse_chip_id_get_test();
  369. csi_efuse_user_dbg_mode_test();
  370. csi_efuse_boot_offset_test();
  371. csi_efuse_boot_index_test();
  372. csi_efuse_bak_boot_offset_test();
  373. csi_efuse_bak_boot_index_test();
  374. csi_efuse_usr_brom_usb_fastboot_test();
  375. csi_efuse_usr_brom_cct_test();
  376. printf("welcome to riscv world!!!\n");
  377. csi_efuse_bl2_img_encrypt_test();
  378. csi_efuse_bl3_img_encrypt_test();
  379. csi_efuse_bl4_img_encrypt_test();
  380. csi_efuse_get_bl1_version_test();
  381. csi_efuse_get_bl2_version_test();
  382. csi_efuse_get_secure_boot_st_test();
  383. csi_efuse_get_hash_challenge_test();
  384. csi_efuse_userdata_group_test();
  385. csi_efuse_offset_test();
  386. csi_efuse_update_lc_rma_test();
  387. csi_efuse_update_lc_rip_test();
  388. csi_efuse_gmac_macaddr_test();
  389. #endif
  390. return 0;
  391. }