1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (c) 2013 The Chromium OS Authors.
8 #include <asm/unaligned.h>
9 #include <tpm-common.h>
11 #include "tpm-user-utils.h"
13 static int do_tpm_startup(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
16 enum tpm_startup_type mode
;
25 if (!strcasecmp("TPM_ST_CLEAR", argv
[1])) {
27 } else if (!strcasecmp("TPM_ST_STATE", argv
[1])) {
29 } else if (!strcasecmp("TPM_ST_DEACTIVATED", argv
[1])) {
30 mode
= TPM_ST_DEACTIVATED
;
32 printf("Couldn't recognize mode string: %s\n", argv
[1]);
33 return CMD_RET_FAILURE
;
36 return report_return_code(tpm_startup(dev
, mode
));
39 static int do_tpm_nv_define_space(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
42 u32 index
, perm
, size
;
52 index
= simple_strtoul(argv
[1], NULL
, 0);
53 perm
= simple_strtoul(argv
[2], NULL
, 0);
54 size
= simple_strtoul(argv
[3], NULL
, 0);
56 return report_return_code(tpm_nv_define_space(dev
, index
, perm
, size
));
59 static int do_tpm_nv_read_value(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
72 index
= simple_strtoul(argv
[1], NULL
, 0);
73 data
= (void *)simple_strtoul(argv
[2], NULL
, 0);
74 count
= simple_strtoul(argv
[3], NULL
, 0);
76 rc
= tpm_nv_read_value(dev
, index
, data
, count
);
78 puts("area content:\n");
79 print_byte_string(data
, count
);
82 return report_return_code(rc
);
85 static int do_tpm_nv_write_value(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
99 index
= simple_strtoul(argv
[1], NULL
, 0);
100 data
= parse_byte_string(argv
[2], NULL
, &count
);
102 printf("Couldn't parse byte string %s\n", argv
[2]);
103 return CMD_RET_FAILURE
;
106 rc
= tpm_nv_write_value(dev
, index
, data
, count
);
109 return report_return_code(rc
);
112 static int do_tpm_extend(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
115 u8 in_digest
[20], out_digest
[20];
124 return CMD_RET_USAGE
;
125 index
= simple_strtoul(argv
[1], NULL
, 0);
126 if (!parse_byte_string(argv
[2], in_digest
, NULL
)) {
127 printf("Couldn't parse byte string %s\n", argv
[2]);
128 return CMD_RET_FAILURE
;
131 rc
= tpm_extend(dev
, index
, in_digest
, out_digest
);
133 puts("PCR value after execution of the command:\n");
134 print_byte_string(out_digest
, sizeof(out_digest
));
137 return report_return_code(rc
);
140 static int do_tpm_pcr_read(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
143 u32 index
, count
, rc
;
152 return CMD_RET_USAGE
;
153 index
= simple_strtoul(argv
[1], NULL
, 0);
154 data
= (void *)simple_strtoul(argv
[2], NULL
, 0);
155 count
= simple_strtoul(argv
[3], NULL
, 0);
157 rc
= tpm_pcr_read(dev
, index
, data
, count
);
159 puts("Named PCR content:\n");
160 print_byte_string(data
, count
);
163 return report_return_code(rc
);
166 static int do_tpm_tsc_physical_presence(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
178 return CMD_RET_USAGE
;
179 presence
= (u16
)simple_strtoul(argv
[1], NULL
, 0);
181 return report_return_code(tpm_tsc_physical_presence(dev
, presence
));
184 static int do_tpm_read_pubek(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
196 return CMD_RET_USAGE
;
197 data
= (void *)simple_strtoul(argv
[1], NULL
, 0);
198 count
= simple_strtoul(argv
[2], NULL
, 0);
200 rc
= tpm_read_pubek(dev
, data
, count
);
202 puts("pubek value:\n");
203 print_byte_string(data
, count
);
206 return report_return_code(rc
);
209 static int do_tpm_physical_set_deactivated(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
221 return CMD_RET_USAGE
;
222 state
= (u8
)simple_strtoul(argv
[1], NULL
, 0);
224 return report_return_code(tpm_physical_set_deactivated(dev
, state
));
227 static int do_tpm_get_capability(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
230 u32 cap_area
, sub_cap
, rc
;
240 return CMD_RET_USAGE
;
241 cap_area
= simple_strtoul(argv
[1], NULL
, 0);
242 sub_cap
= simple_strtoul(argv
[2], NULL
, 0);
243 cap
= (void *)simple_strtoul(argv
[3], NULL
, 0);
244 count
= simple_strtoul(argv
[4], NULL
, 0);
246 rc
= tpm_get_capability(dev
, cap_area
, sub_cap
, cap
, count
);
248 puts("capability information:\n");
249 print_byte_string(cap
, count
);
252 return report_return_code(rc
);
255 static int do_tpm_raw_transfer(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
261 size_t count
, response_length
= sizeof(response
);
264 command
= parse_byte_string(argv
[1], NULL
, &count
);
266 printf("Couldn't parse byte string %s\n", argv
[1]);
267 return CMD_RET_FAILURE
;
274 rc
= tpm_xfer(dev
, command
, count
, response
, &response_length
);
277 puts("tpm response:\n");
278 print_byte_string(response
, response_length
);
281 return report_return_code(rc
);
284 static int do_tpm_nv_define(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
287 u32 index
, perm
, size
;
296 return CMD_RET_USAGE
;
297 size
= type_string_get_space_size(argv
[1]);
299 printf("Couldn't parse arguments\n");
300 return CMD_RET_USAGE
;
302 index
= simple_strtoul(argv
[2], NULL
, 0);
303 perm
= simple_strtoul(argv
[3], NULL
, 0);
305 return report_return_code(tpm_nv_define_space(dev
, index
, perm
, size
));
308 static int do_tpm_nv_read(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
311 u32 index
, count
, err
;
321 return CMD_RET_USAGE
;
322 if (argc
!= 3 + type_string_get_num_values(argv
[1]))
323 return CMD_RET_USAGE
;
324 index
= simple_strtoul(argv
[2], NULL
, 0);
325 data
= type_string_alloc(argv
[1], &count
);
327 printf("Couldn't parse arguments\n");
328 return CMD_RET_USAGE
;
331 err
= tpm_nv_read_value(dev
, index
, data
, count
);
333 if (type_string_write_vars(argv
[1], data
, argv
+ 3)) {
334 printf("Couldn't write to variables\n");
340 return report_return_code(err
);
343 static int do_tpm_nv_write(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
346 u32 index
, count
, err
;
356 return CMD_RET_USAGE
;
357 if (argc
!= 3 + type_string_get_num_values(argv
[1]))
358 return CMD_RET_USAGE
;
359 index
= simple_strtoul(argv
[2], NULL
, 0);
360 data
= type_string_alloc(argv
[1], &count
);
362 printf("Couldn't parse arguments\n");
363 return CMD_RET_USAGE
;
365 if (type_string_pack(argv
[1], argv
+ 3, data
)) {
366 printf("Couldn't parse arguments\n");
368 return CMD_RET_USAGE
;
371 err
= tpm_nv_write_value(dev
, index
, data
, count
);
374 return report_return_code(err
);
377 #ifdef CONFIG_TPM_AUTH_SESSIONS
379 static int do_tpm_oiap(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
382 u32 auth_handle
, err
;
390 err
= tpm_oiap(dev
, &auth_handle
);
392 return report_return_code(err
);
395 #ifdef CONFIG_TPM_LOAD_KEY_BY_SHA1
396 static int do_tpm_load_key_by_sha1(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char *
399 u32 parent_handle
= 0;
400 u32 key_len
, key_handle
, err
;
401 u8 usage_auth
[DIGEST_LENGTH
];
402 u8 parent_hash
[DIGEST_LENGTH
];
411 return CMD_RET_USAGE
;
413 parse_byte_string(argv
[1], parent_hash
, NULL
);
414 key
= (void *)simple_strtoul(argv
[2], NULL
, 0);
415 key_len
= simple_strtoul(argv
[3], NULL
, 0);
416 if (strlen(argv
[4]) != 2 * DIGEST_LENGTH
)
417 return CMD_RET_FAILURE
;
418 parse_byte_string(argv
[4], usage_auth
, NULL
);
420 err
= tpm_find_key_sha1(usage_auth
, parent_hash
, &parent_handle
);
422 printf("Could not find matching parent key (err = %d)\n", err
);
423 return CMD_RET_FAILURE
;
426 printf("Found parent key %08x\n", parent_handle
);
428 err
= tpm_load_key2_oiap(parent_handle
, key
, key_len
, usage_auth
,
431 printf("Key handle is 0x%x\n", key_handle
);
432 env_set_hex("key_handle", key_handle
);
435 return report_return_code(err
);
437 #endif /* CONFIG_TPM_LOAD_KEY_BY_SHA1 */
439 static int do_tpm_load_key2_oiap(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
442 u32 parent_handle
, key_len
, key_handle
, err
;
443 u8 usage_auth
[DIGEST_LENGTH
];
453 return CMD_RET_USAGE
;
455 parent_handle
= simple_strtoul(argv
[1], NULL
, 0);
456 key
= (void *)simple_strtoul(argv
[2], NULL
, 0);
457 key_len
= simple_strtoul(argv
[3], NULL
, 0);
458 if (strlen(argv
[4]) != 2 * DIGEST_LENGTH
)
459 return CMD_RET_FAILURE
;
460 parse_byte_string(argv
[4], usage_auth
, NULL
);
462 err
= tpm_load_key2_oiap(dev
, parent_handle
, key
, key_len
, usage_auth
,
465 printf("Key handle is 0x%x\n", key_handle
);
467 return report_return_code(err
);
470 static int do_tpm_get_pub_key_oiap(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
474 u8 usage_auth
[DIGEST_LENGTH
];
475 u8 pub_key_buffer
[TPM_PUBKEY_MAX_LENGTH
];
476 size_t pub_key_len
= sizeof(pub_key_buffer
);
485 return CMD_RET_USAGE
;
487 key_handle
= simple_strtoul(argv
[1], NULL
, 0);
488 if (strlen(argv
[2]) != 2 * DIGEST_LENGTH
)
489 return CMD_RET_FAILURE
;
490 parse_byte_string(argv
[2], usage_auth
, NULL
);
492 err
= tpm_get_pub_key_oiap(dev
, key_handle
, usage_auth
, pub_key_buffer
,
495 printf("dump of received pub key structure:\n");
496 print_byte_string(pub_key_buffer
, pub_key_len
);
498 return report_return_code(err
);
501 TPM_COMMAND_NO_ARG(tpm_end_oiap
)
503 #endif /* CONFIG_TPM_AUTH_SESSIONS */
505 #ifdef CONFIG_TPM_FLUSH_RESOURCES
506 static int do_tpm_flush(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
518 return CMD_RET_USAGE
;
520 if (!strcasecmp(argv
[1], "key"))
522 else if (!strcasecmp(argv
[1], "auth"))
524 else if (!strcasecmp(argv
[1], "hash"))
526 else if (!strcasecmp(argv
[1], "trans"))
528 else if (!strcasecmp(argv
[1], "context"))
529 type
= TPM_RT_CONTEXT
;
530 else if (!strcasecmp(argv
[1], "counter"))
531 type
= TPM_RT_COUNTER
;
532 else if (!strcasecmp(argv
[1], "delegate"))
533 type
= TPM_RT_DELEGATE
;
534 else if (!strcasecmp(argv
[1], "daa_tpm"))
535 type
= TPM_RT_DAA_TPM
;
536 else if (!strcasecmp(argv
[1], "daa_v0"))
537 type
= TPM_RT_DAA_V0
;
538 else if (!strcasecmp(argv
[1], "daa_v1"))
539 type
= TPM_RT_DAA_V1
;
542 printf("Resource type %s unknown.\n", argv
[1]);
546 if (!strcasecmp(argv
[2], "all")) {
553 /* fetch list of already loaded resources in the TPM */
554 err
= tpm_get_capability(dev
, TPM_CAP_HANDLE
, type
, buf
,
557 printf("tpm_get_capability returned error %d.\n", err
);
560 res_count
= get_unaligned_be16(buf
);
562 for (i
= 0; i
< res_count
; ++i
, ptr
+= 4)
563 tpm_flush_specific(dev
, get_unaligned_be32(ptr
), type
);
565 u32 handle
= simple_strtoul(argv
[2], NULL
, 0);
568 printf("Illegal resource handle %s\n", argv
[2]);
571 tpm_flush_specific(dev
, cpu_to_be32(handle
), type
);
576 #endif /* CONFIG_TPM_FLUSH_RESOURCES */
578 #ifdef CONFIG_TPM_LIST_RESOURCES
579 static int do_tpm_list(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
590 return CMD_RET_USAGE
;
592 if (!strcasecmp(argv
[1], "key"))
594 else if (!strcasecmp(argv
[1], "auth"))
596 else if (!strcasecmp(argv
[1], "hash"))
598 else if (!strcasecmp(argv
[1], "trans"))
600 else if (!strcasecmp(argv
[1], "context"))
601 type
= TPM_RT_CONTEXT
;
602 else if (!strcasecmp(argv
[1], "counter"))
603 type
= TPM_RT_COUNTER
;
604 else if (!strcasecmp(argv
[1], "delegate"))
605 type
= TPM_RT_DELEGATE
;
606 else if (!strcasecmp(argv
[1], "daa_tpm"))
607 type
= TPM_RT_DAA_TPM
;
608 else if (!strcasecmp(argv
[1], "daa_v0"))
609 type
= TPM_RT_DAA_V0
;
610 else if (!strcasecmp(argv
[1], "daa_v1"))
611 type
= TPM_RT_DAA_V1
;
614 printf("Resource type %s unknown.\n", argv
[1]);
618 /* fetch list of already loaded resources in the TPM */
619 err
= tpm_get_capability(TPM_CAP_HANDLE
, type
, buf
,
622 printf("tpm_get_capability returned error %d.\n", err
);
625 res_count
= get_unaligned_be16(buf
);
628 printf("Resources of type %s (%02x):\n", argv
[1], type
);
632 for (i
= 0; i
< res_count
; ++i
, ptr
+= 4)
633 printf("Index %d: %08x\n", i
, get_unaligned_be32(ptr
));
638 #endif /* CONFIG_TPM_LIST_RESOURCES */
640 TPM_COMMAND_NO_ARG(tpm_self_test_full
)
641 TPM_COMMAND_NO_ARG(tpm_continue_self_test
)
642 TPM_COMMAND_NO_ARG(tpm_force_clear
)
643 TPM_COMMAND_NO_ARG(tpm_physical_enable
)
644 TPM_COMMAND_NO_ARG(tpm_physical_disable
)
646 static cmd_tbl_t tpm1_commands
[] = {
647 U_BOOT_CMD_MKENT(info
, 0, 1, do_tpm_info
, "", ""),
648 U_BOOT_CMD_MKENT(init
, 0, 1, do_tpm_init
, "", ""),
649 U_BOOT_CMD_MKENT(startup
, 0, 1,
650 do_tpm_startup
, "", ""),
651 U_BOOT_CMD_MKENT(self_test_full
, 0, 1,
652 do_tpm_self_test_full
, "", ""),
653 U_BOOT_CMD_MKENT(continue_self_test
, 0, 1,
654 do_tpm_continue_self_test
, "", ""),
655 U_BOOT_CMD_MKENT(force_clear
, 0, 1,
656 do_tpm_force_clear
, "", ""),
657 U_BOOT_CMD_MKENT(physical_enable
, 0, 1,
658 do_tpm_physical_enable
, "", ""),
659 U_BOOT_CMD_MKENT(physical_disable
, 0, 1,
660 do_tpm_physical_disable
, "", ""),
661 U_BOOT_CMD_MKENT(nv_define_space
, 0, 1,
662 do_tpm_nv_define_space
, "", ""),
663 U_BOOT_CMD_MKENT(nv_read_value
, 0, 1,
664 do_tpm_nv_read_value
, "", ""),
665 U_BOOT_CMD_MKENT(nv_write_value
, 0, 1,
666 do_tpm_nv_write_value
, "", ""),
667 U_BOOT_CMD_MKENT(extend
, 0, 1,
668 do_tpm_extend
, "", ""),
669 U_BOOT_CMD_MKENT(pcr_read
, 0, 1,
670 do_tpm_pcr_read
, "", ""),
671 U_BOOT_CMD_MKENT(tsc_physical_presence
, 0, 1,
672 do_tpm_tsc_physical_presence
, "", ""),
673 U_BOOT_CMD_MKENT(read_pubek
, 0, 1,
674 do_tpm_read_pubek
, "", ""),
675 U_BOOT_CMD_MKENT(physical_set_deactivated
, 0, 1,
676 do_tpm_physical_set_deactivated
, "", ""),
677 U_BOOT_CMD_MKENT(get_capability
, 0, 1,
678 do_tpm_get_capability
, "", ""),
679 U_BOOT_CMD_MKENT(raw_transfer
, 0, 1,
680 do_tpm_raw_transfer
, "", ""),
681 U_BOOT_CMD_MKENT(nv_define
, 0, 1,
682 do_tpm_nv_define
, "", ""),
683 U_BOOT_CMD_MKENT(nv_read
, 0, 1,
684 do_tpm_nv_read
, "", ""),
685 U_BOOT_CMD_MKENT(nv_write
, 0, 1,
686 do_tpm_nv_write
, "", ""),
687 #ifdef CONFIG_TPM_AUTH_SESSIONS
688 U_BOOT_CMD_MKENT(oiap
, 0, 1,
689 do_tpm_oiap
, "", ""),
690 U_BOOT_CMD_MKENT(end_oiap
, 0, 1,
691 do_tpm_end_oiap
, "", ""),
692 U_BOOT_CMD_MKENT(load_key2_oiap
, 0, 1,
693 do_tpm_load_key2_oiap
, "", ""),
694 #ifdef CONFIG_TPM_LOAD_KEY_BY_SHA1
695 U_BOOT_CMD_MKENT(load_key_by_sha1
, 0, 1,
696 do_tpm_load_key_by_sha1
, "", ""),
697 #endif /* CONFIG_TPM_LOAD_KEY_BY_SHA1 */
698 U_BOOT_CMD_MKENT(get_pub_key_oiap
, 0, 1,
699 do_tpm_get_pub_key_oiap
, "", ""),
700 #endif /* CONFIG_TPM_AUTH_SESSIONS */
701 #ifdef CONFIG_TPM_FLUSH_RESOURCES
702 U_BOOT_CMD_MKENT(flush
, 0, 1,
703 do_tpm_flush
, "", ""),
704 #endif /* CONFIG_TPM_FLUSH_RESOURCES */
705 #ifdef CONFIG_TPM_LIST_RESOURCES
706 U_BOOT_CMD_MKENT(list
, 0, 1,
707 do_tpm_list
, "", ""),
708 #endif /* CONFIG_TPM_LIST_RESOURCES */
711 cmd_tbl_t
*get_tpm1_commands(unsigned int *size
)
713 *size
= ARRAY_SIZE(tpm1_commands
);
715 return tpm1_commands
;
718 U_BOOT_CMD(tpm
, CONFIG_SYS_MAXARGS
, 1, do_tpm
,
719 "Issue a TPMv1.x command",
721 " - Issue TPM command <cmd> with arguments <args...>.\n"
722 "Admin Startup and State Commands:\n"
723 " info - Show information about the TPM\n"
725 " - Put TPM into a state where it waits for 'startup' command.\n"
727 " - Issue TPM_Starup command. <mode> is one of TPM_ST_CLEAR,\n"
728 " TPM_ST_STATE, and TPM_ST_DEACTIVATED.\n"
729 "Admin Testing Commands:\n"
731 " - Test all of the TPM capabilities.\n"
732 " continue_self_test\n"
733 " - Inform TPM that it should complete the self-test.\n"
734 "Admin Opt-in Commands:\n"
736 " - Set the PERMANENT disable flag to FALSE using physical presence as\n"
738 " physical_disable\n"
739 " - Set the PERMANENT disable flag to TRUE using physical presence as\n"
741 " physical_set_deactivated 0|1\n"
742 " - Set deactivated flag.\n"
743 "Admin Ownership Commands:\n"
745 " - Issue TPM_ForceClear command.\n"
746 " tsc_physical_presence flags\n"
747 " - Set TPM device's Physical Presence flags to <flags>.\n"
748 "The Capability Commands:\n"
749 " get_capability cap_area sub_cap addr count\n"
750 " - Read <count> bytes of TPM capability indexed by <cap_area> and\n"
751 " <sub_cap> to memory address <addr>.\n"
752 #if defined(CONFIG_TPM_FLUSH_RESOURCES) || defined(CONFIG_TPM_LIST_RESOURCES)
753 "Resource management functions\n"
755 #ifdef CONFIG_TPM_FLUSH_RESOURCES
756 " flush resource_type id\n"
757 " - flushes a resource of type <resource_type> (may be one of key, auth,\n"
758 " hash, trans, context, counter, delegate, daa_tpm, daa_v0, daa_v1),\n"
759 " and id <id> from the TPM. Use an <id> of \"all\" to flush all\n"
760 " resources of that type.\n"
761 #endif /* CONFIG_TPM_FLUSH_RESOURCES */
762 #ifdef CONFIG_TPM_LIST_RESOURCES
763 " list resource_type\n"
764 " - lists resources of type <resource_type> (may be one of key, auth,\n"
765 " hash, trans, context, counter, delegate, daa_tpm, daa_v0, daa_v1),\n"
766 " contained in the TPM.\n"
767 #endif /* CONFIG_TPM_LIST_RESOURCES */
768 #ifdef CONFIG_TPM_AUTH_SESSIONS
769 "Storage functions\n"
770 " loadkey2_oiap parent_handle key_addr key_len usage_auth\n"
771 " - loads a key data from memory address <key_addr>, <key_len> bytes\n"
772 " into TPM using the parent key <parent_handle> with authorization\n"
773 " <usage_auth> (20 bytes hex string).\n"
774 #ifdef CONFIG_TPM_LOAD_KEY_BY_SHA1
775 " load_key_by_sha1 parent_hash key_addr key_len usage_auth\n"
776 " - loads a key data from memory address <key_addr>, <key_len> bytes\n"
777 " into TPM using the parent hash <parent_hash> (20 bytes hex string)\n"
778 " with authorization <usage_auth> (20 bytes hex string).\n"
779 #endif /* CONFIG_TPM_LOAD_KEY_BY_SHA1 */
780 " get_pub_key_oiap key_handle usage_auth\n"
781 " - get the public key portion of a loaded key <key_handle> using\n"
782 " authorization <usage auth> (20 bytes hex string)\n"
783 #endif /* CONFIG_TPM_AUTH_SESSIONS */
784 "Endorsement Key Handling Commands:\n"
785 " read_pubek addr count\n"
786 " - Read <count> bytes of the public endorsement key to memory\n"
788 "Integrity Collection and Reporting Commands:\n"
789 " extend index digest_hex_string\n"
790 " - Add a new measurement to a PCR. Update PCR <index> with the 20-bytes\n"
791 " <digest_hex_string>\n"
792 " pcr_read index addr count\n"
793 " - Read <count> bytes from PCR <index> to memory address <addr>.\n"
794 #ifdef CONFIG_TPM_AUTH_SESSIONS
795 "Authorization Sessions\n"
797 " - setup an OIAP session\n"
799 " - terminates an active OIAP session\n"
800 #endif /* CONFIG_TPM_AUTH_SESSIONS */
801 "Non-volatile Storage Commands:\n"
802 " nv_define_space index permission size\n"
803 " - Establish a space at index <index> with <permission> of <size> bytes.\n"
804 " nv_read_value index addr count\n"
805 " - Read <count> bytes from space <index> to memory address <addr>.\n"
806 " nv_write_value index addr count\n"
807 " - Write <count> bytes from memory address <addr> to space <index>.\n"
808 "Miscellaneous helper functions:\n"
809 " raw_transfer byte_string\n"
810 " - Send a byte string <byte_string> to TPM and print the response.\n"
811 " Non-volatile storage helper functions:\n"
812 " These helper functions treat a non-volatile space as a non-padded\n"
813 " sequence of integer values. These integer values are defined by a type\n"
814 " string, which is a text string of 'bwd' characters: 'b' means a 8-bit\n"
815 " value, 'w' 16-bit value, 'd' 32-bit value. All helper functions take\n"
816 " a type string as their first argument.\n"
817 " nv_define type_string index perm\n"
818 " - Define a space <index> with permission <perm>.\n"
819 " nv_read types_string index vars...\n"
820 " - Read from space <index> to environment variables <vars...>.\n"
821 " nv_write types_string index values...\n"
822 " - Write to space <index> from values <values...>.\n"