[U-Boot] [PATCH v2 1/2] Introduce generic TPM support in u-boot

[Marek Vasut]

On Saturday, October 15, 2011 05:38:50 AM Vadim Bendebury wrote:
> TPM (Trusted Platform Module) is an integrated circuit and
> software platform that provides computer manufacturers with the
> core components of a subsystem used to assure authenticity,
> integrity and confidentiality.

[...]

Quick points:
* The license
* Use debug() when fitting

> diff --git a/drivers/tpm/generic_lpc_tpm.c b/drivers/tpm/generic_lpc_tpm.c
> new file mode 100644
> index 0000000..8319286
> --- /dev/null
> +++ b/drivers/tpm/generic_lpc_tpm.c

[...]

> +
> +struct lpc_tpm {
> +	struct tpm_locality locality[TPM_TOTAL_LOCALITIES];
> +};

Do you need such envelope ?

> +
> +static struct lpc_tpm *lpc_tpm_dev =
> +	(struct lpc_tpm *)CONFIG_TPM_TIS_BASE_ADDRESS;
> +
> +/* Some registers' bit field definitions */
> +#define TIS_STS_VALID                  (1 << 7) /* 0x80 */
> +#define TIS_STS_COMMAND_READY          (1 << 6) /* 0x40 */
> +#define TIS_STS_TPM_GO                 (1 << 5) /* 0x20 */
> +#define TIS_STS_DATA_AVAILABLE         (1 << 4) /* 0x10 */
> +#define TIS_STS_EXPECT                 (1 << 3) /* 0x08 */
> +#define TIS_STS_RESPONSE_RETRY         (1 << 1) /* 0x02 */
> +
> +#define TIS_ACCESS_TPM_REG_VALID_STS   (1 << 7) /* 0x80 */
> +#define TIS_ACCESS_ACTIVE_LOCALITY     (1 << 5) /* 0x20 */
> +#define TIS_ACCESS_BEEN_SEIZED         (1 << 4) /* 0x10 */
> +#define TIS_ACCESS_SEIZE               (1 << 3) /* 0x08 */
> +#define TIS_ACCESS_PENDING_REQUEST     (1 << 2) /* 0x04 */
> +#define TIS_ACCESS_REQUEST_USE         (1 << 1) /* 0x02 */
> +#define TIS_ACCESS_TPM_ESTABLISHMENT   (1 << 0) /* 0x01 */
> +
> +#define TIS_STS_BURST_COUNT_MASK       (0xffff)
> +#define TIS_STS_BURST_COUNT_SHIFT      (8)
> +
> +/*
> + * Error value returned if a tpm register does not enter the expected
> state + * after continuous polling. No actual TPM register reading ever
> returns ~0, + * so this value is a safe error indication to be mixed with
> possible status + * register values.
> + */
> +#define TPM_TIMEOUT_ERR			(~0)
> +
> +/* Error value returned on various TPM driver errors */

Dot missing at the end.

> +#define TPM_DRIVER_ERR		(-1)
> +
> + /* 1 second is plenty for anything TPM does.*/
> +#define MAX_DELAY_US	(1000 * 1000)
> +
> +/* Retrieve burst count value out of the status register contents. */
> +#define BURST_COUNT(status) ((u16)(((status) >> TIS_STS_BURST_COUNT_SHIFT)
> & \ +				   TIS_STS_BURST_COUNT_MASK))

Do you need the cast ?

> +
> +/*
> + * Structures defined below allow creating descriptions of TPM
> vendor/device + * ID information for run time discovery. The only device
> the system knows + * about at this time is Infineon slb9635
> + */
> +struct device_name {
> +	u16 dev_id;
> +	const char * const dev_name;
> +};
> +
> +struct vendor_name {
> +	u16 vendor_id;
> +	const char *vendor_name;
> +	const struct device_name *dev_names;
> +};
> +
> +static const struct device_name infineon_devices[] = {
> +	{0xb, "SLB9635 TT 1.2"},
> +	{0}
> +};
> +
> +static const struct vendor_name vendor_names[] = {
> +	{0x15d1, "Infineon", infineon_devices},
> +};
> +
> +/*
> + * Cached vendor/device ID pair to indicate that the device has been
> already + * discovered
> + */
> +static u32 vendor_dev_id;
> +
> +/* TPM access going through macros to make tracing easier. */
> +#define tpm_read(ptr) ({ \
> +	u32  __ret; \
> +	__ret = (sizeof(*ptr) == 1) ? readb(ptr) : readl(ptr); \
> +	 debug(PREFIX "Read reg 0x%x returns 0x%x\n", \
> +	       (u32)ptr - (u32)lpc_tpm_dev, __ret); \
> +					 __ret; })
> +

Make this inline function

> +#define tpm_write(value, ptr) ({		   \
> +	u32 __v = value;	\
> +	debug(PREFIX "Write reg 0x%x with 0x%x\n", \
> +	       (u32)ptr - (u32)lpc_tpm_dev, __v); \
> +	if (sizeof(*ptr) == 1) \
> +		writeb(__v, ptr); \
> +	else \
> +		writel(__v, ptr); })
> +

DTTO

[...]

> +static u32 tis_senddata(const u8 * const data, u32 len)
> +{
> +	u32 offset = 0;
> +	u16 burst = 0;
> +	u32 max_cycles = 0;
> +	u8 locality = 0;
> +	u32 value;
> +
> +	value = tis_wait_reg(&lpc_tpm_dev->locality[locality].tpm_status,
> +			     TIS_STS_COMMAND_READY, TIS_STS_COMMAND_READY);
> +	if (value == TPM_TIMEOUT_ERR) {
> +		printf("%s:%d - failed to get 'command_ready' status\n",
> +		       __FILE__, __LINE__);
> +		return TPM_DRIVER_ERR;
> +	}
> +	burst = BURST_COUNT(value);
> +
> +	while (1) {

No endless loops please.

> +		unsigned count;
> +
> +		/* Wait till the device is ready to accept more data. */
> +		while (!burst) {
> +			if (max_cycles++ == MAX_DELAY_US) {
> +				printf("%s:%d failed to feed %d bytes of %d\n",
> +				       __FILE__, __LINE__, len - offset, len);
> +				return TPM_DRIVER_ERR;
> +			}
> +			udelay(1);
> +			burst = BURST_COUNT(tpm_read(&lpc_tpm_dev->locality
> +						     [locality].tpm_status));
> +		}
> +
> +		max_cycles = 0;
> +
> +		/*
> +		 * Calculate number of bytes the TPM is ready to accept in one
> +		 * shot.
> +		 *
> +		 * We want to send the last byte outside of the loop (hence
> +		 * the -1 below) to make sure that the 'expected' status bit
> +		 * changes to zero exactly after the last byte is fed into the
> +		 * FIFO.
> +		 */
> +		count = min(burst, len - offset - 1);
> +		while (count--)
> +			tpm_write(data[offset++],
> +				  &lpc_tpm_dev->locality[locality].data);
> +
> +		value = tis_wait_reg(&lpc_tpm_dev->locality
> +				     [locality].tpm_status,
> +				     TIS_STS_VALID, TIS_STS_VALID);
> +
> +		if ((value == TPM_TIMEOUT_ERR) || !(value & TIS_STS_EXPECT)) {
> +			printf("%s:%d TPM command feed overflow\n",
> +			       __FILE__, __LINE__);
> +			return TPM_DRIVER_ERR;
> +		}
> +
> +		burst = BURST_COUNT(value);
> +		if ((offset == (len - 1)) && burst)
> +			/*
> +			 * We need to be able to send the last byte to the
> +			 * device, so burst size must be nonzero before we
> +			 * break out.
> +			 */
> +			break;
> +	}
> +
> +	/* Send the last byte. */
> +	tpm_write(data[offset++], &lpc_tpm_dev->locality[locality].data);
> +	/*
> +	 * Verify that TPM does not expect any more data as part of this
> +	 * command.
> +	 */
> +	value = tis_wait_reg(&lpc_tpm_dev->locality[locality].tpm_status,
> +			     TIS_STS_VALID, TIS_STS_VALID);
> +	if ((value == TPM_TIMEOUT_ERR) || (value & TIS_STS_EXPECT)) {
> +		printf("%s:%d unexpected TPM status 0x%x\n",
> +		       __FILE__, __LINE__, value);
> +		return TPM_DRIVER_ERR;
> +	}
> +
> +	/* OK, sitting pretty, let's start the command execution. */
> +	tpm_write(TIS_STS_TPM_GO, &lpc_tpm_dev->locality[locality].tpm_status);
> +	return 0;
> +}
> +
> +/*
> + * tis_readresponse()
> + *
> + * read the TPM device response after a command was issued.
> + *
> + * @buffer - address where to read the response, byte by byte.
> + * @len - pointer to the size of buffer
> + *
> + * On success stores the number of received bytes to len and returns 0. On
> + * errors (misformatted TPM data or synchronization problems) returns
> + * TPM_DRIVER_ERR.
> + */
> +static u32 tis_readresponse(u8 *buffer, u32 *len)
> +{
> +	u16 burst_count;
> +	u32 status;
> +	u32 offset = 0;
> +	u8 locality = 0;
> +	const u32 has_data = TIS_STS_DATA_AVAILABLE | TIS_STS_VALID;
> +	u32 expected_count = *len;
> +	int max_cycles = 0;
> +
> +	/* Wait for the TPM to process the command */
> +	status = tis_wait_reg(&lpc_tpm_dev->locality[locality].tpm_status,
> +			      has_data, has_data);
> +	if (status == TPM_TIMEOUT_ERR) {

Just make it return non-zero for timeout and check for non-zero. And unify the 
variable names please.

> +		printf("%s:%d failed processing command\n",
> +		       __FILE__, __LINE__);
> +		return TPM_DRIVER_ERR;
> +	}
> +
> +	do {
> +		while ((burst_count = BURST_COUNT(status)) == 0) {
> +			if (max_cycles++ == MAX_DELAY_US) {
> +				printf("%s:%d TPM stuck on read\n",
> +				       __FILE__, __LINE__);
> +				return TPM_DRIVER_ERR;
> +			}
> +			udelay(1);
> +			status = tpm_read(&lpc_tpm_dev->locality
> +					  [locality].tpm_status);
> +		}
> +
> +		max_cycles = 0;
> +
> +		while (burst_count-- && (offset < expected_count)) {
> +			buffer[offset++] = (u8) tpm_read(&lpc_tpm_dev->locality
> +							 [locality].data);
> +
> +			if (offset == 6) {
> +				/*
> +				 * We got the first six bytes of the reply,
> +				 * let's figure out how many bytes to expect
> +				 * total - it is stored as a 4 byte number in
> +				 * network order, starting with offset 2 into
> +				 * the body of the reply.
> +				 */
> +				u32 real_length;
> +				memcpy(&real_length,
> +				       buffer + 2,
> +				       sizeof(real_length));
> +				expected_count = be32_to_cpu(real_length);
> +
> +				if ((expected_count < offset) ||
> +				    (expected_count > *len)) {
> +					printf("%s:%d bad response size %d\n",
> +					       __FILE__, __LINE__,
> +					       expected_count);
> +					return TPM_DRIVER_ERR;
> +				}
> +			}
> +		}
> +
> +		/* Wait for the next portion */
> +		status = tis_wait_reg(&lpc_tpm_dev->locality
> +				      [locality].tpm_status,
> +				      TIS_STS_VALID, TIS_STS_VALID);
> +		if (status == TPM_TIMEOUT_ERR) {
> +			printf("%s:%d failed to read response\n",
> +			       __FILE__, __LINE__);
> +			return TPM_DRIVER_ERR;
> +		}
> +
> +		if (offset == expected_count)
> +			break;	/* We got all we need */
> +
> +	} while ((status & has_data) == has_data);

No endless loop please.

> +
> +	/*
> +	 * Make sure we indeed read all there was. The TIS_STS_VALID bit is
> +	 * known to be set.
> +	 */
> +	if (status & TIS_STS_DATA_AVAILABLE) {
> +		printf("%s:%d wrong receive status %x\n",
> +		       __FILE__, __LINE__, status);
> +		return TPM_DRIVER_ERR;
> +	}
> +
> +	/* Tell the TPM that we are done. */
> +	tpm_write(TIS_STS_COMMAND_READY, &lpc_tpm_dev->locality
> +		  [locality].tpm_status);
> +	*len = offset;
> +	return 0;
> +}
> +
> +int tis_init(void)
> +{
> +	return tis_probe();
> +}

Make tis_probe into tis_init and be done with it ?
> +
> +int tis_open(void)
> +{
> +	u8 locality = 0; /* we use locality zero for everything */
> +
> +	if (tis_close())
> +		return TPM_DRIVER_ERR;
> +
> +	/* now request access to locality */
> +	tpm_write(TIS_ACCESS_REQUEST_USE,
> +		  &lpc_tpm_dev->locality[locality].access);
> +
> +
> +	/* did we get a lock? */
> +	if (tis_wait_reg(&lpc_tpm_dev->locality[locality].access,
> +			 TIS_ACCESS_ACTIVE_LOCALITY,
> +			 TIS_ACCESS_ACTIVE_LOCALITY) == TPM_TIMEOUT_ERR) {
> +		printf("%s:%d - failed to lock locality %d\n",
> +		       __FILE__, __LINE__, locality);
> +		return TPM_DRIVER_ERR;
> +	}
> +
> +	tpm_write(TIS_STS_COMMAND_READY,
> +		  &lpc_tpm_dev->locality[locality].tpm_status);
> +	return 0;
> +}

[...]

Cheers