blob: 086b672718e1dcc98ed157e282e547311cce87d1 [file] [log] [blame]
Vadim Bendebury5e124722011-10-17 08:36:14 +00001/*
Che-liang Chiou8732b072013-02-28 09:34:57 +00002 * Copyright (c) 2013 The Chromium OS Authors.
Reinhard Pfaube6c1522013-06-26 15:55:13 +02003 * Coypright (c) 2013 Guntermann & Drunck GmbH
Vadim Bendebury5e124722011-10-17 08:36:14 +00004 *
Wolfgang Denk1a459662013-07-08 09:37:19 +02005 * SPDX-License-Identifier: GPL-2.0+
Vadim Bendebury5e124722011-10-17 08:36:14 +00006 */
7
Che-liang Chiou8732b072013-02-28 09:34:57 +00008#ifndef __TPM_H
9#define __TPM_H
Vadim Bendebury5e124722011-10-17 08:36:14 +000010
Che-liang Chiou8732b072013-02-28 09:34:57 +000011#include <tis.h>
Vadim Bendebury5e124722011-10-17 08:36:14 +000012
13/*
Che-liang Chiou8732b072013-02-28 09:34:57 +000014 * Here is a partial implementation of TPM commands. Please consult TCG Main
15 * Specification for definitions of TPM commands.
Vadim Bendebury5e124722011-10-17 08:36:14 +000016 */
Vadim Bendebury5e124722011-10-17 08:36:14 +000017
Simon Glassf255d312015-08-22 18:31:31 -060018#define TPM_HEADER_SIZE 10
19
20enum tpm_duration {
21 TPM_SHORT = 0,
22 TPM_MEDIUM = 1,
23 TPM_LONG = 2,
24 TPM_UNDEFINED,
25
26 TPM_DURATION_COUNT,
27};
28
Che-liang Chiou8732b072013-02-28 09:34:57 +000029enum tpm_startup_type {
30 TPM_ST_CLEAR = 0x0001,
31 TPM_ST_STATE = 0x0002,
32 TPM_ST_DEACTIVATED = 0x0003,
33};
34
35enum tpm_physical_presence {
36 TPM_PHYSICAL_PRESENCE_HW_DISABLE = 0x0200,
37 TPM_PHYSICAL_PRESENCE_CMD_DISABLE = 0x0100,
38 TPM_PHYSICAL_PRESENCE_LIFETIME_LOCK = 0x0080,
39 TPM_PHYSICAL_PRESENCE_HW_ENABLE = 0x0040,
40 TPM_PHYSICAL_PRESENCE_CMD_ENABLE = 0x0020,
41 TPM_PHYSICAL_PRESENCE_NOTPRESENT = 0x0010,
42 TPM_PHYSICAL_PRESENCE_PRESENT = 0x0008,
43 TPM_PHYSICAL_PRESENCE_LOCK = 0x0004,
44};
45
46enum tpm_nv_index {
47 TPM_NV_INDEX_LOCK = 0xffffffff,
48 TPM_NV_INDEX_0 = 0x00000000,
49 TPM_NV_INDEX_DIR = 0x10000001,
50};
51
Simon Glass2132f972015-08-22 18:31:41 -060052#define TPM_NV_PER_GLOBALLOCK (1U << 15)
53#define TPM_NV_PER_PPWRITE (1U << 0)
54#define TPM_NV_PER_READ_STCLEAR (1U << 31)
55#define TPM_NV_PER_WRITE_STCLEAR (1U << 14)
56
57enum {
58 TPM_PUBEK_SIZE = 256,
59};
60
Che-liang Chiou8732b072013-02-28 09:34:57 +000061/**
Reinhard Pfaube6c1522013-06-26 15:55:13 +020062 * TPM return codes as defined in the TCG Main specification
63 * (TPM Main Part 2 Structures; Specification version 1.2)
64 */
65enum tpm_return_code {
66 TPM_BASE = 0x00000000,
67 TPM_NON_FATAL = 0x00000800,
68 TPM_SUCCESS = TPM_BASE,
69 /* TPM-defined fatal error codes */
70 TPM_AUTHFAIL = TPM_BASE + 1,
71 TPM_BADINDEX = TPM_BASE + 2,
72 TPM_BAD_PARAMETER = TPM_BASE + 3,
73 TPM_AUDITFAILURE = TPM_BASE + 4,
74 TPM_CLEAR_DISABLED = TPM_BASE + 5,
75 TPM_DEACTIVATED = TPM_BASE + 6,
76 TPM_DISABLED = TPM_BASE + 7,
77 TPM_DISABLED_CMD = TPM_BASE + 8,
78 TPM_FAIL = TPM_BASE + 9,
79 TPM_BAD_ORDINAL = TPM_BASE + 10,
80 TPM_INSTALL_DISABLED = TPM_BASE + 11,
81 TPM_INVALID_KEYHANDLE = TPM_BASE + 12,
82 TPM_KEYNOTFOUND = TPM_BASE + 13,
83 TPM_INAPPROPRIATE_ENC = TPM_BASE + 14,
84 TPM_MIGRATE_FAIL = TPM_BASE + 15,
85 TPM_INVALID_PCR_INFO = TPM_BASE + 16,
86 TPM_NOSPACE = TPM_BASE + 17,
87 TPM_NOSRK = TPM_BASE + 18,
88 TPM_NOTSEALED_BLOB = TPM_BASE + 19,
89 TPM_OWNER_SET = TPM_BASE + 20,
90 TPM_RESOURCES = TPM_BASE + 21,
91 TPM_SHORTRANDOM = TPM_BASE + 22,
92 TPM_SIZE = TPM_BASE + 23,
93 TPM_WRONGPCRVAL = TPM_BASE + 24,
94 TPM_BAD_PARAM_SIZE = TPM_BASE + 25,
95 TPM_SHA_THREAD = TPM_BASE + 26,
96 TPM_SHA_ERROR = TPM_BASE + 27,
97 TPM_FAILEDSELFTEST = TPM_BASE + 28,
98 TPM_AUTH2FAIL = TPM_BASE + 29,
99 TPM_BADTAG = TPM_BASE + 30,
100 TPM_IOERROR = TPM_BASE + 31,
101 TPM_ENCRYPT_ERROR = TPM_BASE + 32,
102 TPM_DECRYPT_ERROR = TPM_BASE + 33,
103 TPM_INVALID_AUTHHANDLE = TPM_BASE + 34,
104 TPM_NO_ENDORSEMENT = TPM_BASE + 35,
105 TPM_INVALID_KEYUSAGE = TPM_BASE + 36,
106 TPM_WRONG_ENTITYTYPE = TPM_BASE + 37,
107 TPM_INVALID_POSTINIT = TPM_BASE + 38,
108 TPM_INAPPROPRIATE_SIG = TPM_BASE + 39,
109 TPM_BAD_KEY_PROPERTY = TPM_BASE + 40,
110 TPM_BAD_MIGRATION = TPM_BASE + 41,
111 TPM_BAD_SCHEME = TPM_BASE + 42,
112 TPM_BAD_DATASIZE = TPM_BASE + 43,
113 TPM_BAD_MODE = TPM_BASE + 44,
114 TPM_BAD_PRESENCE = TPM_BASE + 45,
115 TPM_BAD_VERSION = TPM_BASE + 46,
116 TPM_NO_WRAP_TRANSPORT = TPM_BASE + 47,
117 TPM_AUDITFAIL_UNSUCCESSFUL = TPM_BASE + 48,
118 TPM_AUDITFAIL_SUCCESSFUL = TPM_BASE + 49,
119 TPM_NOTRESETABLE = TPM_BASE + 50,
120 TPM_NOTLOCAL = TPM_BASE + 51,
121 TPM_BAD_TYPE = TPM_BASE + 52,
122 TPM_INVALID_RESOURCE = TPM_BASE + 53,
123 TPM_NOTFIPS = TPM_BASE + 54,
124 TPM_INVALID_FAMILY = TPM_BASE + 55,
125 TPM_NO_NV_PERMISSION = TPM_BASE + 56,
126 TPM_REQUIRES_SIGN = TPM_BASE + 57,
127 TPM_KEY_NOTSUPPORTED = TPM_BASE + 58,
128 TPM_AUTH_CONFLICT = TPM_BASE + 59,
129 TPM_AREA_LOCKED = TPM_BASE + 60,
130 TPM_BAD_LOCALITY = TPM_BASE + 61,
131 TPM_READ_ONLY = TPM_BASE + 62,
132 TPM_PER_NOWRITE = TPM_BASE + 63,
133 TPM_FAMILY_COUNT = TPM_BASE + 64,
134 TPM_WRITE_LOCKED = TPM_BASE + 65,
135 TPM_BAD_ATTRIBUTES = TPM_BASE + 66,
136 TPM_INVALID_STRUCTURE = TPM_BASE + 67,
137 TPM_KEY_OWNER_CONTROL = TPM_BASE + 68,
138 TPM_BAD_COUNTER = TPM_BASE + 69,
139 TPM_NOT_FULLWRITE = TPM_BASE + 70,
140 TPM_CONTEXT_GAP = TPM_BASE + 71,
141 TPM_MAXNVWRITES = TPM_BASE + 72,
142 TPM_NOOPERATOR = TPM_BASE + 73,
143 TPM_RESOURCEMISSING = TPM_BASE + 74,
144 TPM_DELEGATE_LOCK = TPM_BASE + 75,
145 TPM_DELEGATE_FAMILY = TPM_BASE + 76,
146 TPM_DELEGATE_ADMIN = TPM_BASE + 77,
147 TPM_TRANSPORT_NOTEXCLUSIVE = TPM_BASE + 78,
148 TPM_OWNER_CONTROL = TPM_BASE + 79,
149 TPM_DAA_RESOURCES = TPM_BASE + 80,
150 TPM_DAA_INPUT_DATA0 = TPM_BASE + 81,
151 TPM_DAA_INPUT_DATA1 = TPM_BASE + 82,
152 TPM_DAA_ISSUER_SETTINGS = TPM_BASE + 83,
153 TPM_DAA_TPM_SETTINGS = TPM_BASE + 84,
154 TPM_DAA_STAGE = TPM_BASE + 85,
155 TPM_DAA_ISSUER_VALIDITY = TPM_BASE + 86,
156 TPM_DAA_WRONG_W = TPM_BASE + 87,
157 TPM_BAD_HANDLE = TPM_BASE + 88,
158 TPM_BAD_DELEGATE = TPM_BASE + 89,
159 TPM_BADCONTEXT = TPM_BASE + 90,
160 TPM_TOOMANYCONTEXTS = TPM_BASE + 91,
161 TPM_MA_TICKET_SIGNATURE = TPM_BASE + 92,
162 TPM_MA_DESTINATION = TPM_BASE + 93,
163 TPM_MA_SOURCE = TPM_BASE + 94,
164 TPM_MA_AUTHORITY = TPM_BASE + 95,
165 TPM_PERMANENTEK = TPM_BASE + 97,
166 TPM_BAD_SIGNATURE = TPM_BASE + 98,
167 TPM_NOCONTEXTSPACE = TPM_BASE + 99,
168 /* TPM-defined non-fatal errors */
169 TPM_RETRY = TPM_BASE + TPM_NON_FATAL,
170 TPM_NEEDS_SELFTEST = TPM_BASE + TPM_NON_FATAL + 1,
171 TPM_DOING_SELFTEST = TPM_BASE + TPM_NON_FATAL + 2,
172 TPM_DEFEND_LOCK_RUNNING = TPM_BASE + TPM_NON_FATAL + 3,
173};
174
Simon Glass2132f972015-08-22 18:31:41 -0600175struct tpm_permanent_flags {
176 __be16 tag;
177 u8 disable;
178 u8 ownership;
179 u8 deactivated;
180 u8 read_pubek;
181 u8 disable_owner_clear;
182 u8 allow_maintenance;
183 u8 physical_presence_lifetime_lock;
184 u8 physical_presence_hw_enable;
185 u8 physical_presence_cmd_enable;
186 u8 cekp_used;
187 u8 tpm_post;
188 u8 tpm_post_lock;
189 u8 fips;
190 u8 operator;
191 u8 enable_revoke_ek;
192 u8 nv_locked;
193 u8 read_srk_pub;
194 u8 tpm_established;
195 u8 maintenance_done;
196 u8 disable_full_da_logic_info;
197} __packed;
198
Simon Glassf255d312015-08-22 18:31:31 -0600199#ifdef CONFIG_DM_TPM
200
201/* Max buffer size supported by our tpm */
202#define TPM_DEV_BUFSIZE 1260
203
204/**
205 * struct tpm_chip_priv - Information about a TPM, stored by the uclass
206 *
207 * These values must be set up by the device's probe() method before
208 * communcation is attempted. If the device has an xfer() method, this is
209 * not needed. There is no need to set up @buf.
210 *
211 * @duration_ms: Length of each duration type in milliseconds
212 * @retry_time_ms: Time to wait before retrying receive
213 */
214struct tpm_chip_priv {
215 uint duration_ms[TPM_DURATION_COUNT];
216 uint retry_time_ms;
217 u8 buf[TPM_DEV_BUFSIZE + sizeof(u8)]; /* Max buffer size + addr */
218};
219
220/**
221 * struct tpm_ops - low-level TPM operations
222 *
223 * These are designed to avoid loops and delays in the driver itself. These
224 * should be handled in the uclass.
225 *
226 * In gneral you should implement everything except xfer(). Where you need
227 * complete control of the transfer, then xfer() can be provided and will
228 * override the other methods.
229 *
230 * This interface is for low-level TPM access. It does not understand the
231 * concept of localities or the various TPM messages. That interface is
232 * defined in the functions later on in this file, but they all translate
233 * to bytes which are sent and received.
234 */
235struct tpm_ops {
236 /**
237 * open() - Request access to locality 0 for the caller
238 *
239 * After all commands have been completed the caller should call
240 * close().
241 *
242 * @dev: Device to close
243 * @return 0 ok OK, -ve on error
244 */
245 int (*open)(struct udevice *dev);
246
247 /**
248 * close() - Close the current session
249 *
250 * Releasing the locked locality. Returns 0 on success, -ve 1 on
251 * failure (in case lock removal did not succeed).
252 *
253 * @dev: Device to close
254 * @return 0 ok OK, -ve on error
255 */
256 int (*close)(struct udevice *dev);
257
258 /**
259 * get_desc() - Get a text description of the TPM
260 *
261 * @dev: Device to check
262 * @buf: Buffer to put the string
263 * @size: Maximum size of buffer
264 * @return length of string, or -ENOSPC it no space
265 */
266 int (*get_desc)(struct udevice *dev, char *buf, int size);
267
268 /**
269 * send() - send data to the TPM
270 *
271 * @dev: Device to talk to
272 * @sendbuf: Buffer of the data to send
273 * @send_size: Size of the data to send
274 *
275 * Returns 0 on success or -ve on failure.
276 */
277 int (*send)(struct udevice *dev, const uint8_t *sendbuf,
278 size_t send_size);
279
280 /**
281 * recv() - receive a response from the TPM
282 *
283 * @dev: Device to talk to
284 * @recvbuf: Buffer to save the response to
285 * @max_size: Maximum number of bytes to receive
286 *
287 * Returns number of bytes received on success, -EAGAIN if the TPM
288 * response is not ready, -EINTR if cancelled, or other -ve value on
289 * failure.
290 */
291 int (*recv)(struct udevice *dev, uint8_t *recvbuf, size_t max_size);
292
293 /**
294 * cleanup() - clean up after an operation in progress
295 *
296 * This is called if receiving times out. The TPM may need to abort
297 * the current transaction if it did not complete, and make itself
298 * ready for another.
299 *
300 * @dev: Device to talk to
301 */
302 int (*cleanup)(struct udevice *dev);
303
304 /**
305 * xfer() - send data to the TPM and get response
306 *
307 * This method is optional. If it exists it is used in preference
308 * to send(), recv() and cleanup(). It should handle all aspects of
309 * TPM communication for a single transfer.
310 *
311 * @dev: Device to talk to
312 * @sendbuf: Buffer of the data to send
313 * @send_size: Size of the data to send
314 * @recvbuf: Buffer to save the response to
315 * @recv_size: Pointer to the size of the response buffer
316 *
317 * Returns 0 on success (and places the number of response bytes at
318 * recv_size) or -ve on failure.
319 */
320 int (*xfer)(struct udevice *dev, const uint8_t *sendbuf,
321 size_t send_size, uint8_t *recvbuf, size_t *recv_size);
322};
323
324#define tpm_get_ops(dev) ((struct tpm_ops *)device_get_ops(dev))
325
326/**
327 * tpm_open() - Request access to locality 0 for the caller
328 *
329 * After all commands have been completed the caller is supposed to
330 * call tpm_close().
331 *
332 * Returns 0 on success, -ve on failure.
333 */
334int tpm_open(struct udevice *dev);
335
336/**
337 * tpm_close() - Close the current session
338 *
339 * Releasing the locked locality. Returns 0 on success, -ve 1 on
340 * failure (in case lock removal did not succeed).
341 */
342int tpm_close(struct udevice *dev);
343
344/**
345 * tpm_get_desc() - Get a text description of the TPM
346 *
347 * @dev: Device to check
348 * @buf: Buffer to put the string
349 * @size: Maximum size of buffer
350 * @return length of string, or -ENOSPC it no space
351 */
352int tpm_get_desc(struct udevice *dev, char *buf, int size);
353
354/**
355 * tpm_xfer() - send data to the TPM and get response
356 *
357 * This first uses the device's send() method to send the bytes. Then it calls
358 * recv() to get the reply. If recv() returns -EAGAIN then it will delay a
359 * short time and then call recv() again.
360 *
361 * Regardless of whether recv() completes successfully, it will then call
362 * cleanup() to finish the transaction.
363 *
364 * Note that the outgoing data is inspected to determine command type
365 * (ordinal) and a timeout is used for that command type.
366 *
367 * @sendbuf - buffer of the data to send
368 * @send_size size of the data to send
369 * @recvbuf - memory to save the response to
370 * @recv_len - pointer to the size of the response buffer
371 *
372 * Returns 0 on success (and places the number of response bytes at
373 * recv_len) or -ve on failure.
374 */
375int tpm_xfer(struct udevice *dev, const uint8_t *sendbuf, size_t send_size,
376 uint8_t *recvbuf, size_t *recv_size);
377
378#endif /* CONFIG_DM_TPM */
379
Reinhard Pfaube6c1522013-06-26 15:55:13 +0200380/**
Che-liang Chiou8732b072013-02-28 09:34:57 +0000381 * Initialize TPM device. It must be called before any TPM commands.
Vadim Bendebury5e124722011-10-17 08:36:14 +0000382 *
Che-liang Chiou8732b072013-02-28 09:34:57 +0000383 * @return 0 on success, non-0 on error.
Vadim Bendebury5e124722011-10-17 08:36:14 +0000384 */
Simon Glassc8a8c512015-08-22 18:31:32 -0600385int tpm_init(void);
Vadim Bendebury5e124722011-10-17 08:36:14 +0000386
Che-liang Chiou8732b072013-02-28 09:34:57 +0000387/**
388 * Issue a TPM_Startup command.
Vadim Bendebury5e124722011-10-17 08:36:14 +0000389 *
Che-liang Chiou8732b072013-02-28 09:34:57 +0000390 * @param mode TPM startup mode
391 * @return return code of the operation
Vadim Bendebury5e124722011-10-17 08:36:14 +0000392 */
Che-liang Chiou8732b072013-02-28 09:34:57 +0000393uint32_t tpm_startup(enum tpm_startup_type mode);
Vadim Bendebury5e124722011-10-17 08:36:14 +0000394
Che-liang Chiou8732b072013-02-28 09:34:57 +0000395/**
396 * Issue a TPM_SelfTestFull command.
Vadim Bendebury5e124722011-10-17 08:36:14 +0000397 *
Che-liang Chiou8732b072013-02-28 09:34:57 +0000398 * @return return code of the operation
Vadim Bendebury5e124722011-10-17 08:36:14 +0000399 */
Che-liang Chiou8732b072013-02-28 09:34:57 +0000400uint32_t tpm_self_test_full(void);
Vadim Bendebury5e124722011-10-17 08:36:14 +0000401
Che-liang Chiou8732b072013-02-28 09:34:57 +0000402/**
403 * Issue a TPM_ContinueSelfTest command.
404 *
405 * @return return code of the operation
406 */
407uint32_t tpm_continue_self_test(void);
408
409/**
410 * Issue a TPM_NV_DefineSpace command. The implementation is limited
411 * to specify TPM_NV_ATTRIBUTES and size of the area. The area index
412 * could be one of the special value listed in enum tpm_nv_index.
413 *
414 * @param index index of the area
415 * @param perm TPM_NV_ATTRIBUTES of the area
416 * @param size size of the area
417 * @return return code of the operation
418 */
419uint32_t tpm_nv_define_space(uint32_t index, uint32_t perm, uint32_t size);
420
421/**
422 * Issue a TPM_NV_ReadValue command. This implementation is limited
423 * to read the area from offset 0. The area index could be one of
424 * the special value listed in enum tpm_nv_index.
425 *
426 * @param index index of the area
427 * @param data output buffer of the area contents
428 * @param count size of output buffer
429 * @return return code of the operation
430 */
431uint32_t tpm_nv_read_value(uint32_t index, void *data, uint32_t count);
432
433/**
434 * Issue a TPM_NV_WriteValue command. This implementation is limited
435 * to write the area from offset 0. The area index could be one of
436 * the special value listed in enum tpm_nv_index.
437 *
438 * @param index index of the area
439 * @param data input buffer to be wrote to the area
440 * @param length length of data bytes of input buffer
441 * @return return code of the operation
442 */
443uint32_t tpm_nv_write_value(uint32_t index, const void *data, uint32_t length);
444
445/**
446 * Issue a TPM_Extend command.
447 *
448 * @param index index of the PCR
449 * @param in_digest 160-bit value representing the event to be
450 * recorded
451 * @param out_digest 160-bit PCR value after execution of the
452 * command
453 * @return return code of the operation
454 */
455uint32_t tpm_extend(uint32_t index, const void *in_digest, void *out_digest);
456
457/**
458 * Issue a TPM_PCRRead command.
459 *
460 * @param index index of the PCR
461 * @param data output buffer for contents of the named PCR
462 * @param count size of output buffer
463 * @return return code of the operation
464 */
465uint32_t tpm_pcr_read(uint32_t index, void *data, size_t count);
466
467/**
468 * Issue a TSC_PhysicalPresence command. TPM physical presence flag
469 * is bit-wise OR'ed of flags listed in enum tpm_physical_presence.
470 *
471 * @param presence TPM physical presence flag
472 * @return return code of the operation
473 */
474uint32_t tpm_tsc_physical_presence(uint16_t presence);
475
476/**
477 * Issue a TPM_ReadPubek command.
478 *
479 * @param data output buffer for the public endorsement key
480 * @param count size of ouput buffer
481 * @return return code of the operation
482 */
483uint32_t tpm_read_pubek(void *data, size_t count);
484
485/**
486 * Issue a TPM_ForceClear command.
487 *
488 * @return return code of the operation
489 */
490uint32_t tpm_force_clear(void);
491
492/**
493 * Issue a TPM_PhysicalEnable command.
494 *
495 * @return return code of the operation
496 */
497uint32_t tpm_physical_enable(void);
498
499/**
500 * Issue a TPM_PhysicalDisable command.
501 *
502 * @return return code of the operation
503 */
504uint32_t tpm_physical_disable(void);
505
506/**
507 * Issue a TPM_PhysicalSetDeactivated command.
508 *
509 * @param state boolean state of the deactivated flag
510 * @return return code of the operation
511 */
512uint32_t tpm_physical_set_deactivated(uint8_t state);
513
514/**
515 * Issue a TPM_GetCapability command. This implementation is limited
516 * to query sub_cap index that is 4-byte wide.
517 *
518 * @param cap_area partition of capabilities
519 * @param sub_cap further definition of capability, which is
520 * limited to be 4-byte wide
521 * @param cap output buffer for capability information
522 * @param count size of ouput buffer
523 * @return return code of the operation
524 */
525uint32_t tpm_get_capability(uint32_t cap_area, uint32_t sub_cap,
526 void *cap, size_t count);
527
Reinhard Pfaube6c1522013-06-26 15:55:13 +0200528/**
529 * Issue a TPM_FlushSpecific command for a AUTH ressource.
530 *
531 * @param auth_handle handle of the auth session
532 * @return return code of the operation
533 */
534uint32_t tpm_terminate_auth_session(uint32_t auth_handle);
535
536/**
537 * Issue a TPM_OIAP command to setup an object independant authorization
538 * session.
539 * Information about the session is stored internally.
540 * If there was already an OIAP session active it is terminated and a new
541 * session is set up.
542 *
543 * @param auth_handle pointer to the (new) auth handle or NULL.
544 * @return return code of the operation
545 */
546uint32_t tpm_oiap(uint32_t *auth_handle);
547
548/**
549 * Ends an active OIAP session.
550 *
551 * @return return code of the operation
552 */
553uint32_t tpm_end_oiap(void);
554
555/**
556 * Issue a TPM_LoadKey2 (Auth1) command using an OIAP session for authenticating
557 * the usage of the parent key.
558 *
559 * @param parent_handle handle of the parent key.
560 * @param key pointer to the key structure (TPM_KEY or TPM_KEY12).
561 * @param key_length size of the key structure
562 * @param parent_key_usage_auth usage auth for the parent key
563 * @param key_handle pointer to the key handle
564 * @return return code of the operation
565 */
566uint32_t tpm_load_key2_oiap(uint32_t parent_handle,
567 const void *key, size_t key_length,
568 const void *parent_key_usage_auth,
569 uint32_t *key_handle);
570
571/**
572 * Issue a TPM_GetPubKey (Auth1) command using an OIAP session for
573 * authenticating the usage of the key.
574 *
575 * @param key_handle handle of the key
576 * @param usage_auth usage auth for the key
577 * @param pubkey pointer to the pub key buffer; may be NULL if the pubkey
578 * should not be stored.
579 * @param pubkey_len pointer to the pub key buffer len. On entry: the size of
580 * the provided pubkey buffer. On successful exit: the size
581 * of the stored TPM_PUBKEY structure (iff pubkey != NULL).
582 * @return return code of the operation
583 */
584uint32_t tpm_get_pub_key_oiap(uint32_t key_handle, const void *usage_auth,
585 void *pubkey, size_t *pubkey_len);
586
Simon Glass2132f972015-08-22 18:31:41 -0600587/**
588 * Get the TPM permanent flags value
589 *
590 * @param pflags Place to put permanent flags
591 * @return return code of the operation
592 */
593uint32_t tpm_get_permanent_flags(struct tpm_permanent_flags *pflags);
594
595/**
596 * Get the TPM permissions
597 *
598 * @param perm Returns permissions value
599 * @return return code of the operation
600 */
601uint32_t tpm_get_permissions(uint32_t index, uint32_t *perm);
602
Che-liang Chiou8732b072013-02-28 09:34:57 +0000603#endif /* __TPM_H */