Add Infineon v05 TPM driver

drivers/tpm/slb9635_i2c/tpm_proto.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 <config.h>
 #include <common.h>
 #include <i2c.h>
 
-#define INFINEON_TPM_CHIP   (CONFIG_INFINEON_TPM_CHIP_ADDRESS)
 
 /* infineon prototype i2c tpm's internal registers
  */
+#define INFINEON_TPM_CHIP   (0x1A)
 #define REG_RDATA           (0xA4)
 #define REG_WDATA           (0xA5)
 #define REG_STAT            (0xA7)
 /* i2c timeout value and polling period
  */
-#define I2CBUSY_WAIT_US     (1000ul)
-#define TIMEOUT_REG_US      (1000000ul)
+#define I2CBUSY_WAIT_MS     (1ul)
+#define TIMEOUT_REG_MS      (1000ul)
 
 /* error code follows u-boot standard
  * 0        : success
  * non zero : failed
  */
 enum {
         E_TIMEOUT   = -7,
         E_CHECKSUM  = -6,
         E_SIZE      = -5,
         E_MEMORY    = -4,
         E_DATA      = -3,
         E_PARAMETER = -2,
         E_GENERAL   = -1,
         S_OK        = 0,
         E_WARNING   = 1
 };
 
 /* tpm chip timeout value on read/write
  * TODO:
  * find the correct timeout when tpm in i2c mode. but since this is the
  * prototype i2c tpm chip, spec is not as clear as lpc tpm chip. just use
  * the maximum wait time as the timeout value.
  */
-#define TIMEOUT_READ_US     (3000000ul)
-#define TIMEOUT_WRITE_US    (1000000ul)
+#define TIMEOUT_READ_MS     (3000ul)
+#define TIMEOUT_WRITE_MS    (1000ul)
 
 /* tpm stat register bits
  */
 #define TPM_RECEIVE_DATA_AVAILABLE  (1u)
 #define TPM_TRANSMIT_FIFO_NOTFULL   (1u << 7)
 
 /* tpm transport and vendor layers
  */
 enum {
         TSPT_VER    = 0,
@@ skipping 161 matching lines @@
         *pcopy_size = data_len;
         tpm_i2c_debug_dump(from, 0, DATA_START + data_len + 1);
         return 0;
 }
 
 static int tpm_i2c_reg(uint8_t *reg)
 {
         ulong stime = get_timer(0);
         while (i2c_write_data((uchar)INFINEON_TPM_CHIP, reg, 1)) {
                 /* i2c busy, wait 1ms */
-                udelay(I2CBUSY_WAIT_US);
-                if (get_timer(stime) > TIMEOUT_REG_US)
+                udelay(I2CBUSY_WAIT_MS * 1000);
+                if (get_timer(stime) > TIMEOUT_REG_MS)
                         return E_TIMEOUT;
         }
         return 0;
 }
 
 static int tpm_i2c_read_status(t_inf_stat_reg *preg)
 {
         uint8_t s_reg[8];
         uint8_t stat[4];
         s_reg[0] = (uchar)REG_STAT;
@@ skipping 89 matching lines @@
                 TPM_CHECK(tpm_i2c_read_status(&st_reg));
         } while ((get_timer(stime) < timeout_us) &&
                 (st_reg.status & TPM_RECEIVE_DATA_AVAILABLE) == 0);
 
         return (st_reg.status & TPM_RECEIVE_DATA_AVAILABLE) == 0 ?
                 E_TIMEOUT : 0;
 }
 
 /* TPM API
  */
-int tpm_status(int *ready_write, int *ready_read, size_t *p_len)
+int tpm_status_v03(int *ready_write, int *ready_read, size_t *p_len)
 {
         t_inf_stat_reg reg;
 
         TPM_CHECK(tpm_i2c_read_status(&reg));
         /* exception case in prototype spec, error
          */
         if (reg.status == 0xff && reg.len_h == 0xff && reg.len_l == 0xff)
                 return E_GENERAL;
         /* verify status checksum
          */
         if ((reg.status ^ reg.len_h ^ reg.len_l) != reg.checksum)
                 return E_CHECKSUM;
         /* data available
-         */  
+         */
         if (ready_read)
                 *ready_read = (reg.status & TPM_RECEIVE_DATA_AVAILABLE) ? 1 : 0;
         /* data length
          */
         if (p_len) {
                 if (*ready_read)
                         *p_len = ((size_t)reg.len_h << 8) + (size_t)reg.len_l;
                 else
                         *p_len = 0;
         }
         /* device writable
          */
         if (ready_write)
                 *ready_write = (reg.status & TPM_TRANSMIT_FIFO_NOTFULL) ? 1 : 0;
         return 0;
 }
 
 
-int tpm_init(void)
+int tpm_init_v03(void)
 {
         int ready_write = 0, ready_read = 0;
         size_t read_len = 0;
         int ret_code;
         #if defined(CONFIG_I2C_MULTI_BUS)
         i2c_set_bus_num(CONFIG_INFINEON_TPM_I2C_BUS);
         #endif
         ret_code = i2c_probe(INFINEON_TPM_CHIP);
         #ifdef VBOOT_DEBUG
-        printf("probe  : %d\n", ret_code);
+        printf("v03 probe  : %s\n", ret_code ? "N/A" : "found");
         #endif /* VBOOT_DEBUG */
         if (ret_code)
                 return ret_code;
-        ret_code = tpm_status(&ready_write, &ready_read, &read_len);
+        ret_code = tpm_status_v03(&ready_write, &ready_read, &read_len);
         #ifdef VBOOT_DEBUG
         printf("status : %d\n\tw[%c] r[%c : %u]\n", ret_code,
         ready_write ? 'y' : 'n',
         ready_read  ? 'y' : 'n', read_len);
         #endif /* VBOOT_DEBUG */
         if (ret_code)
                 return ret_code;
-        TPM_CHECK(tpm_prepare_write(TIMEOUT_WRITE_US));
+        TPM_CHECK(tpm_prepare_write(TIMEOUT_WRITE_MS));
         return 0;
 }
 
-int tpm_send(const uint8_t *pdata, size_t length)
+int tpm_sendrecv_v03(const uint8_t *sendbuf, size_t buf_size, uint8_t *recvbuf,
+        size_t *recv_len)
 {
-        TPM_CHECK(tpm_prepare_write(TIMEOUT_WRITE_US));
-        TPM_CHECK(tpm_i2c_write_data(pdata, length));
+        int ready_write = 0, ready_read = 0;
+        size_t read_length = 0;
+        TPM_CHECK(tpm_prepare_write(TIMEOUT_WRITE_MS));
+        TPM_CHECK(tpm_i2c_write_data(sendbuf, buf_size));
+        TPM_CHECK(tpm_prepare_read(TIMEOUT_READ_MS));
+        TPM_CHECK(tpm_status_v03(&ready_write, &ready_read, &read_length));
+        if (read_length == 0)
+                return E_GENERAL;
+        if (recv_len) {
+                /* *recv_len sets the maximum data can be feched
+                 * if *recv_len == 0, means the buffer is large enough to read any tpm
+                 * response
+                 */
+                if (*recv_len != 0 && *recv_len < read_length)
+                        return E_SIZE;
+        }
+        if (recvbuf) {
+                TPM_CHECK(tpm_i2c_read_data(recvbuf, read_length, NULL));
+                /* update recv_len only on success */
+                if (recv_len)
+                        *recv_len = read_length;
+        } else {
+                /* discard data in read buffer */
+                TPM_CHECK(tpm_prepare_write(TIMEOUT_WRITE_MS));
+        }
         return 0;
 }
 
-int tpm_receive(uint8_t *pdata, size_t max_length)
-{
-        int ready_write = 0, ready_read = 0;
-        size_t read_length = 0;
-        TPM_CHECK(tpm_prepare_read(TIMEOUT_READ_US));
-        TPM_CHECK(tpm_status(&ready_write, &ready_read, &read_length));
-        if (read_length == 0)
-                return E_GENERAL;
-        if (max_length < read_length)
-                return E_SIZE;
-        TPM_CHECK(tpm_i2c_read_data(pdata, read_length, NULL));
-        return 0;
-}