diff options
author | Simon Glass <sjg@chromium.org> | 2018-11-18 14:22:27 -0700 |
---|---|---|
committer | Simon Glass <sjg@chromium.org> | 2018-11-29 09:30:06 -0700 |
commit | abdc7b8a2d7f2b8527ce4f9133b777942af99126 (patch) | |
tree | e45abe92dc40db0d684f7ed82453504469b99cc3 /cmd | |
parent | 51f00c1704e505f51a02a3687e4384231ce8ae20 (diff) |
tpm: Convert to use a device parameter
At present many TPM calls assume there is only one TPM in the system and
look up this TPM themselves. This is inconsistent with driver model, which
expects all driver methods to have a device parameter. Update the code to
correct this.
Signed-off-by: Simon Glass <sjg@chromium.org>
Diffstat (limited to 'cmd')
-rw-r--r-- | cmd/tpm-common.c | 8 | ||||
-rw-r--r-- | cmd/tpm-v1.c | 140 | ||||
-rw-r--r-- | cmd/tpm-v2.c | 78 | ||||
-rw-r--r-- | cmd/tpm_test.c | 327 |
4 files changed, 364 insertions, 189 deletions
diff --git a/cmd/tpm-common.c b/cmd/tpm-common.c index 56443862c22..89f2aa001ba 100644 --- a/cmd/tpm-common.c +++ b/cmd/tpm-common.c @@ -264,10 +264,16 @@ int do_tpm_info(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) int do_tpm_init(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { + struct udevice *dev; + int rc; + if (argc != 1) return CMD_RET_USAGE; + rc = get_tpm(&dev); + if (rc) + return rc; - return report_return_code(tpm_init()); + return report_return_code(tpm_init(dev)); } int do_tpm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) diff --git a/cmd/tpm-v1.c b/cmd/tpm-v1.c index 69870002d4f..b75e0933a1c 100644 --- a/cmd/tpm-v1.c +++ b/cmd/tpm-v1.c @@ -14,7 +14,12 @@ static int do_tpm_startup(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { enum tpm_startup_type mode; + struct udevice *dev; + int rc; + rc = get_tpm(&dev); + if (rc) + return rc; if (argc != 2) return CMD_RET_USAGE; if (!strcasecmp("TPM_ST_CLEAR", argv[1])) { @@ -28,13 +33,19 @@ static int do_tpm_startup(cmd_tbl_t *cmdtp, int flag, int argc, return CMD_RET_FAILURE; } - return report_return_code(tpm_startup(mode)); + return report_return_code(tpm_startup(dev, mode)); } static int do_tpm_nv_define_space(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { u32 index, perm, size; + struct udevice *dev; + int rc; + + rc = get_tpm(&dev); + if (rc) + return rc; if (argc != 4) return CMD_RET_USAGE; @@ -42,22 +53,27 @@ static int do_tpm_nv_define_space(cmd_tbl_t *cmdtp, int flag, int argc, perm = simple_strtoul(argv[2], NULL, 0); size = simple_strtoul(argv[3], NULL, 0); - return report_return_code(tpm_nv_define_space(index, perm, size)); + return report_return_code(tpm_nv_define_space(dev, index, perm, size)); } static int do_tpm_nv_read_value(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { u32 index, count, rc; + struct udevice *dev; void *data; + rc = get_tpm(&dev); + if (rc) + return rc; + if (argc != 4) return CMD_RET_USAGE; index = simple_strtoul(argv[1], NULL, 0); data = (void *)simple_strtoul(argv[2], NULL, 0); count = simple_strtoul(argv[3], NULL, 0); - rc = tpm_nv_read_value(index, data, count); + rc = tpm_nv_read_value(dev, index, data, count); if (!rc) { puts("area content:\n"); print_byte_string(data, count); @@ -69,10 +85,15 @@ static int do_tpm_nv_read_value(cmd_tbl_t *cmdtp, int flag, int argc, static int do_tpm_nv_write_value(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { + struct udevice *dev; u32 index, rc; size_t count; void *data; + rc = get_tpm(&dev); + if (rc) + return rc; + if (argc != 3) return CMD_RET_USAGE; index = simple_strtoul(argv[1], NULL, 0); @@ -82,7 +103,7 @@ static int do_tpm_nv_write_value(cmd_tbl_t *cmdtp, int flag, int argc, return CMD_RET_FAILURE; } - rc = tpm_nv_write_value(index, data, count); + rc = tpm_nv_write_value(dev, index, data, count); free(data); return report_return_code(rc); @@ -91,8 +112,13 @@ static int do_tpm_nv_write_value(cmd_tbl_t *cmdtp, int flag, int argc, static int do_tpm_extend(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { - u32 index, rc; u8 in_digest[20], out_digest[20]; + struct udevice *dev; + u32 index, rc; + + rc = get_tpm(&dev); + if (rc) + return rc; if (argc != 3) return CMD_RET_USAGE; @@ -102,7 +128,7 @@ static int do_tpm_extend(cmd_tbl_t *cmdtp, int flag, int argc, return CMD_RET_FAILURE; } - rc = tpm_extend(index, in_digest, out_digest); + rc = tpm_extend(dev, index, in_digest, out_digest); if (!rc) { puts("PCR value after execution of the command:\n"); print_byte_string(out_digest, sizeof(out_digest)); @@ -115,15 +141,20 @@ static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { u32 index, count, rc; + struct udevice *dev; void *data; + rc = get_tpm(&dev); + if (rc) + return rc; + if (argc != 4) return CMD_RET_USAGE; index = simple_strtoul(argv[1], NULL, 0); data = (void *)simple_strtoul(argv[2], NULL, 0); count = simple_strtoul(argv[3], NULL, 0); - rc = tpm_pcr_read(index, data, count); + rc = tpm_pcr_read(dev, index, data, count); if (!rc) { puts("Named PCR content:\n"); print_byte_string(data, count); @@ -135,27 +166,38 @@ static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag, int argc, static int do_tpm_tsc_physical_presence(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { + struct udevice *dev; u16 presence; + int rc; + + rc = get_tpm(&dev); + if (rc) + return rc; if (argc != 2) return CMD_RET_USAGE; presence = (u16)simple_strtoul(argv[1], NULL, 0); - return report_return_code(tpm_tsc_physical_presence(presence)); + return report_return_code(tpm_tsc_physical_presence(dev, presence)); } static int do_tpm_read_pubek(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { + struct udevice *dev; u32 count, rc; void *data; + rc = get_tpm(&dev); + if (rc) + return rc; + if (argc != 3) return CMD_RET_USAGE; data = (void *)simple_strtoul(argv[1], NULL, 0); count = simple_strtoul(argv[2], NULL, 0); - rc = tpm_read_pubek(data, count); + rc = tpm_read_pubek(dev, data, count); if (!rc) { puts("pubek value:\n"); print_byte_string(data, count); @@ -167,13 +209,19 @@ static int do_tpm_read_pubek(cmd_tbl_t *cmdtp, int flag, int argc, static int do_tpm_physical_set_deactivated(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { + struct udevice *dev; u8 state; + int rc; + + rc = get_tpm(&dev); + if (rc) + return rc; if (argc != 2) return CMD_RET_USAGE; state = (u8)simple_strtoul(argv[1], NULL, 0); - return report_return_code(tpm_physical_set_deactivated(state)); + return report_return_code(tpm_physical_set_deactivated(dev, state)); } static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag, int argc, @@ -182,6 +230,11 @@ static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag, int argc, u32 cap_area, sub_cap, rc; void *cap; size_t count; + struct udevice *dev; + + rc = get_tpm(&dev); + if (rc) + return rc; if (argc != 5) return CMD_RET_USAGE; @@ -190,7 +243,7 @@ static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag, int argc, cap = (void *)simple_strtoul(argv[3], NULL, 0); count = simple_strtoul(argv[4], NULL, 0); - rc = tpm_get_capability(cap_area, sub_cap, cap, count); + rc = tpm_get_capability(dev, cap_area, sub_cap, cap, count); if (!rc) { puts("capability information:\n"); print_byte_string(cap, count); @@ -232,6 +285,12 @@ static int do_tpm_nv_define(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { u32 index, perm, size; + struct udevice *dev; + int rc; + + rc = get_tpm(&dev); + if (rc) + return rc; if (argc != 4) return CMD_RET_USAGE; @@ -243,14 +302,20 @@ static int do_tpm_nv_define(cmd_tbl_t *cmdtp, int flag, int argc, index = simple_strtoul(argv[2], NULL, 0); perm = simple_strtoul(argv[3], NULL, 0); - return report_return_code(tpm_nv_define_space(index, perm, size)); + return report_return_code(tpm_nv_define_space(dev, index, perm, size)); } static int do_tpm_nv_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { u32 index, count, err; + struct udevice *dev; void *data; + int rc; + + rc = get_tpm(&dev); + if (rc) + return rc; if (argc < 3) return CMD_RET_USAGE; @@ -263,7 +328,7 @@ static int do_tpm_nv_read(cmd_tbl_t *cmdtp, int flag, int argc, return CMD_RET_USAGE; } - err = tpm_nv_read_value(index, data, count); + err = tpm_nv_read_value(dev, index, data, count); if (!err) { if (type_string_write_vars(argv[1], data, argv + 3)) { printf("Couldn't write to variables\n"); @@ -279,7 +344,13 @@ static int do_tpm_nv_write(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { u32 index, count, err; + struct udevice *dev; void *data; + int rc; + + rc = get_tpm(&dev); + if (rc) + return rc; if (argc < 3) return CMD_RET_USAGE; @@ -297,7 +368,7 @@ static int do_tpm_nv_write(cmd_tbl_t *cmdtp, int flag, int argc, return CMD_RET_USAGE; } - err = tpm_nv_write_value(index, data, count); + err = tpm_nv_write_value(dev, index, data, count); free(data); return report_return_code(err); @@ -309,8 +380,14 @@ static int do_tpm_oiap(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { u32 auth_handle, err; + struct udevice *dev; + int rc; + + rc = get_tpm(&dev); + if (rc) + return rc; - err = tpm_oiap(&auth_handle); + err = tpm_oiap(dev, &auth_handle); return report_return_code(err); } @@ -324,6 +401,11 @@ static int do_tpm_load_key_by_sha1(cmd_tbl_t *cmdtp, int flag, int argc, char * u8 usage_auth[DIGEST_LENGTH]; u8 parent_hash[DIGEST_LENGTH]; void *key; + struct udevice *dev; + + rc = get_tpm(&dev); + if (rc) + return rc; if (argc < 5) return CMD_RET_USAGE; @@ -360,6 +442,12 @@ static int do_tpm_load_key2_oiap(cmd_tbl_t *cmdtp, int flag, int argc, u32 parent_handle, key_len, key_handle, err; u8 usage_auth[DIGEST_LENGTH]; void *key; + struct udevice *dev; + int rc; + + rc = get_tpm(&dev); + if (rc) + return rc; if (argc < 5) return CMD_RET_USAGE; @@ -371,7 +459,7 @@ static int do_tpm_load_key2_oiap(cmd_tbl_t *cmdtp, int flag, int argc, return CMD_RET_FAILURE; parse_byte_string(argv[4], usage_auth, NULL); - err = tpm_load_key2_oiap(parent_handle, key, key_len, usage_auth, + err = tpm_load_key2_oiap(dev, parent_handle, key, key_len, usage_auth, &key_handle); if (!err) printf("Key handle is 0x%x\n", key_handle); @@ -386,6 +474,12 @@ static int do_tpm_get_pub_key_oiap(cmd_tbl_t *cmdtp, int flag, int argc, u8 usage_auth[DIGEST_LENGTH]; u8 pub_key_buffer[TPM_PUBKEY_MAX_LENGTH]; size_t pub_key_len = sizeof(pub_key_buffer); + struct udevice *dev; + int rc; + + rc = get_tpm(&dev); + if (rc) + return rc; if (argc < 3) return CMD_RET_USAGE; @@ -395,7 +489,7 @@ static int do_tpm_get_pub_key_oiap(cmd_tbl_t *cmdtp, int flag, int argc, return CMD_RET_FAILURE; parse_byte_string(argv[2], usage_auth, NULL); - err = tpm_get_pub_key_oiap(key_handle, usage_auth, pub_key_buffer, + err = tpm_get_pub_key_oiap(dev, key_handle, usage_auth, pub_key_buffer, &pub_key_len); if (!err) { printf("dump of received pub key structure:\n"); @@ -412,7 +506,13 @@ TPM_COMMAND_NO_ARG(tpm_end_oiap) static int do_tpm_flush(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { + struct udevice *dev; int type = 0; + int rc; + + rc = get_tpm(&dev); + if (rc) + return rc; if (argc != 3) return CMD_RET_USAGE; @@ -451,7 +551,7 @@ static int do_tpm_flush(cmd_tbl_t *cmdtp, int flag, int argc, uint i; /* fetch list of already loaded resources in the TPM */ - err = tpm_get_capability(TPM_CAP_HANDLE, type, buf, + err = tpm_get_capability(dev, TPM_CAP_HANDLE, type, buf, sizeof(buf)); if (err) { printf("tpm_get_capability returned error %d.\n", err); @@ -460,7 +560,7 @@ static int do_tpm_flush(cmd_tbl_t *cmdtp, int flag, int argc, res_count = get_unaligned_be16(buf); ptr = buf + 2; for (i = 0; i < res_count; ++i, ptr += 4) - tpm_flush_specific(get_unaligned_be32(ptr), type); + tpm_flush_specific(dev, get_unaligned_be32(ptr), type); } else { u32 handle = simple_strtoul(argv[2], NULL, 0); @@ -468,7 +568,7 @@ static int do_tpm_flush(cmd_tbl_t *cmdtp, int flag, int argc, printf("Illegal resource handle %s\n", argv[2]); return -1; } - tpm_flush_specific(cpu_to_be32(handle), type); + tpm_flush_specific(dev, cpu_to_be32(handle), type); } return 0; diff --git a/cmd/tpm-v2.c b/cmd/tpm-v2.c index ffbf35a75c5..bb51834c478 100644 --- a/cmd/tpm-v2.c +++ b/cmd/tpm-v2.c @@ -16,7 +16,12 @@ static int do_tpm2_startup(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { enum tpm2_startup_types mode; + struct udevice *dev; + int ret; + ret = get_tpm(&dev); + if (ret) + return ret; if (argc != 2) return CMD_RET_USAGE; @@ -29,14 +34,19 @@ static int do_tpm2_startup(cmd_tbl_t *cmdtp, int flag, int argc, return CMD_RET_FAILURE; } - return report_return_code(tpm2_startup(mode)); + return report_return_code(tpm2_startup(dev, mode)); } static int do_tpm2_self_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { enum tpm2_yes_no full_test; + struct udevice *dev; + int ret; + ret = get_tpm(&dev); + if (ret) + return ret; if (argc != 2) return CMD_RET_USAGE; @@ -49,7 +59,7 @@ static int do_tpm2_self_test(cmd_tbl_t *cmdtp, int flag, int argc, return CMD_RET_FAILURE; } - return report_return_code(tpm2_self_test(full_test)); + return report_return_code(tpm2_self_test(dev, full_test)); } static int do_tpm2_clear(cmd_tbl_t *cmdtp, int flag, int argc, @@ -58,6 +68,12 @@ static int do_tpm2_clear(cmd_tbl_t *cmdtp, int flag, int argc, u32 handle = 0; const char *pw = (argc < 3) ? NULL : argv[2]; const ssize_t pw_sz = pw ? strlen(pw) : 0; + struct udevice *dev; + int ret; + + ret = get_tpm(&dev); + if (ret) + return ret; if (argc < 2 || argc > 3) return CMD_RET_USAGE; @@ -72,7 +88,7 @@ static int do_tpm2_clear(cmd_tbl_t *cmdtp, int flag, int argc, else return CMD_RET_USAGE; - return report_return_code(tpm2_clear(handle, pw, pw_sz)); + return report_return_code(tpm2_clear(dev, handle, pw, pw_sz)); } static int do_tpm2_pcr_extend(cmd_tbl_t *cmdtp, int flag, int argc, @@ -88,7 +104,7 @@ static int do_tpm2_pcr_extend(cmd_tbl_t *cmdtp, int flag, int argc, if (argc != 3) return CMD_RET_USAGE; - ret = uclass_first_device_err(UCLASS_TPM, &dev); + ret = get_tpm(&dev); if (ret) return ret; @@ -99,7 +115,7 @@ static int do_tpm2_pcr_extend(cmd_tbl_t *cmdtp, int flag, int argc, if (index >= priv->pcr_count) return -EINVAL; - rc = tpm2_pcr_extend(index, digest); + rc = tpm2_pcr_extend(dev, index, digest); unmap_sysmem(digest); @@ -119,7 +135,7 @@ static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag, int argc, if (argc != 3) return CMD_RET_USAGE; - ret = uclass_first_device_err(UCLASS_TPM, &dev); + ret = get_tpm(&dev); if (ret) return ret; @@ -133,7 +149,7 @@ static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag, int argc, data = map_sysmem(simple_strtoul(argv[2], NULL, 0), 0); - rc = tpm2_pcr_read(index, priv->pcr_select_min, data, &updates); + rc = tpm2_pcr_read(dev, index, priv->pcr_select_min, data, &updates); if (!rc) { printf("PCR #%u content (%d known updates):\n", index, updates); print_byte_string(data, TPM2_DIGEST_LEN); @@ -151,6 +167,12 @@ static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag, int argc, u8 *data; size_t count; int i, j; + struct udevice *dev; + int ret; + + ret = get_tpm(&dev); + if (ret) + return ret; if (argc != 5) return CMD_RET_USAGE; @@ -160,7 +182,7 @@ static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag, int argc, data = map_sysmem(simple_strtoul(argv[3], NULL, 0), 0); count = simple_strtoul(argv[4], NULL, 0); - rc = tpm2_get_capability(capability, property, data, count); + rc = tpm2_get_capability(dev, capability, property, data, count); if (rc) goto unmap_data; @@ -186,6 +208,12 @@ static int do_tpm_dam_reset(cmd_tbl_t *cmdtp, int flag, int argc, { const char *pw = (argc < 2) ? NULL : argv[1]; const ssize_t pw_sz = pw ? strlen(pw) : 0; + struct udevice *dev; + int ret; + + ret = get_tpm(&dev); + if (ret) + return ret; if (argc > 2) return CMD_RET_USAGE; @@ -193,7 +221,7 @@ static int do_tpm_dam_reset(cmd_tbl_t *cmdtp, int flag, int argc, if (pw_sz > TPM2_DIGEST_LEN) return -EINVAL; - return report_return_code(tpm2_dam_reset(pw, pw_sz)); + return report_return_code(tpm2_dam_reset(dev, pw, pw_sz)); } static int do_tpm_dam_parameters(cmd_tbl_t *cmdtp, int flag, int argc, @@ -208,6 +236,12 @@ static int do_tpm_dam_parameters(cmd_tbl_t *cmdtp, int flag, int argc, unsigned long int max_tries; unsigned long int recovery_time; unsigned long int lockout_recovery; + struct udevice *dev; + int ret; + + ret = get_tpm(&dev); + if (ret) + return ret; if (argc < 4 || argc > 5) return CMD_RET_USAGE; @@ -229,7 +263,7 @@ static int do_tpm_dam_parameters(cmd_tbl_t *cmdtp, int flag, int argc, log(LOGC_NONE, LOGL_INFO, "- recoveryTime: %lu\n", recovery_time); log(LOGC_NONE, LOGL_INFO, "- lockoutRecovery: %lu\n", lockout_recovery); - return report_return_code(tpm2_dam_parameters(pw, pw_sz, max_tries, + return report_return_code(tpm2_dam_parameters(dev, pw, pw_sz, max_tries, recovery_time, lockout_recovery)); } @@ -242,6 +276,12 @@ static int do_tpm_change_auth(cmd_tbl_t *cmdtp, int flag, int argc, const char *oldpw = (argc == 3) ? NULL : argv[3]; const ssize_t newpw_sz = strlen(newpw); const ssize_t oldpw_sz = oldpw ? strlen(oldpw) : 0; + struct udevice *dev; + int ret; + + ret = get_tpm(&dev); + if (ret) + return ret; if (argc < 3 || argc > 4) return CMD_RET_USAGE; @@ -260,7 +300,7 @@ static int do_tpm_change_auth(cmd_tbl_t *cmdtp, int flag, int argc, else return CMD_RET_USAGE; - return report_return_code(tpm2_change_auth(handle, newpw, newpw_sz, + return report_return_code(tpm2_change_auth(dev, handle, newpw, newpw_sz, oldpw, oldpw_sz)); } @@ -271,6 +311,12 @@ static int do_tpm_pcr_setauthpolicy(cmd_tbl_t *cmdtp, int flag, int argc, char *key = argv[2]; const char *pw = (argc < 4) ? NULL : argv[3]; const ssize_t pw_sz = pw ? strlen(pw) : 0; + struct udevice *dev; + int ret; + + ret = get_tpm(&dev); + if (ret) + return ret; if (strlen(key) != TPM2_DIGEST_LEN) return -EINVAL; @@ -278,7 +324,7 @@ static int do_tpm_pcr_setauthpolicy(cmd_tbl_t *cmdtp, int flag, int argc, if (argc < 3 || argc > 4) return CMD_RET_USAGE; - return report_return_code(tpm2_pcr_setauthpolicy(pw, pw_sz, index, + return report_return_code(tpm2_pcr_setauthpolicy(dev, pw, pw_sz, index, key)); } @@ -290,6 +336,12 @@ static int do_tpm_pcr_setauthvalue(cmd_tbl_t *cmdtp, int flag, const ssize_t key_sz = strlen(key); const char *pw = (argc < 4) ? NULL : argv[3]; const ssize_t pw_sz = pw ? strlen(pw) : 0; + struct udevice *dev; + int ret; + + ret = get_tpm(&dev); + if (ret) + return ret; if (strlen(key) != TPM2_DIGEST_LEN) return -EINVAL; @@ -297,7 +349,7 @@ static int do_tpm_pcr_setauthvalue(cmd_tbl_t *cmdtp, int flag, if (argc < 3 || argc > 4) return CMD_RET_USAGE; - return report_return_code(tpm2_pcr_setauthvalue(pw, pw_sz, index, + return report_return_code(tpm2_pcr_setauthvalue(dev, pw, pw_sz, index, key, key_sz)); } diff --git a/cmd/tpm_test.c b/cmd/tpm_test.c index f21ad5d3cf9..56a5aa4aa5e 100644 --- a/cmd/tpm_test.c +++ b/cmd/tpm_test.c @@ -7,6 +7,7 @@ #include <command.h> #include <environment.h> #include <tpm-v1.h> +#include "tpm-user-utils.h" /* Prints error and returns on failure */ #define TPM_CHECK(tpm_command) do { \ @@ -28,26 +29,26 @@ #define PHYS_PRESENCE 4 #define PRESENCE 8 -static uint32_t TlclStartupIfNeeded(void) +static uint32_t TlclStartupIfNeeded(struct udevice *dev) { - uint32_t result = tpm_startup(TPM_ST_CLEAR); + uint32_t result = tpm_startup(dev, TPM_ST_CLEAR); return result == TPM_INVALID_POSTINIT ? TPM_SUCCESS : result; } -static int test_timer(void) +static int test_timer(struct udevice *dev) { 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) +static uint32_t tpm_get_flags(struct udevice *dev, uint8_t *disable, + uint8_t *deactivated, uint8_t *nvlocked) { struct tpm_permanent_flags pflags; uint32_t result; - result = tpm_get_permanent_flags(&pflags); + result = tpm_get_permanent_flags(dev, &pflags); if (result) return result; if (disable) @@ -62,79 +63,79 @@ static uint32_t tpm_get_flags(uint8_t *disable, uint8_t *deactivated, return 0; } -static uint32_t tpm_nv_write_value_lock(uint32_t index) +static uint32_t tpm_nv_write_value_lock(struct udevice *dev, uint32_t index) { debug("TPM: Write lock 0x%x\n", index); - return tpm_nv_write_value(index, NULL, 0); + return tpm_nv_write_value(dev, index, NULL, 0); } -static int tpm_is_owned(void) +static int tpm_is_owned(struct udevice *dev) { uint8_t response[TPM_PUBEK_SIZE]; uint32_t result; - result = tpm_read_pubek(response, sizeof(response)); + result = tpm_read_pubek(dev, response, sizeof(response)); return result != TPM_SUCCESS; } -static int test_early_extend(void) +static int test_early_extend(struct udevice *dev) { 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)); + tpm_init(dev); + TPM_CHECK(tpm_startup(dev, TPM_ST_CLEAR)); + TPM_CHECK(tpm_continue_self_test(dev)); + TPM_CHECK(tpm_extend(dev, 1, value_in, value_out)); printf("done\n"); return 0; } -static int test_early_nvram(void) +static int test_early_nvram(struct udevice *dev) { 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))); + tpm_init(dev); + TPM_CHECK(tpm_startup(dev, TPM_ST_CLEAR)); + TPM_CHECK(tpm_continue_self_test(dev)); + TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); + TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x))); printf("done\n"); return 0; } -static int test_early_nvram2(void) +static int test_early_nvram2(struct udevice *dev) { 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))); + tpm_init(dev); + TPM_CHECK(tpm_startup(dev, TPM_ST_CLEAR)); + TPM_CHECK(tpm_continue_self_test(dev)); + TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); + TPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&x, sizeof(x))); printf("done\n"); return 0; } -static int test_enable(void) +static int test_enable(struct udevice *dev) { 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)); + tpm_init(dev); + TPM_CHECK(TlclStartupIfNeeded(dev)); + TPM_CHECK(tpm_self_test_full(dev)); + TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); + TPM_CHECK(tpm_get_flags(dev, &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)); + TPM_CHECK(tpm_physical_enable(dev)); + TPM_CHECK(tpm_physical_set_deactivated(dev, 0)); + TPM_CHECK(tpm_get_flags(dev, &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"); @@ -147,27 +148,27 @@ static int test_enable(void) reset_cpu(0); \ } while (0) -static int test_fast_enable(void) +static int test_fast_enable(struct udevice *dev) { 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)); + tpm_init(dev); + TPM_CHECK(TlclStartupIfNeeded(dev)); + TPM_CHECK(tpm_self_test_full(dev)); + TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); + TPM_CHECK(tpm_get_flags(dev, &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)); + TPM_CHECK(tpm_force_clear(dev)); + TPM_CHECK(tpm_get_flags(dev, &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)); + TPM_CHECK(tpm_physical_enable(dev)); + TPM_CHECK(tpm_physical_set_deactivated(dev, 0)); + TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL)); printf("\tdisable is %d, deactivated is %d\n", disable, deactivated); assert(disable == 0 && deactivated == 0); @@ -176,105 +177,109 @@ static int test_fast_enable(void) return 0; } -static int test_global_lock(void) +static int test_global_lock(struct udevice *dev) { 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, + tpm_init(dev); + TPM_CHECK(TlclStartupIfNeeded(dev)); + TPM_CHECK(tpm_self_test_full(dev)); + TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); + TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x))); + TPM_CHECK(tpm_nv_write_value(dev, 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, + TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x))); + TPM_CHECK(tpm_nv_write_value(dev, INDEX1, (uint8_t *)&zero, sizeof(uint32_t))); - TPM_CHECK(tpm_set_global_lock()); + TPM_CHECK(tpm_set_global_lock(dev)); /* Verifies that write to index0 fails */ x = 1; - result = tpm_nv_write_value(INDEX0, (uint8_t *)&x, sizeof(x)); + result = tpm_nv_write_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)); assert(result == TPM_AREA_LOCKED); - TPM_CHECK(tpm_nv_read_value(INDEX0, (uint8_t *)&x, sizeof(x))); + TPM_CHECK(tpm_nv_read_value(dev, 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))); + TPM_CHECK(tpm_nv_write_value(dev, INDEX1, (uint8_t *)&x, sizeof(x))); + TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x))); assert(x == 2); /* Turns off PP */ - tpm_tsc_physical_presence(PHYS_PRESENCE); + tpm_tsc_physical_presence(dev, PHYS_PRESENCE); /* Verifies that write to index1 fails */ x = 3; - result = tpm_nv_write_value(INDEX1, (uint8_t *)&x, sizeof(x)); + result = tpm_nv_write_value(dev, INDEX1, (uint8_t *)&x, sizeof(x)); assert(result == TPM_BAD_PRESENCE); - TPM_CHECK(tpm_nv_read_value(INDEX1, (uint8_t *)&x, sizeof(x))); + TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x))); assert(x == 2); printf("\tdone\n"); return 0; } -static int test_lock(void) +static int test_lock(struct udevice *dev) { 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); + tpm_init(dev); + tpm_startup(dev, TPM_ST_CLEAR); + tpm_self_test_full(dev); + tpm_tsc_physical_presence(dev, PRESENCE); + tpm_nv_write_value_lock(dev, INDEX0); printf("\tLocked 0x%x\n", INDEX0); printf("\tdone\n"); return 0; } -static void initialise_spaces(void) +static void initialise_spaces(struct udevice *dev) { 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); + tpm_nv_set_locked(dev); /* useful only the first time */ + tpm_nv_define_space(dev, INDEX0, perm, 4); + tpm_nv_write_value(dev, INDEX0, (uint8_t *)&zero, 4); + tpm_nv_define_space(dev, INDEX1, perm, 4); + tpm_nv_write_value(dev, INDEX1, (uint8_t *)&zero, 4); + tpm_nv_define_space(dev, INDEX2, perm, 4); + tpm_nv_write_value(dev, INDEX2, (uint8_t *)&zero, 4); + tpm_nv_define_space(dev, INDEX3, perm, 4); + tpm_nv_write_value(dev, 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); + tpm_nv_define_space(dev, INDEX_INITIALISED, perm, 1); } -static int test_readonly(void) +static int test_readonly(struct udevice *dev) { 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); + tpm_init(dev); + tpm_startup(dev, TPM_ST_CLEAR); + tpm_self_test_full(dev); + tpm_tsc_physical_presence(dev, 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) { + if (tpm_nv_read_value(dev, INDEX_INITIALISED, &c, 0) == TPM_BADINDEX) { /* The initialisation did not complete */ - initialise_spaces(); + initialise_spaces(dev); } /* 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)); + read0 = tpm_nv_read_value(dev, INDEX0, (uint8_t *)&index_0, + sizeof(index_0)); + read1 = tpm_nv_read_value(dev, INDEX1, (uint8_t *)&index_1, + sizeof(index_1)); + read2 = tpm_nv_read_value(dev, INDEX2, (uint8_t *)&index_2, + sizeof(index_2)); + read3 = tpm_nv_read_value(dev, INDEX3, (uint8_t *)&index_3, + sizeof(index_3)); if (read0 || read1 || read2 || read3) { printf("Invalid contents\n"); return 0; @@ -285,12 +290,14 @@ static int test_readonly(void) * I really wish I could use the imperative. */ index_0 += 1; - if (tpm_nv_write_value(INDEX0, (uint8_t *)&index_0, sizeof(index_0) != + if (tpm_nv_write_value(dev, 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_nv_write_value_lock(dev, INDEX0); + if (tpm_nv_write_value(dev, INDEX0, (uint8_t *)&index_0, + sizeof(index_0)) == TPM_SUCCESS) pr_err("\tindex 0 is not locked\n"); @@ -298,49 +305,49 @@ static int test_readonly(void) return 0; } -static int test_redefine_unowned(void) +static int test_redefine_unowned(struct udevice *dev) { 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()); + tpm_init(dev); + TPM_CHECK(TlclStartupIfNeeded(dev)); + TPM_CHECK(tpm_self_test_full(dev)); + TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); + assert(!tpm_is_owned(dev)); /* 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))); + TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x))); + TPM_CHECK(tpm_nv_read_value(dev, 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))); + TPM_CHECK(tpm_nv_define_space(dev, INDEX0, perm, 2 * sizeof(uint32_t))); + TPM_CHECK(tpm_nv_define_space(dev, 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))); + TPM_CHECK(tpm_nv_define_space(dev, INDEX1, perm, 2 * sizeof(uint32_t))); + TPM_CHECK(tpm_nv_define_space(dev, INDEX1, perm, sizeof(uint32_t))); /* Sets the global lock */ - tpm_set_global_lock(); + tpm_set_global_lock(dev); /* Verifies that index0 cannot be redefined */ - result = tpm_nv_define_space(INDEX0, perm, sizeof(uint32_t)); + result = tpm_nv_define_space(dev, 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))); + TPM_CHECK(tpm_nv_define_space(dev, INDEX1, perm, 2 * sizeof(uint32_t))); + TPM_CHECK(tpm_nv_define_space(dev, INDEX1, perm, sizeof(uint32_t))); /* Turns off PP */ - tpm_tsc_physical_presence(PHYS_PRESENCE); + tpm_tsc_physical_presence(dev, PHYS_PRESENCE); /* Verifies that neither index0 nor index1 can be redefined */ - result = tpm_nv_define_space(INDEX0, perm, sizeof(uint32_t)); + result = tpm_nv_define_space(dev, INDEX0, perm, sizeof(uint32_t)); assert(result == TPM_BAD_PRESENCE); - result = tpm_nv_define_space(INDEX1, perm, sizeof(uint32_t)); + result = tpm_nv_define_space(dev, INDEX1, perm, sizeof(uint32_t)); assert(result == TPM_BAD_PRESENCE); printf("done\n"); @@ -350,38 +357,39 @@ static int test_redefine_unowned(void) #define PERMPPGL (TPM_NV_PER_PPWRITE | TPM_NV_PER_GLOBALLOCK) #define PERMPP TPM_NV_PER_PPWRITE -static int test_space_perm(void) +static int test_space_perm(struct udevice *dev) { 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)); + tpm_init(dev); + TPM_CHECK(TlclStartupIfNeeded(dev)); + TPM_CHECK(tpm_continue_self_test(dev)); + TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); + TPM_CHECK(tpm_get_permissions(dev, INDEX0, &perm)); assert((perm & PERMPPGL) == PERMPPGL); - TPM_CHECK(tpm_get_permissions(INDEX1, &perm)); + TPM_CHECK(tpm_get_permissions(dev, INDEX1, &perm)); assert((perm & PERMPP) == PERMPP); printf("done\n"); return 0; } -static int test_startup(void) +static int test_startup(struct udevice *dev) { uint32_t result; + printf("Testing startup ...\n"); - tpm_init(); - result = tpm_startup(TPM_ST_CLEAR); + tpm_init(dev); + result = tpm_startup(dev, 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); + result = tpm_get_flags(dev, 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); + tpm_self_test_full(dev); + result = tpm_get_flags(dev, NULL, NULL, NULL); if (result != 0) printf("\ttpm getflags failed with 0x%x\n", result); printf("\tdone\n"); @@ -410,45 +418,48 @@ static int test_startup(void) } while (0) -static int test_timing(void) +static int test_timing(struct udevice *dev) { - uint32_t x; uint8_t in[20], out[20]; + uint32_t x; 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); + tpm_init(dev); + TTPM_CHECK(TlclStartupIfNeeded(dev), 50); + TTPM_CHECK(tpm_continue_self_test(dev), 100); + TTPM_CHECK(tpm_self_test_full(dev), 1000); + TTPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE), 100); + TTPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)), + 100); + TTPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)), + 100); + TTPM_CHECK(tpm_extend(dev, 0, in, out), 200); + TTPM_CHECK(tpm_set_global_lock(dev), 50); + TTPM_CHECK(tpm_tsc_physical_presence(dev, PHYS_PRESENCE), 100); printf("done\n"); return 0; } #define TPM_MAX_NV_WRITES_NOOWNER 64 -static int test_write_limit(void) +static int test_write_limit(struct udevice *dev) { - printf("Testing writelimit ...\n"); - int i; uint32_t result; + int i; - 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)); + printf("Testing writelimit ...\n"); + tpm_init(dev); + TPM_CHECK(TlclStartupIfNeeded(dev)); + TPM_CHECK(tpm_self_test_full(dev)); + TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); + TPM_CHECK(tpm_force_clear(dev)); + TPM_CHECK(tpm_physical_enable(dev)); + TPM_CHECK(tpm_physical_set_deactivated(dev, 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)); + result = tpm_nv_write_value(dev, INDEX0, (uint8_t *)&i, + sizeof(i)); switch (result) { case TPM_SUCCESS: break; @@ -461,12 +472,12 @@ static int test_write_limit(void) } /* Reset write count */ - TPM_CHECK(tpm_force_clear()); - TPM_CHECK(tpm_physical_enable()); - TPM_CHECK(tpm_physical_set_deactivated(0)); + TPM_CHECK(tpm_force_clear(dev)); + TPM_CHECK(tpm_physical_enable(dev)); + TPM_CHECK(tpm_physical_set_deactivated(dev, 0)); /* Try writing again. */ - TPM_CHECK(tpm_nv_write_value(INDEX0, (uint8_t *)&i, sizeof(i))); + TPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&i, sizeof(i))); printf("\tdone\n"); return 0; } @@ -475,7 +486,13 @@ static int test_write_limit(void) int do_test_##XFUNC(cmd_tbl_t *cmd_tbl, int flag, int argc, \ char * const argv[]) \ { \ - return test_##XFUNC(); \ + struct udevice *dev; \ + int ret; \ +\ + ret = get_tpm(&dev); \ + if (ret) \ + return ret; \ + return test_##XFUNC(dev); \ } #define VOIDENT(XNAME) \ |