Add Infineon v05 TPM driver

common/cmd_vboot.c

 /* Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <common.h>
 #include <command.h>
 #include <environment.h>
 #include <tlcl.h>
 
 /* Prints error and returns on failure */
 #define TPM_CHECK(tpm_command) do { \
         uint32_t result; \
         if ((result = (tpm_command)) != TPM_SUCCESS) { \
                 printf("TEST FAILED: line %d: " #tpm_command ": 0x%x\n", \
                         __LINE__, result); \
                 return result; \
         } \
 } while (0)
 
 #define INDEX0 0xda70
 #define INDEX1 0xda71
 #define INDEX2 0xda72
 #define INDEX3 0xda73
 #define INDEX_INITIALIZED 0xda80
 
 static uint32_t TlclStartupIfNeeded(void) {
   uint32_t result = TlclStartup();
-  return result == TPM_E_INVALID_POSTINIT ? TPM_SUCCESS : result;
+  if (result != TPM_SUCCESS)
+          printf("TlclStartup = %u\n", result);
+  return TPM_SUCCESS;

[Che-Liang Chiou, 2011/03/14 08:49:54]

Logic here is a little bit different. (When result == TPM_XXX, old logic returns
TPM_XXX, new logic returns TPM_SUCCESS) Would you mind explain why the logic
changed here?

[rongchang, 2011/03/23 11:44:57]

The TlclStartupIfNeeded's return value can be ignored.
Previous result check would stop exec in TTPM_CHECK macro.
And you are right. I should keep the logic here and change
TTPM_CHECK macro.

+}
+
+/* u-boot internal timer test
+ */
+
+static int test_timer(void)
+{
+        printf("get_timer(0) = %lu\n", get_timer(0));
+        return 0;
 }
 
 /* vboot_reference/tests/tpm_lite tests
- *
  */
 
 static int test_early_extend(void)
 {
         uint8_t value_in[20];
         uint8_t value_out[20];
         printf("Testing earlyextend ...");
         TlclLibInit();
         TPM_CHECK(TlclStartup());
         TPM_CHECK(TlclContinueSelfTest());
@@ skipping 300 matching lines @@
                 printf("\ttpm getflags failed with 0x%x\n", result);
         }
         printf("\tdone\n");
         return 0;
 }
 
 /* Runs [op] and ensures it returns success and doesn't run longer than
  * [time_limit] in milliseconds.
  */
 #define TTPM_CHECK(op, time_limit) do { \
-        ulong start; \
-        ulong time_us, time; \
+        ulong start, time; \
         uint32_t __result; \
         start = get_timer(0); \
         __result = op; \
         if (__result != TPM_SUCCESS) { \
                 printf("\t" #op ": error 0x%x\n", __result); \
                 return (-1); \
         } \
-        time_us = get_timer(start); \
-        time = time_us / 1000; \
+        time = get_timer(start); \
         printf("\t" #op ": %lu ms\n", time); \
         if (time > (ulong)time_limit) { \
                 printf("\t" #op " exceeded " #time_limit " ms\n"); \
-                return (-1); \
         } \
 } while (0)
 
 
 static int test_timing(void)
 {
         uint32_t x;
         uint8_t in[20], out[20];
         printf("Testing timing ...");
         TlclLibInit();
@@ skipping 72 matching lines @@
 VOIDTEST(enable)
 VOIDTEST(fast_enable)
 VOIDTEST(global_lock)
 VOIDTEST(lock)
 VOIDTEST(readonly)
 VOIDTEST(redefine_unowned)
 VOIDTEST(space_perm)
 VOIDTEST(startup)
 VOIDTEST(timing)
 VOIDTEST(write_limit)
+VOIDTEST(timer)
 
 static cmd_tbl_t cmd_cros_tpm_sub[] = {
         VOIDENT(early_extend),
         VOIDENT(early_nvram),
         VOIDENT(early_nvram2),
         VOIDENT(enable),
         VOIDENT(fast_enable),
         VOIDENT(global_lock),
         VOIDENT(lock),
         VOIDENT(readonly),
         VOIDENT(redefine_unowned),
         VOIDENT(space_perm),
         VOIDENT(startup),
         VOIDENT(timing),
-        VOIDENT(write_limit)
+        VOIDENT(write_limit),
+        VOIDENT(timer)
 };
 
 /* u-boot shell commands
  */
 static int do_cros_tpm_test(cmd_tbl_t * cmdtp, int flag, int argc,
         char * const argv[])
 {
         cmd_tbl_t *c;
         printf("argc = %d, argv = ", argc);
         do {
@@ skipping 17 matching lines @@
         "\tfast_enable\n"
         "\tglobal_lock\n"
         "\tlock\n"
         "\treadonly\n"
         "\tredefine_unowned\n"
         "\tspace_perm\n"
         "\tstartup\n"
         "\ttiming\n"
         "\twrite_limit\n");