[thirdparty/u-boot.git] / include / tpm-common.h

/* SPDX-License-Identifier: GPL-2.0+ */
/*
 * Copyright (c) 2013 The Chromium OS Authors.
 * Coypright (c) 2013 Guntermann & Drunck GmbH
 */

#ifndef __TPM_COMMON_H
#define __TPM_COMMON_H

#include <command.h>

struct udevice;

enum tpm_duration {
	TPM_SHORT = 0,
	TPM_MEDIUM = 1,
	TPM_LONG = 2,
	TPM_UNDEFINED,

	TPM_DURATION_COUNT,
};

/*
 * Here is a partial implementation of TPM commands.  Please consult TCG Main
 * Specification for definitions of TPM commands.
 */

#define TPM_HEADER_SIZE		10

/* Max buffer size supported by our tpm */
#define TPM_DEV_BUFSIZE		1260

#define TPM_PCR_MINIMUM_DIGEST_SIZE 20

/**
 * enum tpm_version - The version of the TPM stack to be used
 * @TPM_V1:		Use TPM v1.x stack
 * @TPM_V2:		Use TPM v2.x stack
 */
enum tpm_version {
	TPM_V1 = 0,
	TPM_V2,
};

/**
 * struct tpm_chip_priv - Information about a TPM, stored by the uclass
 *
 * These values must be set up by the device's probe() method before
 * communcation is attempted. If the device has an xfer() method, this is
 * not needed. There is no need to set up @buf.
 *
 * @version:		TPM stack to be used
 * @duration_ms:	Length of each duration type in milliseconds
 * @retry_time_ms:	Time to wait before retrying receive
 * @buf:		Buffer used during the exchanges with the chip
 * @pcr_count:		Number of PCR per bank
 * @pcr_select_min:	Minimum size in bytes of the pcrSelect array
 * @plat_hier_disabled:	Platform hierarchy has been disabled (TPM is locked
 *			down until next reboot)
 */
struct tpm_chip_priv {
	enum tpm_version version;

	uint duration_ms[TPM_DURATION_COUNT];
	uint retry_time_ms;
	u8 buf[TPM_DEV_BUFSIZE + sizeof(u8)];  /* Max buffer size + addr */

	/* TPM v2 specific data */
	uint pcr_count;
	uint pcr_select_min;
	bool plat_hier_disabled;
};

/**
 * struct tpm_ops - low-level TPM operations
 *
 * These are designed to avoid loops and delays in the driver itself. These
 * should be handled in the uclass.
 *
 * In gneral you should implement everything except xfer(). Where you need
 * complete control of the transfer, then xfer() can be provided and will
 * override the other methods.
 *
 * This interface is for low-level TPM access. It does not understand the
 * concept of localities or the various TPM messages. That interface is
 * defined in the functions later on in this file, but they all translate
 * to bytes which are sent and received.
 */
struct tpm_ops {
	/**
	 * open() - Request access to locality 0 for the caller
	 *
	 * After all commands have been completed the caller should call
	 * close().
	 *
	 * @dev:	Device to open
	 * @return 0 ok OK, -EBUSY if already opened, other -ve on other error
	 */
	int (*open)(struct udevice *dev);

	/**
	 * close() - Close the current session
	 *
	 * Releasing the locked locality. Returns 0 on success, -ve 1 on
	 * failure (in case lock removal did not succeed).
	 *
	 * @dev:	Device to close
	 * @return 0 ok OK, -ve on error
	 */
	int (*close)(struct udevice *dev);

	/**
	 * get_desc() - Get a text description of the TPM
	 *
	 * @dev:	Device to check
	 * @buf:	Buffer to put the string
	 * @size:	Maximum size of buffer
	 * @return length of string, or -ENOSPC it no space
	 */
	int (*get_desc)(struct udevice *dev, char *buf, int size);

	/**
	 * report_state() - Collect information about the current TPM state
	 *
	 * @dev:	Device to check
	 * @buf:	Buffer to put the string
	 * @size:	Maximum size of buffer
	 * Return: return code of the operation (0 = success)
	 */
	int (*report_state)(struct udevice *dev, char *buf, int size);

	/**
	 * send() - send data to the TPM
	 *
	 * @dev:	Device to talk to
	 * @sendbuf:	Buffer of the data to send
	 * @send_size:	Size of the data to send
	 *
	 * Returns 0 on success or -ve on failure.
	 */
	int (*send)(struct udevice *dev, const u8 *sendbuf, size_t send_size);

	/**
	 * recv() - receive a response from the TPM
	 *
	 * @dev:	Device to talk to
	 * @recvbuf:	Buffer to save the response to
	 * @max_size:	Maximum number of bytes to receive
	 *
	 * Returns number of bytes received on success, -EAGAIN if the TPM
	 * response is not ready, -EINTR if cancelled, or other -ve value on
	 * failure.
	 */
	int (*recv)(struct udevice *dev, u8 *recvbuf, size_t max_size);

	/**
	 * cleanup() - clean up after an operation in progress
	 *
	 * This is called if receiving times out. The TPM may need to abort
	 * the current transaction if it did not complete, and make itself
	 * ready for another.
	 *
	 * @dev:	Device to talk to
	 */
	int (*cleanup)(struct udevice *dev);

	/**
	 * xfer() - send data to the TPM and get response
	 *
	 * This method is optional. If it exists it is used in preference
	 * to send(), recv() and cleanup(). It should handle all aspects of
	 * TPM communication for a single transfer.
	 *
	 * @dev:	Device to talk to
	 * @sendbuf:	Buffer of the data to send
	 * @send_size:	Size of the data to send
	 * @recvbuf:	Buffer to save the response to
	 * @recv_size:	Pointer to the size of the response buffer
	 *
	 * Returns 0 on success (and places the number of response bytes at
	 * recv_size) or -ve on failure.
	 */
	int (*xfer)(struct udevice *dev, const u8 *sendbuf, size_t send_size,
		    u8 *recvbuf, size_t *recv_size);
};

#define tpm_get_ops(dev)        ((struct tpm_ops *)device_get_ops(dev))

#define MAKE_TPM_CMD_ENTRY(cmd) \
	U_BOOT_CMD_MKENT(cmd, 0, 1, do_tpm_ ## cmd, "", "")

#define TPM_COMMAND_NO_ARG(cmd)				\
int do_##cmd(struct cmd_tbl *cmdtp, int flag,		\
	     int argc, char *const argv[])		\
{							\
	struct udevice *dev;				\
	int rc;						\
							\
	rc = get_tpm(&dev);				\
	if (rc)						\
		return rc;				\
	if (argc != 1)					\
		return CMD_RET_USAGE;			\
	return report_return_code(cmd(dev));		\
}

/**
 * tpm_open() - Request access to locality 0 for the caller
 *
 * After all commands have been completed the caller is supposed to
 * call tpm_close().
 *
 * @dev - TPM device
 * Returns 0 on success, -ve on failure.
 */
int tpm_open(struct udevice *dev);

/**
 * tpm_close() - Close the current session
 *
 * Releasing the locked locality. Returns 0 on success, -ve 1 on
 * failure (in case lock removal did not succeed).
 *
 * @dev - TPM device
 * Returns 0 on success, -ve on failure.
 */
int tpm_close(struct udevice *dev);

/**
 * tpm_clear_and_reenable() - Force clear the TPM and reenable it
 *
 * @dev: TPM device
 * Return: 0 on success, -ve on failure
 */
u32 tpm_clear_and_reenable(struct udevice *dev);

/**
 * tpm_get_desc() - Get a text description of the TPM
 *
 * @dev:	Device to check
 * @buf:	Buffer to put the string
 * @size:	Maximum size of buffer
 * Return: length of string, or -ENOSPC it no space
 */
int tpm_get_desc(struct udevice *dev, char *buf, int size);

/**
 * tpm_report_state() - Collect information about the current TPM state
 *
 * @dev:	Device to check
 * @buf:	Buffer to put the string
 * @size:	Maximum size of buffer
 * Return: return code of the operation (0 = success)
 */
int tpm_report_state(struct udevice *dev, char *buf, int size);

/**
 * tpm_xfer() - send data to the TPM and get response
 *
 * This first uses the device's send() method to send the bytes. Then it calls
 * recv() to get the reply. If recv() returns -EAGAIN then it will delay a
 * short time and then call recv() again.
 *
 * Regardless of whether recv() completes successfully, it will then call
 * cleanup() to finish the transaction.
 *
 * Note that the outgoing data is inspected to determine command type
 * (ordinal) and a timeout is used for that command type.
 *
 * @dev - TPM device
 * @sendbuf - buffer of the data to send
 * @send_size size of the data to send
 * @recvbuf - memory to save the response to
 * @recv_len - pointer to the size of the response buffer
 *
 * Returns 0 on success (and places the number of response bytes at
 * recv_len) or -ve on failure.
 */
int tpm_xfer(struct udevice *dev, const u8 *sendbuf, size_t send_size,
	     u8 *recvbuf, size_t *recv_size);

/**
 * Initialize TPM device.  It must be called before any TPM commands.
 *
 * @dev - TPM device
 * Return: 0 on success, non-0 on error.
 */
int tpm_init(struct udevice *dev);

/**
 * Retrieve the array containing all the v1 (resp. v2) commands.
 *
 * Return: a struct cmd_tbl array.
 */
#if defined(CONFIG_TPM_V1)
struct cmd_tbl *get_tpm1_commands(unsigned int *size);
#else
static inline struct cmd_tbl *get_tpm1_commands(unsigned int *size)
{
	return NULL;
}
#endif
#if defined(CONFIG_TPM_V2)
struct cmd_tbl *get_tpm2_commands(unsigned int *size);
#else
static inline struct cmd_tbl *get_tpm2_commands(unsigned int *size)
{
	return NULL;
}
#endif

/**
 * tpm_get_version() - Find the version of a TPM
 *
 * This checks the uclass data for a TPM device and returns the version number
 * it supports.
 *
 * @dev: TPM device
 * Return: version number (TPM_V1 or TPMV2)
 */
enum tpm_version tpm_get_version(struct udevice *dev);

/* Iterate on all TPM devices */
#define for_each_tpm_device(dev) uclass_foreach_dev_probe(UCLASS_TPM, (dev))

#endif /* __TPM_COMMON_H */
Commit	Line	Data
d677bfe2 MR	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
09140113 SG	10	#include <command.h>
09140113 SG	11
401d1c4f SG	12	struct udevice;
401d1c4f SG	13
d677bfe2 MR	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
07e127d8 SG	33	#define TPM_PCR_MINIMUM_DIGEST_SIZE 20
07e127d8 SG	34
2a2096ea MR	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
d677bfe2 MR	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	*
2a2096ea	52	* @version: TPM stack to be used
d677bfe2 MR	53	* @duration_ms: Length of each duration type in milliseconds
d677bfe2 MR	54	* @retry_time_ms: Time to wait before retrying receive
2a2096ea	55	* @buf: Buffer used during the exchanges with the chip
ff32245b MR	56	* @pcr_count: Number of PCR per bank
ff32245b MR	57	* @pcr_select_min: Minimum size in bytes of the pcrSelect array
6719cbe3 SG	58	* @plat_hier_disabled: Platform hierarchy has been disabled (TPM is locked
6719cbe3 SG	59	* down until next reboot)
d677bfe2 MR	60	*/
d677bfe2 MR	61	struct tpm_chip_priv {
2a2096ea MR	62	enum tpm_version version;
2a2096ea MR	63
d677bfe2 MR	64	uint duration_ms[TPM_DURATION_COUNT];
d677bfe2 MR	65	uint retry_time_ms;
2a2096ea MR	66	u8 buf[TPM_DEV_BUFSIZE + sizeof(u8)]; /* Max buffer size + addr */
	67
	68	/* TPM v2 specific data */
ff32245b MR	69	uint pcr_count;
ff32245b MR	70	uint pcr_select_min;
6719cbe3	71	bool plat_hier_disabled;
d677bfe2 MR	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	*
350988ff	96	* @dev: Device to open
a11be4c3	97	* @return 0 ok OK, -EBUSY if already opened, other -ve on other error
d677bfe2 MR	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
3bb4db4c SG	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
d677bfe2 MR	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) \
09140113 SG	193	int do_##cmd(struct cmd_tbl *cmdtp, int flag, \
09140113 SG	194	int argc, char *const argv[]) \
d677bfe2	195	{ \
abdc7b8a SG	196	struct udevice *dev; \
	197	int rc; \
	198	\
	199	rc = get_tpm(&dev); \
	200	if (rc) \
	201	return rc; \
d677bfe2 MR	202	if (argc != 1) \
d677bfe2 MR	203	return CMD_RET_USAGE; \
abdc7b8a	204	return report_return_code(cmd(dev)); \
d677bfe2 MR	205	}
d677bfe2 MR	206
51f00c17 SG	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	*
abdc7b8a	213	* @dev - TPM device
51f00c17 SG	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).
abdc7b8a SG	223	*
	224	* @dev - TPM device
	225	* Returns 0 on success, -ve on failure.
51f00c17 SG	226	*/
	227	int tpm_close(struct udevice *dev);
	228
5e69b8bc SG	229	/**
	230	* tpm_clear_and_reenable() - Force clear the TPM and reenable it
	231	*
	232	* @dev: TPM device
185f812c	233	* Return: 0 on success, -ve on failure
5e69b8bc SG	234	*/
	235	u32 tpm_clear_and_reenable(struct udevice *dev);
	236
d677bfe2 MR	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
185f812c	243	* Return: length of string, or -ENOSPC it no space
d677bfe2 MR	244	*/
	245	int tpm_get_desc(struct udevice dev, char buf, int size);
	246
3bb4db4c SG	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
d677bfe2 MR	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	*
abdc7b8a	270	* @dev - TPM device
d677bfe2 MR	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	*
abdc7b8a	285	* @dev - TPM device
185f812c	286	* Return: 0 on success, non-0 on error.
d677bfe2	287	*/
abdc7b8a	288	int tpm_init(struct udevice *dev);
d677bfe2 MR	289
d677bfe2 MR	290	/**
2a2096ea	291	* Retrieve the array containing all the v1 (resp. v2) commands.
d677bfe2	292	*
185f812c	293	* Return: a struct cmd_tbl array.
d677bfe2	294	*/
2a2096ea	295	#if defined(CONFIG_TPM_V1)
09140113	296	struct cmd_tbl get_tpm1_commands(unsigned int size);
2a2096ea	297	#else
09140113	298	static inline struct cmd_tbl get_tpm1_commands(unsigned int size)
2a2096ea MR	299	{
	300	return NULL;
	301	}
	302	#endif
	303	#if defined(CONFIG_TPM_V2)
09140113	304	struct cmd_tbl get_tpm2_commands(unsigned int size);
2a2096ea	305	#else
09140113	306	static inline struct cmd_tbl get_tpm2_commands(unsigned int size)
2a2096ea MR	307	{
	308	return NULL;
	309	}
	310	#endif
d677bfe2	311
0a60a0a6 SG	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
185f812c	319	* Return: version number (TPM_V1 or TPMV2)
0a60a0a6 SG	320	*/
	321	enum tpm_version tpm_get_version(struct udevice *dev);
	322
bb3f47eb PR	323	/* Iterate on all TPM devices */
	324	#define for_each_tpm_device(dev) uclass_foreach_dev_probe(UCLASS_TPM, (dev))
	325
d677bfe2	326	#endif /* __TPM_COMMON_H */