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