Skip to content

L
linux
Commit 1107d065 authored by Christophe Ricard's avatar Christophe Ricard Committed by Jarkko Sakkinen
3 Browse files
Options

tpm_tis: Introduce intermediate layer for TPM access 

This splits tpm_tis in a high-level protocol part and a low-level interface
for the actual TPM communication. The low-level interface can then be
implemented by additional drivers to provide access to TPMs using other
mechanisms, for example native I2C or SPI transfers, while still reusing
the same TIS protocol implementation.

Though the ioread/iowrite calls cannot fail, other implementations of this
interface might want to return error codes if their communication fails.

This follows the usual pattern of negative values representing errors and
zero representing success. Positive values are not used (yet).

Errors are passed back to the caller if possible. If the interface of a
function does not allow that, it tries to do the most sensible thing it
can, but this might also mean ignoring the error in this instance.

This commit is based on the initial work by Peter Huewe.
Signed-off-by: default avatarAlexander Steffen <Alexander.Steffen@infineon.com>
Signed-off-by: default avatarChristophe Ricard <christophe-h.ricard@st.com>
Reviewed-by: default avatarJarkko Sakkinen <jarkko.sakkinen@linux.intel.com>
Tested-by: default avatarJarkko Sakkinen <jarkko.sakkinen@linux.intel.com>
Tested-by: default avatarStefan Berger <stefanb@linux.vnet.ibm.com>
Reviewed-by: default avatarStefan Berger <stefanb@linux.vnet.ibm.com>
Signed-off-by: default avatarJarkko Sakkinen <jarkko.sakkinen@linux.intel.com>
parent 57dacc2b
Hide whitespace changes
Inline Side-by-side
Showing with 270 additions and 101 deletions
drivers/char/tpm/tpm_tis.c
View file @ 1107d065
...@@ -134,11 +134,16 @@ static inline int is_itpm(struct acpi_device *dev) ...@@ -134,11 +134,16 @@ static inline int is_itpm(struct acpi_device *dev)
static int wait_startup(struct tpm_chip *chip, int l) static int wait_startup(struct tpm_chip *chip, int l)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv);
unsigned long stop = jiffies + chip->timeout_a; unsigned long stop = jiffies + chip->timeout_a;
int rc;
u8 access;
do { do {
if (ioread8(phy->iobase + TPM_ACCESS(l)) & rc = tpm_tis_read8(priv, TPM_ACCESS(l), &access);
TPM_ACCESS_VALID) if (rc < 0)
return rc;
if (access & TPM_ACCESS_VALID)
return 0; return 0;
msleep(TPM_TIMEOUT); msleep(TPM_TIMEOUT);
} while (time_before(jiffies, stop)); } while (time_before(jiffies, stop));
...@@ -148,10 +153,14 @@ static int wait_startup(struct tpm_chip *chip, int l) ...@@ -148,10 +153,14 @@ static int wait_startup(struct tpm_chip *chip, int l)
static int check_locality(struct tpm_chip *chip, int l) static int check_locality(struct tpm_chip *chip, int l)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv); int rc;
u8 access;
rc = tpm_tis_read8(priv, TPM_ACCESS(l), &access);
if (rc < 0)
return rc;
if ((ioread8(phy->iobase + TPM_ACCESS(l)) & if ((access & (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
(TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
(TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID))
return priv->locality = l; return priv->locality = l;
...@@ -161,27 +170,32 @@ static int check_locality(struct tpm_chip *chip, int l) ...@@ -161,27 +170,32 @@ static int check_locality(struct tpm_chip *chip, int l)
static void release_locality(struct tpm_chip *chip, int l, int force) static void release_locality(struct tpm_chip *chip, int l, int force)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv); int rc;
u8 access;
rc = tpm_tis_read8(priv, TPM_ACCESS(l), &access);
if (rc < 0)
return;
if (force || (ioread8(phy->iobase + TPM_ACCESS(l)) & if (force || (access &
(TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) == (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) ==
(TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID))
iowrite8(TPM_ACCESS_ACTIVE_LOCALITY, tpm_tis_write8(priv, TPM_ACCESS(l), TPM_ACCESS_ACTIVE_LOCALITY);
phy->iobase + TPM_ACCESS(l));
} }
static int request_locality(struct tpm_chip *chip, int l) static int request_locality(struct tpm_chip *chip, int l)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv);
unsigned long stop, timeout; unsigned long stop, timeout;
long rc; long rc;
if (check_locality(chip, l) >= 0) if (check_locality(chip, l) >= 0)
return l; return l;
iowrite8(TPM_ACCESS_REQUEST_USE, rc = tpm_tis_write8(priv, TPM_ACCESS(l), TPM_ACCESS_REQUEST_USE);
phy->iobase + TPM_ACCESS(l)); if (rc < 0)
return rc;
stop = jiffies + chip->timeout_a; stop = jiffies + chip->timeout_a;
...@@ -215,38 +229,45 @@ static int request_locality(struct tpm_chip *chip, int l) ...@@ -215,38 +229,45 @@ static int request_locality(struct tpm_chip *chip, int l)
static u8 tpm_tis_status(struct tpm_chip *chip) static u8 tpm_tis_status(struct tpm_chip *chip)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv); int rc;
u8 status;
rc = tpm_tis_read8(priv, TPM_STS(priv->locality), &status);
if (rc < 0)
return 0;
return ioread8(phy->iobase + return status;
TPM_STS(priv->locality));
} }
static void tpm_tis_ready(struct tpm_chip *chip) static void tpm_tis_ready(struct tpm_chip *chip)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv);
/* this causes the current command to be aborted */ /* this causes the current command to be aborted */
iowrite8(TPM_STS_COMMAND_READY, tpm_tis_write8(priv, TPM_STS(priv->locality), TPM_STS_COMMAND_READY);
phy->iobase + TPM_STS(priv->locality));
} }
static int get_burstcount(struct tpm_chip *chip) static int get_burstcount(struct tpm_chip *chip)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv);
unsigned long stop; unsigned long stop;
int burstcnt; int burstcnt, rc;
u8 value;
/* wait for burstcount */ /* wait for burstcount */
/* which timeout value, spec has 2 answers (c & d) */ /* which timeout value, spec has 2 answers (c & d) */
stop = jiffies + chip->timeout_d; stop = jiffies + chip->timeout_d;
do { do {
burstcnt = ioread8(phy->iobase + rc = tpm_tis_read8(priv, TPM_STS(priv->locality) + 1, &value);
TPM_STS(priv->locality) + 1); if (rc < 0)
burstcnt += ioread8(phy->iobase + return rc;
TPM_STS(priv->locality) +
2) << 8; burstcnt = value;
rc = tpm_tis_read8(priv, TPM_STS(priv->locality) + 2, &value);
if (rc < 0)
return rc;
burstcnt += value << 8;
if (burstcnt) if (burstcnt)
return burstcnt; return burstcnt;
msleep(TPM_TIMEOUT); msleep(TPM_TIMEOUT);
...@@ -257,18 +278,20 @@ static int get_burstcount(struct tpm_chip *chip) ...@@ -257,18 +278,20 @@ static int get_burstcount(struct tpm_chip *chip)
static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count) static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv); int size = 0, burstcnt, rc;
int size = 0, burstcnt;
while (size < count && while (size < count &&
wait_for_tpm_stat(chip, wait_for_tpm_stat(chip,
TPM_STS_DATA_AVAIL | TPM_STS_VALID, TPM_STS_DATA_AVAIL | TPM_STS_VALID,
chip->timeout_c, chip->timeout_c,
&priv->read_queue, true) &priv->read_queue, true) == 0) {
== 0) { burstcnt = min_t(int, get_burstcount(chip), count - size);
burstcnt = get_burstcount(chip); rc = tpm_tis_read_bytes(priv, TPM_DATA_FIFO(priv->locality),
for (; burstcnt > 0 && size < count; burstcnt--) burstcnt, buf + size);
buf[size++] = ioread8(phy->iobase + if (rc < 0)
TPM_DATA_FIFO(priv->locality)); return rc;
size += burstcnt;
} }
return size; return size;
} }
...@@ -332,7 +355,6 @@ MODULE_PARM_DESC(itpm, "Force iTPM workarounds (found on some Lenovo laptops)"); ...@@ -332,7 +355,6 @@ MODULE_PARM_DESC(itpm, "Force iTPM workarounds (found on some Lenovo laptops)");
static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len) static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv);
int rc, status, burstcnt; int rc, status, burstcnt;
size_t count = 0; size_t count = 0;
...@@ -351,12 +373,13 @@ static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len) ...@@ -351,12 +373,13 @@ static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len)
} }
while (count < len - 1) { while (count < len - 1) {
burstcnt = get_burstcount(chip); burstcnt = min_t(int, get_burstcount(chip), len - count - 1);
for (; burstcnt > 0 && count < len - 1; burstcnt--) { rc = tpm_tis_write_bytes(priv, TPM_DATA_FIFO(priv->locality),
iowrite8(buf[count], phy->iobase + burstcnt, buf + count);
TPM_DATA_FIFO(priv->locality)); if (rc < 0)
count++; goto out_err;
}
count += burstcnt;
wait_for_tpm_stat(chip, TPM_STS_VALID, chip->timeout_c, wait_for_tpm_stat(chip, TPM_STS_VALID, chip->timeout_c,
&priv->int_queue, false); &priv->int_queue, false);
...@@ -368,8 +391,10 @@ static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len) ...@@ -368,8 +391,10 @@ static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len)
} }
/* write last byte */ /* write last byte */
iowrite8(buf[count], rc = tpm_tis_write8(priv, TPM_DATA_FIFO(priv->locality), buf[count]);
phy->iobase + TPM_DATA_FIFO(priv->locality)); if (rc < 0)
goto out_err;
wait_for_tpm_stat(chip, TPM_STS_VALID, chip->timeout_c, wait_for_tpm_stat(chip, TPM_STS_VALID, chip->timeout_c,
&priv->int_queue, false); &priv->int_queue, false);
status = tpm_tis_status(chip); status = tpm_tis_status(chip);
...@@ -389,15 +414,16 @@ static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len) ...@@ -389,15 +414,16 @@ static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len)
static void disable_interrupts(struct tpm_chip *chip) static void disable_interrupts(struct tpm_chip *chip)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv);
u32 intmask; u32 intmask;
int rc;
rc = tpm_tis_read32(priv, TPM_INT_ENABLE(priv->locality), &intmask);
if (rc < 0)
intmask = 0;
intmask =
ioread32(phy->iobase +
TPM_INT_ENABLE(priv->locality));
intmask &= ~TPM_GLOBAL_INT_ENABLE; intmask &= ~TPM_GLOBAL_INT_ENABLE;
iowrite32(intmask, tpm_tis_write32(priv, TPM_INT_ENABLE(priv->locality), intmask);
phy->iobase + TPM_INT_ENABLE(priv->locality));
devm_free_irq(chip->dev.parent, priv->irq, chip); devm_free_irq(chip->dev.parent, priv->irq, chip);
priv->irq = 0; priv->irq = 0;
chip->flags &= ~TPM_CHIP_FLAG_IRQ; chip->flags &= ~TPM_CHIP_FLAG_IRQ;
...@@ -411,7 +437,6 @@ static void disable_interrupts(struct tpm_chip *chip) ...@@ -411,7 +437,6 @@ static void disable_interrupts(struct tpm_chip *chip)
static int tpm_tis_send_main(struct tpm_chip *chip, u8 *buf, size_t len) static int tpm_tis_send_main(struct tpm_chip *chip, u8 *buf, size_t len)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv);
int rc; int rc;
u32 ordinal; u32 ordinal;
unsigned long dur; unsigned long dur;
...@@ -421,8 +446,9 @@ static int tpm_tis_send_main(struct tpm_chip *chip, u8 *buf, size_t len) ...@@ -421,8 +446,9 @@ static int tpm_tis_send_main(struct tpm_chip *chip, u8 *buf, size_t len)
return rc; return rc;
/* go and do it */ /* go and do it */
iowrite8(TPM_STS_GO, rc = tpm_tis_write8(priv, TPM_STS(priv->locality), TPM_STS_GO);
phy->iobase + TPM_STS(priv->locality)); if (rc < 0)
return rc;
if (chip->flags & TPM_CHIP_FLAG_IRQ) { if (chip->flags & TPM_CHIP_FLAG_IRQ) {
ordinal = be32_to_cpu(*((__be32 *) (buf + 6))); ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
...@@ -484,11 +510,12 @@ static bool tpm_tis_update_timeouts(struct tpm_chip *chip, ...@@ -484,11 +510,12 @@ static bool tpm_tis_update_timeouts(struct tpm_chip *chip,
unsigned long *timeout_cap) unsigned long *timeout_cap)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv); int i, rc;
int i;
u32 did_vid; u32 did_vid;
did_vid = ioread32(phy->iobase + TPM_DID_VID(0)); rc = tpm_tis_read32(priv, TPM_DID_VID(0), &did_vid);
if (rc < 0)
return rc;
for (i = 0; i != ARRAY_SIZE(vendor_timeout_overrides); i++) { for (i = 0; i != ARRAY_SIZE(vendor_timeout_overrides); i++) {
if (vendor_timeout_overrides[i].did_vid != did_vid) if (vendor_timeout_overrides[i].did_vid != did_vid)
...@@ -509,7 +536,6 @@ static bool tpm_tis_update_timeouts(struct tpm_chip *chip, ...@@ -509,7 +536,6 @@ static bool tpm_tis_update_timeouts(struct tpm_chip *chip,
static int probe_itpm(struct tpm_chip *chip) static int probe_itpm(struct tpm_chip *chip)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv);
int rc = 0; int rc = 0;
u8 cmd_getticks[] = { u8 cmd_getticks[] = {
0x00, 0xc1, 0x00, 0x00, 0x00, 0x0a, 0x00, 0xc1, 0x00, 0x00, 0x00, 0x0a,
...@@ -517,7 +543,11 @@ static int probe_itpm(struct tpm_chip *chip) ...@@ -517,7 +543,11 @@ static int probe_itpm(struct tpm_chip *chip)
}; };
size_t len = sizeof(cmd_getticks); size_t len = sizeof(cmd_getticks);
bool rem_itpm = itpm; bool rem_itpm = itpm;
u16 vendor = ioread16(phy->iobase + TPM_DID_VID(0)); u16 vendor;
rc = tpm_tis_read16(priv, TPM_DID_VID(0), &vendor);
if (rc < 0)
return rc;
/* probe only iTPMS */ /* probe only iTPMS */
if (vendor != TPM_VID_INTEL) if (vendor != TPM_VID_INTEL)
...@@ -575,16 +605,68 @@ static const struct tpm_class_ops tpm_tis = { ...@@ -575,16 +605,68 @@ static const struct tpm_class_ops tpm_tis = {
.req_canceled = tpm_tis_req_canceled, .req_canceled = tpm_tis_req_canceled,
}; };
static int tpm_tcg_read_bytes(struct tpm_tis_data *data, u32 addr, u16 len,
u8 *result)
{
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data);
while (len--)
*result++ = ioread8(phy->iobase + addr);
return 0;
}
static int tpm_tcg_write_bytes(struct tpm_tis_data *data, u32 addr, u16 len,
u8 *value)
{
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data);
while (len--)
iowrite8(*value++, phy->iobase + addr);
return 0;
}
static int tpm_tcg_read16(struct tpm_tis_data *data, u32 addr, u16 *result)
{
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data);
*result = ioread16(phy->iobase + addr);
return 0;
}
static int tpm_tcg_read32(struct tpm_tis_data *data, u32 addr, u32 *result)
{
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data);
*result = ioread32(phy->iobase + addr);
return 0;
}
static int tpm_tcg_write32(struct tpm_tis_data *data, u32 addr, u32 value)
{
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data);
iowrite32(value, phy->iobase + addr);
return 0;
}
static const struct tpm_tis_phy_ops tpm_tcg = {
.read_bytes = tpm_tcg_read_bytes,
.write_bytes = tpm_tcg_write_bytes,
.read16 = tpm_tcg_read16,
.read32 = tpm_tcg_read32,
.write32 = tpm_tcg_write32,
};
static irqreturn_t tis_int_handler(int dummy, void *dev_id) static irqreturn_t tis_int_handler(int dummy, void *dev_id)
{ {
struct tpm_chip *chip = dev_id; struct tpm_chip *chip = dev_id;
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv);
u32 interrupt; u32 interrupt;
int i; int i, rc;
interrupt = ioread32(phy->iobase + rc = tpm_tis_read32(priv, TPM_INT_STATUS(priv->locality), &interrupt);
TPM_INT_STATUS(priv->locality)); if (rc < 0)
return IRQ_NONE;
if (interrupt == 0) if (interrupt == 0)
return IRQ_NONE; return IRQ_NONE;
...@@ -602,10 +684,11 @@ static irqreturn_t tis_int_handler(int dummy, void *dev_id) ...@@ -602,10 +684,11 @@ static irqreturn_t tis_int_handler(int dummy, void *dev_id)
wake_up_interruptible(&priv->int_queue); wake_up_interruptible(&priv->int_queue);
/* Clear interrupts handled with TPM_EOI */ /* Clear interrupts handled with TPM_EOI */
iowrite32(interrupt, rc = tpm_tis_write32(priv, TPM_INT_STATUS(priv->locality), interrupt);
phy->iobase + if (rc < 0)
TPM_INT_STATUS(priv->locality)); return IRQ_NONE;
ioread32(phy->iobase + TPM_INT_STATUS(priv->locality));
tpm_tis_read32(priv, TPM_INT_STATUS(priv->locality), &interrupt);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
...@@ -617,8 +700,9 @@ static int tpm_tis_probe_irq_single(struct tpm_chip *chip, u32 intmask, ...@@ -617,8 +700,9 @@ static int tpm_tis_probe_irq_single(struct tpm_chip *chip, u32 intmask,
int flags, int irq) int flags, int irq)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv);
u8 original_int_vec; u8 original_int_vec;
int rc;
u32 int_status;
if (devm_request_irq(chip->dev.parent, irq, tis_int_handler, flags, if (devm_request_irq(chip->dev.parent, irq, tis_int_handler, flags,
dev_name(&chip->dev), chip) != 0) { dev_name(&chip->dev), chip) != 0) {
...@@ -628,19 +712,29 @@ static int tpm_tis_probe_irq_single(struct tpm_chip *chip, u32 intmask, ...@@ -628,19 +712,29 @@ static int tpm_tis_probe_irq_single(struct tpm_chip *chip, u32 intmask,
} }
priv->irq = irq; priv->irq = irq;
original_int_vec = ioread8(phy->iobase + rc = tpm_tis_read8(priv, TPM_INT_VECTOR(priv->locality),
TPM_INT_VECTOR(priv->locality)); &original_int_vec);
iowrite8(irq, if (rc < 0)
phy->iobase + TPM_INT_VECTOR(priv->locality)); return rc;
rc = tpm_tis_write8(priv, TPM_INT_VECTOR(priv->locality), irq);
if (rc < 0)
return rc;
rc = tpm_tis_read32(priv, TPM_INT_STATUS(priv->locality), &int_status);
if (rc < 0)
return rc;
/* Clear all existing */ /* Clear all existing */
iowrite32(ioread32(phy->iobase + rc = tpm_tis_write32(priv, TPM_INT_STATUS(priv->locality), int_status);
TPM_INT_STATUS(priv->locality)), if (rc < 0)
phy->iobase + TPM_INT_STATUS(priv->locality)); return rc;
/* Turn on */ /* Turn on */
iowrite32(intmask | TPM_GLOBAL_INT_ENABLE, rc = tpm_tis_write32(priv, TPM_INT_ENABLE(priv->locality),
phy->iobase + TPM_INT_ENABLE(priv->locality)); intmask | TPM_GLOBAL_INT_ENABLE);
if (rc < 0)
return rc;
priv->irq_tested = false; priv->irq_tested = false;
...@@ -656,8 +750,11 @@ static int tpm_tis_probe_irq_single(struct tpm_chip *chip, u32 intmask, ...@@ -656,8 +750,11 @@ static int tpm_tis_probe_irq_single(struct tpm_chip *chip, u32 intmask,
* will call disable_irq which undoes all of the above. * will call disable_irq which undoes all of the above.
*/ */
if (!(chip->flags & TPM_CHIP_FLAG_IRQ)) { if (!(chip->flags & TPM_CHIP_FLAG_IRQ)) {
iowrite8(original_int_vec, rc = tpm_tis_write8(priv, TPM_INT_VECTOR(priv->locality),
phy->iobase + TPM_INT_VECTOR(priv->locality)); original_int_vec);
if (rc < 0)
return rc;
return 1; return 1;
} }
...@@ -671,12 +768,13 @@ static int tpm_tis_probe_irq_single(struct tpm_chip *chip, u32 intmask, ...@@ -671,12 +768,13 @@ static int tpm_tis_probe_irq_single(struct tpm_chip *chip, u32 intmask,
static void tpm_tis_probe_irq(struct tpm_chip *chip, u32 intmask) static void tpm_tis_probe_irq(struct tpm_chip *chip, u32 intmask)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv);
u8 original_int_vec; u8 original_int_vec;
int i; int i, rc;
original_int_vec = ioread8(phy->iobase + rc = tpm_tis_read8(priv, TPM_INT_VECTOR(priv->locality),
TPM_INT_VECTOR(priv->locality)); &original_int_vec);
if (rc < 0)
return;
if (!original_int_vec) { if (!original_int_vec) {
if (IS_ENABLED(CONFIG_X86)) if (IS_ENABLED(CONFIG_X86))
...@@ -696,10 +794,15 @@ MODULE_PARM_DESC(interrupts, "Enable interrupts"); ...@@ -696,10 +794,15 @@ MODULE_PARM_DESC(interrupts, "Enable interrupts");
static void tpm_tis_remove(struct tpm_chip *chip) static void tpm_tis_remove(struct tpm_chip *chip)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv); u32 reg = TPM_INT_ENABLE(priv->locality);
void __iomem *reg = phy->iobase + TPM_INT_ENABLE(priv->locality); u32 interrupt;
int rc;
rc = tpm_tis_read32(priv, reg, &interrupt);
if (rc < 0)
interrupt = 0;
iowrite32(~TPM_GLOBAL_INT_ENABLE & ioread32(reg), reg); tpm_tis_write32(priv, reg, ~TPM_GLOBAL_INT_ENABLE & interrupt);
release_locality(chip, priv->locality, 1); release_locality(chip, priv->locality, 1);
} }
...@@ -707,6 +810,7 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info, ...@@ -707,6 +810,7 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
acpi_handle acpi_dev_handle) acpi_handle acpi_dev_handle)
{ {
u32 vendor, intfcaps, intmask; u32 vendor, intfcaps, intmask;
u8 rid;
int rc, probe; int rc, probe;
struct tpm_chip *chip; struct tpm_chip *chip;
struct tpm_tis_tcg_phy *phy; struct tpm_tis_tcg_phy *phy;
...@@ -727,6 +831,8 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info, ...@@ -727,6 +831,8 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
if (IS_ERR(phy->iobase)) if (IS_ERR(phy->iobase))
return PTR_ERR(phy->iobase); return PTR_ERR(phy->iobase);
phy->priv.phy_ops = &tpm_tcg;
/* Maximum timeouts */ /* Maximum timeouts */
chip->timeout_a = TIS_TIMEOUT_A_MAX; chip->timeout_a = TIS_TIMEOUT_A_MAX;
chip->timeout_b = TIS_TIMEOUT_B_MAX; chip->timeout_b = TIS_TIMEOUT_B_MAX;
...@@ -741,13 +847,16 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info, ...@@ -741,13 +847,16 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
} }
/* Take control of the TPM's interrupt hardware and shut it off */ /* Take control of the TPM's interrupt hardware and shut it off */
intmask = ioread32(phy->iobase + rc = tpm_tis_read32(&phy->priv, TPM_INT_ENABLE(phy->priv.locality),
TPM_INT_ENABLE(phy->priv.locality)); &intmask);
if (rc < 0)
goto out_err;
intmask |= TPM_INTF_CMD_READY_INT | TPM_INTF_LOCALITY_CHANGE_INT | intmask |= TPM_INTF_CMD_READY_INT | TPM_INTF_LOCALITY_CHANGE_INT |
TPM_INTF_DATA_AVAIL_INT | TPM_INTF_STS_VALID_INT; TPM_INTF_DATA_AVAIL_INT | TPM_INTF_STS_VALID_INT;
intmask &= ~TPM_GLOBAL_INT_ENABLE; intmask &= ~TPM_GLOBAL_INT_ENABLE;
iowrite32(intmask, tpm_tis_write32(&phy->priv, TPM_INT_ENABLE(phy->priv.locality),
phy->iobase + TPM_INT_ENABLE(phy->priv.locality)); intmask);
if (request_locality(chip, 0) != 0) { if (request_locality(chip, 0) != 0) {
rc = -ENODEV; rc = -ENODEV;
...@@ -758,12 +867,19 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info, ...@@ -758,12 +867,19 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
if (rc) if (rc)
goto out_err; goto out_err;
vendor = ioread32(phy->iobase + TPM_DID_VID(0)); rc = tpm_tis_read32(&phy->priv, TPM_DID_VID(0), &vendor);
if (rc < 0)
goto out_err;
phy->priv.manufacturer_id = vendor; phy->priv.manufacturer_id = vendor;
rc = tpm_tis_read8(&phy->priv, TPM_RID(0), &rid);
if (rc < 0)
goto out_err;
dev_info(dev, "%s TPM (device-id 0x%X, rev-id %d)\n", dev_info(dev, "%s TPM (device-id 0x%X, rev-id %d)\n",
(chip->flags & TPM_CHIP_FLAG_TPM2) ? "2.0" : "1.2", (chip->flags & TPM_CHIP_FLAG_TPM2) ? "2.0" : "1.2",
vendor >> 16, ioread8(phy->iobase + TPM_RID(0))); vendor >> 16, rid);
if (!itpm) { if (!itpm) {
probe = probe_itpm(chip); probe = probe_itpm(chip);
...@@ -777,11 +893,12 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info, ...@@ -777,11 +893,12 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
if (itpm) if (itpm)
dev_info(dev, "Intel iTPM workaround enabled\n"); dev_info(dev, "Intel iTPM workaround enabled\n");
/* Figure out the capabilities */ /* Figure out the capabilities */
intfcaps = rc = tpm_tis_read32(&phy->priv, TPM_INTF_CAPS(phy->priv.locality),
ioread32(phy->iobase + &intfcaps);
TPM_INTF_CAPS(phy->priv.locality)); if (rc < 0)
goto out_err;
dev_dbg(dev, "TPM interface capabilities (0x%x):\n", dev_dbg(dev, "TPM interface capabilities (0x%x):\n",
intfcaps); intfcaps);
if (intfcaps & TPM_INTF_BURST_COUNT_STATIC) if (intfcaps & TPM_INTF_BURST_COUNT_STATIC)
...@@ -860,23 +977,24 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info, ...@@ -860,23 +977,24 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
static void tpm_tis_reenable_interrupts(struct tpm_chip *chip) static void tpm_tis_reenable_interrupts(struct tpm_chip *chip)
{ {
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev); struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(priv);
u32 intmask; u32 intmask;
int rc;
/* reenable interrupts that device may have lost or /* reenable interrupts that device may have lost or
BIOS/firmware may have disabled */ BIOS/firmware may have disabled */
iowrite8(priv->irq, phy->iobase + rc = tpm_tis_write8(priv, TPM_INT_VECTOR(priv->locality), priv->irq);
TPM_INT_VECTOR(priv->locality)); if (rc < 0)
return;
intmask = rc = tpm_tis_read32(priv, TPM_INT_ENABLE(priv->locality), &intmask);
ioread32(phy->iobase + TPM_INT_ENABLE(priv->locality)); if (rc < 0)
return;
intmask |= TPM_INTF_CMD_READY_INT intmask |= TPM_INTF_CMD_READY_INT
| TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_DATA_AVAIL_INT | TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_DATA_AVAIL_INT
| TPM_INTF_STS_VALID_INT | TPM_GLOBAL_INT_ENABLE; | TPM_INTF_STS_VALID_INT | TPM_GLOBAL_INT_ENABLE;
iowrite32(intmask, tpm_tis_write32(priv, TPM_INT_ENABLE(priv->locality), intmask);
phy->iobase + TPM_INT_ENABLE(priv->locality));
} }
static int tpm_tis_resume(struct device *dev) static int tpm_tis_resume(struct device *dev)
......
drivers/char/tpm/tpm_tis_core.h
View file @ 1107d065
...@@ -32,6 +32,57 @@ struct tpm_tis_data { ...@@ -32,6 +32,57 @@ struct tpm_tis_data {
bool irq_tested; bool irq_tested;
wait_queue_head_t int_queue; wait_queue_head_t int_queue;
wait_queue_head_t read_queue; wait_queue_head_t read_queue;
const struct tpm_tis_phy_ops *phy_ops;
}; };
struct tpm_tis_phy_ops {
int (*read_bytes)(struct tpm_tis_data *data, u32 addr, u16 len,
u8 *result);
int (*write_bytes)(struct tpm_tis_data *data, u32 addr, u16 len,
u8 *value);
int (*read16)(struct tpm_tis_data *data, u32 addr, u16 *result);
int (*read32)(struct tpm_tis_data *data, u32 addr, u32 *result);
int (*write32)(struct tpm_tis_data *data, u32 addr, u32 src);
};
static inline int tpm_tis_read_bytes(struct tpm_tis_data *data, u32 addr,
u16 len, u8 *result)
{
return data->phy_ops->read_bytes(data, addr, len, result);
}
static inline int tpm_tis_read8(struct tpm_tis_data *data, u32 addr, u8 *result)
{
return data->phy_ops->read_bytes(data, addr, 1, result);
}
static inline int tpm_tis_read16(struct tpm_tis_data *data, u32 addr,
u16 *result)
{
return data->phy_ops->read16(data, addr, result);
}
static inline int tpm_tis_read32(struct tpm_tis_data *data, u32 addr,
u32 *result)
{
return data->phy_ops->read32(data, addr, result);
}
static inline int tpm_tis_write_bytes(struct tpm_tis_data *data, u32 addr,
u16 len, u8 *value)
{
return data->phy_ops->write_bytes(data, addr, len, value);
}
static inline int tpm_tis_write8(struct tpm_tis_data *data, u32 addr, u8 value)
{
return data->phy_ops->write_bytes(data, addr, 1, &value);
}
static inline int tpm_tis_write32(struct tpm_tis_data *data, u32 addr,
u32 value)
{
return data->phy_ops->write32(data, addr, value);
}
#endif #endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7