cmd/tpm-v1.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2013 The Chromium OS Authors.
   4  */
   5
   6 #include <common.h>
   7 #include <malloc.h>
   8 #include <asm/unaligned.h>
   9 #include <tpm-common.h>
  10 #include <tpm-v1.h>
  11 #include "tpm-user-utils.h"
  12
  13 static int do_tpm_startup(cmd_tbl_t *cmdtp, int flag, int argc,
  14                           char * const argv[])
  15 {
  16         enum tpm_startup_type mode;
  17         struct udevice *dev;
  18         int rc;
  19
  20         rc = get_tpm(&dev);
  21         if (rc)
  22                 return rc;
  23         if (argc != 2)
  24                 return CMD_RET_USAGE;
  25         if (!strcasecmp("TPM_ST_CLEAR", argv[1])) {
  26                 mode = TPM_ST_CLEAR;
  27         } else if (!strcasecmp("TPM_ST_STATE", argv[1])) {
  28                 mode = TPM_ST_STATE;
  29         } else if (!strcasecmp("TPM_ST_DEACTIVATED", argv[1])) {
  30                 mode = TPM_ST_DEACTIVATED;
  31         } else {
  32                 printf("Couldn't recognize mode string: %s\n", argv[1]);
  33                 return CMD_RET_FAILURE;
  34         }
  35
  36         return report_return_code(tpm_startup(dev, mode));
  37 }
  38
  39 static int do_tpm_nv_define_space(cmd_tbl_t *cmdtp, int flag, int argc,
  40                                   char * const argv[])
  41 {
  42         u32 index, perm, size;
  43         struct udevice *dev;
  44         int rc;
  45
  46         rc = get_tpm(&dev);
  47         if (rc)
  48                 return rc;
  49
  50         if (argc != 4)
  51                 return CMD_RET_USAGE;
  52         index = simple_strtoul(argv[1], NULL, 0);
  53         perm = simple_strtoul(argv[2], NULL, 0);
  54         size = simple_strtoul(argv[3], NULL, 0);
  55
  56         return report_return_code(tpm_nv_define_space(dev, index, perm, size));
  57 }
  58
  59 static int do_tpm_nv_read_value(cmd_tbl_t *cmdtp, int flag, int argc,
  60                                 char * const argv[])
  61 {
  62         u32 index, count, rc;
  63         struct udevice *dev;
  64         void *data;
  65
  66         rc = get_tpm(&dev);
  67         if (rc)
  68                 return rc;
  69
  70         if (argc != 4)
  71                 return CMD_RET_USAGE;
  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);
  75
  76         rc = tpm_nv_read_value(dev, index, data, count);
  77         if (!rc) {
  78                 puts("area content:\n");
  79                 print_byte_string(data, count);
  80         }
  81
  82         return report_return_code(rc);
  83 }
  84
  85 static int do_tpm_nv_write_value(cmd_tbl_t *cmdtp, int flag, int argc,
  86                                  char * const argv[])
  87 {
  88         struct udevice *dev;
  89         u32 index, rc;
  90         size_t count;
  91         void *data;
  92
  93         rc = get_tpm(&dev);
  94         if (rc)
  95                 return rc;
  96
  97         if (argc != 3)
  98                 return CMD_RET_USAGE;
  99         index = simple_strtoul(argv[1], NULL, 0);
 100         data = parse_byte_string(argv[2], NULL, &count);
 101         if (!data) {
 102                 printf("Couldn't parse byte string %s\n", argv[2]);
 103                 return CMD_RET_FAILURE;
 104         }
 105
 106         rc = tpm_nv_write_value(dev, index, data, count);
 107         free(data);
 108
 109         return report_return_code(rc);
 110 }
 111
 112 static int do_tpm_extend(cmd_tbl_t *cmdtp, int flag, int argc,
 113                          char * const argv[])
 114 {
 115         u8 in_digest[20], out_digest[20];
 116         struct udevice *dev;
 117         u32 index, rc;
 118
 119         rc = get_tpm(&dev);
 120         if (rc)
 121                 return rc;
 122
 123         if (argc != 3)
 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;
 129         }
 130
 131         rc = tpm_extend(dev, index, in_digest, out_digest);
 132         if (!rc) {
 133                 puts("PCR value after execution of the command:\n");
 134                 print_byte_string(out_digest, sizeof(out_digest));
 135         }
 136
 137         return report_return_code(rc);
 138 }
 139
 140 static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag, int argc,
 141                            char * const argv[])
 142 {
 143         u32 index, count, rc;
 144         struct udevice *dev;
 145         void *data;
 146
 147         rc = get_tpm(&dev);
 148         if (rc)
 149                 return rc;
 150
 151         if (argc != 4)
 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);
 156
 157         rc = tpm_pcr_read(dev, index, data, count);
 158         if (!rc) {
 159                 puts("Named PCR content:\n");
 160                 print_byte_string(data, count);
 161         }
 162
 163         return report_return_code(rc);
 164 }
 165
 166 static int do_tpm_tsc_physical_presence(cmd_tbl_t *cmdtp, int flag, int argc,
 167                                         char * const argv[])
 168 {
 169         struct udevice *dev;
 170         u16 presence;
 171         int rc;
 172
 173         rc = get_tpm(&dev);
 174         if (rc)
 175                 return rc;
 176
 177         if (argc != 2)
 178                 return CMD_RET_USAGE;
 179         presence = (u16)simple_strtoul(argv[1], NULL, 0);
 180
 181         return report_return_code(tpm_tsc_physical_presence(dev, presence));
 182 }
 183
 184 static int do_tpm_read_pubek(cmd_tbl_t *cmdtp, int flag, int argc,
 185                              char * const argv[])
 186 {
 187         struct udevice *dev;
 188         u32 count, rc;
 189         void *data;
 190
 191         rc = get_tpm(&dev);
 192         if (rc)
 193                 return rc;
 194
 195         if (argc != 3)
 196                 return CMD_RET_USAGE;
 197         data = (void *)simple_strtoul(argv[1], NULL, 0);
 198         count = simple_strtoul(argv[2], NULL, 0);
 199
 200         rc = tpm_read_pubek(dev, data, count);
 201         if (!rc) {
 202                 puts("pubek value:\n");
 203                 print_byte_string(data, count);
 204         }
 205
 206         return report_return_code(rc);
 207 }
 208
 209 static int do_tpm_physical_set_deactivated(cmd_tbl_t *cmdtp, int flag, int argc,
 210                                            char * const argv[])
 211 {
 212         struct udevice *dev;
 213         u8 state;
 214         int rc;
 215
 216         rc = get_tpm(&dev);
 217         if (rc)
 218                 return rc;
 219
 220         if (argc != 2)
 221                 return CMD_RET_USAGE;
 222         state = (u8)simple_strtoul(argv[1], NULL, 0);
 223
 224         return report_return_code(tpm_physical_set_deactivated(dev, state));
 225 }
 226
 227 static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag, int argc,
 228                                  char * const argv[])
 229 {
 230         u32 cap_area, sub_cap, rc;
 231         void *cap;
 232         size_t count;
 233         struct udevice *dev;
 234
 235         rc = get_tpm(&dev);
 236         if (rc)
 237                 return rc;
 238
 239         if (argc != 5)
 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);
 245
 246         rc = tpm_get_capability(dev, cap_area, sub_cap, cap, count);
 247         if (!rc) {
 248                 puts("capability information:\n");
 249                 print_byte_string(cap, count);
 250         }
 251
 252         return report_return_code(rc);
 253 }
 254
 255 static int do_tpm_raw_transfer(cmd_tbl_t *cmdtp, int flag, int argc,
 256                                char * const argv[])
 257 {
 258         struct udevice *dev;
 259         void *command;
 260         u8 response[1024];
 261         size_t count, response_length = sizeof(response);
 262         u32 rc;
 263
 264         command = parse_byte_string(argv[1], NULL, &count);
 265         if (!command) {
 266                 printf("Couldn't parse byte string %s\n", argv[1]);
 267                 return CMD_RET_FAILURE;
 268         }
 269
 270         rc = get_tpm(&dev);
 271         if (rc)
 272                 return rc;
 273
 274         rc = tpm_xfer(dev, command, count, response, &response_length);
 275         free(command);
 276         if (!rc) {
 277                 puts("tpm response:\n");
 278                 print_byte_string(response, response_length);
 279         }
 280
 281         return report_return_code(rc);
 282 }
 283
 284 static int do_tpm_nv_define(cmd_tbl_t *cmdtp, int flag, int argc,
 285                             char * const argv[])
 286 {
 287         u32 index, perm, size;
 288         struct udevice *dev;
 289         int rc;
 290
 291         rc = get_tpm(&dev);
 292         if (rc)
 293                 return rc;
 294
 295         if (argc != 4)
 296                 return CMD_RET_USAGE;
 297         size = type_string_get_space_size(argv[1]);
 298         if (!size) {
 299                 printf("Couldn't parse arguments\n");
 300                 return CMD_RET_USAGE;
 301         }
 302         index = simple_strtoul(argv[2], NULL, 0);
 303         perm = simple_strtoul(argv[3], NULL, 0);
 304
 305         return report_return_code(tpm_nv_define_space(dev, index, perm, size));
 306 }
 307
 308 static int do_tpm_nv_read(cmd_tbl_t *cmdtp, int flag, int argc,
 309                           char * const argv[])
 310 {
 311         u32 index, count, err;
 312         struct udevice *dev;
 313         void *data;
 314         int rc;
 315
 316         rc = get_tpm(&dev);
 317         if (rc)
 318                 return rc;
 319
 320         if (argc < 3)
 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);
 326         if (!data) {
 327                 printf("Couldn't parse arguments\n");
 328                 return CMD_RET_USAGE;
 329         }
 330
 331         err = tpm_nv_read_value(dev, index, data, count);
 332         if (!err) {
 333                 if (type_string_write_vars(argv[1], data, argv + 3)) {
 334                         printf("Couldn't write to variables\n");
 335                         err = ~0;
 336                 }
 337         }
 338         free(data);
 339
 340         return report_return_code(err);
 341 }
 342
 343 static int do_tpm_nv_write(cmd_tbl_t *cmdtp, int flag, int argc,
 344                            char * const argv[])
 345 {
 346         u32 index, count, err;
 347         struct udevice *dev;
 348         void *data;
 349         int rc;
 350
 351         rc = get_tpm(&dev);
 352         if (rc)
 353                 return rc;
 354
 355         if (argc < 3)
 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);
 361         if (!data) {
 362                 printf("Couldn't parse arguments\n");
 363                 return CMD_RET_USAGE;
 364         }
 365         if (type_string_pack(argv[1], argv + 3, data)) {
 366                 printf("Couldn't parse arguments\n");
 367                 free(data);
 368                 return CMD_RET_USAGE;
 369         }
 370
 371         err = tpm_nv_write_value(dev, index, data, count);
 372         free(data);
 373
 374         return report_return_code(err);
 375 }
 376
 377 #ifdef CONFIG_TPM_AUTH_SESSIONS
 378
 379 static int do_tpm_oiap(cmd_tbl_t *cmdtp, int flag, int argc,
 380                        char * const argv[])
 381 {
 382         u32 auth_handle, err;
 383         struct udevice *dev;
 384         int rc;
 385
 386         rc = get_tpm(&dev);
 387         if (rc)
 388                 return rc;
 389
 390         err = tpm_oiap(dev, &auth_handle);
 391
 392         return report_return_code(err);
 393 }
 394
 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 *
 397                                    const argv[])
 398 {
 399         u32 parent_handle = 0;
 400         u32 key_len, key_handle, err;
 401         u8 usage_auth[DIGEST_LENGTH];
 402         u8 parent_hash[DIGEST_LENGTH];
 403         void *key;
 404         struct udevice *dev;
 405
 406         rc = get_tpm(&dev);
 407         if (rc)
 408                 return rc;
 409
 410         if (argc < 5)
 411                 return CMD_RET_USAGE;
 412
 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);
 419
 420         err = tpm_find_key_sha1(usage_auth, parent_hash, &parent_handle);
 421         if (err) {
 422                 printf("Could not find matching parent key (err = %d)\n", err);
 423                 return CMD_RET_FAILURE;
 424         }
 425
 426         printf("Found parent key %08x\n", parent_handle);
 427
 428         err = tpm_load_key2_oiap(parent_handle, key, key_len, usage_auth,
 429                                  &key_handle);
 430         if (!err) {
 431                 printf("Key handle is 0x%x\n", key_handle);
 432                 env_set_hex("key_handle", key_handle);
 433         }
 434
 435         return report_return_code(err);
 436 }
 437 #endif /* CONFIG_TPM_LOAD_KEY_BY_SHA1 */
 438
 439 static int do_tpm_load_key2_oiap(cmd_tbl_t *cmdtp, int flag, int argc,
 440                                  char * const argv[])
 441 {
 442         u32 parent_handle, key_len, key_handle, err;
 443         u8 usage_auth[DIGEST_LENGTH];
 444         void *key;
 445         struct udevice *dev;
 446         int rc;
 447
 448         rc = get_tpm(&dev);
 449         if (rc)
 450                 return rc;
 451
 452         if (argc < 5)
 453                 return CMD_RET_USAGE;
 454
 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);
 461
 462         err = tpm_load_key2_oiap(dev, parent_handle, key, key_len, usage_auth,
 463                                  &key_handle);
 464         if (!err)
 465                 printf("Key handle is 0x%x\n", key_handle);
 466
 467         return report_return_code(err);
 468 }
 469
 470 static int do_tpm_get_pub_key_oiap(cmd_tbl_t *cmdtp, int flag, int argc,
 471                                    char * const argv[])
 472 {
 473         u32 key_handle, err;
 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);
 477         struct udevice *dev;
 478         int rc;
 479
 480         rc = get_tpm(&dev);
 481         if (rc)
 482                 return rc;
 483
 484         if (argc < 3)
 485                 return CMD_RET_USAGE;
 486
 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);
 491
 492         err = tpm_get_pub_key_oiap(dev, key_handle, usage_auth, pub_key_buffer,
 493                                    &pub_key_len);
 494         if (!err) {
 495                 printf("dump of received pub key structure:\n");
 496                 print_byte_string(pub_key_buffer, pub_key_len);
 497         }
 498         return report_return_code(err);
 499 }
 500
 501 TPM_COMMAND_NO_ARG(tpm_end_oiap)
 502
 503 #endif /* CONFIG_TPM_AUTH_SESSIONS */
 504
 505 #ifdef CONFIG_TPM_FLUSH_RESOURCES
 506 static int do_tpm_flush(cmd_tbl_t *cmdtp, int flag, int argc,
 507                         char * const argv[])
 508 {
 509         struct udevice *dev;
 510         int type = 0;
 511         int rc;
 512
 513         rc = get_tpm(&dev);
 514         if (rc)
 515                 return rc;
 516
 517         if (argc != 3)
 518                 return CMD_RET_USAGE;
 519
 520         if (!strcasecmp(argv[1], "key"))
 521                 type = TPM_RT_KEY;
 522         else if (!strcasecmp(argv[1], "auth"))
 523                 type = TPM_RT_AUTH;
 524         else if (!strcasecmp(argv[1], "hash"))
 525                 type = TPM_RT_HASH;
 526         else if (!strcasecmp(argv[1], "trans"))
 527                 type = TPM_RT_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;
 540
 541         if (!type) {
 542                 printf("Resource type %s unknown.\n", argv[1]);
 543                 return -1;
 544         }
 545
 546         if (!strcasecmp(argv[2], "all")) {
 547                 u16 res_count;
 548                 u8 buf[288];
 549                 u8 *ptr;
 550                 int err;
 551                 uint i;
 552
 553                 /* fetch list of already loaded resources in the TPM */
 554                 err = tpm_get_capability(dev, TPM_CAP_HANDLE, type, buf,
 555                                          sizeof(buf));
 556                 if (err) {
 557                         printf("tpm_get_capability returned error %d.\n", err);
 558                         return -1;
 559                 }
 560                 res_count = get_unaligned_be16(buf);
 561                 ptr = buf + 2;
 562                 for (i = 0; i < res_count; ++i, ptr += 4)
 563                         tpm_flush_specific(dev, get_unaligned_be32(ptr), type);
 564         } else {
 565                 u32 handle = simple_strtoul(argv[2], NULL, 0);
 566
 567                 if (!handle) {
 568                         printf("Illegal resource handle %s\n", argv[2]);
 569                         return -1;
 570                 }
 571                 tpm_flush_specific(dev, cpu_to_be32(handle), type);
 572         }
 573
 574         return 0;
 575 }
 576 #endif /* CONFIG_TPM_FLUSH_RESOURCES */
 577
 578 #ifdef CONFIG_TPM_LIST_RESOURCES
 579 static int do_tpm_list(cmd_tbl_t *cmdtp, int flag, int argc,
 580                        char * const argv[])
 581 {
 582         int type = 0;
 583         u16 res_count;
 584         u8 buf[288];
 585         u8 *ptr;
 586         int err;
 587         uint i;
 588
 589         if (argc != 2)
 590                 return CMD_RET_USAGE;
 591
 592         if (!strcasecmp(argv[1], "key"))
 593                 type = TPM_RT_KEY;
 594         else if (!strcasecmp(argv[1], "auth"))
 595                 type = TPM_RT_AUTH;
 596         else if (!strcasecmp(argv[1], "hash"))
 597                 type = TPM_RT_HASH;
 598         else if (!strcasecmp(argv[1], "trans"))
 599                 type = TPM_RT_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;
 612
 613         if (!type) {
 614                 printf("Resource type %s unknown.\n", argv[1]);
 615                 return -1;
 616         }
 617
 618         /* fetch list of already loaded resources in the TPM */
 619         err = tpm_get_capability(TPM_CAP_HANDLE, type, buf,
 620                                  sizeof(buf));
 621         if (err) {
 622                 printf("tpm_get_capability returned error %d.\n", err);
 623                 return -1;
 624         }
 625         res_count = get_unaligned_be16(buf);
 626         ptr = buf + 2;
 627
 628         printf("Resources of type %s (%02x):\n", argv[1], type);
 629         if (!res_count) {
 630                 puts("None\n");
 631         } else {
 632                 for (i = 0; i < res_count; ++i, ptr += 4)
 633                         printf("Index %d: %08x\n", i, get_unaligned_be32(ptr));
 634         }
 635
 636         return 0;
 637 }
 638 #endif /* CONFIG_TPM_LIST_RESOURCES */
 639
 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)
 645
 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 */
 709 };
 710
 711 cmd_tbl_t *get_tpm1_commands(unsigned int *size)
 712 {
 713         *size = ARRAY_SIZE(tpm1_commands);
 714
 715         return tpm1_commands;
 716 }
 717
 718 U_BOOT_CMD(tpm, CONFIG_SYS_MAXARGS, 1, do_tpm,
 719 "Issue a TPMv1.x command",
 720 "cmd args...\n"
 721 "    - Issue TPM command <cmd> with arguments <args...>.\n"
 722 "Admin Startup and State Commands:\n"
 723 "  info - Show information about the TPM\n"
 724 "  init\n"
 725 "    - Put TPM into a state where it waits for 'startup' command.\n"
 726 "  startup mode\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"
 730 "  self_test_full\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"
 735 "  physical_enable\n"
 736 "    - Set the PERMANENT disable flag to FALSE using physical presence as\n"
 737 "      authorization.\n"
 738 "  physical_disable\n"
 739 "    - Set the PERMANENT disable flag to TRUE using physical presence as\n"
 740 "      authorization.\n"
 741 "  physical_set_deactivated 0|1\n"
 742 "    - Set deactivated flag.\n"
 743 "Admin Ownership Commands:\n"
 744 "  force_clear\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"
 754 #endif
 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"
 787 "      address <addr>\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"
 796 "  oiap\n"
 797 "    - setup an OIAP session\n"
 798 "  end_oiap\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"
 823 );