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