include/tpm-common.h

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /*
   3  * Copyright (c) 2013 The Chromium OS Authors.
   4  * Coypright (c) 2013 Guntermann & Drunck GmbH
   5  */
   6
   7 #ifndef __TPM_COMMON_H
   8 #define __TPM_COMMON_H
   9
  10 enum tpm_duration {
  11         TPM_SHORT = 0,
  12         TPM_MEDIUM = 1,
  13         TPM_LONG = 2,
  14         TPM_UNDEFINED,
  15
  16         TPM_DURATION_COUNT,
  17 };
  18
  19 /*
  20  * Here is a partial implementation of TPM commands.  Please consult TCG Main
  21  * Specification for definitions of TPM commands.
  22  */
  23
  24 #define TPM_HEADER_SIZE         10
  25
  26 /* Max buffer size supported by our tpm */
  27 #define TPM_DEV_BUFSIZE         1260
  28
  29 #define TPM_PCR_MINIMUM_DIGEST_SIZE 20
  30
  31 /**
  32  * enum tpm_version - The version of the TPM stack to be used
  33  * @TPM_V1:             Use TPM v1.x stack
  34  * @TPM_V2:             Use TPM v2.x stack
  35  */
  36 enum tpm_version {
  37         TPM_V1 = 0,
  38         TPM_V2,
  39 };
  40
  41 /**
  42  * struct tpm_chip_priv - Information about a TPM, stored by the uclass
  43  *
  44  * These values must be set up by the device's probe() method before
  45  * communcation is attempted. If the device has an xfer() method, this is
  46  * not needed. There is no need to set up @buf.
  47  *
  48  * @version:            TPM stack to be used
  49  * @duration_ms:        Length of each duration type in milliseconds
  50  * @retry_time_ms:      Time to wait before retrying receive
  51  * @buf:                Buffer used during the exchanges with the chip
  52  * @pcr_count:          Number of PCR per bank
  53  * @pcr_select_min:     Minimum size in bytes of the pcrSelect array
  54  */
  55 struct tpm_chip_priv {
  56         enum tpm_version version;
  57
  58         uint duration_ms[TPM_DURATION_COUNT];
  59         uint retry_time_ms;
  60         u8 buf[TPM_DEV_BUFSIZE + sizeof(u8)];  /* Max buffer size + addr */
  61
  62         /* TPM v2 specific data */
  63         uint pcr_count;
  64         uint pcr_select_min;
  65 };
  66
  67 /**
  68  * struct tpm_ops - low-level TPM operations
  69  *
  70  * These are designed to avoid loops and delays in the driver itself. These
  71  * should be handled in the uclass.
  72  *
  73  * In gneral you should implement everything except xfer(). Where you need
  74  * complete control of the transfer, then xfer() can be provided and will
  75  * override the other methods.
  76  *
  77  * This interface is for low-level TPM access. It does not understand the
  78  * concept of localities or the various TPM messages. That interface is
  79  * defined in the functions later on in this file, but they all translate
  80  * to bytes which are sent and received.
  81  */
  82 struct tpm_ops {
  83         /**
  84          * open() - Request access to locality 0 for the caller
  85          *
  86          * After all commands have been completed the caller should call
  87          * close().
  88          *
  89          * @dev:        Device to open
  90          * @return 0 ok OK, -ve on error
  91          */
  92         int (*open)(struct udevice *dev);
  93
  94         /**
  95          * close() - Close the current session
  96          *
  97          * Releasing the locked locality. Returns 0 on success, -ve 1 on
  98          * failure (in case lock removal did not succeed).
  99          *
 100          * @dev:        Device to close
 101          * @return 0 ok OK, -ve on error
 102          */
 103         int (*close)(struct udevice *dev);
 104
 105         /**
 106          * get_desc() - Get a text description of the TPM
 107          *
 108          * @dev:        Device to check
 109          * @buf:        Buffer to put the string
 110          * @size:       Maximum size of buffer
 111          * @return length of string, or -ENOSPC it no space
 112          */
 113         int (*get_desc)(struct udevice *dev, char *buf, int size);
 114
 115         /**
 116          * send() - send data to the TPM
 117          *
 118          * @dev:        Device to talk to
 119          * @sendbuf:    Buffer of the data to send
 120          * @send_size:  Size of the data to send
 121          *
 122          * Returns 0 on success or -ve on failure.
 123          */
 124         int (*send)(struct udevice *dev, const u8 *sendbuf, size_t send_size);
 125
 126         /**
 127          * recv() - receive a response from the TPM
 128          *
 129          * @dev:        Device to talk to
 130          * @recvbuf:    Buffer to save the response to
 131          * @max_size:   Maximum number of bytes to receive
 132          *
 133          * Returns number of bytes received on success, -EAGAIN if the TPM
 134          * response is not ready, -EINTR if cancelled, or other -ve value on
 135          * failure.
 136          */
 137         int (*recv)(struct udevice *dev, u8 *recvbuf, size_t max_size);
 138
 139         /**
 140          * cleanup() - clean up after an operation in progress
 141          *
 142          * This is called if receiving times out. The TPM may need to abort
 143          * the current transaction if it did not complete, and make itself
 144          * ready for another.
 145          *
 146          * @dev:        Device to talk to
 147          */
 148         int (*cleanup)(struct udevice *dev);
 149
 150         /**
 151          * xfer() - send data to the TPM and get response
 152          *
 153          * This method is optional. If it exists it is used in preference
 154          * to send(), recv() and cleanup(). It should handle all aspects of
 155          * TPM communication for a single transfer.
 156          *
 157          * @dev:        Device to talk to
 158          * @sendbuf:    Buffer of the data to send
 159          * @send_size:  Size of the data to send
 160          * @recvbuf:    Buffer to save the response to
 161          * @recv_size:  Pointer to the size of the response buffer
 162          *
 163          * Returns 0 on success (and places the number of response bytes at
 164          * recv_size) or -ve on failure.
 165          */
 166         int (*xfer)(struct udevice *dev, const u8 *sendbuf, size_t send_size,
 167                     u8 *recvbuf, size_t *recv_size);
 168 };
 169
 170 #define tpm_get_ops(dev)        ((struct tpm_ops *)device_get_ops(dev))
 171
 172 #define MAKE_TPM_CMD_ENTRY(cmd) \
 173         U_BOOT_CMD_MKENT(cmd, 0, 1, do_tpm_ ## cmd, "", "")
 174
 175 #define TPM_COMMAND_NO_ARG(cmd)                         \
 176 int do_##cmd(cmd_tbl_t *cmdtp, int flag,                \
 177              int argc, char * const argv[])             \
 178 {                                                       \
 179         struct udevice *dev;                            \
 180         int rc;                                         \
 181                                                         \
 182         rc = get_tpm(&dev);                             \
 183         if (rc)                                         \
 184                 return rc;                              \
 185         if (argc != 1)                                  \
 186                 return CMD_RET_USAGE;                   \
 187         return report_return_code(cmd(dev));            \
 188 }
 189
 190 /**
 191  * tpm_open() - Request access to locality 0 for the caller
 192  *
 193  * After all commands have been completed the caller is supposed to
 194  * call tpm_close().
 195  *
 196  * @dev - TPM device
 197  * Returns 0 on success, -ve on failure.
 198  */
 199 int tpm_open(struct udevice *dev);
 200
 201 /**
 202  * tpm_close() - Close the current session
 203  *
 204  * Releasing the locked locality. Returns 0 on success, -ve 1 on
 205  * failure (in case lock removal did not succeed).
 206  *
 207  * @dev - TPM device
 208  * Returns 0 on success, -ve on failure.
 209  */
 210 int tpm_close(struct udevice *dev);
 211
 212 /**
 213  * tpm_clear_and_reenable() - Force clear the TPM and reenable it
 214  *
 215  * @dev: TPM device
 216  * @return 0 on success, -ve on failure
 217  */
 218 u32 tpm_clear_and_reenable(struct udevice *dev);
 219
 220 /**
 221  * tpm_get_desc() - Get a text description of the TPM
 222  *
 223  * @dev:        Device to check
 224  * @buf:        Buffer to put the string
 225  * @size:       Maximum size of buffer
 226  * @return length of string, or -ENOSPC it no space
 227  */
 228 int tpm_get_desc(struct udevice *dev, char *buf, int size);
 229
 230 /**
 231  * tpm_xfer() - send data to the TPM and get response
 232  *
 233  * This first uses the device's send() method to send the bytes. Then it calls
 234  * recv() to get the reply. If recv() returns -EAGAIN then it will delay a
 235  * short time and then call recv() again.
 236  *
 237  * Regardless of whether recv() completes successfully, it will then call
 238  * cleanup() to finish the transaction.
 239  *
 240  * Note that the outgoing data is inspected to determine command type
 241  * (ordinal) and a timeout is used for that command type.
 242  *
 243  * @dev - TPM device
 244  * @sendbuf - buffer of the data to send
 245  * @send_size size of the data to send
 246  * @recvbuf - memory to save the response to
 247  * @recv_len - pointer to the size of the response buffer
 248  *
 249  * Returns 0 on success (and places the number of response bytes at
 250  * recv_len) or -ve on failure.
 251  */
 252 int tpm_xfer(struct udevice *dev, const u8 *sendbuf, size_t send_size,
 253              u8 *recvbuf, size_t *recv_size);
 254
 255 /**
 256  * Initialize TPM device.  It must be called before any TPM commands.
 257  *
 258  * @dev - TPM device
 259  * @return 0 on success, non-0 on error.
 260  */
 261 int tpm_init(struct udevice *dev);
 262
 263 /**
 264  * Retrieve the array containing all the v1 (resp. v2) commands.
 265  *
 266  * @return a cmd_tbl_t array.
 267  */
 268 #if defined(CONFIG_TPM_V1)
 269 cmd_tbl_t *get_tpm1_commands(unsigned int *size);
 270 #else
 271 static inline cmd_tbl_t *get_tpm1_commands(unsigned int *size)
 272 {
 273         return NULL;
 274 }
 275 #endif
 276 #if defined(CONFIG_TPM_V2)
 277 cmd_tbl_t *get_tpm2_commands(unsigned int *size);
 278 #else
 279 static inline cmd_tbl_t *get_tpm2_commands(unsigned int *size)
 280 {
 281         return NULL;
 282 }
 283 #endif
 284
 285 /**
 286  * tpm_get_version() - Find the version of a TPM
 287  *
 288  * This checks the uclass data for a TPM device and returns the version number
 289  * it supports.
 290  *
 291  * @dev: TPM device
 292  * @return version number (TPM_V1 or TPMV2)
 293  */
 294 enum tpm_version tpm_get_version(struct udevice *dev);
 295
 296 #endif /* __TPM_COMMON_H */