[J-u-boot.git] / drivers / tpm / tpm_atmel_twi.c

/*
 * Copyright (C) 2013 Guntermann & Drunck, GmbH
 *
 * Written by Dirk Eibach <[email protected]>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <dm.h>
#include <tpm.h>
#include <i2c.h>
#include <asm/unaligned.h>

#include "tpm_internal.h"

#define ATMEL_TPM_TIMEOUT_MS 5000 /* sufficient for anything but
				     generating/exporting keys */

/*
 * tpm_atmel_twi_open()
 *
 * Requests access to locality 0 for the caller. After all commands have been
 * completed the caller is supposed to call tis_close().
 *
 * Returns 0 on success, -1 on failure.
 */
static int tpm_atmel_twi_open(struct udevice *dev)
{
	return 0;
}

/*
 * tpm_atmel_twi_close()
 *
 * terminate the currect session with the TPM by releasing the locked
 * locality. Returns 0 on success of -1 on failure (in case lock
 * removal did not succeed).
 */
static int tpm_atmel_twi_close(struct udevice *dev)
{
	return 0;
}

/*
 * tpm_atmel_twi_get_desc()
 *
 * @dev:        Device to check
 * @buf:        Buffer to put the string
 * @size:       Maximum size of buffer
 * @return length of string, or -ENOSPC it no space
 */
static int tpm_atmel_twi_get_desc(struct udevice *dev, char *buf, int size)
{
	return 0;
}

/*
 * tpm_atmel_twi_xfer()
 *
 * Send the requested data to the TPM and then try to get its response
 *
 * @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 -1 on failure.
 */
static int tpm_atmel_twi_xfer(struct udevice *dev,
			      const uint8_t *sendbuf, size_t send_size,
			      uint8_t *recvbuf, size_t *recv_len)
{
	int res;
	unsigned long start;

#ifdef DEBUG
	memset(recvbuf, 0xcc, *recv_len);
	printf("send to TPM (%d bytes, recv_len=%d):\n", send_size, *recv_len);
	print_buffer(0, (void *)sendbuf, 1, send_size, 0);
#endif

	res = i2c_write(0x29, 0, 0, (uchar *)sendbuf, send_size);
	if (res) {
		printf("i2c_write returned %d\n", res);
		return -1;
	}

	start = get_timer(0);
	while ((res = i2c_read(0x29, 0, 0, recvbuf, 10))) {
		/* TODO Use TIS_TIMEOUT from tpm_tis_infineon.h */
		if (get_timer(start) > ATMEL_TPM_TIMEOUT_MS) {
			puts("tpm timed out\n");
			return -1;
		}
		udelay(100);
	}
	if (!res) {
		*recv_len = get_unaligned_be32(recvbuf + 2);
		if (*recv_len > 10)
			res = i2c_read(0x29, 0, 0, recvbuf, *recv_len);
	}
	if (res) {
		printf("i2c_read returned %d (rlen=%d)\n", res, *recv_len);
#ifdef DEBUG
		print_buffer(0, recvbuf, 1, *recv_len, 0);
#endif
	}

#ifdef DEBUG
	if (!res) {
		printf("read from TPM (%d bytes):\n", *recv_len);
		print_buffer(0, recvbuf, 1, *recv_len, 0);
	}
#endif

	return res;
}

static int tpm_atmel_twi_probe(struct udevice *dev)
{
	return 0;
}

static const struct udevice_id tpm_atmel_twi_ids[] = {
	{ .compatible = "atmel,at97sc3204t"},
	{ }
};

static const struct tpm_ops tpm_atmel_twi_ops = {
	.open = tpm_atmel_twi_open,
	.close = tpm_atmel_twi_close,
	.xfer = tpm_atmel_twi_xfer,
	.get_desc = tpm_atmel_twi_get_desc,
};

U_BOOT_DRIVER(tpm_atmel_twi) = {
	.name = "tpm_atmel_twi",
	.id = UCLASS_TPM,
	.of_match = tpm_atmel_twi_ids,
	.ops = &tpm_atmel_twi_ops,
	.probe = tpm_atmel_twi_probe,
};
Commit	Line	Data
c01939c7	1	/*
07470d6f	2	* Copyright (C) 2013 Guntermann & Drunck, GmbH
c01939c7	3	*
07470d6f	4	* Written by Dirk Eibach <[email protected]>
c01939c7	5	*
07470d6f	6	* SPDX-License-Identifier: GPL-2.0+
c01939c7 DE	7	*/
	8
	9	#include <common.h>
302c5dba	10	#include <dm.h>
c01939c7 DE	11	#include <tpm.h>
	12	#include <i2c.h>
	13	#include <asm/unaligned.h>
	14
302c5dba CR	15	#include "tpm_internal.h"
302c5dba CR	16
c01939c7 DE	17	#define ATMEL_TPM_TIMEOUT_MS 5000 /* sufficient for anything but
	18	generating/exporting keys */
	19
	20	/*
302c5dba	21	* tpm_atmel_twi_open()
c01939c7 DE	22	*
	23	* Requests access to locality 0 for the caller. After all commands have been
	24	* completed the caller is supposed to call tis_close().
	25	*
	26	* Returns 0 on success, -1 on failure.
	27	*/
302c5dba	28	static int tpm_atmel_twi_open(struct udevice *dev)
c01939c7 DE	29	{
	30	return 0;
	31	}
	32
	33	/*
302c5dba	34	* tpm_atmel_twi_close()
c01939c7 DE	35	*
	36	* terminate the currect session with the TPM by releasing the locked
	37	* locality. Returns 0 on success of -1 on failure (in case lock
	38	* removal did not succeed).
	39	*/
302c5dba CR	40	static int tpm_atmel_twi_close(struct udevice *dev)
	41	{
	42	return 0;
	43	}
	44
	45	/*
	46	* tpm_atmel_twi_get_desc()
	47	*
	48	* @dev: Device to check
	49	* @buf: Buffer to put the string
	50	* @size: Maximum size of buffer
	51	* @return length of string, or -ENOSPC it no space
	52	*/
	53	static int tpm_atmel_twi_get_desc(struct udevice dev, char buf, int size)
c01939c7 DE	54	{
	55	return 0;
	56	}
	57
	58	/*
302c5dba	59	* tpm_atmel_twi_xfer()
c01939c7 DE	60	*
	61	* Send the requested data to the TPM and then try to get its response
	62	*
	63	* @sendbuf - buffer of the data to send
	64	* @send_size size of the data to send
	65	* @recvbuf - memory to save the response to
	66	* @recv_len - pointer to the size of the response buffer
	67	*
	68	* Returns 0 on success (and places the number of response bytes at recv_len)
	69	* or -1 on failure.
	70	*/
302c5dba CR	71	static int tpm_atmel_twi_xfer(struct udevice *dev,
	72	const uint8_t *sendbuf, size_t send_size,
	73	uint8_t recvbuf, size_t recv_len)
c01939c7 DE	74	{
	75	int res;
	76	unsigned long start;
	77
	78	#ifdef DEBUG
	79	memset(recvbuf, 0xcc, *recv_len);
	80	printf("send to TPM (%d bytes, recv_len=%d):\n", send_size, *recv_len);
	81	print_buffer(0, (void *)sendbuf, 1, send_size, 0);
	82	#endif
	83
	84	res = i2c_write(0x29, 0, 0, (uchar *)sendbuf, send_size);
	85	if (res) {
	86	printf("i2c_write returned %d\n", res);
	87	return -1;
	88	}
	89
	90	start = get_timer(0);
	91	while ((res = i2c_read(0x29, 0, 0, recvbuf, 10))) {
302c5dba	92	/* TODO Use TIS_TIMEOUT from tpm_tis_infineon.h */
c01939c7 DE	93	if (get_timer(start) > ATMEL_TPM_TIMEOUT_MS) {
	94	puts("tpm timed out\n");
	95	return -1;
	96	}
	97	udelay(100);
	98	}
	99	if (!res) {
	100	*recv_len = get_unaligned_be32(recvbuf + 2);
	101	if (*recv_len > 10)
	102	res = i2c_read(0x29, 0, 0, recvbuf, *recv_len);
	103	}
	104	if (res) {
	105	printf("i2c_read returned %d (rlen=%d)\n", res, *recv_len);
	106	#ifdef DEBUG
	107	print_buffer(0, recvbuf, 1, *recv_len, 0);
	108	#endif
	109	}
	110
	111	#ifdef DEBUG
	112	if (!res) {
	113	printf("read from TPM (%d bytes):\n", *recv_len);
	114	print_buffer(0, recvbuf, 1, *recv_len, 0);
	115	}
	116	#endif
	117
	118	return res;
	119	}
302c5dba CR	120
	121	static int tpm_atmel_twi_probe(struct udevice *dev)
	122	{
	123	return 0;
	124	}
	125
	126	static const struct udevice_id tpm_atmel_twi_ids[] = {
	127	{ .compatible = "atmel,at97sc3204t"},
	128	{ }
	129	};
	130
	131	static const struct tpm_ops tpm_atmel_twi_ops = {
	132	.open = tpm_atmel_twi_open,
	133	.close = tpm_atmel_twi_close,
	134	.xfer = tpm_atmel_twi_xfer,
	135	.get_desc = tpm_atmel_twi_get_desc,
	136	};
	137
	138	U_BOOT_DRIVER(tpm_atmel_twi) = {
	139	.name = "tpm_atmel_twi",
	140	.id = UCLASS_TPM,
	141	.of_match = tpm_atmel_twi_ids,
	142	.ops = &tpm_atmel_twi_ops,
	143	.probe = tpm_atmel_twi_probe,
	144	};