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 <env.h>
   8 #include <malloc.h>
   9 #include <asm/unaligned.h>
  10 #include <tpm-common.h>
  11 #include <tpm-v1.h>
  12 #include "tpm-user-utils.h"
  13
  14 static int do_tpm_startup(cmd_tbl_t *cmdtp, int flag, int argc,
  15                           char * const argv[])
  16 {
  17         enum tpm_startup_type mode;
  18         struct udevice *dev;
  19         int rc;
  20
  21         rc = get_tpm(&dev);
  22         if (rc)
  23                 return rc;
  24         if (argc != 2)
  25                 return CMD_RET_USAGE;
  26         if (!strcasecmp("TPM_ST_CLEAR", argv[1])) {
  27                 mode = TPM_ST_CLEAR;
  28         } else if (!strcasecmp("TPM_ST_STATE", argv[1])) {
  29                 mode = TPM_ST_STATE;
  30         } else if (!strcasecmp("TPM_ST_DEACTIVATED", argv[1])) {
  31                 mode = TPM_ST_DEACTIVATED;
  32         } else {
  33                 printf("Couldn't recognize mode string: %s\n", argv[1]);
  34                 return CMD_RET_FAILURE;
  35         }
  36
  37         return report_return_code(tpm_startup(dev, mode));
  38 }
  39
  40 static int do_tpm_nv_define_space(cmd_tbl_t *cmdtp, int flag, int argc,
  41                                   char * const argv[])
  42 {
  43         u32 index, perm, size;
  44         struct udevice *dev;
  45         int rc;
  46
  47         rc = get_tpm(&dev);
  48         if (rc)
  49                 return rc;
  50
  51         if (argc != 4)
  52                 return CMD_RET_USAGE;
  53         index = simple_strtoul(argv[1], NULL, 0);
  54         perm = simple_strtoul(argv[2], NULL, 0);
  55         size = simple_strtoul(argv[3], NULL, 0);
  56
  57         return report_return_code(tpm_nv_define_space(dev, index, perm, size));
  58 }
  59
  60 static int do_tpm_nv_read_value(cmd_tbl_t *cmdtp, int flag, int argc,
  61                                 char * const argv[])
  62 {
  63         u32 index, count, rc;
  64         struct udevice *dev;
  65         void *data;
  66
  67         rc = get_tpm(&dev);
  68         if (rc)
  69                 return rc;
  70
  71         if (argc != 4)
  72                 return CMD_RET_USAGE;
  73         index = simple_strtoul(argv[1], NULL, 0);
  74         data = (void *)simple_strtoul(argv[2], NULL, 0);
  75         count = simple_strtoul(argv[3], NULL, 0);
  76
  77         rc = tpm_nv_read_value(dev, index, data, count);
  78         if (!rc) {
  79                 puts("area content:\n");
  80                 print_byte_string(data, count);
  81         }
  82
  83         return report_return_code(rc);
  84 }
  85
  86 static int do_tpm_nv_write_value(cmd_tbl_t *cmdtp, int flag, int argc,
  87                                  char * const argv[])
  88 {
  89         struct udevice *dev;
  90         u32 index, rc;
  91         size_t count;
  92         void *data;
  93
  94         rc = get_tpm(&dev);
  95         if (rc)
  96                 return rc;
  97
  98         if (argc != 3)
  99                 return CMD_RET_USAGE;
 100         index = simple_strtoul(argv[1], NULL, 0);
 101         data = parse_byte_string(argv[2], NULL, &count);
 102         if (!data) {
 103                 printf("Couldn't parse byte string %s\n", argv[2]);
 104                 return CMD_RET_FAILURE;
 105         }
 106
 107         rc = tpm_nv_write_value(dev, index, data, count);
 108         free(data);
 109
 110         return report_return_code(rc);
 111 }
 112
 113 static int do_tpm_extend(cmd_tbl_t *cmdtp, int flag, int argc,
 114                          char * const argv[])
 115 {
 116         u8 in_digest[20], out_digest[20];
 117         struct udevice *dev;
 118         u32 index, rc;
 119
 120         rc = get_tpm(&dev);
 121         if (rc)
 122                 return rc;
 123
 124         if (argc != 3)
 125                 return CMD_RET_USAGE;
 126         index = simple_strtoul(argv[1], NULL, 0);
 127         if (!parse_byte_string(argv[2], in_digest, NULL)) {
 128                 printf("Couldn't parse byte string %s\n", argv[2]);
 129                 return CMD_RET_FAILURE;
 130         }
 131
 132         rc = tpm_extend(dev, index, in_digest, out_digest);
 133         if (!rc) {
 134                 puts("PCR value after execution of the command:\n");
 135                 print_byte_string(out_digest, sizeof(out_digest));
 136         }
 137
 138         return report_return_code(rc);
 139 }
 140
 141 static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag, int argc,
 142                            char * const argv[])
 143 {
 144         u32 index, count, rc;
 145         struct udevice *dev;
 146         void *data;
 147
 148         rc = get_tpm(&dev);
 149         if (rc)
 150                 return rc;
 151
 152         if (argc != 4)
 153                 return CMD_RET_USAGE;
 154         index = simple_strtoul(argv[1], NULL, 0);
 155         data = (void *)simple_strtoul(argv[2], NULL, 0);
 156         count = simple_strtoul(argv[3], NULL, 0);
 157
 158         rc = tpm_pcr_read(dev, index, data, count);
 159         if (!rc) {
 160                 puts("Named PCR content:\n");
 161                 print_byte_string(data, count);
 162         }
 163
 164         return report_return_code(rc);
 165 }
 166
 167 static int do_tpm_tsc_physical_presence(cmd_tbl_t *cmdtp, int flag, int argc,
 168                                         char * const argv[])
 169 {
 170         struct udevice *dev;
 171         u16 presence;
 172         int rc;
 173
 174         rc = get_tpm(&dev);
 175         if (rc)
 176                 return rc;
 177
 178         if (argc != 2)
 179                 return CMD_RET_USAGE;
 180         presence = (u16)simple_strtoul(argv[1], NULL, 0);
 181
 182         return report_return_code(tpm_tsc_physical_presence(dev, presence));
 183 }
 184
 185 static int do_tpm_read_pubek(cmd_tbl_t *cmdtp, int flag, int argc,
 186                              char * const argv[])
 187 {
 188         struct udevice *dev;
 189         u32 count, rc;
 190         void *data;
 191
 192         rc = get_tpm(&dev);
 193         if (rc)
 194                 return rc;
 195
 196         if (argc != 3)
 197                 return CMD_RET_USAGE;
 198         data = (void *)simple_strtoul(argv[1], NULL, 0);
 199         count = simple_strtoul(argv[2], NULL, 0);
 200
 201         rc = tpm_read_pubek(dev, data, count);
 202         if (!rc) {
 203                 puts("pubek value:\n");
 204                 print_byte_string(data, count);
 205         }
 206
 207         return report_return_code(rc);
 208 }
 209
 210 static int do_tpm_physical_set_deactivated(cmd_tbl_t *cmdtp, int flag, int argc,
 211                                            char * const argv[])
 212 {
 213         struct udevice *dev;
 214         u8 state;
 215         int rc;
 216
 217         rc = get_tpm(&dev);
 218         if (rc)
 219                 return rc;
 220
 221         if (argc != 2)
 222                 return CMD_RET_USAGE;
 223         state = (u8)simple_strtoul(argv[1], NULL, 0);
 224
 225         return report_return_code(tpm_physical_set_deactivated(dev, state));
 226 }
 227
 228 static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag, int argc,
 229                                  char * const argv[])
 230 {
 231         u32 cap_area, sub_cap, rc;
 232         void *cap;
 233         size_t count;
 234         struct udevice *dev;
 235
 236         rc = get_tpm(&dev);
 237         if (rc)
 238                 return rc;
 239
 240         if (argc != 5)
 241                 return CMD_RET_USAGE;
 242         cap_area = simple_strtoul(argv[1], NULL, 0);
 243         sub_cap = simple_strtoul(argv[2], NULL, 0);
 244         cap = (void *)simple_strtoul(argv[3], NULL, 0);
 245         count = simple_strtoul(argv[4], NULL, 0);
 246
 247         rc = tpm_get_capability(dev, cap_area, sub_cap, cap, count);
 248         if (!rc) {
 249                 puts("capability information:\n");
 250                 print_byte_string(cap, count);
 251         }
 252
 253         return report_return_code(rc);
 254 }
 255
 256 static int do_tpm_raw_transfer(cmd_tbl_t *cmdtp, int flag, int argc,
 257                                char * const argv[])
 258 {
 259         struct udevice *dev;
 260         void *command;
 261         u8 response[1024];
 262         size_t count, response_length = sizeof(response);
 263         u32 rc;
 264
 265         command = parse_byte_string(argv[1], NULL, &count);
 266         if (!command) {
 267                 printf("Couldn't parse byte string %s\n", argv[1]);
 268                 return CMD_RET_FAILURE;
 269         }
 270
 271         rc = get_tpm(&dev);
 272         if (rc)
 273                 return rc;
 274
 275         rc = tpm_xfer(dev, command, count, response, &response_length);
 276         free(command);
 277         if (!rc) {
 278                 puts("tpm response:\n");
 279                 print_byte_string(response, response_length);
 280         }
 281
 282         return report_return_code(rc);
 283 }
 284
 285 static int do_tpm_nv_define(cmd_tbl_t *cmdtp, int flag, int argc,
 286                             char * const argv[])
 287 {
 288         u32 index, perm, size;
 289         struct udevice *dev;
 290         int rc;
 291
 292         rc = get_tpm(&dev);
 293         if (rc)
 294                 return rc;
 295
 296         if (argc != 4)
 297                 return CMD_RET_USAGE;
 298         size = type_string_get_space_size(argv[1]);
 299         if (!size) {
 300                 printf("Couldn't parse arguments\n");
 301                 return CMD_RET_USAGE;
 302         }
 303         index = simple_strtoul(argv[2], NULL, 0);
 304         perm = simple_strtoul(argv[3], NULL, 0);
 305
 306         return report_return_code(tpm_nv_define_space(dev, index, perm, size));
 307 }
 308
 309 static int do_tpm_nv_read(cmd_tbl_t *cmdtp, int flag, int argc,
 310                           char * const argv[])
 311 {
 312         u32 index, count, err;
 313         struct udevice *dev;
 314         void *data;
 315         int rc;
 316
 317         rc = get_tpm(&dev);
 318         if (rc)
 319                 return rc;
 320
 321         if (argc < 3)
 322                 return CMD_RET_USAGE;
 323         if (argc != 3 + type_string_get_num_values(argv[1]))
 324                 return CMD_RET_USAGE;
 325         index = simple_strtoul(argv[2], NULL, 0);
 326         data = type_string_alloc(argv[1], &count);
 327         if (!data) {
 328                 printf("Couldn't parse arguments\n");
 329                 return CMD_RET_USAGE;
 330         }
 331
 332         err = tpm_nv_read_value(dev, index, data, count);
 333         if (!err) {
 334                 if (type_string_write_vars(argv[1], data, argv + 3)) {
 335                         printf("Couldn't write to variables\n");
 336                         err = ~0;
 337                 }
 338         }
 339         free(data);
 340
 341         return report_return_code(err);
 342 }
 343
 344 static int do_tpm_nv_write(cmd_tbl_t *cmdtp, int flag, int argc,
 345                            char * const argv[])
 346 {
 347         u32 index, count, err;
 348         struct udevice *dev;
 349         void *data;
 350         int rc;
 351
 352         rc = get_tpm(&dev);
 353         if (rc)
 354                 return rc;
 355
 356         if (argc < 3)
 357                 return CMD_RET_USAGE;
 358         if (argc != 3 + type_string_get_num_values(argv[1]))
 359                 return CMD_RET_USAGE;
 360         index = simple_strtoul(argv[2], NULL, 0);
 361         data = type_string_alloc(argv[1], &count);
 362         if (!data) {
 363                 printf("Couldn't parse arguments\n");
 364                 return CMD_RET_USAGE;
 365         }
 366         if (type_string_pack(argv[1], argv + 3, data)) {
 367                 printf("Couldn't parse arguments\n");
 368                 free(data);
 369                 return CMD_RET_USAGE;
 370         }
 371
 372         err = tpm_nv_write_value(dev, index, data, count);
 373         free(data);
 374
 375         return report_return_code(err);
 376 }
 377
 378 #ifdef CONFIG_TPM_AUTH_SESSIONS
 379
 380 static int do_tpm_oiap(cmd_tbl_t *cmdtp, int flag, int argc,
 381                        char * const argv[])
 382 {
 383         u32 auth_handle, err;
 384         struct udevice *dev;
 385         int rc;
 386
 387         rc = get_tpm(&dev);
 388         if (rc)
 389                 return rc;
 390
 391         err = tpm_oiap(dev, &auth_handle);
 392
 393         return report_return_code(err);
 394 }
 395
 396 #ifdef CONFIG_TPM_LOAD_KEY_BY_SHA1
 397 static int do_tpm_load_key_by_sha1(cmd_tbl_t *cmdtp, int flag, int argc, char *
 398                                    const argv[])
 399 {
 400         u32 parent_handle = 0;
 401         u32 key_len, key_handle, err;
 402         u8 usage_auth[DIGEST_LENGTH];
 403         u8 parent_hash[DIGEST_LENGTH];
 404         void *key;
 405         struct udevice *dev;
 406
 407         rc = get_tpm(&dev);
 408         if (rc)
 409                 return rc;
 410
 411         if (argc < 5)
 412                 return CMD_RET_USAGE;
 413
 414         parse_byte_string(argv[1], parent_hash, NULL);
 415         key = (void *)simple_strtoul(argv[2], NULL, 0);
 416         key_len = simple_strtoul(argv[3], NULL, 0);
 417         if (strlen(argv[4]) != 2 * DIGEST_LENGTH)
 418                 return CMD_RET_FAILURE;
 419         parse_byte_string(argv[4], usage_auth, NULL);
 420
 421         err = tpm_find_key_sha1(usage_auth, parent_hash, &parent_handle);
 422         if (err) {
 423                 printf("Could not find matching parent key (err = %d)\n", err);
 424                 return CMD_RET_FAILURE;
 425         }
 426
 427         printf("Found parent key %08x\n", parent_handle);
 428
 429         err = tpm_load_key2_oiap(parent_handle, key, key_len, usage_auth,
 430                                  &key_handle);
 431         if (!err) {
 432                 printf("Key handle is 0x%x\n", key_handle);
 433                 env_set_hex("key_handle", key_handle);
 434         }
 435
 436         return report_return_code(err);
 437 }
 438 #endif /* CONFIG_TPM_LOAD_KEY_BY_SHA1 */
 439
 440 static int do_tpm_load_key2_oiap(cmd_tbl_t *cmdtp, int flag, int argc,
 441                                  char * const argv[])
 442 {
 443         u32 parent_handle, key_len, key_handle, err;
 444         u8 usage_auth[DIGEST_LENGTH];
 445         void *key;
 446         struct udevice *dev;
 447         int rc;
 448
 449         rc = get_tpm(&dev);
 450         if (rc)
 451                 return rc;
 452
 453         if (argc < 5)
 454                 return CMD_RET_USAGE;
 455
 456         parent_handle = simple_strtoul(argv[1], NULL, 0);
 457         key = (void *)simple_strtoul(argv[2], NULL, 0);
 458         key_len = simple_strtoul(argv[3], NULL, 0);
 459         if (strlen(argv[4]) != 2 * DIGEST_LENGTH)
 460                 return CMD_RET_FAILURE;
 461         parse_byte_string(argv[4], usage_auth, NULL);
 462
 463         err = tpm_load_key2_oiap(dev, parent_handle, key, key_len, usage_auth,
 464                                  &key_handle);
 465         if (!err)
 466                 printf("Key handle is 0x%x\n", key_handle);
 467
 468         return report_return_code(err);
 469 }
 470
 471 static int do_tpm_get_pub_key_oiap(cmd_tbl_t *cmdtp, int flag, int argc,
 472                                    char * const argv[])
 473 {
 474         u32 key_handle, err;
 475         u8 usage_auth[DIGEST_LENGTH];
 476         u8 pub_key_buffer[TPM_PUBKEY_MAX_LENGTH];
 477         size_t pub_key_len = sizeof(pub_key_buffer);
 478         struct udevice *dev;
 479         int rc;
 480
 481         rc = get_tpm(&dev);
 482         if (rc)
 483                 return rc;
 484
 485         if (argc < 3)
 486                 return CMD_RET_USAGE;
 487
 488         key_handle = simple_strtoul(argv[1], NULL, 0);
 489         if (strlen(argv[2]) != 2 * DIGEST_LENGTH)
 490                 return CMD_RET_FAILURE;
 491         parse_byte_string(argv[2], usage_auth, NULL);
 492
 493         err = tpm_get_pub_key_oiap(dev, key_handle, usage_auth, pub_key_buffer,
 494                                    &pub_key_len);
 495         if (!err) {
 496                 printf("dump of received pub key structure:\n");
 497                 print_byte_string(pub_key_buffer, pub_key_len);
 498         }
 499         return report_return_code(err);
 500 }
 501
 502 TPM_COMMAND_NO_ARG(tpm_end_oiap)
 503
 504 #endif /* CONFIG_TPM_AUTH_SESSIONS */
 505
 506 #ifdef CONFIG_TPM_FLUSH_RESOURCES
 507 static int do_tpm_flush(cmd_tbl_t *cmdtp, int flag, int argc,
 508                         char * const argv[])
 509 {
 510         struct udevice *dev;
 511         int type = 0;
 512         int rc;
 513
 514         rc = get_tpm(&dev);
 515         if (rc)
 516                 return rc;
 517
 518         if (argc != 3)
 519                 return CMD_RET_USAGE;
 520
 521         if (!strcasecmp(argv[1], "key"))
 522                 type = TPM_RT_KEY;
 523         else if (!strcasecmp(argv[1], "auth"))
 524                 type = TPM_RT_AUTH;
 525         else if (!strcasecmp(argv[1], "hash"))
 526                 type = TPM_RT_HASH;
 527         else if (!strcasecmp(argv[1], "trans"))
 528                 type = TPM_RT_TRANS;
 529         else if (!strcasecmp(argv[1], "context"))
 530                 type = TPM_RT_CONTEXT;
 531         else if (!strcasecmp(argv[1], "counter"))
 532                 type = TPM_RT_COUNTER;
 533         else if (!strcasecmp(argv[1], "delegate"))
 534                 type = TPM_RT_DELEGATE;
 535         else if (!strcasecmp(argv[1], "daa_tpm"))
 536                 type = TPM_RT_DAA_TPM;
 537         else if (!strcasecmp(argv[1], "daa_v0"))
 538                 type = TPM_RT_DAA_V0;
 539         else if (!strcasecmp(argv[1], "daa_v1"))
 540                 type = TPM_RT_DAA_V1;
 541
 542         if (!type) {
 543                 printf("Resource type %s unknown.\n", argv[1]);
 544                 return -1;
 545         }
 546
 547         if (!strcasecmp(argv[2], "all")) {
 548                 u16 res_count;
 549                 u8 buf[288];
 550                 u8 *ptr;
 551                 int err;
 552                 uint i;
 553
 554                 /* fetch list of already loaded resources in the TPM */
 555                 err = tpm_get_capability(dev, TPM_CAP_HANDLE, type, buf,
 556                                          sizeof(buf));
 557                 if (err) {
 558                         printf("tpm_get_capability returned error %d.\n", err);
 559                         return -1;
 560                 }
 561                 res_count = get_unaligned_be16(buf);
 562                 ptr = buf + 2;
 563                 for (i = 0; i < res_count; ++i, ptr += 4)
 564                         tpm_flush_specific(dev, get_unaligned_be32(ptr), type);
 565         } else {
 566                 u32 handle = simple_strtoul(argv[2], NULL, 0);
 567
 568                 if (!handle) {
 569                         printf("Illegal resource handle %s\n", argv[2]);
 570                         return -1;
 571                 }
 572                 tpm_flush_specific(dev, cpu_to_be32(handle), type);
 573         }
 574
 575         return 0;
 576 }
 577 #endif /* CONFIG_TPM_FLUSH_RESOURCES */
 578
 579 #ifdef CONFIG_TPM_LIST_RESOURCES
 580 static int do_tpm_list(cmd_tbl_t *cmdtp, int flag, int argc,
 581                        char * const argv[])
 582 {
 583         int type = 0;
 584         u16 res_count;
 585         u8 buf[288];
 586         u8 *ptr;
 587         int err;
 588         uint i;
 589
 590         if (argc != 2)
 591                 return CMD_RET_USAGE;
 592
 593         if (!strcasecmp(argv[1], "key"))
 594                 type = TPM_RT_KEY;
 595         else if (!strcasecmp(argv[1], "auth"))
 596                 type = TPM_RT_AUTH;
 597         else if (!strcasecmp(argv[1], "hash"))
 598                 type = TPM_RT_HASH;
 599         else if (!strcasecmp(argv[1], "trans"))
 600                 type = TPM_RT_TRANS;
 601         else if (!strcasecmp(argv[1], "context"))
 602                 type = TPM_RT_CONTEXT;
 603         else if (!strcasecmp(argv[1], "counter"))
 604                 type = TPM_RT_COUNTER;
 605         else if (!strcasecmp(argv[1], "delegate"))
 606                 type = TPM_RT_DELEGATE;
 607         else if (!strcasecmp(argv[1], "daa_tpm"))
 608                 type = TPM_RT_DAA_TPM;
 609         else if (!strcasecmp(argv[1], "daa_v0"))
 610                 type = TPM_RT_DAA_V0;
 611         else if (!strcasecmp(argv[1], "daa_v1"))
 612                 type = TPM_RT_DAA_V1;
 613
 614         if (!type) {
 615                 printf("Resource type %s unknown.\n", argv[1]);
 616                 return -1;
 617         }
 618
 619         /* fetch list of already loaded resources in the TPM */
 620         err = tpm_get_capability(TPM_CAP_HANDLE, type, buf,
 621                                  sizeof(buf));
 622         if (err) {
 623                 printf("tpm_get_capability returned error %d.\n", err);
 624                 return -1;
 625         }
 626         res_count = get_unaligned_be16(buf);
 627         ptr = buf + 2;
 628
 629         printf("Resources of type %s (%02x):\n", argv[1], type);
 630         if (!res_count) {
 631                 puts("None\n");
 632         } else {
 633                 for (i = 0; i < res_count; ++i, ptr += 4)
 634                         printf("Index %d: %08x\n", i, get_unaligned_be32(ptr));
 635         }
 636
 637         return 0;
 638 }
 639 #endif /* CONFIG_TPM_LIST_RESOURCES */
 640
 641 TPM_COMMAND_NO_ARG(tpm_self_test_full)
 642 TPM_COMMAND_NO_ARG(tpm_continue_self_test)
 643 TPM_COMMAND_NO_ARG(tpm_force_clear)
 644 TPM_COMMAND_NO_ARG(tpm_physical_enable)
 645 TPM_COMMAND_NO_ARG(tpm_physical_disable)
 646
 647 static cmd_tbl_t tpm1_commands[] = {
 648         U_BOOT_CMD_MKENT(info, 0, 1, do_tpm_info, "", ""),
 649         U_BOOT_CMD_MKENT(init, 0, 1, do_tpm_init, "", ""),
 650         U_BOOT_CMD_MKENT(startup, 0, 1,
 651                          do_tpm_startup, "", ""),
 652         U_BOOT_CMD_MKENT(self_test_full, 0, 1,
 653                          do_tpm_self_test_full, "", ""),
 654         U_BOOT_CMD_MKENT(continue_self_test, 0, 1,
 655                          do_tpm_continue_self_test, "", ""),
 656         U_BOOT_CMD_MKENT(force_clear, 0, 1,
 657                          do_tpm_force_clear, "", ""),
 658         U_BOOT_CMD_MKENT(physical_enable, 0, 1,
 659                          do_tpm_physical_enable, "", ""),
 660         U_BOOT_CMD_MKENT(physical_disable, 0, 1,
 661                          do_tpm_physical_disable, "", ""),
 662         U_BOOT_CMD_MKENT(nv_define_space, 0, 1,
 663                          do_tpm_nv_define_space, "", ""),
 664         U_BOOT_CMD_MKENT(nv_read_value, 0, 1,
 665                          do_tpm_nv_read_value, "", ""),
 666         U_BOOT_CMD_MKENT(nv_write_value, 0, 1,
 667                          do_tpm_nv_write_value, "", ""),
 668         U_BOOT_CMD_MKENT(extend, 0, 1,
 669                          do_tpm_extend, "", ""),
 670         U_BOOT_CMD_MKENT(pcr_read, 0, 1,
 671                          do_tpm_pcr_read, "", ""),
 672         U_BOOT_CMD_MKENT(tsc_physical_presence, 0, 1,
 673                          do_tpm_tsc_physical_presence, "", ""),
 674         U_BOOT_CMD_MKENT(read_pubek, 0, 1,
 675                          do_tpm_read_pubek, "", ""),
 676         U_BOOT_CMD_MKENT(physical_set_deactivated, 0, 1,
 677                          do_tpm_physical_set_deactivated, "", ""),
 678         U_BOOT_CMD_MKENT(get_capability, 0, 1,
 679                          do_tpm_get_capability, "", ""),
 680         U_BOOT_CMD_MKENT(raw_transfer, 0, 1,
 681                          do_tpm_raw_transfer, "", ""),
 682         U_BOOT_CMD_MKENT(nv_define, 0, 1,
 683                          do_tpm_nv_define, "", ""),
 684         U_BOOT_CMD_MKENT(nv_read, 0, 1,
 685                          do_tpm_nv_read, "", ""),
 686         U_BOOT_CMD_MKENT(nv_write, 0, 1,
 687                          do_tpm_nv_write, "", ""),
 688 #ifdef CONFIG_TPM_AUTH_SESSIONS
 689         U_BOOT_CMD_MKENT(oiap, 0, 1,
 690                          do_tpm_oiap, "", ""),
 691         U_BOOT_CMD_MKENT(end_oiap, 0, 1,
 692                          do_tpm_end_oiap, "", ""),
 693         U_BOOT_CMD_MKENT(load_key2_oiap, 0, 1,
 694                          do_tpm_load_key2_oiap, "", ""),
 695 #ifdef CONFIG_TPM_LOAD_KEY_BY_SHA1
 696         U_BOOT_CMD_MKENT(load_key_by_sha1, 0, 1,
 697                          do_tpm_load_key_by_sha1, "", ""),
 698 #endif /* CONFIG_TPM_LOAD_KEY_BY_SHA1 */
 699         U_BOOT_CMD_MKENT(get_pub_key_oiap, 0, 1,
 700                          do_tpm_get_pub_key_oiap, "", ""),
 701 #endif /* CONFIG_TPM_AUTH_SESSIONS */
 702 #ifdef CONFIG_TPM_FLUSH_RESOURCES
 703         U_BOOT_CMD_MKENT(flush, 0, 1,
 704                          do_tpm_flush, "", ""),
 705 #endif /* CONFIG_TPM_FLUSH_RESOURCES */
 706 #ifdef CONFIG_TPM_LIST_RESOURCES
 707         U_BOOT_CMD_MKENT(list, 0, 1,
 708                          do_tpm_list, "", ""),
 709 #endif /* CONFIG_TPM_LIST_RESOURCES */
 710 };
 711
 712 cmd_tbl_t *get_tpm1_commands(unsigned int *size)
 713 {
 714         *size = ARRAY_SIZE(tpm1_commands);
 715
 716         return tpm1_commands;
 717 }
 718
 719 U_BOOT_CMD(tpm, CONFIG_SYS_MAXARGS, 1, do_tpm,
 720 "Issue a TPMv1.x command",
 721 "cmd args...\n"
 722 "    - Issue TPM command <cmd> with arguments <args...>.\n"
 723 "Admin Startup and State Commands:\n"
 724 "  info - Show information about the TPM\n"
 725 "  init\n"
 726 "    - Put TPM into a state where it waits for 'startup' command.\n"
 727 "  startup mode\n"
 728 "    - Issue TPM_Starup command.  <mode> is one of TPM_ST_CLEAR,\n"
 729 "      TPM_ST_STATE, and TPM_ST_DEACTIVATED.\n"
 730 "Admin Testing Commands:\n"
 731 "  self_test_full\n"
 732 "    - Test all of the TPM capabilities.\n"
 733 "  continue_self_test\n"
 734 "    - Inform TPM that it should complete the self-test.\n"
 735 "Admin Opt-in Commands:\n"
 736 "  physical_enable\n"
 737 "    - Set the PERMANENT disable flag to FALSE using physical presence as\n"
 738 "      authorization.\n"
 739 "  physical_disable\n"
 740 "    - Set the PERMANENT disable flag to TRUE using physical presence as\n"
 741 "      authorization.\n"
 742 "  physical_set_deactivated 0|1\n"
 743 "    - Set deactivated flag.\n"
 744 "Admin Ownership Commands:\n"
 745 "  force_clear\n"
 746 "    - Issue TPM_ForceClear command.\n"
 747 "  tsc_physical_presence flags\n"
 748 "    - Set TPM device's Physical Presence flags to <flags>.\n"
 749 "The Capability Commands:\n"
 750 "  get_capability cap_area sub_cap addr count\n"
 751 "    - Read <count> bytes of TPM capability indexed by <cap_area> and\n"
 752 "      <sub_cap> to memory address <addr>.\n"
 753 #if defined(CONFIG_TPM_FLUSH_RESOURCES) || defined(CONFIG_TPM_LIST_RESOURCES)
 754 "Resource management functions\n"
 755 #endif
 756 #ifdef CONFIG_TPM_FLUSH_RESOURCES
 757 "  flush resource_type id\n"
 758 "    - flushes a resource of type <resource_type> (may be one of key, auth,\n"
 759 "      hash, trans, context, counter, delegate, daa_tpm, daa_v0, daa_v1),\n"
 760 "      and id <id> from the TPM. Use an <id> of \"all\" to flush all\n"
 761 "      resources of that type.\n"
 762 #endif /* CONFIG_TPM_FLUSH_RESOURCES */
 763 #ifdef CONFIG_TPM_LIST_RESOURCES
 764 "  list resource_type\n"
 765 "    - lists resources of type <resource_type> (may be one of key, auth,\n"
 766 "      hash, trans, context, counter, delegate, daa_tpm, daa_v0, daa_v1),\n"
 767 "      contained in the TPM.\n"
 768 #endif /* CONFIG_TPM_LIST_RESOURCES */
 769 #ifdef CONFIG_TPM_AUTH_SESSIONS
 770 "Storage functions\n"
 771 "  loadkey2_oiap parent_handle key_addr key_len usage_auth\n"
 772 "    - loads a key data from memory address <key_addr>, <key_len> bytes\n"
 773 "      into TPM using the parent key <parent_handle> with authorization\n"
 774 "      <usage_auth> (20 bytes hex string).\n"
 775 #ifdef CONFIG_TPM_LOAD_KEY_BY_SHA1
 776 "  load_key_by_sha1 parent_hash key_addr key_len usage_auth\n"
 777 "    - loads a key data from memory address <key_addr>, <key_len> bytes\n"
 778 "      into TPM using the parent hash <parent_hash> (20 bytes hex string)\n"
 779 "      with authorization <usage_auth> (20 bytes hex string).\n"
 780 #endif /* CONFIG_TPM_LOAD_KEY_BY_SHA1 */
 781 "  get_pub_key_oiap key_handle usage_auth\n"
 782 "    - get the public key portion of a loaded key <key_handle> using\n"
 783 "      authorization <usage auth> (20 bytes hex string)\n"
 784 #endif /* CONFIG_TPM_AUTH_SESSIONS */
 785 "Endorsement Key Handling Commands:\n"
 786 "  read_pubek addr count\n"
 787 "    - Read <count> bytes of the public endorsement key to memory\n"
 788 "      address <addr>\n"
 789 "Integrity Collection and Reporting Commands:\n"
 790 "  extend index digest_hex_string\n"
 791 "    - Add a new measurement to a PCR.  Update PCR <index> with the 20-bytes\n"
 792 "      <digest_hex_string>\n"
 793 "  pcr_read index addr count\n"
 794 "    - Read <count> bytes from PCR <index> to memory address <addr>.\n"
 795 #ifdef CONFIG_TPM_AUTH_SESSIONS
 796 "Authorization Sessions\n"
 797 "  oiap\n"
 798 "    - setup an OIAP session\n"
 799 "  end_oiap\n"
 800 "    - terminates an active OIAP session\n"
 801 #endif /* CONFIG_TPM_AUTH_SESSIONS */
 802 "Non-volatile Storage Commands:\n"
 803 "  nv_define_space index permission size\n"
 804 "    - Establish a space at index <index> with <permission> of <size> bytes.\n"
 805 "  nv_read_value index addr count\n"
 806 "    - Read <count> bytes from space <index> to memory address <addr>.\n"
 807 "  nv_write_value index addr count\n"
 808 "    - Write <count> bytes from memory address <addr> to space <index>.\n"
 809 "Miscellaneous helper functions:\n"
 810 "  raw_transfer byte_string\n"
 811 "    - Send a byte string <byte_string> to TPM and print the response.\n"
 812 " Non-volatile storage helper functions:\n"
 813 "    These helper functions treat a non-volatile space as a non-padded\n"
 814 "    sequence of integer values.  These integer values are defined by a type\n"
 815 "    string, which is a text string of 'bwd' characters: 'b' means a 8-bit\n"
 816 "    value, 'w' 16-bit value, 'd' 32-bit value.  All helper functions take\n"
 817 "    a type string as their first argument.\n"
 818 "  nv_define type_string index perm\n"
 819 "    - Define a space <index> with permission <perm>.\n"
 820 "  nv_read types_string index vars...\n"
 821 "    - Read from space <index> to environment variables <vars...>.\n"
 822 "  nv_write types_string index values...\n"
 823 "    - Write to space <index> from values <values...>.\n"
 824 );