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 /** 30 * enum tpm_version - The version of the TPM stack to be used 31 * @TPM_V1: Use TPM v1.x stack 32 * @TPM_V2: Use TPM v2.x stack 33 */ 34 enum tpm_version { 35 TPM_V1 = 0, 36 TPM_V2, 37 }; 38 39 /** 40 * struct tpm_chip_priv - Information about a TPM, stored by the uclass 41 * 42 * These values must be set up by the device's probe() method before 43 * communcation is attempted. If the device has an xfer() method, this is 44 * not needed. There is no need to set up @buf. 45 * 46 * @version: TPM stack to be used 47 * @duration_ms: Length of each duration type in milliseconds 48 * @retry_time_ms: Time to wait before retrying receive 49 * @buf: Buffer used during the exchanges with the chip 50 * @pcr_count: Number of PCR per bank 51 * @pcr_select_min: Minimum size in bytes of the pcrSelect array 52 */ 53 struct tpm_chip_priv { 54 enum tpm_version version; 55 56 uint duration_ms[TPM_DURATION_COUNT]; 57 uint retry_time_ms; 58 u8 buf[TPM_DEV_BUFSIZE + sizeof(u8)]; /* Max buffer size + addr */ 59 60 /* TPM v2 specific data */ 61 uint pcr_count; 62 uint pcr_select_min; 63 }; 64 65 /** 66 * struct tpm_ops - low-level TPM operations 67 * 68 * These are designed to avoid loops and delays in the driver itself. These 69 * should be handled in the uclass. 70 * 71 * In gneral you should implement everything except xfer(). Where you need 72 * complete control of the transfer, then xfer() can be provided and will 73 * override the other methods. 74 * 75 * This interface is for low-level TPM access. It does not understand the 76 * concept of localities or the various TPM messages. That interface is 77 * defined in the functions later on in this file, but they all translate 78 * to bytes which are sent and received. 79 */ 80 struct tpm_ops { 81 /** 82 * open() - Request access to locality 0 for the caller 83 * 84 * After all commands have been completed the caller should call 85 * close(). 86 * 87 * @dev: Device to open 88 * @return 0 ok OK, -ve on error 89 */ 90 int (*open)(struct udevice *dev); 91 92 /** 93 * close() - Close the current session 94 * 95 * Releasing the locked locality. Returns 0 on success, -ve 1 on 96 * failure (in case lock removal did not succeed). 97 * 98 * @dev: Device to close 99 * @return 0 ok OK, -ve on error 100 */ 101 int (*close)(struct udevice *dev); 102 103 /** 104 * get_desc() - Get a text description of the TPM 105 * 106 * @dev: Device to check 107 * @buf: Buffer to put the string 108 * @size: Maximum size of buffer 109 * @return length of string, or -ENOSPC it no space 110 */ 111 int (*get_desc)(struct udevice *dev, char *buf, int size); 112 113 /** 114 * send() - send data to the TPM 115 * 116 * @dev: Device to talk to 117 * @sendbuf: Buffer of the data to send 118 * @send_size: Size of the data to send 119 * 120 * Returns 0 on success or -ve on failure. 121 */ 122 int (*send)(struct udevice *dev, const u8 *sendbuf, size_t send_size); 123 124 /** 125 * recv() - receive a response from the TPM 126 * 127 * @dev: Device to talk to 128 * @recvbuf: Buffer to save the response to 129 * @max_size: Maximum number of bytes to receive 130 * 131 * Returns number of bytes received on success, -EAGAIN if the TPM 132 * response is not ready, -EINTR if cancelled, or other -ve value on 133 * failure. 134 */ 135 int (*recv)(struct udevice *dev, u8 *recvbuf, size_t max_size); 136 137 /** 138 * cleanup() - clean up after an operation in progress 139 * 140 * This is called if receiving times out. The TPM may need to abort 141 * the current transaction if it did not complete, and make itself 142 * ready for another. 143 * 144 * @dev: Device to talk to 145 */ 146 int (*cleanup)(struct udevice *dev); 147 148 /** 149 * xfer() - send data to the TPM and get response 150 * 151 * This method is optional. If it exists it is used in preference 152 * to send(), recv() and cleanup(). It should handle all aspects of 153 * TPM communication for a single transfer. 154 * 155 * @dev: Device to talk to 156 * @sendbuf: Buffer of the data to send 157 * @send_size: Size of the data to send 158 * @recvbuf: Buffer to save the response to 159 * @recv_size: Pointer to the size of the response buffer 160 * 161 * Returns 0 on success (and places the number of response bytes at 162 * recv_size) or -ve on failure. 163 */ 164 int (*xfer)(struct udevice *dev, const u8 *sendbuf, size_t send_size, 165 u8 *recvbuf, size_t *recv_size); 166 }; 167 168 #define tpm_get_ops(dev) ((struct tpm_ops *)device_get_ops(dev)) 169 170 #define MAKE_TPM_CMD_ENTRY(cmd) \ 171 U_BOOT_CMD_MKENT(cmd, 0, 1, do_tpm_ ## cmd, "", "") 172 173 #define TPM_COMMAND_NO_ARG(cmd) \ 174 int do_##cmd(cmd_tbl_t *cmdtp, int flag, \ 175 int argc, char * const argv[]) \ 176 { \ 177 if (argc != 1) \ 178 return CMD_RET_USAGE; \ 179 return report_return_code(cmd()); \ 180 } 181 182 /** 183 * tpm_get_desc() - Get a text description of the TPM 184 * 185 * @dev: Device to check 186 * @buf: Buffer to put the string 187 * @size: Maximum size of buffer 188 * @return length of string, or -ENOSPC it no space 189 */ 190 int tpm_get_desc(struct udevice *dev, char *buf, int size); 191 192 /** 193 * tpm_xfer() - send data to the TPM and get response 194 * 195 * This first uses the device's send() method to send the bytes. Then it calls 196 * recv() to get the reply. If recv() returns -EAGAIN then it will delay a 197 * short time and then call recv() again. 198 * 199 * Regardless of whether recv() completes successfully, it will then call 200 * cleanup() to finish the transaction. 201 * 202 * Note that the outgoing data is inspected to determine command type 203 * (ordinal) and a timeout is used for that command type. 204 * 205 * @sendbuf - buffer of the data to send 206 * @send_size size of the data to send 207 * @recvbuf - memory to save the response to 208 * @recv_len - pointer to the size of the response buffer 209 * 210 * Returns 0 on success (and places the number of response bytes at 211 * recv_len) or -ve on failure. 212 */ 213 int tpm_xfer(struct udevice *dev, const u8 *sendbuf, size_t send_size, 214 u8 *recvbuf, size_t *recv_size); 215 216 /** 217 * Initialize TPM device. It must be called before any TPM commands. 218 * 219 * @return 0 on success, non-0 on error. 220 */ 221 int tpm_init(void); 222 223 /** 224 * Retrieve the array containing all the v1 (resp. v2) commands. 225 * 226 * @return a cmd_tbl_t array. 227 */ 228 #if defined(CONFIG_TPM_V1) 229 cmd_tbl_t *get_tpm1_commands(unsigned int *size); 230 #else 231 static inline cmd_tbl_t *get_tpm1_commands(unsigned int *size) 232 { 233 return NULL; 234 } 235 #endif 236 #if defined(CONFIG_TPM_V2) 237 cmd_tbl_t *get_tpm2_commands(unsigned int *size); 238 #else 239 static inline cmd_tbl_t *get_tpm2_commands(unsigned int *size) 240 { 241 return NULL; 242 } 243 #endif 244 245 #endif /* __TPM_COMMON_H */ 246