[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

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

/**
 * 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
 */
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;
};

/**
 * 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, -ve on 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);

	/**
	 * 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(cmd_tbl_t *cmdtp, int flag,		\
	     int argc, char * const argv[])		\
{							\
	if (argc != 1)					\
		return CMD_RET_USAGE;			\
	return report_return_code(cmd());		\
}

/**
 * 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_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.
 *
 * @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.
 *
 * @return 0 on success, non-0 on error.
 */
int tpm_init(void);

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

#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
	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
2a2096ea MR	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
d677bfe2 MR	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	*
2a2096ea	46	* @version: TPM stack to be used
d677bfe2 MR	47	* @duration_ms: Length of each duration type in milliseconds
d677bfe2 MR	48	* @retry_time_ms: Time to wait before retrying receive
2a2096ea	49	* @buf: Buffer used during the exchanges with the chip
ff32245b MR	50	* @pcr_count: Number of PCR per bank
ff32245b MR	51	* @pcr_select_min: Minimum size in bytes of the pcrSelect array
d677bfe2 MR	52	*/
d677bfe2 MR	53	struct tpm_chip_priv {
2a2096ea MR	54	enum tpm_version version;
2a2096ea MR	55
d677bfe2 MR	56	uint duration_ms[TPM_DURATION_COUNT];
d677bfe2 MR	57	uint retry_time_ms;
2a2096ea MR	58	u8 buf[TPM_DEV_BUFSIZE + sizeof(u8)]; /* Max buffer size + addr */
	59
	60	/* TPM v2 specific data */
ff32245b MR	61	uint pcr_count;
ff32245b MR	62	uint pcr_select_min;
d677bfe2 MR	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	*
350988ff	87	* @dev: Device to open
d677bfe2 MR	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	/**
2a2096ea	224	* Retrieve the array containing all the v1 (resp. v2) commands.
d677bfe2 MR	225	*
	226	* @return a cmd_tbl_t array.
	227	*/
2a2096ea MR	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
d677bfe2 MR	244
d677bfe2 MR	245	#endif /* __TPM_COMMON_H */