powerpc: P4080DS: Remove macro CONFIG_P4080DS

[J-u-boot.git] / lib / tpm.c

diff --git a/lib/tpm.c b/lib/tpm.c
index 967c8e65150a354a098db3c8196db6e4cc129f5c..88f24060f00683c001e982b9365d9d098d62a2e3 100644 (file)
--- a/lib/tpm.c
+++ b/lib/tpm.c
@@ -6,10 +6,10 @@
  */
 
 #include <common.h>
  */
 
 #include <common.h>

-#include <stdarg.h>
-#include <sha1.h>
+#include <dm.h>

 #include <tpm.h>
 #include <asm/unaligned.h>
 #include <tpm.h>
 #include <asm/unaligned.h>

+#include <u-boot/sha1.h>

 
 /* Internal error of TPM command library */
 #define TPM_LIB_ERROR  ((uint32_t)~0u)
 
 /* Internal error of TPM command library */
 #define TPM_LIB_ERROR  ((uint32_t)~0u)


@@ -17,7 +17,6 @@
 /* Useful constants */
 enum {
        COMMAND_BUFFER_SIZE             = 256,
 /* Useful constants */
 enum {
        COMMAND_BUFFER_SIZE             = 256,

-       TPM_PUBEK_SIZE                  = 256,

        TPM_REQUEST_HEADER_LENGTH       = 10,
        TPM_RESPONSE_HEADER_LENGTH      = 10,
        PCR_DIGEST_LENGTH               = 20,
        TPM_REQUEST_HEADER_LENGTH       = 10,
        TPM_RESPONSE_HEADER_LENGTH      = 10,
        PCR_DIGEST_LENGTH               = 20,


@@ -230,6 +229,8 @@ static uint32_t tpm_return_code(const void *response)
 static uint32_t tpm_sendrecv_command(const void *command,
                void *response, size_t *size_ptr)
 {
 static uint32_t tpm_sendrecv_command(const void *command,
                void *response, size_t *size_ptr)
 {

+       struct udevice *dev;
+       int ret;

        uint8_t response_buffer[COMMAND_BUFFER_SIZE];
        size_t response_length;
        uint32_t err;
        uint8_t response_buffer[COMMAND_BUFFER_SIZE];
        size_t response_length;
        uint32_t err;


@@ -240,9 +241,14 @@ static uint32_t tpm_sendrecv_command(const void *command,
                response = response_buffer;
                response_length = sizeof(response_buffer);
        }
                response = response_buffer;
                response_length = sizeof(response_buffer);
        }

-       err = tis_sendrecv(command, tpm_command_size(command),
-                       response, &response_length);
-       if (err)
+
+       ret = uclass_first_device_err(UCLASS_TPM, &dev);
+       if (ret)
+               return ret;
+       err = tpm_xfer(dev, command, tpm_command_size(command),
+                      response, &response_length);
+
+       if (err < 0)

                return TPM_LIB_ERROR;
        if (size_ptr)
                *size_ptr = response_length;
                return TPM_LIB_ERROR;
        if (size_ptr)
                *size_ptr = response_length;


@@ -250,15 +256,15 @@ static uint32_t tpm_sendrecv_command(const void *command,
        return tpm_return_code(response);
 }
 
        return tpm_return_code(response);
 }
 

-uint32_t tpm_init(void)
+int tpm_init(void)

 {
 {

-       uint32_t err;
+       int err;
+       struct udevice *dev;

 
 

-       err = tis_init();
+       err = uclass_first_device_err(UCLASS_TPM, &dev);

        if (err)
                return err;
        if (err)
                return err;

-
-       return tis_open();
+       return tpm_open(dev);

 }
 
 uint32_t tpm_startup(enum tpm_startup_type mode)
 }
 
 uint32_t tpm_startup(enum tpm_startup_type mode)


@@ -589,6 +595,56 @@ uint32_t tpm_get_capability(uint32_t cap_area, uint32_t sub_cap,
        return 0;
 }
 
        return 0;
 }
 

+uint32_t tpm_get_permanent_flags(struct tpm_permanent_flags *pflags)
+{
+       const uint8_t command[22] = {
+               0x0, 0xc1,              /* TPM_TAG */
+               0x0, 0x0, 0x0, 0x16,    /* parameter size */
+               0x0, 0x0, 0x0, 0x65,    /* TPM_COMMAND_CODE */
+               0x0, 0x0, 0x0, 0x4,     /* TPM_CAP_FLAG_PERM */
+               0x0, 0x0, 0x0, 0x4,     /* subcap size */
+               0x0, 0x0, 0x1, 0x8,     /* subcap value */
+       };
+       uint8_t response[COMMAND_BUFFER_SIZE];
+       size_t response_length = sizeof(response);
+       uint32_t err;
+
+       err = tpm_sendrecv_command(command, response, &response_length);
+       if (err)
+               return err;
+       memcpy(pflags, response + TPM_HEADER_SIZE, sizeof(*pflags));
+
+       return 0;
+}
+
+uint32_t tpm_get_permissions(uint32_t index, uint32_t *perm)
+{
+       const uint8_t command[22] = {
+               0x0, 0xc1,              /* TPM_TAG */
+               0x0, 0x0, 0x0, 0x16,    /* parameter size */
+               0x0, 0x0, 0x0, 0x65,    /* TPM_COMMAND_CODE */
+               0x0, 0x0, 0x0, 0x11,
+               0x0, 0x0, 0x0, 0x4,
+       };
+       const size_t index_offset = 18;
+       const size_t perm_offset = 60;
+       uint8_t buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
+       size_t response_length = sizeof(response);
+       uint32_t err;
+
+       if (pack_byte_string(buf, sizeof(buf), "d", 0, command, sizeof(command),
+                            index_offset, index))
+               return TPM_LIB_ERROR;
+       err = tpm_sendrecv_command(buf, response, &response_length);
+       if (err)
+               return err;
+       if (unpack_byte_string(response, response_length, "d",
+                              perm_offset, perm))
+               return TPM_LIB_ERROR;
+
+       return 0;
+}
+

 #ifdef CONFIG_TPM_AUTH_SESSIONS
 
 /**
 #ifdef CONFIG_TPM_AUTH_SESSIONS
 
 /**