blob: f9c2ca20539b96884bcfffa5950f6ce647024340 [file] [log] [blame]
Miquel Raynald677bfe2018-05-15 11:57:06 +02001/* 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
10enum 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
Simon Glass07e127d2018-11-18 14:22:25 -070029#define TPM_PCR_MINIMUM_DIGEST_SIZE 20
30
Miquel Raynald677bfe2018-05-15 11:57:06 +020031/**
Miquel Raynal2a2096e2018-07-19 22:35:09 +020032 * 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 */
36enum tpm_version {
37 TPM_V1 = 0,
38 TPM_V2,
39};
40
41/**
Miquel Raynald677bfe2018-05-15 11:57:06 +020042 * 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 *
Miquel Raynal2a2096e2018-07-19 22:35:09 +020048 * @version: TPM stack to be used
Miquel Raynald677bfe2018-05-15 11:57:06 +020049 * @duration_ms: Length of each duration type in milliseconds
50 * @retry_time_ms: Time to wait before retrying receive
Miquel Raynal2a2096e2018-07-19 22:35:09 +020051 * @buf: Buffer used during the exchanges with the chip
Miquel Raynalff322452018-05-15 11:57:08 +020052 * @pcr_count: Number of PCR per bank
53 * @pcr_select_min: Minimum size in bytes of the pcrSelect array
Miquel Raynald677bfe2018-05-15 11:57:06 +020054 */
55struct tpm_chip_priv {
Miquel Raynal2a2096e2018-07-19 22:35:09 +020056 enum tpm_version version;
57
Miquel Raynald677bfe2018-05-15 11:57:06 +020058 uint duration_ms[TPM_DURATION_COUNT];
59 uint retry_time_ms;
Miquel Raynal2a2096e2018-07-19 22:35:09 +020060 u8 buf[TPM_DEV_BUFSIZE + sizeof(u8)]; /* Max buffer size + addr */
61
62 /* TPM v2 specific data */
Miquel Raynalff322452018-05-15 11:57:08 +020063 uint pcr_count;
64 uint pcr_select_min;
Miquel Raynald677bfe2018-05-15 11:57:06 +020065};
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 */
82struct 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 *
Miquel Raynal350988f2018-07-19 22:35:06 +020089 * @dev: Device to open
Miquel Raynald677bfe2018-05-15 11:57:06 +020090 * @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) \
176int do_##cmd(cmd_tbl_t *cmdtp, int flag, \
177 int argc, char * const argv[]) \
178{ \
Simon Glassabdc7b82018-11-18 14:22:27 -0700179 struct udevice *dev; \
180 int rc; \
181 \
182 rc = get_tpm(&dev); \
183 if (rc) \
184 return rc; \
Miquel Raynald677bfe2018-05-15 11:57:06 +0200185 if (argc != 1) \
186 return CMD_RET_USAGE; \
Simon Glassabdc7b82018-11-18 14:22:27 -0700187 return report_return_code(cmd(dev)); \
Miquel Raynald677bfe2018-05-15 11:57:06 +0200188}
189
190/**
Simon Glass51f00c12018-11-18 14:22:26 -0700191 * 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 *
Simon Glassabdc7b82018-11-18 14:22:27 -0700196 * @dev - TPM device
Simon Glass51f00c12018-11-18 14:22:26 -0700197 * Returns 0 on success, -ve on failure.
198 */
199int 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).
Simon Glassabdc7b82018-11-18 14:22:27 -0700206 *
207 * @dev - TPM device
208 * Returns 0 on success, -ve on failure.
Simon Glass51f00c12018-11-18 14:22:26 -0700209 */
210int tpm_close(struct udevice *dev);
211
212/**
Simon Glass5e69b8b2018-11-23 21:29:33 -0700213 * 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 */
218u32 tpm_clear_and_reenable(struct udevice *dev);
219
220/**
Miquel Raynald677bfe2018-05-15 11:57:06 +0200221 * 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 */
228int 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 *
Simon Glassabdc7b82018-11-18 14:22:27 -0700243 * @dev - TPM device
Miquel Raynald677bfe2018-05-15 11:57:06 +0200244 * @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 */
252int 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 *
Simon Glassabdc7b82018-11-18 14:22:27 -0700258 * @dev - TPM device
Miquel Raynald677bfe2018-05-15 11:57:06 +0200259 * @return 0 on success, non-0 on error.
260 */
Simon Glassabdc7b82018-11-18 14:22:27 -0700261int tpm_init(struct udevice *dev);
Miquel Raynald677bfe2018-05-15 11:57:06 +0200262
263/**
Miquel Raynal2a2096e2018-07-19 22:35:09 +0200264 * Retrieve the array containing all the v1 (resp. v2) commands.
Miquel Raynald677bfe2018-05-15 11:57:06 +0200265 *
266 * @return a cmd_tbl_t array.
267 */
Miquel Raynal2a2096e2018-07-19 22:35:09 +0200268#if defined(CONFIG_TPM_V1)
269cmd_tbl_t *get_tpm1_commands(unsigned int *size);
270#else
271static inline cmd_tbl_t *get_tpm1_commands(unsigned int *size)
272{
273 return NULL;
274}
275#endif
276#if defined(CONFIG_TPM_V2)
277cmd_tbl_t *get_tpm2_commands(unsigned int *size);
278#else
279static inline cmd_tbl_t *get_tpm2_commands(unsigned int *size)
280{
281 return NULL;
282}
283#endif
Miquel Raynald677bfe2018-05-15 11:57:06 +0200284
Simon Glass0a60a0a2018-11-23 21:29:32 -0700285/**
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 */
294enum tpm_version tpm_get_version(struct udevice *dev);
295
Miquel Raynald677bfe2018-05-15 11:57:06 +0200296#endif /* __TPM_COMMON_H */