[people/ms/u-boot.git] / cmd / tpm_test.c

/*
 * Copyright (c) 2015 Google, Inc
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <command.h>
#include <environment.h>
#include <tpm.h>

/* Prints error and returns on failure */
#define TPM_CHECK(tpm_command) do { \
	uint32_t result; \
	\
	result = (tpm_command); \
	if (result != TPM_SUCCESS) { \
		printf("TEST FAILED: line %d: " #tpm_command ": 0x%x\n", \
			__LINE__, result); \
		return result; \
	} \
} while (0)

#define INDEX0			0xda70
#define INDEX1			0xda71
#define INDEX2			0xda72
#define INDEX3			0xda73
#define INDEX_INITIALISED	0xda80
#define PHYS_PRESENCE		4
#define PRESENCE		8

static uint32_t TlclStartupIfNeeded(void)
{
	uint32_t result = tpm_startup(TPM_ST_CLEAR);

	return result == TPM_INVALID_POSTINIT ? TPM_SUCCESS : result;
}

static int test_timer(void)
{
	printf("get_timer(0) = %lu\n", get_timer(0));
	return 0;
}

static uint32_t tpm_get_flags(uint8_t *disable, uint8_t *deactivated,
			      uint8_t *nvlocked)
{
	struct tpm_permanent_flags pflags;
	uint32_t result;

	result = tpm_get_permanent_flags(&pflags);
	if (result)
		return result;
	if (disable)
		*disable = pflags.disable;
	if (deactivated)
		*deactivated = pflags.deactivated;
	if (nvlocked)
		*nvlocked = pflags.nv_locked;
	debug("TPM: Got flags disable=%d, deactivated=%d, nvlocked=%d\n",
	      pflags.disable, pflags.deactivated, pflags.nv_locked);

	return 0;
}

static uint32_t tpm_set_global_lock(void)
{
	uint32_t x;

	debug("TPM: Set global lock\n");
	return tpm_nv_write_value(INDEX0, (uint8_t *)&x, 0);
}

static uint32_t tpm_nv_write_value_lock(uint32_t index)
{
	debug("TPM: Write lock 0x%x\n", index);

	return tpm_nv_write_value(index, NULL, 0);
}

static uint32_t tpm_nv_set_locked(void)
{
	debug("TPM: Set NV locked\n");

	return tpm_nv_define_space(TPM_NV_INDEX_LOCK, 0, 0);
}

static int tpm_is_owned(void)
{
	uint8_t response[TPM_PUBEK_SIZE];
	uint32_t result;

	result = tpm_read_pubek(response, sizeof(response));

	return result != TPM_SUCCESS;
}

static int test_early_extend(void)
{
	uint8_t value_in[20];
	uint8_t value_out[20];

	printf("Testing earlyextend ...");
	tpm_init();
	TPM_CHECK(tpm_startup(TPM_ST_CLEAR));
	TPM_CHECK(tpm_continue_self_test());
	TPM_CHECK(tpm_extend(1, value_in, value_out));
	printf("done\n");
	return 0;
}

static int test_early_nvram(void)
{
	uint32_t x;

	printf("Testing earlynvram ...");
	tpm_init();
	TPM_CHECK(tpm_startup(TPM_ST_CLEAR));
	TPM_CHECK(tpm_continue_self_test());
	TPM_CHECK(tpm_tsc_physical_presence(PRESENCE));
	TPM_CHECK(tpm_nv_read_value(INDEX0, (uint8_t *)&x, sizeof(x)));
	printf("done\n");
	return 0;
}

static int test_early_nvram2(void)
{
	uint32_t x;

	printf("Testing earlynvram2 ...");
	tpm_init();
	TPM_CHECK(tpm_startup(TPM_ST_CLEAR));
	TPM_CHECK(tpm_continue_self_test());
	TPM_CHECK(tpm_tsc_physical_presence(PRESENCE));
	TPM_CHECK(tpm_nv_write_value(INDEX0, (uint8_t *)&x, sizeof(x)));
	printf("done\n");
	return 0;
}

static int test_enable(void)
{
	uint8_t disable = 0, deactivated = 0;

	printf("Testing enable ...\n");
	tpm_init();
	TPM_CHECK(TlclStartupIfNeeded());
	TPM_CHECK(tpm_self_test_full());
	TPM_CHECK(tpm_tsc_physical_presence(PRESENCE));
	TPM_CHECK(tpm_get_flags(&disable, &deactivated, NULL));
	printf("\tdisable is %d, deactivated is %d\n", disable, deactivated);
	TPM_CHECK(tpm_physical_enable());
	TPM_CHECK(tpm_physical_set_deactivated(0));
	TPM_CHECK(tpm_get_flags(&disable, &deactivated, NULL));
	printf("\tdisable is %d, deactivated is %d\n", disable, deactivated);
	if (disable == 1 || deactivated == 1)
		printf("\tfailed to enable or activate\n");
	printf("\tdone\n");
	return 0;
}

#define reboot() do { \
	printf("\trebooting...\n"); \
	reset_cpu(0); \
} while (0)

static int test_fast_enable(void)
{
	uint8_t disable = 0, deactivated = 0;
	int i;

	printf("Testing fastenable ...\n");
	tpm_init();
	TPM_CHECK(TlclStartupIfNeeded());
	TPM_CHECK(tpm_self_test_full());
	TPM_CHECK(tpm_tsc_physical_presence(PRESENCE));
	TPM_CHECK(tpm_get_flags(&disable, &deactivated, NULL));
	printf("\tdisable is %d, deactivated is %d\n", disable, deactivated);
	for (i = 0; i < 2; i++) {
		TPM_CHECK(tpm_force_clear());
		TPM_CHECK(tpm_get_flags(&disable, &deactivated, NULL));
		printf("\tdisable is %d, deactivated is %d\n", disable,
		       deactivated);
		assert(disable == 1 && deactivated == 1);
		TPM_CHECK(tpm_physical_enable());
		TPM_CHECK(tpm_physical_set_deactivated(0));
		TPM_CHECK(tpm_get_flags(&disable, &deactivated, NULL));
		printf("\tdisable is %d, deactivated is %d\n", disable,
		       deactivated);
		assert(disable == 0 && deactivated == 0);
	}
	printf("\tdone\n");
	return 0;
}

static int test_global_lock(void)
{
	uint32_t zero = 0;
	uint32_t result;
	uint32_t x;

	printf("Testing globallock ...\n");
	tpm_init();
	TPM_CHECK(TlclStartupIfNeeded());
	TPM_CHECK(tpm_self_test_full());
	TPM_CHECK(tpm_tsc_physical_presence(PRESENCE));
	TPM_CHECK(tpm_nv_read_value(INDEX0, (uint8_t *)&x, sizeof(x)));
	TPM_CHECK(tpm_nv_write_value(INDEX0, (uint8_t *)&zero,
				     sizeof(uint32_t)));
	TPM_CHECK(tpm_nv_read_value(INDEX1, (uint8_t *)&x, sizeof(x)));
	TPM_CHECK(tpm_nv_write_value(INDEX1, (uint8_t *)&zero,
				     sizeof(uint32_t)));
	TPM_CHECK(tpm_set_global_lock());
	/* Verifies that write to index0 fails */
	x = 1;
	result = tpm_nv_write_value(INDEX0, (uint8_t *)&x, sizeof(x));
	assert(result == TPM_AREA_LOCKED);
	TPM_CHECK(tpm_nv_read_value(INDEX0, (uint8_t *)&x, sizeof(x)));
	assert(x == 0);
	/* Verifies that write to index1 is still possible */
	x = 2;
	TPM_CHECK(tpm_nv_write_value(INDEX1, (uint8_t *)&x, sizeof(x)));
	TPM_CHECK(tpm_nv_read_value(INDEX1, (uint8_t *)&x, sizeof(x)));
	assert(x == 2);
	/* Turns off PP */
	tpm_tsc_physical_presence(PHYS_PRESENCE);
	/* Verifies that write to index1 fails */
	x = 3;
	result = tpm_nv_write_value(INDEX1, (uint8_t *)&x, sizeof(x));
	assert(result == TPM_BAD_PRESENCE);
	TPM_CHECK(tpm_nv_read_value(INDEX1, (uint8_t *)&x, sizeof(x)));
	assert(x == 2);
	printf("\tdone\n");
	return 0;
}

static int test_lock(void)
{
	printf("Testing lock ...\n");
	tpm_init();
	tpm_startup(TPM_ST_CLEAR);
	tpm_self_test_full();
	tpm_tsc_physical_presence(PRESENCE);
	tpm_nv_write_value_lock(INDEX0);
	printf("\tLocked 0x%x\n", INDEX0);
	printf("\tdone\n");
	return 0;
}

static void initialise_spaces(void)
{
	uint32_t zero = 0;
	uint32_t perm = TPM_NV_PER_WRITE_STCLEAR | TPM_NV_PER_PPWRITE;

	printf("\tInitialising spaces\n");
	tpm_nv_set_locked();  /* useful only the first time */
	tpm_nv_define_space(INDEX0, perm, 4);
	tpm_nv_write_value(INDEX0, (uint8_t *)&zero, 4);
	tpm_nv_define_space(INDEX1, perm, 4);
	tpm_nv_write_value(INDEX1, (uint8_t *)&zero, 4);
	tpm_nv_define_space(INDEX2, perm, 4);
	tpm_nv_write_value(INDEX2, (uint8_t *)&zero, 4);
	tpm_nv_define_space(INDEX3, perm, 4);
	tpm_nv_write_value(INDEX3, (uint8_t *)&zero, 4);
	perm = TPM_NV_PER_READ_STCLEAR | TPM_NV_PER_WRITE_STCLEAR |
		TPM_NV_PER_PPWRITE;
	tpm_nv_define_space(INDEX_INITIALISED, perm, 1);
}

static int test_readonly(void)
{
	uint8_t c;
	uint32_t index_0, index_1, index_2, index_3;
	int read0, read1, read2, read3;

	printf("Testing readonly ...\n");
	tpm_init();
	tpm_startup(TPM_ST_CLEAR);
	tpm_self_test_full();
	tpm_tsc_physical_presence(PRESENCE);
	/*
	 * Checks if initialisation has completed by trying to read-lock a
	 * space that's created at the end of initialisation
	 */
	if (tpm_nv_read_value(INDEX_INITIALISED, &c, 0) == TPM_BADINDEX) {
		/* The initialisation did not complete */
		initialise_spaces();
	}

	/* Checks if spaces are OK or messed up */
	read0 = tpm_nv_read_value(INDEX0, (uint8_t *)&index_0, sizeof(index_0));
	read1 = tpm_nv_read_value(INDEX1, (uint8_t *)&index_1, sizeof(index_1));
	read2 = tpm_nv_read_value(INDEX2, (uint8_t *)&index_2, sizeof(index_2));
	read3 = tpm_nv_read_value(INDEX3, (uint8_t *)&index_3, sizeof(index_3));
	if (read0 || read1 || read2 || read3) {
		printf("Invalid contents\n");
		return 0;
	}

	/*
	 * Writes space, and locks it.  Then attempts to write again.
	 * I really wish I could use the imperative.
	 */
	index_0 += 1;
	if (tpm_nv_write_value(INDEX0, (uint8_t *)&index_0, sizeof(index_0) !=
		TPM_SUCCESS)) {
		error("\tcould not write index 0\n");
	}
	tpm_nv_write_value_lock(INDEX0);
	if (tpm_nv_write_value(INDEX0, (uint8_t *)&index_0, sizeof(index_0)) ==
			TPM_SUCCESS)
		error("\tindex 0 is not locked\n");

	printf("\tdone\n");
	return 0;
}

static int test_redefine_unowned(void)
{
	uint32_t perm;
	uint32_t result;
	uint32_t x;

	printf("Testing redefine_unowned ...");
	tpm_init();
	TPM_CHECK(TlclStartupIfNeeded());
	TPM_CHECK(tpm_self_test_full());
	TPM_CHECK(tpm_tsc_physical_presence(PRESENCE));
	assert(!tpm_is_owned());

	/* Ensures spaces exist. */
	TPM_CHECK(tpm_nv_read_value(INDEX0, (uint8_t *)&x, sizeof(x)));
	TPM_CHECK(tpm_nv_read_value(INDEX1, (uint8_t *)&x, sizeof(x)));

	/* Redefines spaces a couple of times. */
	perm = TPM_NV_PER_PPWRITE | TPM_NV_PER_GLOBALLOCK;
	TPM_CHECK(tpm_nv_define_space(INDEX0, perm, 2 * sizeof(uint32_t)));
	TPM_CHECK(tpm_nv_define_space(INDEX0, perm, sizeof(uint32_t)));
	perm = TPM_NV_PER_PPWRITE;
	TPM_CHECK(tpm_nv_define_space(INDEX1, perm, 2 * sizeof(uint32_t)));
	TPM_CHECK(tpm_nv_define_space(INDEX1, perm, sizeof(uint32_t)));

	/* Sets the global lock */
	tpm_set_global_lock();

	/* Verifies that index0 cannot be redefined */
	result = tpm_nv_define_space(INDEX0, perm, sizeof(uint32_t));
	assert(result == TPM_AREA_LOCKED);

	/* Checks that index1 can */
	TPM_CHECK(tpm_nv_define_space(INDEX1, perm, 2 * sizeof(uint32_t)));
	TPM_CHECK(tpm_nv_define_space(INDEX1, perm, sizeof(uint32_t)));

	/* Turns off PP */
	tpm_tsc_physical_presence(PHYS_PRESENCE);

	/* Verifies that neither index0 nor index1 can be redefined */
	result = tpm_nv_define_space(INDEX0, perm, sizeof(uint32_t));
	assert(result == TPM_BAD_PRESENCE);
	result = tpm_nv_define_space(INDEX1, perm, sizeof(uint32_t));
	assert(result == TPM_BAD_PRESENCE);

	printf("done\n");
	return 0;
}

#define PERMPPGL (TPM_NV_PER_PPWRITE | TPM_NV_PER_GLOBALLOCK)
#define PERMPP TPM_NV_PER_PPWRITE

static int test_space_perm(void)
{
	uint32_t perm;

	printf("Testing spaceperm ...");
	tpm_init();
	TPM_CHECK(TlclStartupIfNeeded());
	TPM_CHECK(tpm_continue_self_test());
	TPM_CHECK(tpm_tsc_physical_presence(PRESENCE));
	TPM_CHECK(tpm_get_permissions(INDEX0, &perm));
	assert((perm & PERMPPGL) == PERMPPGL);
	TPM_CHECK(tpm_get_permissions(INDEX1, &perm));
	assert((perm & PERMPP) == PERMPP);
	printf("done\n");
	return 0;
}

static int test_startup(void)
{
	uint32_t result;
	printf("Testing startup ...\n");

	tpm_init();
	result = tpm_startup(TPM_ST_CLEAR);
	if (result != 0 && result != TPM_INVALID_POSTINIT)
		printf("\ttpm startup failed with 0x%x\n", result);
	result = tpm_get_flags(NULL, NULL, NULL);
	if (result != 0)
		printf("\ttpm getflags failed with 0x%x\n", result);
	printf("\texecuting SelfTestFull\n");
	tpm_self_test_full();
	result = tpm_get_flags(NULL, NULL, NULL);
	if (result != 0)
		printf("\ttpm getflags failed with 0x%x\n", result);
	printf("\tdone\n");
	return 0;
}

/*
 * Runs [op] and ensures it returns success and doesn't run longer than
 * [time_limit] in milliseconds.
 */
#define TTPM_CHECK(op, time_limit) do { \
	ulong start, time; \
	uint32_t __result; \
	\
	start = get_timer(0); \
	__result = op; \
	if (__result != TPM_SUCCESS) { \
		printf("\t" #op ": error 0x%x\n", __result); \
		return -1; \
	} \
	time = get_timer(start); \
	printf("\t" #op ": %lu ms\n", time); \
	if (time > (ulong)time_limit) { \
		printf("\t" #op " exceeded " #time_limit " ms\n"); \
	} \
} while (0)


static int test_timing(void)
{
	uint32_t x;
	uint8_t in[20], out[20];

	printf("Testing timing ...");
	tpm_init();
	TTPM_CHECK(TlclStartupIfNeeded(), 50);
	TTPM_CHECK(tpm_continue_self_test(), 100);
	TTPM_CHECK(tpm_self_test_full(), 1000);
	TTPM_CHECK(tpm_tsc_physical_presence(PRESENCE), 100);
	TTPM_CHECK(tpm_nv_write_value(INDEX0, (uint8_t *)&x, sizeof(x)), 100);
	TTPM_CHECK(tpm_nv_read_value(INDEX0, (uint8_t *)&x, sizeof(x)), 100);
	TTPM_CHECK(tpm_extend(0, in, out), 200);
	TTPM_CHECK(tpm_set_global_lock(), 50);
	TTPM_CHECK(tpm_tsc_physical_presence(PHYS_PRESENCE), 100);
	printf("done\n");
	return 0;
}

#define TPM_MAX_NV_WRITES_NOOWNER 64

static int test_write_limit(void)
{
	printf("Testing writelimit ...\n");
	int i;
	uint32_t result;

	tpm_init();
	TPM_CHECK(TlclStartupIfNeeded());
	TPM_CHECK(tpm_self_test_full());
	TPM_CHECK(tpm_tsc_physical_presence(PRESENCE));
	TPM_CHECK(tpm_force_clear());
	TPM_CHECK(tpm_physical_enable());
	TPM_CHECK(tpm_physical_set_deactivated(0));

	for (i = 0; i < TPM_MAX_NV_WRITES_NOOWNER + 2; i++) {
		printf("\twriting %d\n", i);
		result = tpm_nv_write_value(INDEX0, (uint8_t *)&i, sizeof(i));
		switch (result) {
		case TPM_SUCCESS:
			break;
		case TPM_MAXNVWRITES:
			assert(i >= TPM_MAX_NV_WRITES_NOOWNER);
		default:
			error("\tunexpected error code %d (0x%x)\n",
			      result, result);
		}
	}

	/* Reset write count */
	TPM_CHECK(tpm_force_clear());
	TPM_CHECK(tpm_physical_enable());
	TPM_CHECK(tpm_physical_set_deactivated(0));

	/* Try writing again. */
	TPM_CHECK(tpm_nv_write_value(INDEX0, (uint8_t *)&i, sizeof(i)));
	printf("\tdone\n");
	return 0;
}

#define VOIDTEST(XFUNC) \
	int do_test_##XFUNC(cmd_tbl_t *cmd_tbl, int flag, int argc, \
	char * const argv[]) \
	{ \
		return test_##XFUNC(); \
	}

#define VOIDENT(XNAME) \
	U_BOOT_CMD_MKENT(XNAME, 0, 1, do_test_##XNAME, "", ""),

VOIDTEST(early_extend)
VOIDTEST(early_nvram)
VOIDTEST(early_nvram2)
VOIDTEST(enable)
VOIDTEST(fast_enable)
VOIDTEST(global_lock)
VOIDTEST(lock)
VOIDTEST(readonly)
VOIDTEST(redefine_unowned)
VOIDTEST(space_perm)
VOIDTEST(startup)
VOIDTEST(timing)
VOIDTEST(write_limit)
VOIDTEST(timer)

static cmd_tbl_t cmd_cros_tpm_sub[] = {
	VOIDENT(early_extend)
	VOIDENT(early_nvram)
	VOIDENT(early_nvram2)
	VOIDENT(enable)
	VOIDENT(fast_enable)
	VOIDENT(global_lock)
	VOIDENT(lock)
	VOIDENT(readonly)
	VOIDENT(redefine_unowned)
	VOIDENT(space_perm)
	VOIDENT(startup)
	VOIDENT(timing)
	VOIDENT(write_limit)
	VOIDENT(timer)
};

static int do_tpmtest(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	cmd_tbl_t *c;
	int i;

	printf("argc = %d, argv = ", argc);

	for (i = 0; i < argc; i++)
		printf(" %s", argv[i]);

	printf("\n------\n");

	argc--;
	argv++;
	c = find_cmd_tbl(argv[0], cmd_cros_tpm_sub,
			 ARRAY_SIZE(cmd_cros_tpm_sub));
	return c ? c->cmd(cmdtp, flag, argc, argv) : cmd_usage(cmdtp);
}

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