[coreboot-gerrit] New patch to review for coreboot: TPM: Merge of two TPM API's into one API.

Philipp Deppenwiese (zaolin@das-labor.org) gerrit at coreboot.org
Sat Jun 13 23:49:08 CEST 2015


Philipp Deppenwiese (zaolin at das-labor.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/10542

-gerrit

commit 12c1a1d3f9bee0b501d433d5878a2e1314a58300
Author: Philipp Deppenwiese <zaolin at das-labor.org>
Date:   Sat Jun 13 23:35:37 2015 +0200

    TPM: Merge of two TPM API's into one API.
    
    Currently coreboot includes two TPM software implementations.
    This does not make any sense.
    
    Following changes are included:
    
    + Add the more featured Google TSS to coreboot.
    + Remove the old one which can't be used for vboot2.
    + Split & Merge implementations into TSS and TSPI (see. tcg webpage for documents)
    + Fix all includes.
    
    Compile:
    
    VBOOT2 Feature = yes
    Coreboot TPM Feature = yes
    
    Run:
    
    VBOOT2 Feature = not tested
    Coreboot TPM Feature = yes
    
    Change-Id: I8cbcd723d83ffcc0c1c47c58438dccdb16bb7cf7
    Signed-off-by: Philipp Deppenwiese <zaolin at das-labor.org>
---
 src/cpu/intel/haswell/romstage.c                   |   2 +-
 src/drivers/pc80/tpm/Makefile.inc                  |   3 +-
 src/drivers/pc80/tpm/romstage.c                    | 255 ----------------
 src/drivers/pc80/tpm/tpm.c                         |   2 +-
 src/drivers/pc80/tpm/tspi/Makefile.inc             |   4 +
 src/drivers/pc80/tpm/tspi/tspi.c                   |  95 ++++++
 src/drivers/pc80/tpm/tss/Makefile.inc              |  11 +
 src/drivers/pc80/tpm/tss/mocked_tss.c              | 136 +++++++++
 src/drivers/pc80/tpm/tss/tss.c                     | 331 +++++++++++++++++++++
 src/drivers/pc80/tpm/tss/tss_internal.h            |  58 ++++
 src/drivers/pc80/tpm/tss/tss_structures.h          | 138 +++++++++
 src/include/antirollback.h                         |   2 +-
 src/include/pc80/tpm.h                             |  66 ++++
 src/include/pc80/tpm/tspi.h                        |  23 ++
 src/include/pc80/tpm/tss.h                         | 133 +++++++++
 src/include/pc80/tpm/tss_constants.h               |  95 ++++++
 src/include/tpm.h                                  |  71 -----
 src/include/tpm_lite/tlcl.h                        | 137 ---------
 src/include/tpm_lite/tss_constants.h               |  96 ------
 src/lib/Makefile.inc                               |   6 -
 src/lib/mocked_tlcl.c                              | 136 ---------
 src/lib/tlcl.c                                     | 327 --------------------
 src/lib/tlcl_internal.h                            |  61 ----
 src/lib/tlcl_structures.h                          | 138 ---------
 src/mainboard/google/link/romstage.c               |   2 +-
 src/mainboard/google/parrot/romstage.c             |   2 +-
 src/mainboard/google/stout/romstage.c              |   2 +-
 src/mainboard/intel/emeraldlake2/romstage.c        |   2 +-
 src/mainboard/lenovo/x201/romstage.c               |   2 +-
 src/mainboard/samsung/lumpy/romstage.c             |   2 +-
 src/mainboard/samsung/stumpy/romstage.c            |   2 +-
 .../intel/sandybridge/romstage_native.c            |   2 +-
 src/soc/intel/baytrail/romstage/romstage.c         |   2 +-
 src/soc/intel/braswell/romstage/romstage.c         |   2 +-
 src/soc/intel/broadwell/romstage/romstage.c        |   2 +-
 .../google/chromeos/vboot2/antirollback.c          |   4 +-
 36 files changed, 1108 insertions(+), 1244 deletions(-)

diff --git a/src/cpu/intel/haswell/romstage.c b/src/cpu/intel/haswell/romstage.c
index 6adb8be..0e0b8af 100644
--- a/src/cpu/intel/haswell/romstage.c
+++ b/src/cpu/intel/haswell/romstage.c
@@ -44,7 +44,7 @@
 #include "northbridge/intel/haswell/raminit.h"
 #include "southbridge/intel/lynxpoint/pch.h"
 #include "southbridge/intel/lynxpoint/me.h"
-#include <tpm.h>
+#include <pc80/tpm/tspi.h>
 
 static inline void reset_system(void)
 {
diff --git a/src/drivers/pc80/tpm/Makefile.inc b/src/drivers/pc80/tpm/Makefile.inc
index 089d067..7d00857 100644
--- a/src/drivers/pc80/tpm/Makefile.inc
+++ b/src/drivers/pc80/tpm/Makefile.inc
@@ -1,3 +1,4 @@
+subdirs-y += tss tspi
+
 romstage-$(CONFIG_LPC_TPM) += tpm.c
 ramstage-$(CONFIG_LPC_TPM) += tpm.c
-romstage-$(CONFIG_LPC_TPM) += romstage.c
diff --git a/src/drivers/pc80/tpm/romstage.c b/src/drivers/pc80/tpm/romstage.c
deleted file mode 100644
index 96760e2..0000000
--- a/src/drivers/pc80/tpm/romstage.c
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
- * This file is part of the coreboot project.
- *
- * Copyright (C) 2011 The ChromiumOS Authors.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc.
- */
-
-#include <types.h>
-#include <console/cbmem_console.h>
-#include <console/console.h>
-#include <arch/acpi.h>
-#include <tpm.h>
-#include <reset.h>
-
-//#define EXTRA_LOGGING
-
-#define TPM_LARGE_ENOUGH_COMMAND_SIZE 256	/* saves space in the firmware */
-
-#define TPM_SUCCESS               ((u32)0x00000000)
-
-#define TPM_E_IOERROR             ((u32)0x0000001f)
-#define TPM_E_COMMUNICATION_ERROR ((u32)0x00005004)
-#define TPM_E_NON_FATAL           ((u32)0x00000800)
-#define TPM_E_INVALID_POSTINIT    ((u32)0x00000026)
-
-#define TPM_E_NEEDS_SELFTEST     ((u32)(TPM_E_NON_FATAL + 1))
-#define TPM_E_DOING_SELFTEST     ((u32)(TPM_E_NON_FATAL + 2))
-
-static const struct {
-	u8 buffer[12];
-} tpm_resume_cmd = {
-	{ 0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x99, 0x0, 0x2 }
-};
-
-static const struct {
-	u8 buffer[12];
-} tpm_startup_cmd = {
-	{0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x99, 0x0, 0x1 }
-};
-
-static const struct {
-	u8 buffer[12];
-} tpm_deactivate_cmd = {
-	{0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x99, 0x0, 0x3 }
-};
-
-static const struct {
-	u8 buffer[10];
-} tpm_continueselftest_cmd = {
-	{ 0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x53 }
-};
-
-static inline void FromTpmUint32(const u8 * buffer, u32 * x)
-{
-	*x = ((buffer[0] << 24) |
-	      (buffer[1] << 16) | (buffer[2] << 8) | buffer[3]);
-}
-
-static inline int TpmCommandSize(const u8 * buffer)
-{
-	u32 size;
-	FromTpmUint32(buffer + sizeof(u16), &size);
-	return (int)size;
-}
-
-/* Gets the code field of a TPM command. */
-static inline int TpmCommandCode(const u8 * buffer)
-{
-	u32 code;
-	FromTpmUint32(buffer + sizeof(u16) + sizeof(u32), &code);
-	return code;
-}
-
-/* Gets the return code field of a TPM result. */
-static inline int TpmReturnCode(const u8 * buffer)
-{
-	return TpmCommandCode(buffer);
-}
-
-/* Like TlclSendReceive below, but do not retry if NEEDS_SELFTEST or
- * DOING_SELFTEST errors are returned.
- */
-static u32 TlclSendReceiveNoRetry(const u8 * request,
-				  u8 * response, int max_length)
-{
-	size_t response_length = max_length;
-	u32 result;
-
-#ifdef EXTRA_LOGGING
-	printk(BIOS_DEBUG, "TPM: command: %x%x %x%x%x%x %x%x%x%x\n",
-	       request[0], request[1],
-	       request[2], request[3], request[4], request[5],
-	       request[6], request[7], request[8], request[9]);
-#endif
-
-	result = TPM_SUCCESS;
-	if (tis_sendrecv
-	    (request, TpmCommandSize(request), response, &response_length))
-		result = TPM_E_IOERROR;
-
-	if (0 != result) {
-		/* Communication with TPM failed, so response is garbage */
-		printk(BIOS_DEBUG,
-		       "TPM: command 0x%x send/receive failed: 0x%x\n",
-		       TpmCommandCode(request), result);
-		return TPM_E_COMMUNICATION_ERROR;
-	}
-	/* Otherwise, use the result code from the response */
-	result = TpmReturnCode(response);
-
-/* TODO: add paranoia about returned response_length vs. max_length
- * (and possibly expected length from the response header).  See
- * crosbug.com/17017 */
-
-#ifdef EXTRA_LOGGING
-	printk(BIOS_DEBUG, "TPM: response: %x%x %x%x%x%x %x%x%x%x\n",
-	       response[0], response[1],
-	       response[2], response[3], response[4], response[5],
-	       response[6], response[7], response[8], response[9]);
-#endif
-
-	printk(BIOS_DEBUG, "TPM: command 0x%x returned 0x%x\n",
-	       TpmCommandCode(request), result);
-
-	return result;
-}
-
-static inline u32 TlclContinueSelfTest(void)
-{
-	u8 response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
-	printk(BIOS_DEBUG, "TPM: Continue self test\n");
-	/* Call the No Retry version of SendReceive to avoid recursion. */
-	return TlclSendReceiveNoRetry(tpm_continueselftest_cmd.buffer,
-				      response, sizeof(response));
-}
-
-/* Sends a TPM command and gets a response.  Returns 0 if success or the TPM
- * error code if error. In the firmware, waits for the self test to complete
- * if needed. In the host, reports the first error without retries. */
-static u32 TlclSendReceive(const u8 * request, u8 * response, int max_length)
-{
-	u32 result = TlclSendReceiveNoRetry(request, response, max_length);
-	/* When compiling for the firmware, hide command failures due to the self
-	 * test not having run or completed. */
-	/* If the command fails because the self test has not completed, try it
-	 * again after attempting to ensure that the self test has completed. */
-	if (result == TPM_E_NEEDS_SELFTEST || result == TPM_E_DOING_SELFTEST) {
-		result = TlclContinueSelfTest();
-		if (result != TPM_SUCCESS) {
-			return result;
-		}
-#if defined(TPM_BLOCKING_CONTINUESELFTEST) || defined(VB_RECOVERY_MODE)
-		/* Retry only once */
-		result = TlclSendReceiveNoRetry(request, response, max_length);
-#else
-		/* This needs serious testing.  The TPM specification says:
-		 * "iii. The caller MUST wait for the actions of
-		 * TPM_ContinueSelfTest to complete before reissuing the
-		 * command C1."  But, if ContinueSelfTest is non-blocking, how
-		 * do we know that the actions have completed other than trying
-		 * again? */
-		do {
-			result =
-			    TlclSendReceiveNoRetry(request, response,
-						   max_length);
-		} while (result == TPM_E_DOING_SELFTEST);
-#endif
-	}
-
-	return result;
-}
-
-void init_tpm(int s3resume)
-{
-	u32 result;
-	u8 response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
-
-	if (CONFIG_TPM_DEACTIVATE) {
-		printk(BIOS_SPEW, "TPM: Deactivate\n");
-		result = TlclSendReceive(tpm_deactivate_cmd.buffer,
-					response, sizeof(response));
-		if (result == TPM_SUCCESS) {
-			printk(BIOS_SPEW, "TPM: OK.\n");
-			return;
-		}
-
-		printk(BIOS_ERR, "TPM: Error code 0x%x.\n", result);
-		return;
-	}
-
-	/* Doing TPM startup when we're not coming in on the S3 resume path
-	 * saves us roughly 20ms in boot time only. This does not seem to
-	 * be worth an API change to vboot_reference-firmware right now, so
-	 * let's keep the code around, but just bail out early:
-	 */
-	if (s3resume ? CONFIG_NO_TPM_RESUME
-	    : CONFIG_SKIP_TPM_STARTUP_ON_NORMAL_BOOT)
-		return;
-
-	printk(BIOS_DEBUG, "TPM initialization.\n");
-
-	printk(BIOS_SPEW, "TPM: Init\n");
-	if (tis_init())
-		return;
-
-	printk(BIOS_SPEW, "TPM: Open\n");
-	if (tis_open())
-		return;
-
-
-	if (s3resume) {
-		/* S3 Resume */
-		printk(BIOS_SPEW, "TPM: Resume\n");
-		result = TlclSendReceive(tpm_resume_cmd.buffer,
-					response, sizeof(response));
-		if (result == TPM_E_INVALID_POSTINIT) {
-			/* We're on a platform where the TPM maintains power
-			 * in S3, so it's already initialized.
-			 */
-			printk(BIOS_DEBUG, "TPM: Already initialized.\n");
-			return;
-		}
-	} else {
-		printk(BIOS_SPEW, "TPM: Startup\n");
-		result = TlclSendReceive(tpm_startup_cmd.buffer,
-					response, sizeof(response));
-	}
-
-	if (result == TPM_SUCCESS) {
-		printk(BIOS_SPEW, "TPM: OK.\n");
-		return;
-	}
-
-	printk(BIOS_ERR, "TPM: Error code 0x%x.\n", result);
-
-	if (CONFIG_TPM_INIT_FAILURE_IS_FATAL) {
-		printk(BIOS_ERR, "Hard reset!\n");
-		post_code(POST_TPM_FAILURE);
-		if (IS_ENABLED(CONFIG_CONSOLE_CBMEM_DUMP_TO_UART))
-			cbmem_dump_console();
-		hard_reset();
-	}
-}
diff --git a/src/drivers/pc80/tpm/tpm.c b/src/drivers/pc80/tpm/tpm.c
index ba2561d..620a77d 100644
--- a/src/drivers/pc80/tpm/tpm.c
+++ b/src/drivers/pc80/tpm/tpm.c
@@ -32,7 +32,7 @@
 #include <delay.h>
 #include <arch/io.h>
 #include <console/console.h>
-#include <tpm.h>
+#include <pc80/tpm.h>
 #include <arch/early_variables.h>
 #include <device/pnp.h>
 #include "chip.h"
diff --git a/src/drivers/pc80/tpm/tspi/Makefile.inc b/src/drivers/pc80/tpm/tspi/Makefile.inc
new file mode 100644
index 0000000..7f4b9ac
--- /dev/null
+++ b/src/drivers/pc80/tpm/tspi/Makefile.inc
@@ -0,0 +1,4 @@
+ifneq ($(CONFIG_CHROMEOS),y)
+romstage-$(CONFIG_LPC_TPM) += tspi.c
+ramstage-$(CONFIG_LPC_TPM) += tspi.c
+endif
\ No newline at end of file
diff --git a/src/drivers/pc80/tpm/tspi/tspi.c b/src/drivers/pc80/tpm/tspi/tspi.c
new file mode 100644
index 0000000..fd3e864
--- /dev/null
+++ b/src/drivers/pc80/tpm/tspi/tspi.c
@@ -0,0 +1,95 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2015 The Chromium OS Authors. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc.
+ */
+
+#include <console/cbmem_console.h>
+#include <console/console.h>
+#include <reset.h>
+
+#include <pc80/tpm/tss.h>
+#include <pc80/tpm/tspi.h>
+
+void init_tpm(int s3resume)
+{
+	u32 result = 0;
+
+	if (CONFIG_TPM_DEACTIVATE) {
+		printk(BIOS_SPEW, "TPM: Deactivate\n");
+
+		result = tlcl_set_deactivated(1);
+		if(result != TPM_SUCCESS) {
+			printk(BIOS_ERR, "TPM: Error code 0x%x.\n", result);
+			return;
+		}
+	}
+
+	/* Doing TPM startup when we're not coming in on the S3 resume path
+	 * saves us roughly 20ms in boot time only. This does not seem to
+	 * be worth an API change to vboot_reference-firmware right now, so
+	 * let's keep the code around, but just bail out early:
+	 */
+	if (s3resume ? CONFIG_NO_TPM_RESUME
+	    : CONFIG_SKIP_TPM_STARTUP_ON_NORMAL_BOOT)
+		return;
+
+	printk(BIOS_DEBUG, "TPM initialization.\n");
+
+	if(tlcl_lib_init() != TPM_SUCCESS) {
+		printk(BIOS_ERR, "TPM: Error code 0x%x.\n", result);
+		return;
+	}
+
+	if (s3resume) {
+		/* S3 Resume */
+		printk(BIOS_SPEW, "TPM: Resume\n");
+
+		result = tlcl_resume();
+		if(result == TPM_E_INVALID_POSTINIT) {
+			/* We're on a platform where the TPM maintains power
+			 * in S3, so it's already initialized.
+			 */
+			printk(BIOS_DEBUG, "TPM: Already initialized.\n");
+			return;
+		} else if(result != TPM_SUCCESS) {
+			printk(BIOS_ERR, "TPM: Error code 0x%x.\n", result);
+			return;
+		}
+	} else {
+		printk(BIOS_SPEW, "TPM: Startup\n");
+		result = tlcl_startup();
+		if(result != TPM_SUCCESS) {
+			printk(BIOS_ERR, "TPM: Error code 0x%x.\n", result);
+			return;
+		}
+	}
+
+	if (result == TPM_SUCCESS) {
+		printk(BIOS_SPEW, "TPM: OK.\n");
+		return;
+	}
+
+	printk(BIOS_ERR, "TPM: Error code 0x%x.\n", result);
+
+	if (CONFIG_TPM_INIT_FAILURE_IS_FATAL) {
+		printk(BIOS_ERR, "Hard reset!\n");
+		post_code(POST_TPM_FAILURE);
+		if (IS_ENABLED(CONFIG_CONSOLE_CBMEM_DUMP_TO_UART))
+			cbmem_dump_console();
+		hard_reset();
+	}
+}
\ No newline at end of file
diff --git a/src/drivers/pc80/tpm/tss/Makefile.inc b/src/drivers/pc80/tpm/tss/Makefile.inc
new file mode 100644
index 0000000..65666bb
--- /dev/null
+++ b/src/drivers/pc80/tpm/tss/Makefile.inc
@@ -0,0 +1,11 @@
+ifneq ($(CONFIG_CHROMEOS),y)
+romstage-$(CONFIG_LPC_TPM) += tss.c
+ramstage-$(CONFIG_LPC_TPM) += tss.c
+endif
+
+ifeq ($(MOCK_TPM),1)
+libverstage-y += mocked_tss.c
+else
+libverstage-y += tss.c
+endif
+
diff --git a/src/drivers/pc80/tpm/tss/mocked_tss.c b/src/drivers/pc80/tpm/tss/mocked_tss.c
new file mode 100644
index 0000000..761def2
--- /dev/null
+++ b/src/drivers/pc80/tpm/tss/mocked_tss.c
@@ -0,0 +1,136 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2015 The ChromiumOS Authors.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc.
+ */
+
+#include <pc80/tpm/tss.h>
+
+#ifdef FOR_TEST
+#include <stdio.h>
+#define VBDEBUG(format, args...) printf(format, ## args)
+#else
+#include <console/console.h>
+#define VBDEBUG(format, args...) printk(BIOS_DEBUG, format, ## args)
+#endif
+
+uint32_t tlcl_lib_init(void) {
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_startup(void) {
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_resume(void) {
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_self_test_full(void)
+{
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_continue_self_test(void)
+{
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_define_space(uint32_t index, uint32_t perm, uint32_t size)
+{
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_write(uint32_t index, const void* data, uint32_t length)
+{
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_read(uint32_t index, void* data, uint32_t length)
+{
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+
+uint32_t tlcl_assert_physical_presence(void) {
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_physical_presence_cmd_enable(void) {
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_finalize_physical_presence(void) {
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_set_nv_locked(void) {
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_force_clear(void) {
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_set_enable(void) {
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_set_deactivated(uint8_t flag)
+{
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_get_permanent_flags(TPM_PERMANENT_FLAGS* pflags)
+{
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_get_flags(uint8_t* disable, uint8_t* deactivated,
+                        uint8_t *nvlocked)
+{
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_set_global_lock(void)
+{
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
+
+uint32_t tlcl_extend(int pcr_num, const uint8_t* in_digest,
+                     uint8_t* out_digest)
+{
+	VBDEBUG("MOCK_TPM: %s\n", __func__);
+	return TPM_E_NO_DEVICE;
+}
diff --git a/src/drivers/pc80/tpm/tss/tss.c b/src/drivers/pc80/tpm/tss/tss.c
new file mode 100644
index 0000000..1bbbed9
--- /dev/null
+++ b/src/drivers/pc80/tpm/tss/tss.c
@@ -0,0 +1,331 @@
+/* Copyright (c) 2012 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.
+ */
+
+/* A lightweight TPM command library.
+ *
+ * The general idea is that TPM commands are array of bytes whose
+ * fields are mostly compile-time constant.  The goal is to build much
+ * of the commands at compile time (or build time) and change some of
+ * the fields at run time as needed.  The code in
+ * utility/tlcl_generator.c builds structures containing the commands,
+ * as well as the offsets of the fields that need to be set at run
+ * time.
+ */
+
+#include <assert.h>
+#include <string.h>
+#include <pc80/tpm/tss.h>
+#include <pc80/tpm.h>
+#include <console/cbmem_console.h>
+#include <console/console.h>
+#include <reset.h>
+#include "tss_internal.h"
+#include "tss_structures.h"
+
+#ifdef FOR_TEST
+#include <stdio.h>
+#define VBDEBUG(format, args...) printf(format, ## args)
+#else
+#include <console/console.h>
+#define VBDEBUG(format, args...) printk(BIOS_DEBUG, format, ## args)
+#endif
+
+#define UNKNOWN_ERROR 0x10000001 // see VBOOT2 error codes..
+
+static int tpm_send_receive(const uint8_t *request,
+				uint32_t request_length,
+				uint8_t *response,
+				uint32_t *response_length)
+{
+	size_t len = *response_length;
+	if (tis_sendrecv(request, request_length, response, &len))
+		return UNKNOWN_ERROR;
+	/* check 64->32bit overflow and (re)check response buffer overflow */
+	if (len > *response_length)
+		return UNKNOWN_ERROR;
+	*response_length = len;
+	return TPM_SUCCESS;
+}
+
+/* Sets the size field of a TPM command. */
+static inline void set_tpm_command_size(uint8_t* buffer, uint32_t size) {
+	to_tpm_uint32(buffer + sizeof(uint16_t), size);
+}
+
+/* Gets the size field of a TPM command. */
+__attribute__((unused))
+static inline int tpm_command_size(const uint8_t* buffer) {
+	uint32_t size;
+	from_tpm_uint32(buffer + sizeof(uint16_t), &size);
+	return (int) size;
+}
+
+/* Gets the code field of a TPM command. */
+static inline int tpm_command_code(const uint8_t* buffer) {
+	uint32_t code;
+	from_tpm_uint32(buffer + sizeof(uint16_t) + sizeof(uint32_t), &code);
+	return code;
+}
+
+/* Gets the return code field of a TPM result. */
+static inline int tpm_return_code(const uint8_t* buffer) {
+	return tpm_command_code(buffer);
+}
+
+/* Like TlclSendReceive below, but do not retry if NEEDS_SELFTEST or
+ * DOING_SELFTEST errors are returned.
+ */
+static uint32_t tlcl_send_receive_no_retry(const uint8_t* request,
+                                           uint8_t* response, int max_length) {
+	uint32_t response_length = max_length;
+	uint32_t result;
+
+	result = tpm_send_receive(request, tpm_command_size(request),
+					response, &response_length);
+	if (0 != result) {
+		/* Communication with TPM failed, so response is garbage */
+		VBDEBUG("TPM: command 0x%x send/receive failed: 0x%x\n",
+			tpm_command_code(request), result);
+		return result;
+	}
+	/* Otherwise, use the result code from the response */
+	result = tpm_return_code(response);
+
+	/* TODO: add paranoia about returned response_length vs. max_length
+	 * (and possibly expected length from the response header).  See
+	 * crosbug.com/17017 */
+
+	VBDEBUG("TPM: command 0x%x returned 0x%x\n",
+		tpm_command_code(request), result);
+
+return result;
+}
+
+
+/* Sends a TPM command and gets a response.  Returns 0 if success or the TPM
+ * error code if error. Waits for the self test to complete if needed. */
+uint32_t tlcl_send_receive(const uint8_t* request, uint8_t* response,
+			   int max_length) {
+	uint32_t result = tlcl_send_receive_no_retry(request, response,
+						     max_length);
+	/* If the command fails because the self test has not completed, try it
+	 * again after attempting to ensure that the self test has completed. */
+	if (result == TPM_E_NEEDS_SELFTEST || result == TPM_E_DOING_SELFTEST) {
+		result = tlcl_continue_self_test();
+		if (result != TPM_SUCCESS)
+			return result;
+#if defined(TPM_BLOCKING_CONTINUESELFTEST) || defined(VB_RECOVERY_MODE)
+		/* Retry only once */
+		result = tlcl_send_receive_no_retry(request, response,
+		                                    max_length);
+#else
+		/* This needs serious testing. The TPM specification says: "iii.
+		 * The caller MUST wait for the actions of TPM_ContinueSelfTest
+		 * to complete before reissuing the command C1."  But, if
+		 * ContinueSelfTest is non-blocking, how do we know that the
+		 * actions have completed other than trying again? */
+		do {
+			result = tlcl_send_receive_no_retry(request, response,
+			                                    max_length);
+		} while (result == TPM_E_DOING_SELFTEST);
+#endif
+	}
+	return result;
+}
+
+/* Sends a command and returns the error code. */
+static uint32_t send(const uint8_t* command) {
+	uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
+	return tlcl_send_receive(command, response, sizeof(response));
+}
+
+/* Exported functions. */
+
+uint32_t tlcl_lib_init(void) {
+	if (tis_init())
+		return UNKNOWN_ERROR;
+	if (tis_open())
+		return UNKNOWN_ERROR;
+	return TPM_SUCCESS;
+}
+
+uint32_t tlcl_startup(void) {
+	VBDEBUG("TPM: Startup\n");
+	return send(tpm_startup_cmd.buffer);
+}
+
+uint32_t tlcl_resume(void) {
+  VBDEBUG("TPM: Resume\n");
+  return send(tpm_resume_cmd.buffer);
+}
+
+uint32_t tlcl_self_test_full(void)
+{
+	VBDEBUG("TPM: Self test full\n");
+	return send(tpm_selftestfull_cmd.buffer);
+}
+
+uint32_t tlcl_continue_self_test(void)
+{
+	uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
+	VBDEBUG("TPM: Continue self test\n");
+	/* Call the No Retry version of SendReceive to avoid recursion. */
+	return tlcl_send_receive_no_retry(tpm_continueselftest_cmd.buffer,
+	                                  response, sizeof(response));
+}
+
+uint32_t tlcl_define_space(uint32_t index, uint32_t perm, uint32_t size)
+{
+	struct s_tpm_nv_definespace_cmd cmd;
+	VBDEBUG("TPM: TlclDefineSpace(0x%x, 0x%x, %d)\n", index, perm, size);
+	memcpy(&cmd, &tpm_nv_definespace_cmd, sizeof(cmd));
+	to_tpm_uint32(cmd.buffer + tpm_nv_definespace_cmd.index, index);
+	to_tpm_uint32(cmd.buffer + tpm_nv_definespace_cmd.perm, perm);
+	to_tpm_uint32(cmd.buffer + tpm_nv_definespace_cmd.size, size);
+	return send(cmd.buffer);
+}
+
+uint32_t tlcl_write(uint32_t index, const void* data, uint32_t length)
+{
+	struct s_tpm_nv_write_cmd cmd;
+	uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
+	const int total_length =
+			kTpmRequestHeaderLength + kWriteInfoLength + length;
+
+	VBDEBUG("TPM: tlcl_write(0x%x, %d)\n", index, length);
+	memcpy(&cmd, &tpm_nv_write_cmd, sizeof(cmd));
+	assert(total_length <= TPM_LARGE_ENOUGH_COMMAND_SIZE);
+	set_tpm_command_size(cmd.buffer, total_length);
+
+	to_tpm_uint32(cmd.buffer + tpm_nv_write_cmd.index, index);
+	to_tpm_uint32(cmd.buffer + tpm_nv_write_cmd.length, length);
+	memcpy(cmd.buffer + tpm_nv_write_cmd.data, data, length);
+
+	return tlcl_send_receive(cmd.buffer, response, sizeof(response));
+}
+
+uint32_t tlcl_read(uint32_t index, void* data, uint32_t length)
+{
+	struct s_tpm_nv_read_cmd cmd;
+	uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
+	uint32_t result_length;
+	uint32_t result;
+
+	VBDEBUG("TPM: tlcl_read(0x%x, %d)\n", index, length);
+	memcpy(&cmd, &tpm_nv_read_cmd, sizeof(cmd));
+	to_tpm_uint32(cmd.buffer + tpm_nv_read_cmd.index, index);
+	to_tpm_uint32(cmd.buffer + tpm_nv_read_cmd.length, length);
+
+	result = tlcl_send_receive(cmd.buffer, response, sizeof(response));
+	if (result == TPM_SUCCESS && length > 0) {
+		uint8_t* nv_read_cursor = response + kTpmResponseHeaderLength;
+		from_tpm_uint32(nv_read_cursor, &result_length);
+		nv_read_cursor += sizeof(uint32_t);
+		memcpy(data, nv_read_cursor, result_length);
+	}
+
+	return result;
+}
+
+
+uint32_t tlcl_assert_physical_presence(void) {
+	VBDEBUG("TPM: Asserting physical presence\n");
+	return send(tpm_ppassert_cmd.buffer);
+}
+
+uint32_t tlcl_physical_presence_cmd_enable(void) {
+	VBDEBUG("TPM: Enable the physical presence command\n");
+	return send(tpm_ppenable_cmd.buffer);
+}
+
+uint32_t tlcl_finalize_physical_presence(void) {
+	VBDEBUG("TPM: Enable PP cmd, disable HW pp, and set lifetime lock\n");
+	return send(tpm_finalizepp_cmd.buffer);
+}
+
+uint32_t tlcl_set_nv_locked(void) {
+	VBDEBUG("TPM: Set NV locked\n");
+	return tlcl_define_space(TPM_NV_INDEX_LOCK, 0, 0);
+}
+
+uint32_t tlcl_force_clear(void) {
+	VBDEBUG("TPM: Force clear\n");
+	return send(tpm_forceclear_cmd.buffer);
+}
+
+uint32_t tlcl_set_enable(void) {
+	VBDEBUG("TPM: Enabling TPM\n");
+	return send(tpm_physicalenable_cmd.buffer);
+}
+
+uint32_t tlcl_set_deactivated(uint8_t flag)
+{
+	struct s_tpm_physicalsetdeactivated_cmd cmd;
+	VBDEBUG("TPM: SetDeactivated(%d)\n", flag);
+	memcpy(&cmd, &tpm_physicalsetdeactivated_cmd, sizeof(cmd));
+	*(cmd.buffer + cmd.deactivated) = flag;
+	return send(cmd.buffer);
+}
+
+uint32_t tlcl_get_permanent_flags(TPM_PERMANENT_FLAGS* pflags)
+{
+	uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
+	uint32_t size;
+	uint32_t result = tlcl_send_receive(tpm_getflags_cmd.buffer, response,
+	                                    sizeof(response));
+	if (result != TPM_SUCCESS)
+		return result;
+	from_tpm_uint32(response + kTpmResponseHeaderLength, &size);
+	assert(size == sizeof(TPM_PERMANENT_FLAGS));
+	memcpy(pflags, response + kTpmResponseHeaderLength + sizeof(size),
+	       sizeof(TPM_PERMANENT_FLAGS));
+	return result;
+}
+
+uint32_t tlcl_get_flags(uint8_t* disable, uint8_t* deactivated,
+                        uint8_t *nvlocked)
+{
+	TPM_PERMANENT_FLAGS pflags;
+	uint32_t result = tlcl_get_permanent_flags(&pflags);
+	if (result == TPM_SUCCESS) {
+		if (disable)
+			*disable = pflags.disable;
+		if (deactivated)
+			*deactivated = pflags.deactivated;
+		if (nvlocked)
+			*nvlocked = pflags.nvLocked;
+		VBDEBUG("TPM: flags disable=%d, deactivated=%d, nvlocked=%d\n",
+			pflags.disable, pflags.deactivated, pflags.nvLocked);
+	}
+	return result;
+}
+
+uint32_t tlcl_set_global_lock(void)
+{
+	uint32_t x;
+	VBDEBUG("TPM: Set global lock\n");
+	return tlcl_write(TPM_NV_INDEX0, (uint8_t*) &x, 0);
+}
+
+uint32_t tlcl_extend(int pcr_num, const uint8_t* in_digest,
+                     uint8_t* out_digest)
+{
+	struct s_tpm_extend_cmd cmd;
+	uint8_t response[kTpmResponseHeaderLength + kPcrDigestLength];
+	uint32_t result;
+
+	memcpy(&cmd, &tpm_extend_cmd, sizeof(cmd));
+	to_tpm_uint32(cmd.buffer + tpm_extend_cmd.pcrNum, pcr_num);
+	memcpy(cmd.buffer + cmd.inDigest, in_digest, kPcrDigestLength);
+
+	result = tlcl_send_receive(cmd.buffer, response, sizeof(response));
+	if (result != TPM_SUCCESS)
+		return result;
+
+	if (out_digest)
+		memcpy(out_digest, response + kTpmResponseHeaderLength,
+		       kPcrDigestLength);
+	return result;
+}
\ No newline at end of file
diff --git a/src/drivers/pc80/tpm/tss/tss_internal.h b/src/drivers/pc80/tpm/tss/tss_internal.h
new file mode 100644
index 0000000..66ae640
--- /dev/null
+++ b/src/drivers/pc80/tpm/tss/tss_internal.h
@@ -0,0 +1,58 @@
+/* Copyright (c) 2010 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.
+ */
+
+#pragma once
+
+/*
+ * These numbers derive from adding the sizes of command fields as shown in the
+ * TPM commands manual.
+ */
+#define kTpmRequestHeaderLength 10
+#define kTpmResponseHeaderLength 10
+#define kTpmReadInfoLength 12
+#define kEncAuthLength 20
+#define kPcrDigestLength 20
+
+
+/*
+ * Conversion functions.  to_tpm_TYPE puts a value of type TYPE into a TPM
+ * command buffer. from_tpm_TYPE gets a value of type TYPE from a TPM command
+ * buffer into a variable.
+ */
+__attribute__((unused))
+static inline void to_tpm_uint32(uint8_t *buffer, uint32_t x) {
+	buffer[0] = (uint8_t)(x >> 24);
+	buffer[1] = (uint8_t)((x >> 16) & 0xff);
+	buffer[2] = (uint8_t)((x >> 8) & 0xff);
+	buffer[3] = (uint8_t)(x & 0xff);
+}
+
+/*
+ * See comment for above function.
+ */
+__attribute__((unused))
+static inline void from_tpm_uint32(const uint8_t *buffer, uint32_t *x) {
+	*x = ((buffer[0] << 24) |
+	      (buffer[1] << 16) |
+	      (buffer[2] << 8) |
+	      buffer[3]);
+}
+
+/*
+ * See comment for above function.
+ */
+__attribute__((unused))
+static inline void to_tpm_uint16(uint8_t *buffer, uint16_t x) {
+	buffer[0] = (uint8_t)(x >> 8);
+	buffer[1] = (uint8_t)(x & 0xff);
+}
+
+/*
+ * See comment for above function.
+ */
+__attribute__((unused))
+static inline void from_tpm_uint16(const uint8_t *buffer, uint16_t *x) {
+	*x = (buffer[0] << 8) | buffer[1];
+}
\ No newline at end of file
diff --git a/src/drivers/pc80/tpm/tss/tss_structures.h b/src/drivers/pc80/tpm/tss/tss_structures.h
new file mode 100644
index 0000000..36c1bb9
--- /dev/null
+++ b/src/drivers/pc80/tpm/tss/tss_structures.h
@@ -0,0 +1,138 @@
+/* This file is automatically generated */
+
+const struct s_tpm_extend_cmd{
+  uint8_t buffer[34];
+  uint16_t pcrNum;
+  uint16_t inDigest;
+} tpm_extend_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0x0, 0x14, },
+10, 14, };
+
+const struct s_tpm_get_random_cmd{
+  uint8_t buffer[14];
+  uint16_t bytesRequested;
+} tpm_get_random_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xe, 0x0, 0x0, 0x0, 0x46, },
+10, };
+
+const struct s_tpm_getownership_cmd{
+  uint8_t buffer[22];
+} tpm_getownership_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x16, 0x0, 0x0, 0x0, 0x65, 0x0, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x1, 0x11, },
+};
+
+const struct s_tpm_getpermissions_cmd{
+  uint8_t buffer[22];
+  uint16_t index;
+} tpm_getpermissions_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x16, 0x0, 0x0, 0x0, 0x65, 0x0, 0x0, 0x0, 0x11, 0x0, 0x0, 0x0, 0x4, },
+18, };
+
+const struct s_tpm_getstclearflags_cmd{
+  uint8_t buffer[22];
+} tpm_getstclearflags_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x16, 0x0, 0x0, 0x0, 0x65, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x1, 0x9, },
+};
+
+const struct s_tpm_getflags_cmd{
+  uint8_t buffer[22];
+} tpm_getflags_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x16, 0x0, 0x0, 0x0, 0x65, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x1, 0x8, },
+};
+
+const struct s_tpm_physicalsetdeactivated_cmd{
+  uint8_t buffer[11];
+  uint16_t deactivated;
+} tpm_physicalsetdeactivated_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xb, 0x0, 0x0, 0x0, 0x72, },
+10, };
+
+const struct s_tpm_physicalenable_cmd{
+  uint8_t buffer[10];
+} tpm_physicalenable_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x6f, },
+};
+
+const struct s_tpm_physicaldisable_cmd{
+  uint8_t buffer[10];
+} tpm_physicaldisable_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x70, },
+};
+
+const struct s_tpm_forceclear_cmd{
+  uint8_t buffer[10];
+} tpm_forceclear_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x5d, },
+};
+
+const struct s_tpm_readpubek_cmd{
+  uint8_t buffer[30];
+} tpm_readpubek_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x1e, 0x0, 0x0, 0x0, 0x7c, },
+};
+
+const struct s_tpm_continueselftest_cmd{
+  uint8_t buffer[10];
+} tpm_continueselftest_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x53, },
+};
+
+const struct s_tpm_selftestfull_cmd{
+  uint8_t buffer[10];
+} tpm_selftestfull_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x50, },
+};
+
+const struct s_tpm_resume_cmd{
+  uint8_t buffer[12];
+} tpm_resume_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x99, 0x0, 0x2, },
+};
+
+const struct s_tpm_savestate_cmd{
+  uint8_t buffer[10];
+} tpm_savestate_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x98, },
+};
+
+const struct s_tpm_startup_cmd{
+  uint8_t buffer[12];
+} tpm_startup_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x99, 0x0, 0x1, },
+};
+
+const struct s_tpm_finalizepp_cmd{
+  uint8_t buffer[12];
+} tpm_finalizepp_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x40, 0x0, 0x0, 0xa, 0x2, 0xa0, },
+};
+
+const struct s_tpm_pplock_cmd{
+  uint8_t buffer[12];
+} tpm_pplock_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x40, 0x0, 0x0, 0xa, 0x0, 0x4, },
+};
+
+const struct s_tpm_ppenable_cmd{
+  uint8_t buffer[12];
+} tpm_ppenable_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x40, 0x0, 0x0, 0xa, 0x0, 0x20, },
+};
+
+const struct s_tpm_ppassert_cmd{
+  uint8_t buffer[12];
+} tpm_ppassert_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x40, 0x0, 0x0, 0xa, 0x0, 0x8, },
+};
+
+const struct s_tpm_pcr_read_cmd{
+  uint8_t buffer[14];
+  uint16_t pcrNum;
+} tpm_pcr_read_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xe, 0x0, 0x0, 0x0, 0x15, },
+10, };
+
+const struct s_tpm_nv_read_cmd{
+  uint8_t buffer[22];
+  uint16_t index;
+  uint16_t length;
+} tpm_nv_read_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x16, 0x0, 0x0, 0x0, 0xcf, },
+10, 18, };
+
+const struct s_tpm_nv_write_cmd{
+  uint8_t buffer[256];
+  uint16_t index;
+  uint16_t length;
+  uint16_t data;
+} tpm_nv_write_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcd, },
+10, 18, 22, };
+
+const struct s_tpm_nv_definespace_cmd{
+  uint8_t buffer[101];
+  uint16_t index;
+  uint16_t perm;
+  uint16_t size;
+} tpm_nv_definespace_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x65, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x18, 0, 0, 0, 0, 0x0, 0x3, 0, 0, 0, 0x1f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0, 0x3, 0, 0, 0, 0x1f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0, 0x17, },
+12, 70, 77, };
+
+const int kWriteInfoLength = 12;
+const int kNvDataPublicPermissionsOffset = 60;
diff --git a/src/include/antirollback.h b/src/include/antirollback.h
index 5ba36f7..5f5c53c 100644
--- a/src/include/antirollback.h
+++ b/src/include/antirollback.h
@@ -9,7 +9,7 @@
 #ifndef ANTIROLLBACK_H_
 #define ANTIROLLBACK_H_
 
-#include "tpm_lite/tss_constants.h"
+#include <pc80/tpm/tss_constants.h>
 
 struct vb2_context;
 enum vb2_pcr_digest;
diff --git a/src/include/pc80/tpm.h b/src/include/pc80/tpm.h
new file mode 100644
index 0000000..51135a5
--- /dev/null
+++ b/src/include/pc80/tpm.h
@@ -0,0 +1,66 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright 2011 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc.
+ */
+
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+
+/*
+ * tis_init()
+ *
+ * Initialize the TPM device. Returns 0 on success or -1 on
+ * failure (in case device probing did not succeed).
+ */
+int tis_init(void);
+
+/*
+ * tis_open()
+ *
+ * Requests access to locality 0 for the caller. After all commands have been
+ * completed the caller is supposed to call tis_close().
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+int tis_open(void);
+
+/*
+ * tis_close()
+ *
+ * terminate the currect session with the TPM by releasing the locked
+ * locality. Returns 0 on success of -1 on failure (in case lock
+ * removal did not succeed).
+ */
+int tis_close(void);
+
+/*
+ * tis_sendrecv()
+ *
+ * Send the requested data to the TPM and then try to get its response
+ *
+ * @sendbuf - buffer of the data to send
+ * @send_size size of the data to send
+ * @recvbuf - memory to save the response to
+ * @recv_len - pointer to the size of the response buffer
+ *
+ * Returns 0 on success (and places the number of response bytes at recv_len)
+ * or -1 on failure.
+ */
+int tis_sendrecv(const u8 *sendbuf, size_t send_size, u8 *recvbuf,
+			size_t *recv_len);
\ No newline at end of file
diff --git a/src/include/pc80/tpm/tspi.h b/src/include/pc80/tpm/tspi.h
new file mode 100644
index 0000000..d6bcd4a
--- /dev/null
+++ b/src/include/pc80/tpm/tspi.h
@@ -0,0 +1,23 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2015 The Chromium OS Authors. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc.
+ */
+
+/**
+ * TSPI Implementation for coreboot without vboot2
+ */
+void init_tpm(int s3resume);
diff --git a/src/include/pc80/tpm/tss.h b/src/include/pc80/tpm/tss.h
new file mode 100644
index 0000000..cb36b2f
--- /dev/null
+++ b/src/include/pc80/tpm/tss.h
@@ -0,0 +1,133 @@
+/* Copyright (c) 2013 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.
+ */
+
+/*
+ * TPM Lightweight Command Library.
+ *
+ * A low-level library for interfacing to TPM hardware or an emulator.
+ */
+
+#pragma once
+
+#include "tss_constants.h"
+
+/*****************************************************************************/
+/* Functions implemented in tlcl.c */
+
+/**
+ * Call this first.  Returns 0 if success, nonzero if error.
+ */
+uint32_t tlcl_lib_init(void);
+
+/**
+ * Perform a raw TPM request/response transaction.
+ */
+uint32_t tlcl_send_receive(const uint8_t *request, uint8_t *response,
+                         int max_length);
+
+/* Commands */
+
+/**
+ * Send a TPM_Startup(ST_CLEAR).  The TPM error code is returned (0 for
+ * success).
+ */
+uint32_t tlcl_startup(void);
+
+/**
+ * Resume by sending a TPM_Startup(ST_STATE).  The TPM error code is returned
+ * (0 for success).
+ */
+uint32_t tlcl_resume(void);
+
+/**
+ * Run the self test.
+ *
+ * Note---this is synchronous.  To run this in parallel with other firmware,
+ * use ContinueSelfTest().  The TPM error code is returned.
+ */
+uint32_t tlcl_self_test_full(void);
+
+/**
+ * Run the self test in the background.
+ */
+uint32_t tlcl_continue_self_test(void);
+
+/**
+ * Define a space with permission [perm].  [index] is the index for the space,
+ * [size] the usable data size.  The TPM error code is returned.
+ */
+uint32_t tlcl_define_space(uint32_t index, uint32_t perm, uint32_t size);
+
+/**
+ * Write [length] bytes of [data] to space at [index].  The TPM error code is
+ * returned.
+ */
+uint32_t tlcl_write(uint32_t index, const void *data, uint32_t length);
+
+/**
+ * Read [length] bytes from space at [index] into [data].  The TPM error code
+ * is returned.
+ */
+uint32_t tlcl_read(uint32_t index, void *data, uint32_t length);
+
+/**
+ * Assert physical presence in software.  The TPM error code is returned.
+ */
+uint32_t tlcl_assert_physical_presence(void);
+
+/**
+ * Enable the physical presence command.  The TPM error code is returned.
+ */
+uint32_t tlcl_physical_presence_cmd_enable(void);
+
+/**
+ * Finalize the physical presence settings: sofware PP is enabled, hardware PP
+ * is disabled, and the lifetime lock is set.  The TPM error code is returned.
+ */
+uint32_t tlcl_finalize_physical_presence(void);
+
+/**
+ * Set the nvLocked bit.  The TPM error code is returned.
+ */
+uint32_t tlcl_set_nv_locked(void);
+
+/**
+ * Issue a ForceClear.  The TPM error code is returned.
+ */
+uint32_t tlcl_force_clear(void);
+
+/**
+ * Issue a PhysicalEnable.  The TPM error code is returned.
+ */
+uint32_t tlcl_set_enable(void);
+
+/**
+ * Issue a SetDeactivated.  Pass 0 to activate.  Returns result code.
+ */
+uint32_t tlcl_set_deactivated(uint8_t flag);
+
+/**
+ * Get flags of interest.  Pointers for flags you aren't interested in may
+ * be NULL.  The TPM error code is returned.
+ */
+uint32_t tlcl_get_flags(uint8_t *disable, uint8_t *deactivated,
+                        uint8_t *nvlocked);
+
+/**
+ * Set the bGlobalLock flag, which only a reboot can clear.  The TPM error
+ * code is returned.
+ */
+uint32_t tlcl_set_global_lock(void);
+
+/**
+ * Perform a TPM_Extend.
+ */
+uint32_t tlcl_extend(int pcr_num, const uint8_t *in_digest,
+                     uint8_t *out_digest);
+
+/**
+ * Get the entire set of permanent flags.
+ */
+uint32_t tlcl_get_permanent_flags(TPM_PERMANENT_FLAGS *pflags);
\ No newline at end of file
diff --git a/src/include/pc80/tpm/tss_constants.h b/src/include/pc80/tpm/tss_constants.h
new file mode 100644
index 0000000..b48880d
--- /dev/null
+++ b/src/include/pc80/tpm/tss_constants.h
@@ -0,0 +1,95 @@
+/* Copyright (c) 2013 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.
+ *
+ * Some TPM constants and type definitions for standalone compilation for use
+ * in the firmware
+ */
+
+#pragma once
+
+#include <stdint.h>
+
+#define TPM_MAX_COMMAND_SIZE 4096
+#define TPM_LARGE_ENOUGH_COMMAND_SIZE 256  /* saves space in the firmware */
+#define TPM_PUBEK_SIZE 256
+#define TPM_PCR_DIGEST 20
+
+#define TPM_E_NON_FATAL 0x800
+
+#define TPM_SUCCESS ((uint32_t)0x00000000)
+
+#define TPM_E_AREA_LOCKED           ((uint32_t)0x0000003c)
+#define TPM_E_BADINDEX              ((uint32_t)0x00000002)
+#define TPM_E_BAD_PRESENCE          ((uint32_t)0x0000002d)
+#define TPM_E_IOERROR               ((uint32_t)0x0000001f)
+#define TPM_E_INVALID_POSTINIT      ((uint32_t)0x00000026)
+#define TPM_E_MAXNVWRITES           ((uint32_t)0x00000048)
+#define TPM_E_OWNER_SET             ((uint32_t)0x00000014)
+
+#define TPM_E_NEEDS_SELFTEST ((uint32_t)(TPM_E_NON_FATAL + 1))
+#define TPM_E_DOING_SELFTEST ((uint32_t)(TPM_E_NON_FATAL + 2))
+
+#define TPM_E_ALREADY_INITIALIZED    ((uint32_t)0x00005000)  /* vboot local */
+#define TPM_E_INTERNAL_INCONSISTENCY ((uint32_t)0x00005001)  /* vboot local */
+#define TPM_E_MUST_REBOOT            ((uint32_t)0x00005002)  /* vboot local */
+#define TPM_E_CORRUPTED_STATE        ((uint32_t)0x00005003)  /* vboot local */
+#define TPM_E_COMMUNICATION_ERROR    ((uint32_t)0x00005004)  /* vboot local */
+#define TPM_E_RESPONSE_TOO_LARGE     ((uint32_t)0x00005005)  /* vboot local */
+#define TPM_E_NO_DEVICE              ((uint32_t)0x00005006)  /* vboot local */
+#define TPM_E_INPUT_TOO_SMALL        ((uint32_t)0x00005007)  /* vboot local */
+#define TPM_E_WRITE_FAILURE          ((uint32_t)0x00005008)  /* vboot local */
+#define TPM_E_READ_EMPTY             ((uint32_t)0x00005009)  /* vboot local */
+#define TPM_E_READ_FAILURE           ((uint32_t)0x0000500a)  /* vboot local */
+
+#define TPM_NV_INDEX0 ((uint32_t)0x00000000)
+#define TPM_NV_INDEX_LOCK ((uint32_t)0xffffffff)
+#define TPM_NV_PER_GLOBALLOCK (((uint32_t)1)<<15)
+#define TPM_NV_PER_PPWRITE (((uint32_t)1)<<0)
+#define TPM_NV_PER_READ_STCLEAR (((uint32_t)1)<<31)
+#define TPM_NV_PER_WRITE_STCLEAR (((uint32_t)1)<<14)
+
+#define TPM_TAG_RQU_COMMAND       ((uint16_t) 0xc1)
+#define TPM_TAG_RQU_AUTH1_COMMAND ((uint16_t) 0xc2)
+#define TPM_TAG_RQU_AUTH2_COMMAND ((uint16_t) 0xc3)
+
+#define TPM_TAG_RSP_COMMAND       ((uint16_t) 0xc4)
+#define TPM_TAG_RSP_AUTH1_COMMAND ((uint16_t) 0xc5)
+#define TPM_TAG_RSP_AUTH2_COMMAND ((uint16_t) 0xc6)
+
+typedef uint8_t TSS_BOOL;
+typedef uint16_t TPM_STRUCTURE_TAG;
+
+typedef struct tdTPM_PERMANENT_FLAGS
+{
+	TPM_STRUCTURE_TAG tag;
+	TSS_BOOL disable;
+	TSS_BOOL ownership;
+	TSS_BOOL deactivated;
+	TSS_BOOL readPubek;
+	TSS_BOOL disableOwnerClear;
+	TSS_BOOL allowMaintenance;
+	TSS_BOOL physicalPresenceLifetimeLock;
+	TSS_BOOL physicalPresenceHWEnable;
+	TSS_BOOL physicalPresenceCMDEnable;
+	TSS_BOOL CEKPUsed;
+	TSS_BOOL TPMpost;
+	TSS_BOOL TPMpostLock;
+	TSS_BOOL FIPS;
+	TSS_BOOL Operator;
+	TSS_BOOL enableRevokeEK;
+	TSS_BOOL nvLocked;
+	TSS_BOOL readSRKPub;
+	TSS_BOOL tpmEstablished;
+	TSS_BOOL maintenanceDone;
+	TSS_BOOL disableFullDALogicInfo;
+} TPM_PERMANENT_FLAGS;
+
+typedef struct tdTPM_STCLEAR_FLAGS{
+	TPM_STRUCTURE_TAG tag;
+	TSS_BOOL deactivated;
+	TSS_BOOL disableForceClear;
+	TSS_BOOL physicalPresence;
+	TSS_BOOL physicalPresenceLock;
+	TSS_BOOL bGlobalLock;
+} TPM_STCLEAR_FLAGS;
\ No newline at end of file
diff --git a/src/include/tpm.h b/src/include/tpm.h
deleted file mode 100644
index 9b4db4a..0000000
--- a/src/include/tpm.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * This file is part of the coreboot project.
- *
- * Copyright 2011 Google Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc.
- */
-
-#ifndef TPM_H_
-#define TPM_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-/*
- * tis_init()
- *
- * Initialize the TPM device. Returns 0 on success or -1 on
- * failure (in case device probing did not succeed).
- */
-int tis_init(void);
-
-/*
- * tis_open()
- *
- * Requests access to locality 0 for the caller. After all commands have been
- * completed the caller is supposed to call tis_close().
- *
- * Returns 0 on success, -1 on failure.
- */
-int tis_open(void);
-
-/*
- * tis_close()
- *
- * terminate the currect session with the TPM by releasing the locked
- * locality. Returns 0 on success of -1 on failure (in case lock
- * removal did not succeed).
- */
-int tis_close(void);
-
-/*
- * tis_sendrecv()
- *
- * Send the requested data to the TPM and then try to get its response
- *
- * @sendbuf - buffer of the data to send
- * @send_size size of the data to send
- * @recvbuf - memory to save the response to
- * @recv_len - pointer to the size of the response buffer
- *
- * Returns 0 on success (and places the number of response bytes at recv_len)
- * or -1 on failure.
- */
-int tis_sendrecv(const u8 *sendbuf, size_t send_size, u8 *recvbuf,
-			size_t *recv_len);
-
-void init_tpm(int s3resume);
-
-#endif /* TPM_H_ */
diff --git a/src/include/tpm_lite/tlcl.h b/src/include/tpm_lite/tlcl.h
deleted file mode 100644
index 7724592..0000000
--- a/src/include/tpm_lite/tlcl.h
+++ /dev/null
@@ -1,137 +0,0 @@
-/* Copyright (c) 2013 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.
- */
-
-/*
- * TPM Lightweight Command Library.
- *
- * A low-level library for interfacing to TPM hardware or an emulator.
- */
-
-#ifndef TPM_LITE_TLCL_H_
-#define TPM_LITE_TLCL_H_
-#include <stdint.h>
-
-#include "tss_constants.h"
-
-/*****************************************************************************/
-/* Functions implemented in tlcl.c */
-
-/**
- * Call this first.  Returns 0 if success, nonzero if error.
- */
-uint32_t tlcl_lib_init(void);
-
-/**
- * Perform a raw TPM request/response transaction.
- */
-uint32_t tlcl_send_receive(const uint8_t *request, uint8_t *response,
-                         int max_length);
-
-/* Commands */
-
-/**
- * Send a TPM_Startup(ST_CLEAR).  The TPM error code is returned (0 for
- * success).
- */
-uint32_t tlcl_startup(void);
-
-/**
- * Resume by sending a TPM_Startup(ST_STATE).  The TPM error code is returned
- * (0 for success).
- */
-uint32_t tlcl_resume(void);
-
-/**
- * Run the self test.
- *
- * Note---this is synchronous.  To run this in parallel with other firmware,
- * use ContinueSelfTest().  The TPM error code is returned.
- */
-uint32_t tlcl_self_test_full(void);
-
-/**
- * Run the self test in the background.
- */
-uint32_t tlcl_continue_self_test(void);
-
-/**
- * Define a space with permission [perm].  [index] is the index for the space,
- * [size] the usable data size.  The TPM error code is returned.
- */
-uint32_t tlcl_define_space(uint32_t index, uint32_t perm, uint32_t size);
-
-/**
- * Write [length] bytes of [data] to space at [index].  The TPM error code is
- * returned.
- */
-uint32_t tlcl_write(uint32_t index, const void *data, uint32_t length);
-
-/**
- * Read [length] bytes from space at [index] into [data].  The TPM error code
- * is returned.
- */
-uint32_t tlcl_read(uint32_t index, void *data, uint32_t length);
-
-/**
- * Assert physical presence in software.  The TPM error code is returned.
- */
-uint32_t tlcl_assert_physical_presence(void);
-
-/**
- * Enable the physical presence command.  The TPM error code is returned.
- */
-uint32_t tlcl_physical_presence_cmd_enable(void);
-
-/**
- * Finalize the physical presence settings: sofware PP is enabled, hardware PP
- * is disabled, and the lifetime lock is set.  The TPM error code is returned.
- */
-uint32_t tlcl_finalize_physical_presence(void);
-
-/**
- * Set the nvLocked bit.  The TPM error code is returned.
- */
-uint32_t tlcl_set_nv_locked(void);
-
-/**
- * Issue a ForceClear.  The TPM error code is returned.
- */
-uint32_t tlcl_force_clear(void);
-
-/**
- * Issue a PhysicalEnable.  The TPM error code is returned.
- */
-uint32_t tlcl_set_enable(void);
-
-/**
- * Issue a SetDeactivated.  Pass 0 to activate.  Returns result code.
- */
-uint32_t tlcl_set_deactivated(uint8_t flag);
-
-/**
- * Get flags of interest.  Pointers for flags you aren't interested in may
- * be NULL.  The TPM error code is returned.
- */
-uint32_t tlcl_get_flags(uint8_t *disable, uint8_t *deactivated,
-                        uint8_t *nvlocked);
-
-/**
- * Set the bGlobalLock flag, which only a reboot can clear.  The TPM error
- * code is returned.
- */
-uint32_t tlcl_set_global_lock(void);
-
-/**
- * Perform a TPM_Extend.
- */
-uint32_t tlcl_extend(int pcr_num, const uint8_t *in_digest,
-                     uint8_t *out_digest);
-
-/**
- * Get the entire set of permanent flags.
- */
-uint32_t tlcl_get_permanent_flags(TPM_PERMANENT_FLAGS *pflags);
-
-#endif  /* TPM_LITE_TLCL_H_ */
diff --git a/src/include/tpm_lite/tss_constants.h b/src/include/tpm_lite/tss_constants.h
deleted file mode 100644
index 883a5ad..0000000
--- a/src/include/tpm_lite/tss_constants.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/* Copyright (c) 2013 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.
- *
- * Some TPM constants and type definitions for standalone compilation for use
- * in the firmware
- */
-#ifndef VBOOT_REFERENCE_TSS_CONSTANTS_H_
-#define VBOOT_REFERENCE_TSS_CONSTANTS_H_
-#include <stdint.h>
-
-#define TPM_MAX_COMMAND_SIZE 4096
-#define TPM_LARGE_ENOUGH_COMMAND_SIZE 256  /* saves space in the firmware */
-#define TPM_PUBEK_SIZE 256
-#define TPM_PCR_DIGEST 20
-
-#define TPM_E_NON_FATAL 0x800
-
-#define TPM_SUCCESS ((uint32_t)0x00000000)
-
-#define TPM_E_AREA_LOCKED           ((uint32_t)0x0000003c)
-#define TPM_E_BADINDEX              ((uint32_t)0x00000002)
-#define TPM_E_BAD_PRESENCE          ((uint32_t)0x0000002d)
-#define TPM_E_IOERROR               ((uint32_t)0x0000001f)
-#define TPM_E_INVALID_POSTINIT      ((uint32_t)0x00000026)
-#define TPM_E_MAXNVWRITES           ((uint32_t)0x00000048)
-#define TPM_E_OWNER_SET             ((uint32_t)0x00000014)
-
-#define TPM_E_NEEDS_SELFTEST ((uint32_t)(TPM_E_NON_FATAL + 1))
-#define TPM_E_DOING_SELFTEST ((uint32_t)(TPM_E_NON_FATAL + 2))
-
-#define TPM_E_ALREADY_INITIALIZED    ((uint32_t)0x00005000)  /* vboot local */
-#define TPM_E_INTERNAL_INCONSISTENCY ((uint32_t)0x00005001)  /* vboot local */
-#define TPM_E_MUST_REBOOT            ((uint32_t)0x00005002)  /* vboot local */
-#define TPM_E_CORRUPTED_STATE        ((uint32_t)0x00005003)  /* vboot local */
-#define TPM_E_COMMUNICATION_ERROR    ((uint32_t)0x00005004)  /* vboot local */
-#define TPM_E_RESPONSE_TOO_LARGE     ((uint32_t)0x00005005)  /* vboot local */
-#define TPM_E_NO_DEVICE              ((uint32_t)0x00005006)  /* vboot local */
-#define TPM_E_INPUT_TOO_SMALL        ((uint32_t)0x00005007)  /* vboot local */
-#define TPM_E_WRITE_FAILURE          ((uint32_t)0x00005008)  /* vboot local */
-#define TPM_E_READ_EMPTY             ((uint32_t)0x00005009)  /* vboot local */
-#define TPM_E_READ_FAILURE           ((uint32_t)0x0000500a)  /* vboot local */
-
-#define TPM_NV_INDEX0 ((uint32_t)0x00000000)
-#define TPM_NV_INDEX_LOCK ((uint32_t)0xffffffff)
-#define TPM_NV_PER_GLOBALLOCK (((uint32_t)1)<<15)
-#define TPM_NV_PER_PPWRITE (((uint32_t)1)<<0)
-#define TPM_NV_PER_READ_STCLEAR (((uint32_t)1)<<31)
-#define TPM_NV_PER_WRITE_STCLEAR (((uint32_t)1)<<14)
-
-#define TPM_TAG_RQU_COMMAND       ((uint16_t) 0xc1)
-#define TPM_TAG_RQU_AUTH1_COMMAND ((uint16_t) 0xc2)
-#define TPM_TAG_RQU_AUTH2_COMMAND ((uint16_t) 0xc3)
-
-#define TPM_TAG_RSP_COMMAND       ((uint16_t) 0xc4)
-#define TPM_TAG_RSP_AUTH1_COMMAND ((uint16_t) 0xc5)
-#define TPM_TAG_RSP_AUTH2_COMMAND ((uint16_t) 0xc6)
-
-typedef uint8_t TSS_BOOL;
-typedef uint16_t TPM_STRUCTURE_TAG;
-
-typedef struct tdTPM_PERMANENT_FLAGS
-{
-	TPM_STRUCTURE_TAG tag;
-	TSS_BOOL disable;
-	TSS_BOOL ownership;
-	TSS_BOOL deactivated;
-	TSS_BOOL readPubek;
-	TSS_BOOL disableOwnerClear;
-	TSS_BOOL allowMaintenance;
-	TSS_BOOL physicalPresenceLifetimeLock;
-	TSS_BOOL physicalPresenceHWEnable;
-	TSS_BOOL physicalPresenceCMDEnable;
-	TSS_BOOL CEKPUsed;
-	TSS_BOOL TPMpost;
-	TSS_BOOL TPMpostLock;
-	TSS_BOOL FIPS;
-	TSS_BOOL Operator;
-	TSS_BOOL enableRevokeEK;
-	TSS_BOOL nvLocked;
-	TSS_BOOL readSRKPub;
-	TSS_BOOL tpmEstablished;
-	TSS_BOOL maintenanceDone;
-	TSS_BOOL disableFullDALogicInfo;
-} TPM_PERMANENT_FLAGS;
-
-typedef struct tdTPM_STCLEAR_FLAGS{
-	TPM_STRUCTURE_TAG tag;
-	TSS_BOOL deactivated;
-	TSS_BOOL disableForceClear;
-	TSS_BOOL physicalPresence;
-	TSS_BOOL physicalPresenceLock;
-	TSS_BOOL bGlobalLock;
-} TPM_STCLEAR_FLAGS;
-
-#endif  /* VBOOT_REFERENCE_TSS_CONSTANTS_H_ */
diff --git a/src/lib/Makefile.inc b/src/lib/Makefile.inc
index 76c8fd3..3ca5185 100644
--- a/src/lib/Makefile.inc
+++ b/src/lib/Makefile.inc
@@ -53,12 +53,6 @@ verstage-y += boot_device.c
 verstage-$(CONFIG_CONSOLE_CBMEM) += cbmem_console.c
 verstage-$(CONFIG_COMMON_CBFS_SPI_WRAPPER) += cbfs_spi.c
 
-ifeq ($(MOCK_TPM),1)
-libverstage-y += mocked_tlcl.c
-else
-libverstage-y += tlcl.c
-endif
-
 verstage-$(CONFIG_GENERIC_UDELAY) += timer.c
 verstage-$(CONFIG_GENERIC_GPIO_LIB) += gpio.c
 verstage-y += mem_pool.c
diff --git a/src/lib/mocked_tlcl.c b/src/lib/mocked_tlcl.c
deleted file mode 100644
index c5c12bf..0000000
--- a/src/lib/mocked_tlcl.c
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * This file is part of the coreboot project.
- *
- * Copyright (C) 2015 The ChromiumOS Authors.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc.
- */
-
-#include <tpm_lite/tlcl.h>
-
-#ifdef FOR_TEST
-#include <stdio.h>
-#define VBDEBUG(format, args...) printf(format, ## args)
-#else
-#include <console/console.h>
-#define VBDEBUG(format, args...) printk(BIOS_DEBUG, format, ## args)
-#endif
-
-uint32_t tlcl_lib_init(void) {
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_startup(void) {
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_resume(void) {
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_self_test_full(void)
-{
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_continue_self_test(void)
-{
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_define_space(uint32_t index, uint32_t perm, uint32_t size)
-{
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_write(uint32_t index, const void* data, uint32_t length)
-{
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_read(uint32_t index, void* data, uint32_t length)
-{
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-
-uint32_t tlcl_assert_physical_presence(void) {
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_physical_presence_cmd_enable(void) {
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_finalize_physical_presence(void) {
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_set_nv_locked(void) {
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_force_clear(void) {
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_set_enable(void) {
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_set_deactivated(uint8_t flag)
-{
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_get_permanent_flags(TPM_PERMANENT_FLAGS* pflags)
-{
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_get_flags(uint8_t* disable, uint8_t* deactivated,
-                        uint8_t *nvlocked)
-{
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_set_global_lock(void)
-{
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
-
-uint32_t tlcl_extend(int pcr_num, const uint8_t* in_digest,
-                     uint8_t* out_digest)
-{
-	VBDEBUG("MOCK_TPM: %s\n", __func__);
-	return TPM_E_NO_DEVICE;
-}
diff --git a/src/lib/tlcl.c b/src/lib/tlcl.c
deleted file mode 100644
index ccf4e80..0000000
--- a/src/lib/tlcl.c
+++ /dev/null
@@ -1,327 +0,0 @@
-/* Copyright (c) 2012 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.
- */
-
-/* A lightweight TPM command library.
- *
- * The general idea is that TPM commands are array of bytes whose
- * fields are mostly compile-time constant.  The goal is to build much
- * of the commands at compile time (or build time) and change some of
- * the fields at run time as needed.  The code in
- * utility/tlcl_generator.c builds structures containing the commands,
- * as well as the offsets of the fields that need to be set at run
- * time.
- */
-
-#include <assert.h>
-#include <string.h>
-#include <tpm_lite/tlcl.h>
-#include <tpm.h>
-#include <vb2_api.h>
-#include "tlcl_internal.h"
-#include "tlcl_structures.h"
-
-#ifdef FOR_TEST
-#include <stdio.h>
-#define VBDEBUG(format, args...) printf(format, ## args)
-#else
-#include <console/console.h>
-#define VBDEBUG(format, args...) printk(BIOS_DEBUG, format, ## args)
-#endif
-
-static int tpm_send_receive(const uint8_t *request,
-				uint32_t request_length,
-				uint8_t *response,
-				uint32_t *response_length)
-{
-	size_t len = *response_length;
-	if (tis_sendrecv(request, request_length, response, &len))
-		return VB2_ERROR_UNKNOWN;
-	/* check 64->32bit overflow and (re)check response buffer overflow */
-	if (len > *response_length)
-		return VB2_ERROR_UNKNOWN;
-	*response_length = len;
-	return VB2_SUCCESS;
-}
-
-/* Sets the size field of a TPM command. */
-static inline void set_tpm_command_size(uint8_t* buffer, uint32_t size) {
-	to_tpm_uint32(buffer + sizeof(uint16_t), size);
-}
-
-/* Gets the size field of a TPM command. */
-__attribute__((unused))
-static inline int tpm_command_size(const uint8_t* buffer) {
-	uint32_t size;
-	from_tpm_uint32(buffer + sizeof(uint16_t), &size);
-	return (int) size;
-}
-
-/* Gets the code field of a TPM command. */
-static inline int tpm_command_code(const uint8_t* buffer) {
-	uint32_t code;
-	from_tpm_uint32(buffer + sizeof(uint16_t) + sizeof(uint32_t), &code);
-	return code;
-}
-
-/* Gets the return code field of a TPM result. */
-static inline int tpm_return_code(const uint8_t* buffer) {
-	return tpm_command_code(buffer);
-}
-
-/* Like TlclSendReceive below, but do not retry if NEEDS_SELFTEST or
- * DOING_SELFTEST errors are returned.
- */
-static uint32_t tlcl_send_receive_no_retry(const uint8_t* request,
-                                           uint8_t* response, int max_length) {
-	uint32_t response_length = max_length;
-	uint32_t result;
-
-	result = tpm_send_receive(request, tpm_command_size(request),
-					response, &response_length);
-	if (0 != result) {
-		/* Communication with TPM failed, so response is garbage */
-		VBDEBUG("TPM: command 0x%x send/receive failed: 0x%x\n",
-			tpm_command_code(request), result);
-		return result;
-	}
-	/* Otherwise, use the result code from the response */
-	result = tpm_return_code(response);
-
-	/* TODO: add paranoia about returned response_length vs. max_length
-	 * (and possibly expected length from the response header).  See
-	 * crosbug.com/17017 */
-
-	VBDEBUG("TPM: command 0x%x returned 0x%x\n",
-		tpm_command_code(request), result);
-
-return result;
-}
-
-
-/* Sends a TPM command and gets a response.  Returns 0 if success or the TPM
- * error code if error. Waits for the self test to complete if needed. */
-uint32_t tlcl_send_receive(const uint8_t* request, uint8_t* response,
-			   int max_length) {
-	uint32_t result = tlcl_send_receive_no_retry(request, response,
-						     max_length);
-	/* If the command fails because the self test has not completed, try it
-	 * again after attempting to ensure that the self test has completed. */
-	if (result == TPM_E_NEEDS_SELFTEST || result == TPM_E_DOING_SELFTEST) {
-		result = tlcl_continue_self_test();
-		if (result != TPM_SUCCESS)
-			return result;
-#if defined(TPM_BLOCKING_CONTINUESELFTEST) || defined(VB_RECOVERY_MODE)
-		/* Retry only once */
-		result = tlcl_send_receive_no_retry(request, response,
-		                                    max_length);
-#else
-		/* This needs serious testing. The TPM specification says: "iii.
-		 * The caller MUST wait for the actions of TPM_ContinueSelfTest
-		 * to complete before reissuing the command C1."  But, if
-		 * ContinueSelfTest is non-blocking, how do we know that the
-		 * actions have completed other than trying again? */
-		do {
-			result = tlcl_send_receive_no_retry(request, response,
-			                                    max_length);
-		} while (result == TPM_E_DOING_SELFTEST);
-#endif
-	}
-	return result;
-}
-
-/* Sends a command and returns the error code. */
-static uint32_t send(const uint8_t* command) {
-	uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
-	return tlcl_send_receive(command, response, sizeof(response));
-}
-
-/* Exported functions. */
-
-uint32_t tlcl_lib_init(void) {
-	if (tis_init())
-		return VB2_ERROR_UNKNOWN;
-	if (tis_open())
-		return VB2_ERROR_UNKNOWN;
-	return VB2_SUCCESS;
-}
-
-uint32_t tlcl_startup(void) {
-	VBDEBUG("TPM: Startup\n");
-	return send(tpm_startup_cmd.buffer);
-}
-
-uint32_t tlcl_resume(void) {
-  VBDEBUG("TPM: Resume\n");
-  return send(tpm_resume_cmd.buffer);
-}
-
-uint32_t tlcl_self_test_full(void)
-{
-	VBDEBUG("TPM: Self test full\n");
-	return send(tpm_selftestfull_cmd.buffer);
-}
-
-uint32_t tlcl_continue_self_test(void)
-{
-	uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
-	VBDEBUG("TPM: Continue self test\n");
-	/* Call the No Retry version of SendReceive to avoid recursion. */
-	return tlcl_send_receive_no_retry(tpm_continueselftest_cmd.buffer,
-	                                  response, sizeof(response));
-}
-
-uint32_t tlcl_define_space(uint32_t index, uint32_t perm, uint32_t size)
-{
-	struct s_tpm_nv_definespace_cmd cmd;
-	VBDEBUG("TPM: TlclDefineSpace(0x%x, 0x%x, %d)\n", index, perm, size);
-	memcpy(&cmd, &tpm_nv_definespace_cmd, sizeof(cmd));
-	to_tpm_uint32(cmd.buffer + tpm_nv_definespace_cmd.index, index);
-	to_tpm_uint32(cmd.buffer + tpm_nv_definespace_cmd.perm, perm);
-	to_tpm_uint32(cmd.buffer + tpm_nv_definespace_cmd.size, size);
-	return send(cmd.buffer);
-}
-
-uint32_t tlcl_write(uint32_t index, const void* data, uint32_t length)
-{
-	struct s_tpm_nv_write_cmd cmd;
-	uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
-	const int total_length =
-			kTpmRequestHeaderLength + kWriteInfoLength + length;
-
-	VBDEBUG("TPM: tlcl_write(0x%x, %d)\n", index, length);
-	memcpy(&cmd, &tpm_nv_write_cmd, sizeof(cmd));
-	assert(total_length <= TPM_LARGE_ENOUGH_COMMAND_SIZE);
-	set_tpm_command_size(cmd.buffer, total_length);
-
-	to_tpm_uint32(cmd.buffer + tpm_nv_write_cmd.index, index);
-	to_tpm_uint32(cmd.buffer + tpm_nv_write_cmd.length, length);
-	memcpy(cmd.buffer + tpm_nv_write_cmd.data, data, length);
-
-	return tlcl_send_receive(cmd.buffer, response, sizeof(response));
-}
-
-uint32_t tlcl_read(uint32_t index, void* data, uint32_t length)
-{
-	struct s_tpm_nv_read_cmd cmd;
-	uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
-	uint32_t result_length;
-	uint32_t result;
-
-	VBDEBUG("TPM: tlcl_read(0x%x, %d)\n", index, length);
-	memcpy(&cmd, &tpm_nv_read_cmd, sizeof(cmd));
-	to_tpm_uint32(cmd.buffer + tpm_nv_read_cmd.index, index);
-	to_tpm_uint32(cmd.buffer + tpm_nv_read_cmd.length, length);
-
-	result = tlcl_send_receive(cmd.buffer, response, sizeof(response));
-	if (result == TPM_SUCCESS && length > 0) {
-		uint8_t* nv_read_cursor = response + kTpmResponseHeaderLength;
-		from_tpm_uint32(nv_read_cursor, &result_length);
-		nv_read_cursor += sizeof(uint32_t);
-		memcpy(data, nv_read_cursor, result_length);
-	}
-
-	return result;
-}
-
-
-uint32_t tlcl_assert_physical_presence(void) {
-	VBDEBUG("TPM: Asserting physical presence\n");
-	return send(tpm_ppassert_cmd.buffer);
-}
-
-uint32_t tlcl_physical_presence_cmd_enable(void) {
-	VBDEBUG("TPM: Enable the physical presence command\n");
-	return send(tpm_ppenable_cmd.buffer);
-}
-
-uint32_t tlcl_finalize_physical_presence(void) {
-	VBDEBUG("TPM: Enable PP cmd, disable HW pp, and set lifetime lock\n");
-	return send(tpm_finalizepp_cmd.buffer);
-}
-
-uint32_t tlcl_set_nv_locked(void) {
-	VBDEBUG("TPM: Set NV locked\n");
-	return tlcl_define_space(TPM_NV_INDEX_LOCK, 0, 0);
-}
-
-uint32_t tlcl_force_clear(void) {
-	VBDEBUG("TPM: Force clear\n");
-	return send(tpm_forceclear_cmd.buffer);
-}
-
-uint32_t tlcl_set_enable(void) {
-	VBDEBUG("TPM: Enabling TPM\n");
-	return send(tpm_physicalenable_cmd.buffer);
-}
-
-uint32_t tlcl_set_deactivated(uint8_t flag)
-{
-	struct s_tpm_physicalsetdeactivated_cmd cmd;
-	VBDEBUG("TPM: SetDeactivated(%d)\n", flag);
-	memcpy(&cmd, &tpm_physicalsetdeactivated_cmd, sizeof(cmd));
-	*(cmd.buffer + cmd.deactivated) = flag;
-	return send(cmd.buffer);
-}
-
-uint32_t tlcl_get_permanent_flags(TPM_PERMANENT_FLAGS* pflags)
-{
-	uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
-	uint32_t size;
-	uint32_t result = tlcl_send_receive(tpm_getflags_cmd.buffer, response,
-	                                    sizeof(response));
-	if (result != TPM_SUCCESS)
-		return result;
-	from_tpm_uint32(response + kTpmResponseHeaderLength, &size);
-	assert(size == sizeof(TPM_PERMANENT_FLAGS));
-	memcpy(pflags, response + kTpmResponseHeaderLength + sizeof(size),
-	       sizeof(TPM_PERMANENT_FLAGS));
-	return result;
-}
-
-uint32_t tlcl_get_flags(uint8_t* disable, uint8_t* deactivated,
-                        uint8_t *nvlocked)
-{
-	TPM_PERMANENT_FLAGS pflags;
-	uint32_t result = tlcl_get_permanent_flags(&pflags);
-	if (result == TPM_SUCCESS) {
-		if (disable)
-			*disable = pflags.disable;
-		if (deactivated)
-			*deactivated = pflags.deactivated;
-		if (nvlocked)
-			*nvlocked = pflags.nvLocked;
-		VBDEBUG("TPM: flags disable=%d, deactivated=%d, nvlocked=%d\n",
-			pflags.disable, pflags.deactivated, pflags.nvLocked);
-	}
-	return result;
-}
-
-uint32_t tlcl_set_global_lock(void)
-{
-	uint32_t x;
-	VBDEBUG("TPM: Set global lock\n");
-	return tlcl_write(TPM_NV_INDEX0, (uint8_t*) &x, 0);
-}
-
-uint32_t tlcl_extend(int pcr_num, const uint8_t* in_digest,
-                     uint8_t* out_digest)
-{
-	struct s_tpm_extend_cmd cmd;
-	uint8_t response[kTpmResponseHeaderLength + kPcrDigestLength];
-	uint32_t result;
-
-	memcpy(&cmd, &tpm_extend_cmd, sizeof(cmd));
-	to_tpm_uint32(cmd.buffer + tpm_extend_cmd.pcrNum, pcr_num);
-	memcpy(cmd.buffer + cmd.inDigest, in_digest, kPcrDigestLength);
-
-	result = tlcl_send_receive(cmd.buffer, response, sizeof(response));
-	if (result != TPM_SUCCESS)
-		return result;
-
-	if (out_digest)
-		memcpy(out_digest, response + kTpmResponseHeaderLength,
-		       kPcrDigestLength);
-	return result;
-}
diff --git a/src/lib/tlcl_internal.h b/src/lib/tlcl_internal.h
deleted file mode 100644
index 8261b0d..0000000
--- a/src/lib/tlcl_internal.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/* Copyright (c) 2010 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.
- */
-
-#ifndef TPM_LITE_TLCL_INTERNAL_H_
-#define TPM_LITE_TLCL_INTERNAL_H_
-
-/*
- * These numbers derive from adding the sizes of command fields as shown in the
- * TPM commands manual.
- */
-#define kTpmRequestHeaderLength 10
-#define kTpmResponseHeaderLength 10
-#define kTpmReadInfoLength 12
-#define kEncAuthLength 20
-#define kPcrDigestLength 20
-
-
-/*
- * Conversion functions.  to_tpm_TYPE puts a value of type TYPE into a TPM
- * command buffer. from_tpm_TYPE gets a value of type TYPE from a TPM command
- * buffer into a variable.
- */
-__attribute__((unused))
-static inline void to_tpm_uint32(uint8_t *buffer, uint32_t x) {
-	buffer[0] = (uint8_t)(x >> 24);
-	buffer[1] = (uint8_t)((x >> 16) & 0xff);
-	buffer[2] = (uint8_t)((x >> 8) & 0xff);
-	buffer[3] = (uint8_t)(x & 0xff);
-}
-
-/*
- * See comment for above function.
- */
-__attribute__((unused))
-static inline void from_tpm_uint32(const uint8_t *buffer, uint32_t *x) {
-	*x = ((buffer[0] << 24) |
-	      (buffer[1] << 16) |
-	      (buffer[2] << 8) |
-	      buffer[3]);
-}
-
-/*
- * See comment for above function.
- */
-__attribute__((unused))
-static inline void to_tpm_uint16(uint8_t *buffer, uint16_t x) {
-	buffer[0] = (uint8_t)(x >> 8);
-	buffer[1] = (uint8_t)(x & 0xff);
-}
-
-/*
- * See comment for above function.
- */
-__attribute__((unused))
-static inline void from_tpm_uint16(const uint8_t *buffer, uint16_t *x) {
-	*x = (buffer[0] << 8) | buffer[1];
-}
-
-#endif  /* TPM_LITE_TLCL_INTERNAL_H_ */
diff --git a/src/lib/tlcl_structures.h b/src/lib/tlcl_structures.h
deleted file mode 100644
index 36c1bb9..0000000
--- a/src/lib/tlcl_structures.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/* This file is automatically generated */
-
-const struct s_tpm_extend_cmd{
-  uint8_t buffer[34];
-  uint16_t pcrNum;
-  uint16_t inDigest;
-} tpm_extend_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0x0, 0x14, },
-10, 14, };
-
-const struct s_tpm_get_random_cmd{
-  uint8_t buffer[14];
-  uint16_t bytesRequested;
-} tpm_get_random_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xe, 0x0, 0x0, 0x0, 0x46, },
-10, };
-
-const struct s_tpm_getownership_cmd{
-  uint8_t buffer[22];
-} tpm_getownership_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x16, 0x0, 0x0, 0x0, 0x65, 0x0, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x1, 0x11, },
-};
-
-const struct s_tpm_getpermissions_cmd{
-  uint8_t buffer[22];
-  uint16_t index;
-} tpm_getpermissions_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x16, 0x0, 0x0, 0x0, 0x65, 0x0, 0x0, 0x0, 0x11, 0x0, 0x0, 0x0, 0x4, },
-18, };
-
-const struct s_tpm_getstclearflags_cmd{
-  uint8_t buffer[22];
-} tpm_getstclearflags_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x16, 0x0, 0x0, 0x0, 0x65, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x1, 0x9, },
-};
-
-const struct s_tpm_getflags_cmd{
-  uint8_t buffer[22];
-} tpm_getflags_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x16, 0x0, 0x0, 0x0, 0x65, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x1, 0x8, },
-};
-
-const struct s_tpm_physicalsetdeactivated_cmd{
-  uint8_t buffer[11];
-  uint16_t deactivated;
-} tpm_physicalsetdeactivated_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xb, 0x0, 0x0, 0x0, 0x72, },
-10, };
-
-const struct s_tpm_physicalenable_cmd{
-  uint8_t buffer[10];
-} tpm_physicalenable_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x6f, },
-};
-
-const struct s_tpm_physicaldisable_cmd{
-  uint8_t buffer[10];
-} tpm_physicaldisable_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x70, },
-};
-
-const struct s_tpm_forceclear_cmd{
-  uint8_t buffer[10];
-} tpm_forceclear_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x5d, },
-};
-
-const struct s_tpm_readpubek_cmd{
-  uint8_t buffer[30];
-} tpm_readpubek_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x1e, 0x0, 0x0, 0x0, 0x7c, },
-};
-
-const struct s_tpm_continueselftest_cmd{
-  uint8_t buffer[10];
-} tpm_continueselftest_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x53, },
-};
-
-const struct s_tpm_selftestfull_cmd{
-  uint8_t buffer[10];
-} tpm_selftestfull_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x50, },
-};
-
-const struct s_tpm_resume_cmd{
-  uint8_t buffer[12];
-} tpm_resume_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x99, 0x0, 0x2, },
-};
-
-const struct s_tpm_savestate_cmd{
-  uint8_t buffer[10];
-} tpm_savestate_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x98, },
-};
-
-const struct s_tpm_startup_cmd{
-  uint8_t buffer[12];
-} tpm_startup_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x99, 0x0, 0x1, },
-};
-
-const struct s_tpm_finalizepp_cmd{
-  uint8_t buffer[12];
-} tpm_finalizepp_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x40, 0x0, 0x0, 0xa, 0x2, 0xa0, },
-};
-
-const struct s_tpm_pplock_cmd{
-  uint8_t buffer[12];
-} tpm_pplock_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x40, 0x0, 0x0, 0xa, 0x0, 0x4, },
-};
-
-const struct s_tpm_ppenable_cmd{
-  uint8_t buffer[12];
-} tpm_ppenable_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x40, 0x0, 0x0, 0xa, 0x0, 0x20, },
-};
-
-const struct s_tpm_ppassert_cmd{
-  uint8_t buffer[12];
-} tpm_ppassert_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x40, 0x0, 0x0, 0xa, 0x0, 0x8, },
-};
-
-const struct s_tpm_pcr_read_cmd{
-  uint8_t buffer[14];
-  uint16_t pcrNum;
-} tpm_pcr_read_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0xe, 0x0, 0x0, 0x0, 0x15, },
-10, };
-
-const struct s_tpm_nv_read_cmd{
-  uint8_t buffer[22];
-  uint16_t index;
-  uint16_t length;
-} tpm_nv_read_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x16, 0x0, 0x0, 0x0, 0xcf, },
-10, 18, };
-
-const struct s_tpm_nv_write_cmd{
-  uint8_t buffer[256];
-  uint16_t index;
-  uint16_t length;
-  uint16_t data;
-} tpm_nv_write_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcd, },
-10, 18, 22, };
-
-const struct s_tpm_nv_definespace_cmd{
-  uint8_t buffer[101];
-  uint16_t index;
-  uint16_t perm;
-  uint16_t size;
-} tpm_nv_definespace_cmd = {{0x0, 0xc1, 0x0, 0x0, 0x0, 0x65, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x18, 0, 0, 0, 0, 0x0, 0x3, 0, 0, 0, 0x1f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0, 0x3, 0, 0, 0, 0x1f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0, 0x17, },
-12, 70, 77, };
-
-const int kWriteInfoLength = 12;
-const int kNvDataPublicPermissionsOffset = 60;
diff --git a/src/mainboard/google/link/romstage.c b/src/mainboard/google/link/romstage.c
index e9b4a09..b8997d3 100644
--- a/src/mainboard/google/link/romstage.c
+++ b/src/mainboard/google/link/romstage.c
@@ -41,7 +41,7 @@
 #include <cpu/x86/msr.h>
 #include <halt.h>
 #include "gpio.h"
-#include <tpm.h>
+#include <pc80/tpm/tspi.h>
 #include <cbfs.h>
 
 #include <southbridge/intel/bd82x6x/chip.h>
diff --git a/src/mainboard/google/parrot/romstage.c b/src/mainboard/google/parrot/romstage.c
index a947c48..51be18e 100644
--- a/src/mainboard/google/parrot/romstage.c
+++ b/src/mainboard/google/parrot/romstage.c
@@ -40,7 +40,7 @@
 #include <halt.h>
 #include "gpio.h"
 #include <cbfs.h>
-#include <tpm.h>
+#include <pc80/tpm/tspi.h>
 #include "ec/compal/ene932/ec.h"
 
 static void pch_enable_lpc(void)
diff --git a/src/mainboard/google/stout/romstage.c b/src/mainboard/google/stout/romstage.c
index 31b61e2..504c410 100644
--- a/src/mainboard/google/stout/romstage.c
+++ b/src/mainboard/google/stout/romstage.c
@@ -40,7 +40,7 @@
 #include <halt.h>
 #include "gpio.h"
 #include <bootmode.h>
-#include <tpm.h>
+#include <pc80/tpm/tspi.h>
 #include <cbfs.h>
 #include <ec/quanta/it8518/ec.h>
 #include "ec.h"
diff --git a/src/mainboard/intel/emeraldlake2/romstage.c b/src/mainboard/intel/emeraldlake2/romstage.c
index bcf498b..d67c399 100644
--- a/src/mainboard/intel/emeraldlake2/romstage.c
+++ b/src/mainboard/intel/emeraldlake2/romstage.c
@@ -39,7 +39,7 @@
 #include <cpu/x86/bist.h>
 #include <cpu/x86/msr.h>
 #include <halt.h>
-#include <tpm.h>
+#include <pc80/tpm/tspi.h>
 #include "gpio.h"
 
 #define SIO_PORT 0x164e
diff --git a/src/mainboard/lenovo/x201/romstage.c b/src/mainboard/lenovo/x201/romstage.c
index 1e335d3..44cc1ca 100644
--- a/src/mainboard/lenovo/x201/romstage.c
+++ b/src/mainboard/lenovo/x201/romstage.c
@@ -37,7 +37,7 @@
 #include <timestamp.h>
 #include <arch/acpi.h>
 #include <cbmem.h>
-#include <tpm.h>
+#include <pc80/tpm/tspi.h>
 
 #include "gpio.h"
 #include "dock.h"
diff --git a/src/mainboard/samsung/lumpy/romstage.c b/src/mainboard/samsung/lumpy/romstage.c
index 015ae08..d14a328 100644
--- a/src/mainboard/samsung/lumpy/romstage.c
+++ b/src/mainboard/samsung/lumpy/romstage.c
@@ -32,7 +32,7 @@
 #include <cbmem.h>
 #include <console/console.h>
 #include <bootmode.h>
-#include <tpm.h>
+#include <pc80/tpm/tspi.h>
 #include <northbridge/intel/sandybridge/sandybridge.h>
 #include <northbridge/intel/sandybridge/raminit.h>
 #include <southbridge/intel/bd82x6x/pch.h>
diff --git a/src/mainboard/samsung/stumpy/romstage.c b/src/mainboard/samsung/stumpy/romstage.c
index 161c8d1..90e1625 100644
--- a/src/mainboard/samsung/stumpy/romstage.c
+++ b/src/mainboard/samsung/stumpy/romstage.c
@@ -41,7 +41,7 @@
 #include <cpu/x86/bist.h>
 #include <cpu/x86/msr.h>
 #include <halt.h>
-#include <tpm.h>
+#include <pc80/tpm/tspi.h>
 #include "gpio.h"
 #if CONFIG_DRIVERS_UART_8250IO
 #include <superio/smsc/lpc47n207/lpc47n207.h>
diff --git a/src/northbridge/intel/sandybridge/romstage_native.c b/src/northbridge/intel/sandybridge/romstage_native.c
index 45f671c..052ed5e 100644
--- a/src/northbridge/intel/sandybridge/romstage_native.c
+++ b/src/northbridge/intel/sandybridge/romstage_native.c
@@ -32,7 +32,7 @@
 #include <device/pci_def.h>
 #include <device/device.h>
 #include <halt.h>
-#include <tpm.h>
+#include <pc80/tpm/tspi.h>
 #include "raminit_native.h"
 #include <northbridge/intel/sandybridge/chip.h>
 #include "southbridge/intel/bd82x6x/pch.h"
diff --git a/src/soc/intel/baytrail/romstage/romstage.c b/src/soc/intel/baytrail/romstage/romstage.c
index 1b93eb6..ff68648 100644
--- a/src/soc/intel/baytrail/romstage/romstage.c
+++ b/src/soc/intel/baytrail/romstage/romstage.c
@@ -33,7 +33,7 @@
 #include <romstage_handoff.h>
 #include <stage_cache.h>
 #include <timestamp.h>
-#include <tpm.h>
+#include <pc80/tpm/tspi.h>
 #include <vendorcode/google/chromeos/chromeos.h>
 #include <soc/gpio.h>
 #include <soc/iomap.h>
diff --git a/src/soc/intel/braswell/romstage/romstage.c b/src/soc/intel/braswell/romstage/romstage.c
index 67716d4..eedb138 100644
--- a/src/soc/intel/braswell/romstage/romstage.c
+++ b/src/soc/intel/braswell/romstage/romstage.c
@@ -43,7 +43,7 @@
 #include <soc/romstage.h>
 #include <soc/smm.h>
 #include <soc/spi.h>
-#include <tpm.h>
+#include <pc80/tpm/tsṕi.h>
 
 /* The cache-as-ram assembly file calls romstage_main() after setting up
  * cache-as-ram.  romstage_main() will then call the mainboards's
diff --git a/src/soc/intel/broadwell/romstage/romstage.c b/src/soc/intel/broadwell/romstage/romstage.c
index e950b1e..081f0a7 100644
--- a/src/soc/intel/broadwell/romstage/romstage.c
+++ b/src/soc/intel/broadwell/romstage/romstage.c
@@ -29,7 +29,7 @@
 #include <cbmem.h>
 #include <cpu/x86/mtrr.h>
 #include <elog.h>
-#include <tpm.h>
+#include <pc80/tpm/tspi.h>
 #include <romstage_handoff.h>
 #include <stage_cache.h>
 #include <timestamp.h>
diff --git a/src/vendorcode/google/chromeos/vboot2/antirollback.c b/src/vendorcode/google/chromeos/vboot2/antirollback.c
index 407b19c..f390df2 100644
--- a/src/vendorcode/google/chromeos/vboot2/antirollback.c
+++ b/src/vendorcode/google/chromeos/vboot2/antirollback.c
@@ -9,8 +9,8 @@
 #include <antirollback.h>
 #include <stdlib.h>
 #include <string.h>
-#include <tpm_lite/tlcl.h>
-#include <tpm_lite/tss_constants.h>
+#include <pc80/tpm/tss.h>
+#include <pc80/tpm/tss_constants.h>
 #include <vb2_api.h>
 
 #ifndef offsetof



More information about the coreboot-gerrit mailing list