[thirdparty/u-boot.git] / cmd / tpm_test.c

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

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