[PATCH 0/3 v3] Inrtoduce TPM TIS

[PATCH 0/3 v3] Inrtoduce TPM TIS

[Ilias Apalodimas]

Introduce a TPM TIS layer, which can be used for all the TIS TPMs.
We can slowly start converting all the TPM TIS based drivers and remove a
lot of code duplication. 
The series also adds an MMIO based driver, which can be used on QEMU along
with swtpm [1]  to provide selftests for the EFI TCG protocol

Changes since v1:
- introduce TPM TIS APUI
Changes since v2:
- Add myself as a maintainer on TPM drivers

[1] https://qemu.readthedocs.io/en/latest/specs/tpm.html

Ilias Apalodimas (3):
  tpm2: Introduce TIS tpm core
  tpm2: Add a TPMv2 MMIO TIS driver
  MAINTAINERS: Add entry for TPM drivers

 MAINTAINERS                 |   5 +
 drivers/tpm/Kconfig         |   9 +
 drivers/tpm/Makefile        |   1 +
 drivers/tpm/tpm2_tis_core.c | 545 ++++++++++++++++++++++++++++++++++++
 drivers/tpm/tpm2_tis_mmio.c | 156 +++++++++++
 drivers/tpm/tpm_tis.h       |  40 +++
 include/tpm-v2.h            |   1 +
 7 files changed, 757 insertions(+)
 create mode 100644 drivers/tpm/tpm2_tis_core.c
 create mode 100644 drivers/tpm/tpm2_tis_mmio.c

-- 
2.32.0.rc0

[PATCH 1/3 v3] tpm2: Introduce TIS tpm core

[Ilias Apalodimas]

There's a lot of code duplication in U-Boot right now.  All the TPM TIS
compatible drivers we have at the moment have their own copy of a TIS
implementation.

So let's create a common layer which implements the core TIS functions.
Any driver added from now own, which is compatible with the TIS spec, will
only have to provide the underlying bus communication mechanisms.

Signed-off-by: Ilias Apalodimas <ilias.apalodimas@linaro.org>
---
 drivers/tpm/tpm2_tis_core.c | 545 ++++++++++++++++++++++++++++++++++++
 drivers/tpm/tpm_tis.h       |  40 +++
 include/tpm-v2.h            |   1 +
 3 files changed, 586 insertions(+)
 create mode 100644 drivers/tpm/tpm2_tis_core.c

diff --git a/drivers/tpm/tpm2_tis_core.c b/drivers/tpm/tpm2_tis_core.c
new file mode 100644
index 000000000000..9860ce2379e0
--- /dev/null
+++ b/drivers/tpm/tpm2_tis_core.c
@@ -0,0 +1,545 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2020, Linaro Limited
+ *
+ * Based on the Linux TIS core interface
+ */
+
+#include <common.h>
+#include <dm.h>
+#include <tpm-v2.h>
+#include <linux/delay.h>
+#include <linux/unaligned/be_byteshift.h>
+#include "tpm_tis.h"
+
+/**
+ * tpm_tis_get_desc - Get the TPM description
+ *
+ * @udev: udevice
+ * @buf:  buffer to fill data
+ * @size: buffer size
+ *
+ * @Return: Number of characters written (or would have been written) in buffer
+ */
+int tpm_tis_get_desc(struct udevice *udev, char *buf, int size)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+
+	if (size < 80)
+		return -ENOSPC;
+
+	return snprintf(buf, size,
+			"%s v2.0: VendorID 0x%04x, DeviceID 0x%04x, RevisionID 0x%02x [%s]",
+			udev->name, chip->vend_dev & 0xFFFF,
+			chip->vend_dev >> 16, chip->rid,
+			(chip->is_open ? "open" : "closed"));
+}
+
+/**
+ * tpm_tis_check_locality - Check the current TPM locality
+ *
+ * @udev: udevice
+ * @loc:  locality
+ *
+ * Return: True if the tested locality matches
+ */
+static bool tpm_tis_check_locality(struct udevice *udev, int loc)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+	struct tpm_tis_phy_ops *phy_ops = chip->phy_ops;
+	u8 locality;
+
+	if (!phy_ops)
+		return false;
+
+	phy_ops->read_bytes(udev, TPM_ACCESS(loc), 1, &locality);
+	if ((locality & (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID |
+	    TPM_ACCESS_REQUEST_USE)) ==
+	    (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) {
+		chip->locality = loc;
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ * tpm_tis_request_locality - Request a locality from the TPM
+ *
+ * @udev: udevce
+ * @loc:  requested locality
+ *
+ * Return: 0 on success -1 on failure
+ */
+int tpm_tis_request_locality(struct udevice *udev, int loc)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+	struct tpm_tis_phy_ops *phy_ops = chip->phy_ops;
+	u8 buf = TPM_ACCESS_REQUEST_USE;
+	unsigned long start, stop;
+
+	if (!phy_ops)
+		return -1;
+
+	if (tpm_tis_check_locality(udev, loc))
+		return 0;
+
+	phy_ops->write_bytes(udev, TPM_ACCESS(loc), 1, &buf);
+	start = get_timer(0);
+	stop = chip->timeout_a;
+	do {
+		if (tpm_tis_check_locality(udev, loc))
+			return 0;
+		mdelay(TPM_TIMEOUT_MS);
+	} while (get_timer(start) < stop);
+
+	return -1;
+}
+
+/**
+ * tpm_tis_status - Check the current device status
+ *
+ * @udev:   udevice
+ * @status: return value of status
+ *
+ * Return: 0 on success, negative on failure
+ */
+static int tpm_tis_status(struct udevice *udev, u8 *status)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+	struct tpm_tis_phy_ops *phy_ops = chip->phy_ops;
+
+	if (!phy_ops)
+		return -EINVAL;
+
+	if (chip->locality < 0)
+		return -EINVAL;
+
+	phy_ops->read_bytes(udev, TPM_STS(chip->locality), 1, status);
+
+	if ((*status & TPM_STS_READ_ZERO)) {
+		log_err("TPM returned invalid status\n");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+/**
+ * tpm_tis_release_locality - Release the requested locality
+ *
+ * @udev: udevice
+ * @loc:  requested locality
+ *
+ * Return: 0 on success, negative on failure
+ */
+int tpm_tis_release_locality(struct udevice *udev, int loc)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+	struct tpm_tis_phy_ops *phy_ops = chip->phy_ops;
+	u8 buf = TPM_ACCESS_ACTIVE_LOCALITY;
+	int ret;
+
+	if (!phy_ops)
+		return -1;
+
+	if (chip->locality < 0)
+		return 0;
+
+	ret = phy_ops->write_bytes(udev, TPM_ACCESS(loc), 1, &buf);
+	if (!ret)
+		chip->locality = -1;
+
+	return ret;
+}
+
+/**
+ * tpm_tis_wait_for_stat - Wait for TPM to become ready
+ *
+ * @udev:    udev
+ * @mask:    mask to match
+ * @timeout: timeout for retries
+ * @status:  current status
+ *
+ * Return: 0 on success, negative on failure
+ */
+static int tpm_tis_wait_for_stat(struct udevice *udev, u8 mask,
+				 unsigned long timeout, u8 *status)
+{
+	unsigned long start = get_timer(0);
+	unsigned long stop = timeout;
+	int ret;
+
+	do {
+		mdelay(TPM_TIMEOUT_MS);
+		ret = tpm_tis_status(udev, status);
+		if (ret)
+			return ret;
+
+		if ((*status & mask) == mask)
+			return 0;
+	} while (get_timer(start) < stop);
+
+	return -ETIMEDOUT;
+}
+
+/**
+ * tpm_tis_get_burstcount - Get the burstcount for the data FIFO
+ *
+ * @udev:       udevice
+ * @burstcount: current burstcount
+ *
+ * Return: 0 on success, negative on failure
+ */
+static int tpm_tis_get_burstcount(struct udevice *udev, size_t *burstcount)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+	struct tpm_tis_phy_ops *phy_ops = chip->phy_ops;
+	unsigned long start, stop;
+	u32 burst;
+
+	if (!phy_ops)
+		return -EINVAL;
+
+	if (chip->locality < 0)
+		return -EINVAL;
+
+	/* wait for burstcount */
+	start = get_timer(0);
+	/*
+	 * This is the TPMv2 defined timeout. Change this in case you want to
+	 * make the driver compatile to TPMv1
+	 */
+	stop = chip->timeout_a;
+	do {
+		phy_ops->read32(udev, TPM_STS(chip->locality), &burst);
+		*burstcount = (burst >> 8) & 0xFFFF;
+		if (*burstcount)
+			return 0;
+
+		mdelay(TPM_TIMEOUT_MS);
+	} while (get_timer(start) < stop);
+
+	return -ETIMEDOUT;
+}
+
+/**
+ * tpm_tis_ready - Cancel pending comands and get the device on a ready state
+ *
+ * @udev: udevcie
+ *
+ * Return: 0 on success, negative on failure
+ */
+static int tpm_tis_ready(struct udevice *udev)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+	struct tpm_tis_phy_ops *phy_ops = chip->phy_ops;
+	u8 data = TPM_STS_COMMAND_READY;
+
+	if (!phy_ops)
+		return -1;
+
+	/* This will cancel any pending commands */
+	return phy_ops->write_bytes(udev, TPM_STS(chip->locality), 1, &data);
+}
+
+/**
+ * tpm_tis_send - send data to the device
+ *
+ * @udev: udevice
+ * @buf:  buffer to send
+ * @len:  size of the buffer
+ *
+ * Return: number of bytes sent or negative on failure
+ */
+int tpm_tis_send(struct udevice *udev, const u8 *buf, size_t len)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+	struct tpm_tis_phy_ops *phy_ops = chip->phy_ops;
+	size_t burstcnt, wr_size, sent = 0;
+	u8 data = TPM_STS_GO;
+	u8 status;
+	int ret;
+
+	if (!phy_ops)
+		return -EINVAL;
+
+	if (!chip)
+		return -ENODEV;
+
+	ret = tpm_tis_request_locality(udev, 0);
+	if (ret < 0)
+		return -EBUSY;
+
+	ret = tpm_tis_status(udev, &status);
+	if (ret)
+		goto release_locality;
+
+	if (!(status & TPM_STS_COMMAND_READY)) {
+		ret = tpm_tis_ready(udev);
+		if (ret) {
+			log_err("Can't cancel previous TPM operation\n");
+			goto release_locality;
+		}
+		ret = tpm_tis_wait_for_stat(udev, TPM_STS_COMMAND_READY,
+					    chip->timeout_b, &status);
+		if (ret) {
+			log_err("TPM not ready\n");
+			goto release_locality;
+		}
+	}
+
+	while (len > 0) {
+		ret = tpm_tis_get_burstcount(udev, &burstcnt);
+		if (ret)
+			goto release_locality;
+
+		wr_size = min(len, burstcnt);
+		ret = phy_ops->write_bytes(udev, TPM_DATA_FIFO(chip->locality),
+					   wr_size, buf + sent);
+		if (ret < 0)
+			goto release_locality;
+
+		ret = tpm_tis_wait_for_stat(udev, TPM_STS_VALID,
+					    chip->timeout_c, &status);
+		if (ret)
+			goto release_locality;
+
+		sent += wr_size;
+		len -= wr_size;
+		/* make sure the TPM expects more data */
+		if (len && !(status & TPM_STS_DATA_EXPECT)) {
+			ret = -EIO;
+			goto release_locality;
+		}
+	}
+
+	/*
+	 * Make a final check ensuring everything is ok and the TPM expects no
+	 * more data
+	 */
+	ret = tpm_tis_wait_for_stat(udev, TPM_STS_VALID, chip->timeout_c,
+				    &status);
+	if (ret)
+		goto release_locality;
+
+	if (status & TPM_STS_DATA_EXPECT) {
+		ret = -EIO;
+		goto release_locality;
+	}
+
+	ret = phy_ops->write_bytes(udev, TPM_STS(chip->locality), 1, &data);
+	if (ret)
+		goto release_locality;
+
+	tpm_tis_release_locality(udev, chip->locality);
+	return sent;
+
+release_locality:
+	tpm_tis_ready(udev);
+	tpm_tis_release_locality(udev, chip->locality);
+
+	return ret;
+}
+
+/**
+ * tpm_tis_recv_data - Receive data from a device. Wrapper for tpm_tis_recv
+ *
+ * @udev: udevice
+ * @buf:  buffer to copy data
+ * @size: buffer size
+ *
+ * Return: bytes read or negative on failure
+ */
+static int tpm_tis_recv_data(struct udevice *udev, u8 *buf, size_t count)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+	struct tpm_tis_phy_ops *phy_ops = chip->phy_ops;
+	int size = 0, len, ret;
+	size_t burstcnt;
+	u8 status;
+
+	if (!phy_ops)
+		return -EINVAL;
+
+	while (size < count &&
+	       tpm_tis_wait_for_stat(udev, TPM_STS_DATA_AVAIL | TPM_STS_VALID,
+				     chip->timeout_c, &status) == 0) {
+		ret = tpm_tis_get_burstcount(udev, &burstcnt);
+		if (ret)
+			return burstcnt;
+
+		len = min_t(int, burstcnt, count - size);
+		ret = phy_ops->read_bytes(udev, TPM_DATA_FIFO(chip->locality),
+					  len, buf + size);
+		if (ret < 0)
+			return ret;
+
+		size += len;
+	}
+
+	return size;
+}
+
+/**
+ * tpm_tis_recv - Receive data from a device
+ *
+ * @udev: udevice
+ * @buf:  buffer to copy data
+ * @size: buffer size
+ *
+ * Return: bytes read or negative on failure
+ */
+int tpm_tis_recv(struct udevice *udev, u8 *buf, size_t count)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+	int ret;
+	int size, expected;
+
+	if (!chip)
+		return -ENODEV;
+
+	if (count < TPM_HEADER_SIZE)
+		return -E2BIG;
+
+	ret = tpm_tis_request_locality(udev, 0);
+	if (ret < 0)
+		return -EBUSY;
+
+	size = tpm_tis_recv_data(udev, buf, TPM_HEADER_SIZE);
+	if (size < TPM_HEADER_SIZE) {
+		log_err("TPM error, unable to read header\n");
+		goto out;
+	}
+
+	expected = get_unaligned_be32(buf + TPM_CMD_COUNT_OFFSET);
+	if (expected > count) {
+		size = -EIO;
+		log_warning("Too much data: %d > %zu\n", expected, count);
+		goto out;
+	}
+
+	size += tpm_tis_recv_data(udev, &buf[TPM_HEADER_SIZE],
+				   expected - TPM_HEADER_SIZE);
+	if (size < expected) {
+		log(LOGC_NONE, LOGL_ERR,
+		    "TPM error, unable to read remaining bytes of result\n");
+		size = -EIO;
+		goto out;
+	}
+
+out:
+	tpm_tis_ready(udev);
+	tpm_tis_release_locality(udev, chip->locality);
+
+	return size;
+}
+
+/** tpm_tis_cleanup - Get the device in ready state and release locality
+ *
+ * @udev: udevice
+ *
+ * Return: always 0
+ */
+int tpm_tis_cleanup(struct udevice *udev)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+
+	tpm_tis_ready(udev);
+	tpm_tis_release_locality(udev, chip->locality);
+
+	return 0;
+}
+
+/**
+ * tpm_tis_open - Open the device and request locality 0
+ *
+ * @udev: udevice
+ *
+ * Return: 0 on success, negative on failure
+ */
+int tpm_tis_open(struct udevice *udev)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+	int ret;
+
+	if (chip->is_open)
+		return -EBUSY;
+
+	ret = tpm_tis_request_locality(udev, 0);
+	if (!ret)
+		chip->is_open = 1;
+
+	return ret;
+}
+
+/**
+ * tpm_tis_ops_register - register the PHY ops for the device
+ *
+ * @udev: udevice
+ * @ops: bus ops for the device
+ */
+void tpm_tis_ops_register(struct udevice *udev, struct tpm_tis_phy_ops *ops)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+
+	chip->phy_ops = ops;
+}
+
+/**
+ * tpm_tis_init - inititalize the device
+ *
+ * @udev: udevice
+ *
+ * Return: 0 on success, negative on failure
+ */
+int tpm_tis_init(struct udevice *udev)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+	struct tpm_tis_phy_ops *phy_ops = chip->phy_ops;
+	int ret;
+	u32 tmp;
+
+	if (!phy_ops)
+		return -1;
+	ret = tpm_tis_request_locality(udev, 0);
+	if (ret)
+		return ret;
+
+	chip->timeout_a = TIS_SHORT_TIMEOUT_MS;
+	chip->timeout_b = TIS_LONG_TIMEOUT_MS;
+	chip->timeout_c = TIS_SHORT_TIMEOUT_MS;
+	chip->timeout_d = TIS_SHORT_TIMEOUT_MS;
+
+	/* Disable interrupts */
+	phy_ops->read32(udev, TPM_INT_ENABLE(chip->locality), &tmp);
+	tmp |= TPM_INTF_CMD_READY_INT | TPM_INTF_LOCALITY_CHANGE_INT |
+	       TPM_INTF_DATA_AVAIL_INT | TPM_INTF_STS_VALID_INT;
+	tmp &= ~TPM_GLOBAL_INT_ENABLE;
+	phy_ops->write32(udev, TPM_INT_ENABLE(chip->locality), tmp);
+
+	phy_ops->read_bytes(udev, TPM_RID(chip->locality), 1, &chip->rid);
+	phy_ops->read32(udev, TPM_DID_VID(chip->locality), &chip->vend_dev);
+
+	return tpm_tis_release_locality(udev, chip->locality);
+}
+
+/**
+ * tpm_tis_close - Close the device and release locality
+ *
+ * @udev: udevice
+ *
+ * Return: 0 on success, negative on failure
+ */
+int tpm_tis_close(struct udevice *udev)
+{
+	struct tpm_chip *chip = dev_get_priv(udev);
+	int ret = 0;
+
+	if (chip->is_open) {
+		ret = tpm_tis_release_locality(udev, chip->locality);
+		chip->is_open = 0;
+	}
+
+	return ret;
+}
diff --git a/drivers/tpm/tpm_tis.h b/drivers/tpm/tpm_tis.h
index 2a160fe05c9a..fde3bb71f7c2 100644
--- a/drivers/tpm/tpm_tis.h
+++ b/drivers/tpm/tpm_tis.h
@@ -21,6 +21,37 @@
 #include <linux/compiler.h>
 #include <linux/types.h>
 
+struct tpm_tis_phy_ops {
+	int (*read_bytes)(struct udevice *udev, u32 addr, u16 len,
+			  u8 *result);
+	int (*write_bytes)(struct udevice *udev, u32 addr, u16 len,
+			   const u8 *value);
+	int (*read16)(struct udevice *udev, u32 addr, u16 *result);
+	int (*read32)(struct udevice *udev, u32 addr, u32 *result);
+	int (*write32)(struct udevice *udev, u32 addr, u32 src);
+};
+
+enum tis_int_flags {
+	TPM_GLOBAL_INT_ENABLE = 0x80000000,
+	TPM_INTF_BURST_COUNT_STATIC = 0x100,
+	TPM_INTF_CMD_READY_INT = 0x080,
+	TPM_INTF_INT_EDGE_FALLING = 0x040,
+	TPM_INTF_INT_EDGE_RISING = 0x020,
+	TPM_INTF_INT_LEVEL_LOW = 0x010,
+	TPM_INTF_INT_LEVEL_HIGH = 0x008,
+	TPM_INTF_LOCALITY_CHANGE_INT = 0x004,
+	TPM_INTF_STS_VALID_INT = 0x002,
+	TPM_INTF_DATA_AVAIL_INT = 0x001,
+};
+
+#define TPM_ACCESS(l)                   (0x0000 | ((l) << 12))
+#define TPM_INT_ENABLE(l)               (0x0008 | ((l) << 12))
+#define TPM_STS(l)                      (0x0018 | ((l) << 12))
+#define TPM_DATA_FIFO(l)                (0x0024 | ((l) << 12))
+#define TPM_DID_VID(l)                  (0x0F00 | ((l) << 12))
+#define TPM_RID(l)                      (0x0F04 | ((l) << 12))
+#define TPM_INTF_CAPS(l)                (0x0014 | ((l) << 12))
+
 enum tpm_timeout {
 	TPM_TIMEOUT_MS			= 5,
 	TIS_SHORT_TIMEOUT_MS		= 750,
@@ -43,6 +74,7 @@ struct tpm_chip {
 	u8 rid;
 	unsigned long timeout_a, timeout_b, timeout_c, timeout_d;  /* msec */
 	ulong chip_type;
+	struct tpm_tis_phy_ops *phy_ops;
 };
 
 struct tpm_input_header {
@@ -130,4 +162,12 @@ enum tis_status {
 };
 #endif
 
+int tpm_tis_open(struct udevice *udev);
+int tpm_tis_close(struct udevice *udev);
+int tpm_tis_cleanup(struct udevice *udev);
+int tpm_tis_send(struct udevice *udev, const u8 *buf, size_t len);
+int tpm_tis_recv(struct udevice *udev, u8 *buf, size_t count);
+int tpm_tis_get_desc(struct udevice *udev, char *buf, int size);
+int tpm_tis_init(struct udevice *udev);
+void tpm_tis_ops_register(struct udevice *udev, struct tpm_tis_phy_ops *ops);
 #endif
diff --git a/include/tpm-v2.h b/include/tpm-v2.h
index 247b38696766..3e48e358613f 100644
--- a/include/tpm-v2.h
+++ b/include/tpm-v2.h
@@ -378,6 +378,7 @@ enum {
 	TPM_STS_DATA_EXPECT		= 1 << 3,
 	TPM_STS_SELF_TEST_DONE		= 1 << 2,
 	TPM_STS_RESPONSE_RETRY		= 1 << 1,
+	TPM_STS_READ_ZERO               = 0x23
 };
 
 enum {
-- 
2.32.0.rc0

[PATCH 2/3 v3] tpm2: Add a TPMv2 MMIO TIS driver

[Ilias Apalodimas]

Add support for devices that expose a TPMv2 though MMIO.
Apart from those devices, we can use the driver in our QEMU setups and
test TPM related code which is difficult to achieve using the sandbox
driver (e.g test the EFI TCG2 protocol).

It's worth noting that a previous patch added TPMv2 TIS core functions,
which the current driver is consuming.

Signed-off-by: Ilias Apalodimas <ilias.apalodimas@linaro.org>
---
 drivers/tpm/Kconfig         |   9 +++
 drivers/tpm/Makefile        |   1 +
 drivers/tpm/tpm2_tis_mmio.c | 156 ++++++++++++++++++++++++++++++++++++
 3 files changed, 166 insertions(+)
 create mode 100644 drivers/tpm/tpm2_tis_mmio.c

diff --git a/drivers/tpm/Kconfig b/drivers/tpm/Kconfig
index 9eebab5cfd90..406ee8716e1e 100644
--- a/drivers/tpm/Kconfig
+++ b/drivers/tpm/Kconfig
@@ -161,6 +161,15 @@ config TPM2_FTPM_TEE
 	help
 	  This driver supports firmware TPM running in TEE.
 
+config TPM2_MMIO
+	bool "MMIO based TPM2 Interface"
+	depends on TPM_V2
+	help
+	  This driver supports firmware TPM2.0 MMIO interface.
+	  The usual TPM operations and the 'tpm' command can be used to talk
+	  to the device using the standard TPM Interface Specification (TIS)
+	  protocol.
+
 endif # TPM_V2
 
 endmenu
diff --git a/drivers/tpm/Makefile b/drivers/tpm/Makefile
index f64d20067f88..1065c1874f58 100644
--- a/drivers/tpm/Makefile
+++ b/drivers/tpm/Makefile
@@ -14,3 +14,4 @@ obj-$(CONFIG_$(SPL_TPL_)TPM2_CR50_I2C) += cr50_i2c.o
 obj-$(CONFIG_TPM2_TIS_SANDBOX) += tpm2_tis_sandbox.o
 obj-$(CONFIG_TPM2_TIS_SPI) += tpm2_tis_spi.o
 obj-$(CONFIG_TPM2_FTPM_TEE) += tpm2_ftpm_tee.o
+obj-$(CONFIG_TPM2_MMIO) += tpm2_tis_core.o tpm2_tis_mmio.o
diff --git a/drivers/tpm/tpm2_tis_mmio.c b/drivers/tpm/tpm2_tis_mmio.c
new file mode 100644
index 000000000000..2183a2807162
--- /dev/null
+++ b/drivers/tpm/tpm2_tis_mmio.c
@@ -0,0 +1,156 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * driver for mmio TCG/TIS TPM (trusted platform module).
+ *
+ * Specifications at www.trustedcomputinggroup.org
+ */
+
+#include <common.h>
+#include <dm.h>
+#include <log.h>
+#include <tpm-v2.h>
+#include <linux/bitops.h>
+#include <linux/compiler.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/io.h>
+#include <linux/unaligned/be_byteshift.h>
+#include "tpm_tis.h"
+#include "tpm_internal.h"
+
+struct tpm_tis_chip_data {
+	unsigned int pcr_count;
+	unsigned int pcr_select_min;
+	unsigned int time_before_first_cmd_ms;
+	void __iomem *iobase;
+};
+
+static int mmio_read_bytes(struct udevice *udev, u32 addr, u16 len,
+			   u8 *result)
+{
+	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
+
+	while (len--)
+		*result++ = ioread8(drv_data->iobase + addr);
+	return 0;
+}
+
+static int mmio_write_bytes(struct udevice *udev, u32 addr, u16 len,
+			    const u8 *value)
+{
+	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
+
+	while (len--)
+		iowrite8(*value++, drv_data->iobase + addr);
+	return 0;
+}
+
+static int mmio_read16(struct udevice *udev, u32 addr, u16 *result)
+{
+	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
+
+	*result = ioread16(drv_data->iobase + addr);
+	return 0;
+}
+
+static int mmio_read32(struct udevice *udev, u32 addr, u32 *result)
+{
+	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
+
+	*result = ioread32(drv_data->iobase + addr);
+	return 0;
+}
+
+static int mmio_write32(struct udevice *udev, u32 addr, u32 value)
+{
+	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
+
+	iowrite32(value, drv_data->iobase + addr);
+	return 0;
+}
+
+static struct tpm_tis_phy_ops phy_ops = {
+	.read_bytes = mmio_read_bytes,
+	.write_bytes = mmio_write_bytes,
+	.read16 = mmio_read16,
+	.read32 = mmio_read32,
+	.write32 = mmio_write32,
+};
+
+static int tpm_tis_probe(struct udevice *udev)
+{
+	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
+	struct tpm_chip_priv *priv = dev_get_uclass_priv(udev);
+	int ret = 0;
+	fdt_addr_t ioaddr;
+	u64 sz;
+
+	ioaddr = dev_read_addr(udev);
+	if (ioaddr == FDT_ADDR_T_NONE)
+		return -EINVAL;
+
+	ret = dev_read_u64(udev, "reg", &sz);
+	if (ret)
+		return -EINVAL;
+
+	drv_data->iobase = ioremap(ioaddr, sz);
+	log_info("Remapped TPM2 base: 0x%llx size: 0x%llx\n", ioaddr, sz);
+	tpm_tis_ops_register(udev, &phy_ops);
+	ret = tpm_tis_init(udev);
+	if (ret)
+		goto iounmap;
+
+	priv->pcr_count = drv_data->pcr_count;
+	priv->pcr_select_min = drv_data->pcr_select_min;
+	/*
+	 * Although the driver probably works with a TPMv1 our Kconfig
+	 * limits the driver to TPMv2 only
+	 */
+	priv->version = TPM_V2;
+
+	return ret;
+iounmap:
+	iounmap(drv_data->iobase);
+	return -EINVAL;
+}
+
+static int tpm_tis_remove(struct udevice *udev)
+{
+	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
+
+	iounmap(drv_data->iobase);
+	return tpm_tis_cleanup(udev);
+}
+
+static const struct tpm_ops tpm_tis_ops = {
+	.open		= tpm_tis_open,
+	.close		= tpm_tis_close,
+	.get_desc	= tpm_tis_get_desc,
+	.send		= tpm_tis_send,
+	.recv		= tpm_tis_recv,
+	.cleanup	= tpm_tis_cleanup,
+};
+
+static const struct tpm_tis_chip_data tpm_tis_std_chip_data = {
+	.pcr_count = 24,
+	.pcr_select_min = 3,
+};
+
+static const struct udevice_id tpm_tis_ids[] = {
+	{
+		.compatible = "tcg,tpm-tis-mmio",
+		.data = (ulong)&tpm_tis_std_chip_data,
+	},
+	{ }
+};
+
+U_BOOT_DRIVER(tpm_tis_mmio) = {
+	.name   = "tpm_tis_mmio",
+	.id     = UCLASS_TPM,
+	.of_match = tpm_tis_ids,
+	.ops    = &tpm_tis_ops,
+	.probe	= tpm_tis_probe,
+	.remove	= tpm_tis_remove,
+	.priv_auto	= sizeof(struct tpm_chip),
+};
-- 
2.32.0.rc0

[PATCH 3/3 v3] MAINTAINERS: Add entry for TPM drivers

[Ilias Apalodimas]

TPM drivers have currently no maintainers.  Add myself since I contributed
the TIS implementation.

Signed-off-by: Ilias Apalodimas <ilias.apalodimas@linaro.org>
---
 MAINTAINERS | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 11e11d51a7da..d67e22401cf4 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1142,6 +1142,11 @@ F:	configs/am65x_hs_evm_a53_defconfig
 F:	configs/j721e_hs_evm_r5_defconfig
 F:	configs/j721e_hs_evm_a72_defconfig
 
+TPM DRIVERS
+M:	Ilias Apalodimas <ilias.apalodimas@linaro.org>
+S:	Maintained
+F:	drivers/tpm/
+
 TQ GROUP
 #M:	Martin Krause <martin.krause@tq-systems.de>
 S:	Orphaned (Since 2016-02)
-- 
2.32.0.rc0

Re: [PATCH 3/3 v3] MAINTAINERS: Add entry for TPM drivers

[Heinrich Schuchardt]

On 08.07.21 10:23, Ilias Apalodimas wrote:
> TPM drivers have currently no maintainers.  Add myself since I contributed
> the TIS implementation.
>
> Signed-off-by: Ilias Apalodimas <ilias.apalodimas@linaro.org>

Thanks for volunteering.

Reviewed-by: Heinrich Schuchardt <xypron.glpk@gmx.de>

> ---
>   MAINTAINERS | 5 +++++
>   1 file changed, 5 insertions(+)
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 11e11d51a7da..d67e22401cf4 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -1142,6 +1142,11 @@ F:	configs/am65x_hs_evm_a53_defconfig
>   F:	configs/j721e_hs_evm_r5_defconfig
>   F:	configs/j721e_hs_evm_a72_defconfig
>
> +TPM DRIVERS
> +M:	Ilias Apalodimas <ilias.apalodimas@linaro.org>
> +S:	Maintained
> +F:	drivers/tpm/
> +
>   TQ GROUP
>   #M:	Martin Krause <martin.krause@tq-systems.de>
>   S:	Orphaned (Since 2016-02)
>

Re: [PATCH 2/3 v3] tpm2: Add a TPMv2 MMIO TIS driver

[Heinrich Schuchardt]

On 08.07.21 10:23, Ilias Apalodimas wrote:
> Add support for devices that expose a TPMv2 though MMIO.
> Apart from those devices, we can use the driver in our QEMU setups and
> test TPM related code which is difficult to achieve using the sandbox
> driver (e.g test the EFI TCG2 protocol).
>
> It's worth noting that a previous patch added TPMv2 TIS core functions,
> which the current driver is consuming.
>
> Signed-off-by: Ilias Apalodimas <ilias.apalodimas@linaro.org>

There should be a defconfig using the driver to ensure that it is built
in CI. As you want to use the driver for testing with QEMU let that be
qemu_arm64_defconfig and qemu_arm_defconfig (we should build both 64bit
and 32bit).

A paragraph in doc/board/emulation/qemu-arm.rst indicating how to
emulate a TPM would be helpful.

I think information like the following is needed:

To emulate a TPM the swtpm package may be used. It can be built from the
following repositories:

     https://github.com/stefanberger/libtpms.git
     https://github.com/stefanberger/swtpm.git

Swtpm provides a socket for the TPM emulation which can be consumed by QEMU.

In a first console invoke swtpm:

     swtpm socket --tpmstate dir=/tmp/mytpm1   \
     --ctrl type=unixio,path=/tmp/mytpm1/swtpm-sock --log level=20

In a second console invoke qemu-system-aarch64 with

     -chardev socket,id=chrtpm,path=/tmp/mytpm1/swtpm-sock \
     -tpmdev emulator,id=tpm0,chardev=chrtpm \
     -device tpm-tis-device,tpmdev=tpm0

To use the TPM emulation U-Boot must be compiled with

???

Best regards

Heinrich

> ---
>   drivers/tpm/Kconfig         |   9 +++
>   drivers/tpm/Makefile        |   1 +
>   drivers/tpm/tpm2_tis_mmio.c | 156 ++++++++++++++++++++++++++++++++++++
>   3 files changed, 166 insertions(+)
>   create mode 100644 drivers/tpm/tpm2_tis_mmio.c
>
> diff --git a/drivers/tpm/Kconfig b/drivers/tpm/Kconfig
> index 9eebab5cfd90..406ee8716e1e 100644
> --- a/drivers/tpm/Kconfig
> +++ b/drivers/tpm/Kconfig
> @@ -161,6 +161,15 @@ config TPM2_FTPM_TEE
>   	help
>   	  This driver supports firmware TPM running in TEE.
>
> +config TPM2_MMIO
> +	bool "MMIO based TPM2 Interface"
> +	depends on TPM_V2
> +	help
> +	  This driver supports firmware TPM2.0 MMIO interface.
> +	  The usual TPM operations and the 'tpm' command can be used to talk
> +	  to the device using the standard TPM Interface Specification (TIS)
> +	  protocol.
> +
>   endif # TPM_V2
>
>   endmenu
> diff --git a/drivers/tpm/Makefile b/drivers/tpm/Makefile
> index f64d20067f88..1065c1874f58 100644
> --- a/drivers/tpm/Makefile
> +++ b/drivers/tpm/Makefile
> @@ -14,3 +14,4 @@ obj-$(CONFIG_$(SPL_TPL_)TPM2_CR50_I2C) += cr50_i2c.o
>   obj-$(CONFIG_TPM2_TIS_SANDBOX) += tpm2_tis_sandbox.o
>   obj-$(CONFIG_TPM2_TIS_SPI) += tpm2_tis_spi.o
>   obj-$(CONFIG_TPM2_FTPM_TEE) += tpm2_ftpm_tee.o
> +obj-$(CONFIG_TPM2_MMIO) += tpm2_tis_core.o tpm2_tis_mmio.o
> diff --git a/drivers/tpm/tpm2_tis_mmio.c b/drivers/tpm/tpm2_tis_mmio.c
> new file mode 100644
> index 000000000000..2183a2807162
> --- /dev/null
> +++ b/drivers/tpm/tpm2_tis_mmio.c
> @@ -0,0 +1,156 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * driver for mmio TCG/TIS TPM (trusted platform module).
> + *
> + * Specifications at www.trustedcomputinggroup.org
> + */
> +
> +#include <common.h>
> +#include <dm.h>
> +#include <log.h>
> +#include <tpm-v2.h>
> +#include <linux/bitops.h>
> +#include <linux/compiler.h>
> +#include <linux/delay.h>
> +#include <linux/errno.h>
> +#include <linux/types.h>
> +#include <linux/io.h>
> +#include <linux/unaligned/be_byteshift.h>
> +#include "tpm_tis.h"
> +#include "tpm_internal.h"
> +
> +struct tpm_tis_chip_data {
> +	unsigned int pcr_count;
> +	unsigned int pcr_select_min;
> +	unsigned int time_before_first_cmd_ms;
> +	void __iomem *iobase;
> +};
> +
> +static int mmio_read_bytes(struct udevice *udev, u32 addr, u16 len,
> +			   u8 *result)
> +{
> +	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
> +
> +	while (len--)
> +		*result++ = ioread8(drv_data->iobase + addr);
> +	return 0;
> +}
> +
> +static int mmio_write_bytes(struct udevice *udev, u32 addr, u16 len,
> +			    const u8 *value)
> +{
> +	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
> +
> +	while (len--)
> +		iowrite8(*value++, drv_data->iobase + addr);
> +	return 0;
> +}
> +
> +static int mmio_read16(struct udevice *udev, u32 addr, u16 *result)
> +{
> +	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
> +
> +	*result = ioread16(drv_data->iobase + addr);
> +	return 0;
> +}
> +
> +static int mmio_read32(struct udevice *udev, u32 addr, u32 *result)
> +{
> +	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
> +
> +	*result = ioread32(drv_data->iobase + addr);
> +	return 0;
> +}
> +
> +static int mmio_write32(struct udevice *udev, u32 addr, u32 value)
> +{
> +	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
> +
> +	iowrite32(value, drv_data->iobase + addr);
> +	return 0;
> +}
> +
> +static struct tpm_tis_phy_ops phy_ops = {
> +	.read_bytes = mmio_read_bytes,
> +	.write_bytes = mmio_write_bytes,
> +	.read16 = mmio_read16,
> +	.read32 = mmio_read32,
> +	.write32 = mmio_write32,
> +};
> +
> +static int tpm_tis_probe(struct udevice *udev)
> +{
> +	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
> +	struct tpm_chip_priv *priv = dev_get_uclass_priv(udev);
> +	int ret = 0;
> +	fdt_addr_t ioaddr;
> +	u64 sz;
> +
> +	ioaddr = dev_read_addr(udev);
> +	if (ioaddr == FDT_ADDR_T_NONE)
> +		return -EINVAL;
> +
> +	ret = dev_read_u64(udev, "reg", &sz);
> +	if (ret)
> +		return -EINVAL;
> +
> +	drv_data->iobase = ioremap(ioaddr, sz);
> +	log_info("Remapped TPM2 base: 0x%llx size: 0x%llx\n", ioaddr, sz);
> +	tpm_tis_ops_register(udev, &phy_ops);
> +	ret = tpm_tis_init(udev);
> +	if (ret)
> +		goto iounmap;
> +
> +	priv->pcr_count = drv_data->pcr_count;
> +	priv->pcr_select_min = drv_data->pcr_select_min;
> +	/*
> +	 * Although the driver probably works with a TPMv1 our Kconfig
> +	 * limits the driver to TPMv2 only
> +	 */
> +	priv->version = TPM_V2;
> +
> +	return ret;
> +iounmap:
> +	iounmap(drv_data->iobase);
> +	return -EINVAL;
> +}
> +
> +static int tpm_tis_remove(struct udevice *udev)
> +{
> +	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
> +
> +	iounmap(drv_data->iobase);
> +	return tpm_tis_cleanup(udev);
> +}
> +
> +static const struct tpm_ops tpm_tis_ops = {
> +	.open		= tpm_tis_open,
> +	.close		= tpm_tis_close,
> +	.get_desc	= tpm_tis_get_desc,
> +	.send		= tpm_tis_send,
> +	.recv		= tpm_tis_recv,
> +	.cleanup	= tpm_tis_cleanup,
> +};
> +
> +static const struct tpm_tis_chip_data tpm_tis_std_chip_data = {
> +	.pcr_count = 24,
> +	.pcr_select_min = 3,
> +};
> +
> +static const struct udevice_id tpm_tis_ids[] = {
> +	{
> +		.compatible = "tcg,tpm-tis-mmio",
> +		.data = (ulong)&tpm_tis_std_chip_data,
> +	},
> +	{ }
> +};
> +
> +U_BOOT_DRIVER(tpm_tis_mmio) = {
> +	.name   = "tpm_tis_mmio",
> +	.id     = UCLASS_TPM,
> +	.of_match = tpm_tis_ids,
> +	.ops    = &tpm_tis_ops,
> +	.probe	= tpm_tis_probe,
> +	.remove	= tpm_tis_remove,
> +	.priv_auto	= sizeof(struct tpm_chip),
> +};
>

Re: [PATCH 2/3 v3] tpm2: Add a TPMv2 MMIO TIS driver

[Ilias Apalodimas]

On Thu, Jul 08, 2021 at 11:42:29AM +0200, Heinrich Schuchardt wrote:
> On 08.07.21 10:23, Ilias Apalodimas wrote:
> > Add support for devices that expose a TPMv2 though MMIO.
> > Apart from those devices, we can use the driver in our QEMU setups and
> > test TPM related code which is difficult to achieve using the sandbox
> > driver (e.g test the EFI TCG2 protocol).
> > 
> > It's worth noting that a previous patch added TPMv2 TIS core functions,
> > which the current driver is consuming.
> > 
> > Signed-off-by: Ilias Apalodimas <ilias.apalodimas@linaro.org>
> 
> There should be a defconfig using the driver to ensure that it is built
> in CI. As you want to use the driver for testing with QEMU let that be
> qemu_arm64_defconfig and qemu_arm_defconfig (we should build both 64bit
> and 32bit).
> 
> A paragraph in doc/board/emulation/qemu-arm.rst indicating how to
> emulate a TPM would be helpful.
> 
> I think information like the following is needed:
> 
> To emulate a TPM the swtpm package may be used. It can be built from the
> following repositories:
> 
>     https://github.com/stefanberger/libtpms.git
>     https://github.com/stefanberger/swtpm.git
> 
> Swtpm provides a socket for the TPM emulation which can be consumed by QEMU.
> 
> In a first console invoke swtpm:
> 
>     swtpm socket --tpmstate dir=/tmp/mytpm1   \
>     --ctrl type=unixio,path=/tmp/mytpm1/swtpm-sock --log level=20
> 
> In a second console invoke qemu-system-aarch64 with
> 
>     -chardev socket,id=chrtpm,path=/tmp/mytpm1/swtpm-sock \
>     -tpmdev emulator,id=tpm0,chardev=chrtpm \
>     -device tpm-tis-device,tpmdev=tpm0
> 
> To use the TPM emulation U-Boot must be compiled with
> 
> ???

Text looks good to me. I'll send a v4 with the defconfigs + help included

Thanks
/Ilias
> 
> Best regards
> 
> Heinrich
> 
> > ---
> >   drivers/tpm/Kconfig         |   9 +++
> >   drivers/tpm/Makefile        |   1 +
> >   drivers/tpm/tpm2_tis_mmio.c | 156 ++++++++++++++++++++++++++++++++++++
> >   3 files changed, 166 insertions(+)
> >   create mode 100644 drivers/tpm/tpm2_tis_mmio.c
> > 
> > diff --git a/drivers/tpm/Kconfig b/drivers/tpm/Kconfig
> > index 9eebab5cfd90..406ee8716e1e 100644
> > --- a/drivers/tpm/Kconfig
> > +++ b/drivers/tpm/Kconfig
> > @@ -161,6 +161,15 @@ config TPM2_FTPM_TEE
> >   	help
> >   	  This driver supports firmware TPM running in TEE.
> > 
> > +config TPM2_MMIO
> > +	bool "MMIO based TPM2 Interface"
> > +	depends on TPM_V2
> > +	help
> > +	  This driver supports firmware TPM2.0 MMIO interface.
> > +	  The usual TPM operations and the 'tpm' command can be used to talk
> > +	  to the device using the standard TPM Interface Specification (TIS)
> > +	  protocol.
> > +
> >   endif # TPM_V2
> > 
> >   endmenu
> > diff --git a/drivers/tpm/Makefile b/drivers/tpm/Makefile
> > index f64d20067f88..1065c1874f58 100644
> > --- a/drivers/tpm/Makefile
> > +++ b/drivers/tpm/Makefile
> > @@ -14,3 +14,4 @@ obj-$(CONFIG_$(SPL_TPL_)TPM2_CR50_I2C) += cr50_i2c.o
> >   obj-$(CONFIG_TPM2_TIS_SANDBOX) += tpm2_tis_sandbox.o
> >   obj-$(CONFIG_TPM2_TIS_SPI) += tpm2_tis_spi.o
> >   obj-$(CONFIG_TPM2_FTPM_TEE) += tpm2_ftpm_tee.o
> > +obj-$(CONFIG_TPM2_MMIO) += tpm2_tis_core.o tpm2_tis_mmio.o
> > diff --git a/drivers/tpm/tpm2_tis_mmio.c b/drivers/tpm/tpm2_tis_mmio.c
> > new file mode 100644
> > index 000000000000..2183a2807162
> > --- /dev/null
> > +++ b/drivers/tpm/tpm2_tis_mmio.c
> > @@ -0,0 +1,156 @@
> > +// SPDX-License-Identifier: GPL-2.0
> > +/*
> > + * driver for mmio TCG/TIS TPM (trusted platform module).
> > + *
> > + * Specifications at www.trustedcomputinggroup.org
> > + */
> > +
> > +#include <common.h>
> > +#include <dm.h>
> > +#include <log.h>
> > +#include <tpm-v2.h>
> > +#include <linux/bitops.h>
> > +#include <linux/compiler.h>
> > +#include <linux/delay.h>
> > +#include <linux/errno.h>
> > +#include <linux/types.h>
> > +#include <linux/io.h>
> > +#include <linux/unaligned/be_byteshift.h>
> > +#include "tpm_tis.h"
> > +#include "tpm_internal.h"
> > +
> > +struct tpm_tis_chip_data {
> > +	unsigned int pcr_count;
> > +	unsigned int pcr_select_min;
> > +	unsigned int time_before_first_cmd_ms;
> > +	void __iomem *iobase;
> > +};
> > +
> > +static int mmio_read_bytes(struct udevice *udev, u32 addr, u16 len,
> > +			   u8 *result)
> > +{
> > +	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
> > +
> > +	while (len--)
> > +		*result++ = ioread8(drv_data->iobase + addr);
> > +	return 0;
> > +}
> > +
> > +static int mmio_write_bytes(struct udevice *udev, u32 addr, u16 len,
> > +			    const u8 *value)
> > +{
> > +	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
> > +
> > +	while (len--)
> > +		iowrite8(*value++, drv_data->iobase + addr);
> > +	return 0;
> > +}
> > +
> > +static int mmio_read16(struct udevice *udev, u32 addr, u16 *result)
> > +{
> > +	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
> > +
> > +	*result = ioread16(drv_data->iobase + addr);
> > +	return 0;
> > +}
> > +
> > +static int mmio_read32(struct udevice *udev, u32 addr, u32 *result)
> > +{
> > +	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
> > +
> > +	*result = ioread32(drv_data->iobase + addr);
> > +	return 0;
> > +}
> > +
> > +static int mmio_write32(struct udevice *udev, u32 addr, u32 value)
> > +{
> > +	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
> > +
> > +	iowrite32(value, drv_data->iobase + addr);
> > +	return 0;
> > +}
> > +
> > +static struct tpm_tis_phy_ops phy_ops = {
> > +	.read_bytes = mmio_read_bytes,
> > +	.write_bytes = mmio_write_bytes,
> > +	.read16 = mmio_read16,
> > +	.read32 = mmio_read32,
> > +	.write32 = mmio_write32,
> > +};
> > +
> > +static int tpm_tis_probe(struct udevice *udev)
> > +{
> > +	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
> > +	struct tpm_chip_priv *priv = dev_get_uclass_priv(udev);
> > +	int ret = 0;
> > +	fdt_addr_t ioaddr;
> > +	u64 sz;
> > +
> > +	ioaddr = dev_read_addr(udev);
> > +	if (ioaddr == FDT_ADDR_T_NONE)
> > +		return -EINVAL;
> > +
> > +	ret = dev_read_u64(udev, "reg", &sz);
> > +	if (ret)
> > +		return -EINVAL;
> > +
> > +	drv_data->iobase = ioremap(ioaddr, sz);
> > +	log_info("Remapped TPM2 base: 0x%llx size: 0x%llx\n", ioaddr, sz);
> > +	tpm_tis_ops_register(udev, &phy_ops);
> > +	ret = tpm_tis_init(udev);
> > +	if (ret)
> > +		goto iounmap;
> > +
> > +	priv->pcr_count = drv_data->pcr_count;
> > +	priv->pcr_select_min = drv_data->pcr_select_min;
> > +	/*
> > +	 * Although the driver probably works with a TPMv1 our Kconfig
> > +	 * limits the driver to TPMv2 only
> > +	 */
> > +	priv->version = TPM_V2;
> > +
> > +	return ret;
> > +iounmap:
> > +	iounmap(drv_data->iobase);
> > +	return -EINVAL;
> > +}
> > +
> > +static int tpm_tis_remove(struct udevice *udev)
> > +{
> > +	struct tpm_tis_chip_data *drv_data = (void *)dev_get_driver_data(udev);
> > +
> > +	iounmap(drv_data->iobase);
> > +	return tpm_tis_cleanup(udev);
> > +}
> > +
> > +static const struct tpm_ops tpm_tis_ops = {
> > +	.open		= tpm_tis_open,
> > +	.close		= tpm_tis_close,
> > +	.get_desc	= tpm_tis_get_desc,
> > +	.send		= tpm_tis_send,
> > +	.recv		= tpm_tis_recv,
> > +	.cleanup	= tpm_tis_cleanup,
> > +};
> > +
> > +static const struct tpm_tis_chip_data tpm_tis_std_chip_data = {
> > +	.pcr_count = 24,
> > +	.pcr_select_min = 3,
> > +};
> > +
> > +static const struct udevice_id tpm_tis_ids[] = {
> > +	{
> > +		.compatible = "tcg,tpm-tis-mmio",
> > +		.data = (ulong)&tpm_tis_std_chip_data,
> > +	},
> > +	{ }
> > +};
> > +
> > +U_BOOT_DRIVER(tpm_tis_mmio) = {
> > +	.name   = "tpm_tis_mmio",
> > +	.id     = UCLASS_TPM,
> > +	.of_match = tpm_tis_ids,
> > +	.ops    = &tpm_tis_ops,
> > +	.probe	= tpm_tis_probe,
> > +	.remove	= tpm_tis_remove,
> > +	.priv_auto	= sizeof(struct tpm_chip),
> > +};
> > 

Re: [PATCH 3/3 v3] MAINTAINERS: Add entry for TPM drivers

[Simon Glass]

On Thu, 8 Jul 2021 at 03:23, Heinrich Schuchardt <xypron.glpk@gmx.de> wrote:
>
> On 08.07.21 10:23, Ilias Apalodimas wrote:
> > TPM drivers have currently no maintainers.  Add myself since I contributed
> > the TIS implementation.
> >
> > Signed-off-by: Ilias Apalodimas <ilias.apalodimas@linaro.org>
>
> Thanks for volunteering.
>
> Reviewed-by: Heinrich Schuchardt <xypron.glpk@gmx.de>

+1

Reviewed-by: Simon Glass <sjg@chromium.org>