tpm_test.c 15 KB

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