tpm_test.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2015 Google, Inc
  4. */
  5. #include <common.h>
  6. #include <command.h>
  7. #include <tpm-v1.h>
  8. #include "tpm-user-utils.h"
  9. /* Prints error and returns on failure */
  10. #define TPM_CHECK(tpm_command) do { \
  11. uint32_t result; \
  12. \
  13. result = (tpm_command); \
  14. if (result != TPM_SUCCESS) { \
  15. printf("TEST FAILED: line %d: " #tpm_command ": 0x%x\n", \
  16. __LINE__, result); \
  17. return result; \
  18. } \
  19. } while (0)
  20. #define INDEX0 0xda70
  21. #define INDEX1 0xda71
  22. #define INDEX2 0xda72
  23. #define INDEX3 0xda73
  24. #define INDEX_INITIALISED 0xda80
  25. #define PHYS_PRESENCE 4
  26. #define PRESENCE 8
  27. static uint32_t TlclStartupIfNeeded(struct udevice *dev)
  28. {
  29. uint32_t result = tpm_startup(dev, TPM_ST_CLEAR);
  30. return result == TPM_INVALID_POSTINIT ? TPM_SUCCESS : result;
  31. }
  32. static int test_timer(struct udevice *dev)
  33. {
  34. printf("get_timer(0) = %lu\n", get_timer(0));
  35. return 0;
  36. }
  37. static uint32_t tpm_get_flags(struct udevice *dev, uint8_t *disable,
  38. uint8_t *deactivated, uint8_t *nvlocked)
  39. {
  40. struct tpm_permanent_flags pflags;
  41. uint32_t result;
  42. result = tpm_get_permanent_flags(dev, &pflags);
  43. if (result)
  44. return result;
  45. if (disable)
  46. *disable = pflags.disable;
  47. if (deactivated)
  48. *deactivated = pflags.deactivated;
  49. if (nvlocked)
  50. *nvlocked = pflags.nv_locked;
  51. debug("TPM: Got flags disable=%d, deactivated=%d, nvlocked=%d\n",
  52. pflags.disable, pflags.deactivated, pflags.nv_locked);
  53. return 0;
  54. }
  55. static uint32_t tpm_nv_write_value_lock(struct udevice *dev, uint32_t index)
  56. {
  57. debug("TPM: Write lock 0x%x\n", index);
  58. return tpm_nv_write_value(dev, index, NULL, 0);
  59. }
  60. static int tpm_is_owned(struct udevice *dev)
  61. {
  62. uint8_t response[TPM_PUBEK_SIZE];
  63. uint32_t result;
  64. result = tpm_read_pubek(dev, response, sizeof(response));
  65. return result != TPM_SUCCESS;
  66. }
  67. static int test_early_extend(struct udevice *dev)
  68. {
  69. uint8_t value_in[20];
  70. uint8_t value_out[20];
  71. printf("Testing earlyextend ...");
  72. tpm_init(dev);
  73. TPM_CHECK(tpm_startup(dev, TPM_ST_CLEAR));
  74. TPM_CHECK(tpm_continue_self_test(dev));
  75. TPM_CHECK(tpm_extend(dev, 1, value_in, value_out));
  76. printf("done\n");
  77. return 0;
  78. }
  79. static int test_early_nvram(struct udevice *dev)
  80. {
  81. uint32_t x;
  82. printf("Testing earlynvram ...");
  83. tpm_init(dev);
  84. TPM_CHECK(tpm_startup(dev, TPM_ST_CLEAR));
  85. TPM_CHECK(tpm_continue_self_test(dev));
  86. TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
  87. TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)));
  88. printf("done\n");
  89. return 0;
  90. }
  91. static int test_early_nvram2(struct udevice *dev)
  92. {
  93. uint32_t x;
  94. printf("Testing earlynvram2 ...");
  95. tpm_init(dev);
  96. TPM_CHECK(tpm_startup(dev, TPM_ST_CLEAR));
  97. TPM_CHECK(tpm_continue_self_test(dev));
  98. TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
  99. TPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)));
  100. printf("done\n");
  101. return 0;
  102. }
  103. static int test_enable(struct udevice *dev)
  104. {
  105. uint8_t disable = 0, deactivated = 0;
  106. printf("Testing enable ...\n");
  107. tpm_init(dev);
  108. TPM_CHECK(TlclStartupIfNeeded(dev));
  109. TPM_CHECK(tpm_self_test_full(dev));
  110. TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
  111. TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL));
  112. printf("\tdisable is %d, deactivated is %d\n", disable, deactivated);
  113. TPM_CHECK(tpm_physical_enable(dev));
  114. TPM_CHECK(tpm_physical_set_deactivated(dev, 0));
  115. TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL));
  116. printf("\tdisable is %d, deactivated is %d\n", disable, deactivated);
  117. if (disable == 1 || deactivated == 1)
  118. printf("\tfailed to enable or activate\n");
  119. printf("\tdone\n");
  120. return 0;
  121. }
  122. #define reboot() do { \
  123. printf("\trebooting...\n"); \
  124. reset_cpu(0); \
  125. } while (0)
  126. static int test_fast_enable(struct udevice *dev)
  127. {
  128. uint8_t disable = 0, deactivated = 0;
  129. int i;
  130. printf("Testing fastenable ...\n");
  131. tpm_init(dev);
  132. TPM_CHECK(TlclStartupIfNeeded(dev));
  133. TPM_CHECK(tpm_self_test_full(dev));
  134. TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
  135. TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL));
  136. printf("\tdisable is %d, deactivated is %d\n", disable, deactivated);
  137. for (i = 0; i < 2; i++) {
  138. TPM_CHECK(tpm_force_clear(dev));
  139. TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL));
  140. printf("\tdisable is %d, deactivated is %d\n", disable,
  141. deactivated);
  142. assert(disable == 1 && deactivated == 1);
  143. TPM_CHECK(tpm_physical_enable(dev));
  144. TPM_CHECK(tpm_physical_set_deactivated(dev, 0));
  145. TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL));
  146. printf("\tdisable is %d, deactivated is %d\n", disable,
  147. deactivated);
  148. assert(disable == 0 && deactivated == 0);
  149. }
  150. printf("\tdone\n");
  151. return 0;
  152. }
  153. static int test_global_lock(struct udevice *dev)
  154. {
  155. uint32_t zero = 0;
  156. uint32_t result;
  157. uint32_t x;
  158. printf("Testing globallock ...\n");
  159. tpm_init(dev);
  160. TPM_CHECK(TlclStartupIfNeeded(dev));
  161. TPM_CHECK(tpm_self_test_full(dev));
  162. TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
  163. TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)));
  164. TPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&zero,
  165. sizeof(uint32_t)));
  166. TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x)));
  167. TPM_CHECK(tpm_nv_write_value(dev, INDEX1, (uint8_t *)&zero,
  168. sizeof(uint32_t)));
  169. TPM_CHECK(tpm_set_global_lock(dev));
  170. /* Verifies that write to index0 fails */
  171. x = 1;
  172. result = tpm_nv_write_value(dev, INDEX0, (uint8_t *)&x, sizeof(x));
  173. assert(result == TPM_AREA_LOCKED);
  174. TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)));
  175. assert(x == 0);
  176. /* Verifies that write to index1 is still possible */
  177. x = 2;
  178. TPM_CHECK(tpm_nv_write_value(dev, INDEX1, (uint8_t *)&x, sizeof(x)));
  179. TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x)));
  180. assert(x == 2);
  181. /* Turns off PP */
  182. tpm_tsc_physical_presence(dev, PHYS_PRESENCE);
  183. /* Verifies that write to index1 fails */
  184. x = 3;
  185. result = tpm_nv_write_value(dev, INDEX1, (uint8_t *)&x, sizeof(x));
  186. assert(result == TPM_BAD_PRESENCE);
  187. TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x)));
  188. assert(x == 2);
  189. printf("\tdone\n");
  190. return 0;
  191. }
  192. static int test_lock(struct udevice *dev)
  193. {
  194. printf("Testing lock ...\n");
  195. tpm_init(dev);
  196. tpm_startup(dev, TPM_ST_CLEAR);
  197. tpm_self_test_full(dev);
  198. tpm_tsc_physical_presence(dev, PRESENCE);
  199. tpm_nv_write_value_lock(dev, INDEX0);
  200. printf("\tLocked 0x%x\n", INDEX0);
  201. printf("\tdone\n");
  202. return 0;
  203. }
  204. static void initialise_spaces(struct udevice *dev)
  205. {
  206. uint32_t zero = 0;
  207. uint32_t perm = TPM_NV_PER_WRITE_STCLEAR | TPM_NV_PER_PPWRITE;
  208. printf("\tInitialising spaces\n");
  209. tpm_nv_set_locked(dev); /* useful only the first time */
  210. tpm_nv_define_space(dev, INDEX0, perm, 4);
  211. tpm_nv_write_value(dev, INDEX0, (uint8_t *)&zero, 4);
  212. tpm_nv_define_space(dev, INDEX1, perm, 4);
  213. tpm_nv_write_value(dev, INDEX1, (uint8_t *)&zero, 4);
  214. tpm_nv_define_space(dev, INDEX2, perm, 4);
  215. tpm_nv_write_value(dev, INDEX2, (uint8_t *)&zero, 4);
  216. tpm_nv_define_space(dev, INDEX3, perm, 4);
  217. tpm_nv_write_value(dev, INDEX3, (uint8_t *)&zero, 4);
  218. perm = TPM_NV_PER_READ_STCLEAR | TPM_NV_PER_WRITE_STCLEAR |
  219. TPM_NV_PER_PPWRITE;
  220. tpm_nv_define_space(dev, INDEX_INITIALISED, perm, 1);
  221. }
  222. static int test_readonly(struct udevice *dev)
  223. {
  224. uint8_t c;
  225. uint32_t index_0, index_1, index_2, index_3;
  226. int read0, read1, read2, read3;
  227. printf("Testing readonly ...\n");
  228. tpm_init(dev);
  229. tpm_startup(dev, TPM_ST_CLEAR);
  230. tpm_self_test_full(dev);
  231. tpm_tsc_physical_presence(dev, PRESENCE);
  232. /*
  233. * Checks if initialisation has completed by trying to read-lock a
  234. * space that's created at the end of initialisation
  235. */
  236. if (tpm_nv_read_value(dev, INDEX_INITIALISED, &c, 0) == TPM_BADINDEX) {
  237. /* The initialisation did not complete */
  238. initialise_spaces(dev);
  239. }
  240. /* Checks if spaces are OK or messed up */
  241. read0 = tpm_nv_read_value(dev, INDEX0, (uint8_t *)&index_0,
  242. sizeof(index_0));
  243. read1 = tpm_nv_read_value(dev, INDEX1, (uint8_t *)&index_1,
  244. sizeof(index_1));
  245. read2 = tpm_nv_read_value(dev, INDEX2, (uint8_t *)&index_2,
  246. sizeof(index_2));
  247. read3 = tpm_nv_read_value(dev, INDEX3, (uint8_t *)&index_3,
  248. sizeof(index_3));
  249. if (read0 || read1 || read2 || read3) {
  250. printf("Invalid contents\n");
  251. return 0;
  252. }
  253. /*
  254. * Writes space, and locks it. Then attempts to write again.
  255. * I really wish I could use the imperative.
  256. */
  257. index_0 += 1;
  258. if (tpm_nv_write_value(dev, INDEX0, (uint8_t *)&index_0,
  259. sizeof(index_0) !=
  260. TPM_SUCCESS)) {
  261. pr_err("\tcould not write index 0\n");
  262. }
  263. tpm_nv_write_value_lock(dev, INDEX0);
  264. if (tpm_nv_write_value(dev, INDEX0, (uint8_t *)&index_0,
  265. sizeof(index_0)) ==
  266. TPM_SUCCESS)
  267. pr_err("\tindex 0 is not locked\n");
  268. printf("\tdone\n");
  269. return 0;
  270. }
  271. static int test_redefine_unowned(struct udevice *dev)
  272. {
  273. uint32_t perm;
  274. uint32_t result;
  275. uint32_t x;
  276. printf("Testing redefine_unowned ...");
  277. tpm_init(dev);
  278. TPM_CHECK(TlclStartupIfNeeded(dev));
  279. TPM_CHECK(tpm_self_test_full(dev));
  280. TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
  281. assert(!tpm_is_owned(dev));
  282. /* Ensures spaces exist. */
  283. TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)));
  284. TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x)));
  285. /* Redefines spaces a couple of times. */
  286. perm = TPM_NV_PER_PPWRITE | TPM_NV_PER_GLOBALLOCK;
  287. TPM_CHECK(tpm_nv_define_space(dev, INDEX0, perm, 2 * sizeof(uint32_t)));
  288. TPM_CHECK(tpm_nv_define_space(dev, INDEX0, perm, sizeof(uint32_t)));
  289. perm = TPM_NV_PER_PPWRITE;
  290. TPM_CHECK(tpm_nv_define_space(dev, INDEX1, perm, 2 * sizeof(uint32_t)));
  291. TPM_CHECK(tpm_nv_define_space(dev, INDEX1, perm, sizeof(uint32_t)));
  292. /* Sets the global lock */
  293. tpm_set_global_lock(dev);
  294. /* Verifies that index0 cannot be redefined */
  295. result = tpm_nv_define_space(dev, INDEX0, perm, sizeof(uint32_t));
  296. assert(result == TPM_AREA_LOCKED);
  297. /* Checks that index1 can */
  298. TPM_CHECK(tpm_nv_define_space(dev, INDEX1, perm, 2 * sizeof(uint32_t)));
  299. TPM_CHECK(tpm_nv_define_space(dev, INDEX1, perm, sizeof(uint32_t)));
  300. /* Turns off PP */
  301. tpm_tsc_physical_presence(dev, PHYS_PRESENCE);
  302. /* Verifies that neither index0 nor index1 can be redefined */
  303. result = tpm_nv_define_space(dev, INDEX0, perm, sizeof(uint32_t));
  304. assert(result == TPM_BAD_PRESENCE);
  305. result = tpm_nv_define_space(dev, INDEX1, perm, sizeof(uint32_t));
  306. assert(result == TPM_BAD_PRESENCE);
  307. printf("done\n");
  308. return 0;
  309. }
  310. #define PERMPPGL (TPM_NV_PER_PPWRITE | TPM_NV_PER_GLOBALLOCK)
  311. #define PERMPP TPM_NV_PER_PPWRITE
  312. static int test_space_perm(struct udevice *dev)
  313. {
  314. uint32_t perm;
  315. printf("Testing spaceperm ...");
  316. tpm_init(dev);
  317. TPM_CHECK(TlclStartupIfNeeded(dev));
  318. TPM_CHECK(tpm_continue_self_test(dev));
  319. TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
  320. TPM_CHECK(tpm_get_permissions(dev, INDEX0, &perm));
  321. assert((perm & PERMPPGL) == PERMPPGL);
  322. TPM_CHECK(tpm_get_permissions(dev, INDEX1, &perm));
  323. assert((perm & PERMPP) == PERMPP);
  324. printf("done\n");
  325. return 0;
  326. }
  327. static int test_startup(struct udevice *dev)
  328. {
  329. uint32_t result;
  330. printf("Testing startup ...\n");
  331. tpm_init(dev);
  332. result = tpm_startup(dev, TPM_ST_CLEAR);
  333. if (result != 0 && result != TPM_INVALID_POSTINIT)
  334. printf("\ttpm startup failed with 0x%x\n", result);
  335. result = tpm_get_flags(dev, NULL, NULL, NULL);
  336. if (result != 0)
  337. printf("\ttpm getflags failed with 0x%x\n", result);
  338. printf("\texecuting SelfTestFull\n");
  339. tpm_self_test_full(dev);
  340. result = tpm_get_flags(dev, NULL, NULL, NULL);
  341. if (result != 0)
  342. printf("\ttpm getflags failed with 0x%x\n", result);
  343. printf("\tdone\n");
  344. return 0;
  345. }
  346. /*
  347. * Runs [op] and ensures it returns success and doesn't run longer than
  348. * [time_limit] in milliseconds.
  349. */
  350. #define TTPM_CHECK(op, time_limit) do { \
  351. ulong start, time; \
  352. uint32_t __result; \
  353. \
  354. start = get_timer(0); \
  355. __result = op; \
  356. if (__result != TPM_SUCCESS) { \
  357. printf("\t" #op ": error 0x%x\n", __result); \
  358. return -1; \
  359. } \
  360. time = get_timer(start); \
  361. printf("\t" #op ": %lu ms\n", time); \
  362. if (time > (ulong)time_limit) { \
  363. printf("\t" #op " exceeded " #time_limit " ms\n"); \
  364. } \
  365. } while (0)
  366. static int test_timing(struct udevice *dev)
  367. {
  368. uint8_t in[20], out[20];
  369. uint32_t x;
  370. printf("Testing timing ...");
  371. tpm_init(dev);
  372. TTPM_CHECK(TlclStartupIfNeeded(dev), 50);
  373. TTPM_CHECK(tpm_continue_self_test(dev), 100);
  374. TTPM_CHECK(tpm_self_test_full(dev), 1000);
  375. TTPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE), 100);
  376. TTPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)),
  377. 100);
  378. TTPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)),
  379. 100);
  380. TTPM_CHECK(tpm_extend(dev, 0, in, out), 200);
  381. TTPM_CHECK(tpm_set_global_lock(dev), 50);
  382. TTPM_CHECK(tpm_tsc_physical_presence(dev, PHYS_PRESENCE), 100);
  383. printf("done\n");
  384. return 0;
  385. }
  386. #define TPM_MAX_NV_WRITES_NOOWNER 64
  387. static int test_write_limit(struct udevice *dev)
  388. {
  389. uint32_t result;
  390. int i;
  391. printf("Testing writelimit ...\n");
  392. tpm_init(dev);
  393. TPM_CHECK(TlclStartupIfNeeded(dev));
  394. TPM_CHECK(tpm_self_test_full(dev));
  395. TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
  396. TPM_CHECK(tpm_force_clear(dev));
  397. TPM_CHECK(tpm_physical_enable(dev));
  398. TPM_CHECK(tpm_physical_set_deactivated(dev, 0));
  399. for (i = 0; i < TPM_MAX_NV_WRITES_NOOWNER + 2; i++) {
  400. printf("\twriting %d\n", i);
  401. result = tpm_nv_write_value(dev, INDEX0, (uint8_t *)&i,
  402. sizeof(i));
  403. switch (result) {
  404. case TPM_SUCCESS:
  405. break;
  406. case TPM_MAXNVWRITES:
  407. assert(i >= TPM_MAX_NV_WRITES_NOOWNER);
  408. default:
  409. pr_err("\tunexpected error code %d (0x%x)\n",
  410. result, result);
  411. }
  412. }
  413. /* Reset write count */
  414. TPM_CHECK(tpm_force_clear(dev));
  415. TPM_CHECK(tpm_physical_enable(dev));
  416. TPM_CHECK(tpm_physical_set_deactivated(dev, 0));
  417. /* Try writing again. */
  418. TPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&i, sizeof(i)));
  419. printf("\tdone\n");
  420. return 0;
  421. }
  422. #define VOIDTEST(XFUNC) \
  423. int do_test_##XFUNC(cmd_tbl_t *cmd_tbl, int flag, int argc, \
  424. char * const argv[]) \
  425. { \
  426. struct udevice *dev; \
  427. int ret; \
  428. \
  429. ret = get_tpm(&dev); \
  430. if (ret) \
  431. return ret; \
  432. return test_##XFUNC(dev); \
  433. }
  434. #define VOIDENT(XNAME) \
  435. U_BOOT_CMD_MKENT(XNAME, 0, 1, do_test_##XNAME, "", ""),
  436. VOIDTEST(early_extend)
  437. VOIDTEST(early_nvram)
  438. VOIDTEST(early_nvram2)
  439. VOIDTEST(enable)
  440. VOIDTEST(fast_enable)
  441. VOIDTEST(global_lock)
  442. VOIDTEST(lock)
  443. VOIDTEST(readonly)
  444. VOIDTEST(redefine_unowned)
  445. VOIDTEST(space_perm)
  446. VOIDTEST(startup)
  447. VOIDTEST(timing)
  448. VOIDTEST(write_limit)
  449. VOIDTEST(timer)
  450. static cmd_tbl_t cmd_cros_tpm_sub[] = {
  451. VOIDENT(early_extend)
  452. VOIDENT(early_nvram)
  453. VOIDENT(early_nvram2)
  454. VOIDENT(enable)
  455. VOIDENT(fast_enable)
  456. VOIDENT(global_lock)
  457. VOIDENT(lock)
  458. VOIDENT(readonly)
  459. VOIDENT(redefine_unowned)
  460. VOIDENT(space_perm)
  461. VOIDENT(startup)
  462. VOIDENT(timing)
  463. VOIDENT(write_limit)
  464. VOIDENT(timer)
  465. };
  466. static int do_tpmtest(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  467. {
  468. cmd_tbl_t *c;
  469. int i;
  470. printf("argc = %d, argv = ", argc);
  471. for (i = 0; i < argc; i++)
  472. printf(" %s", argv[i]);
  473. printf("\n------\n");
  474. argc--;
  475. argv++;
  476. c = find_cmd_tbl(argv[0], cmd_cros_tpm_sub,
  477. ARRAY_SIZE(cmd_cros_tpm_sub));
  478. return c ? c->cmd(cmdtp, flag, argc, argv) : cmd_usage(cmdtp);
  479. }
  480. U_BOOT_CMD(tpmtest, 2, 1, do_tpmtest, "TPM tests",
  481. "\n\tearly_extend\n"
  482. "\tearly_nvram\n"
  483. "\tearly_nvram2\n"
  484. "\tenable\n"
  485. "\tfast_enable\n"
  486. "\tglobal_lock\n"
  487. "\tlock\n"
  488. "\treadonly\n"
  489. "\tredefine_unowned\n"
  490. "\tspace_perm\n"
  491. "\tstartup\n"
  492. "\ttiming\n"
  493. "\twrite_limit\n");