tpm_test.c 15 KB

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