tpm_crb: fix crb_req_canceled behavior

[cascardo/linux.git] / drivers / char / tpm / tpm_crb.c

diff --git a/drivers/char/tpm/tpm_crb.c b/drivers/char/tpm/tpm_crb.c
index 733cd0e..1801f38 100644 (file)
--- a/drivers/char/tpm/tpm_crb.c
+++ b/drivers/char/tpm/tpm_crb.c
@@ -87,7 +87,7 @@ static SIMPLE_DEV_PM_OPS(crb_pm, tpm_pm_suspend, tpm_pm_resume);
 
 static u8 crb_status(struct tpm_chip *chip)
 {
-       struct crb_priv *priv = chip->vendor.priv;
+       struct crb_priv *priv = dev_get_drvdata(&chip->dev);
        u8 sts = 0;
 
        if ((ioread32(&priv->cca->start) & CRB_START_INVOKE) !=
@@ -99,7 +99,7 @@ static u8 crb_status(struct tpm_chip *chip)
 
 static int crb_recv(struct tpm_chip *chip, u8 *buf, size_t count)
 {
-       struct crb_priv *priv = chip->vendor.priv;
+       struct crb_priv *priv = dev_get_drvdata(&chip->dev);
        unsigned int expected;
 
        /* sanity check */
@@ -139,9 +139,14 @@ static int crb_do_acpi_start(struct tpm_chip *chip)
 
 static int crb_send(struct tpm_chip *chip, u8 *buf, size_t len)
 {
-       struct crb_priv *priv = chip->vendor.priv;
+       struct crb_priv *priv = dev_get_drvdata(&chip->dev);
        int rc = 0;
 
+       /* Zero the cancel register so that the next command will not get
+        * canceled.
+        */
+       iowrite32(0, &priv->cca->cancel);
+
        if (len > ioread32(&priv->cca->cmd_size)) {
                dev_err(&chip->dev,
                        "invalid command count value %x %zx\n",
@@ -166,7 +171,7 @@ static int crb_send(struct tpm_chip *chip, u8 *buf, size_t len)
 
 static void crb_cancel(struct tpm_chip *chip)
 {
-       struct crb_priv *priv = chip->vendor.priv;
+       struct crb_priv *priv = dev_get_drvdata(&chip->dev);
 
        iowrite32(cpu_to_le32(CRB_CANCEL_INVOKE), &priv->cca->cancel);
 
@@ -175,19 +180,18 @@ static void crb_cancel(struct tpm_chip *chip)
 
        if ((priv->flags & CRB_FL_ACPI_START) && crb_do_acpi_start(chip))
                dev_err(&chip->dev, "ACPI Start failed\n");
-
-       iowrite32(0, &priv->cca->cancel);
 }
 
 static bool crb_req_canceled(struct tpm_chip *chip, u8 status)
 {
-       struct crb_priv *priv = chip->vendor.priv;
+       struct crb_priv *priv = dev_get_drvdata(&chip->dev);
        u32 cancel = ioread32(&priv->cca->cancel);
 
        return (cancel & CRB_CANCEL_INVOKE) == CRB_CANCEL_INVOKE;
 }
 
 static const struct tpm_class_ops tpm_crb = {
+       .flags = TPM_OPS_AUTO_STARTUP,
        .status = crb_status,
        .recv = crb_recv,
        .send = crb_send,
@@ -200,24 +204,15 @@ static const struct tpm_class_ops tpm_crb = {
 static int crb_init(struct acpi_device *device, struct crb_priv *priv)
 {
        struct tpm_chip *chip;
-       int rc;
 
        chip = tpmm_chip_alloc(&device->dev, &tpm_crb);
        if (IS_ERR(chip))
                return PTR_ERR(chip);
 
-       chip->vendor.priv = priv;
+       dev_set_drvdata(&chip->dev, priv);
        chip->acpi_dev_handle = device->handle;
        chip->flags = TPM_CHIP_FLAG_TPM2;
 
-       rc = tpm_get_timeouts(chip);
-       if (rc)
-               return rc;
-
-       rc = tpm2_do_selftest(chip);
-       if (rc)
-               return rc;
-
        return tpm_chip_register(chip);
 }
 
@@ -245,7 +240,7 @@ static void __iomem *crb_map_res(struct device *dev, struct crb_priv *priv,
 
        /* Detect a 64 bit address on a 32 bit system */
        if (start != new_res.start)
-               return ERR_PTR(-EINVAL);
+               return (void __iomem *) ERR_PTR(-EINVAL);
 
        if (!resource_contains(io_res, &new_res))
                return devm_ioremap_resource(dev, &new_res);
@@ -259,7 +254,10 @@ static int crb_map_io(struct acpi_device *device, struct crb_priv *priv,
        struct list_head resources;
        struct resource io_res;
        struct device *dev = &device->dev;
-       u64 pa;
+       u64 cmd_pa;
+       u32 cmd_size;
+       u64 rsp_pa;
+       u32 rsp_size;
        int ret;
 
        INIT_LIST_HEAD(&resources);
@@ -280,22 +278,36 @@ static int crb_map_io(struct acpi_device *device, struct crb_priv *priv,
                return PTR_ERR(priv->iobase);
 
        priv->cca = crb_map_res(dev, priv, &io_res, buf->control_address,
-                               0x1000);
+                               sizeof(struct crb_control_area));
        if (IS_ERR(priv->cca))
                return PTR_ERR(priv->cca);
 
-       pa = ((u64) ioread32(&priv->cca->cmd_pa_high) << 32) |
-             (u64) ioread32(&priv->cca->cmd_pa_low);
-       priv->cmd = crb_map_res(dev, priv, &io_res, pa,
-                               ioread32(&priv->cca->cmd_size));
+       cmd_pa = ((u64) ioread32(&priv->cca->cmd_pa_high) << 32) |
+                 (u64) ioread32(&priv->cca->cmd_pa_low);
+       cmd_size = ioread32(&priv->cca->cmd_size);
+       priv->cmd = crb_map_res(dev, priv, &io_res, cmd_pa, cmd_size);
        if (IS_ERR(priv->cmd))
                return PTR_ERR(priv->cmd);
 
-       memcpy_fromio(&pa, &priv->cca->rsp_pa, 8);
-       pa = le64_to_cpu(pa);
-       priv->rsp = crb_map_res(dev, priv, &io_res, pa,
-                               ioread32(&priv->cca->rsp_size));
-       return PTR_ERR_OR_ZERO(priv->rsp);
+       memcpy_fromio(&rsp_pa, &priv->cca->rsp_pa, 8);
+       rsp_pa = le64_to_cpu(rsp_pa);
+       rsp_size = ioread32(&priv->cca->rsp_size);
+
+       if (cmd_pa != rsp_pa) {
+               priv->rsp = crb_map_res(dev, priv, &io_res, rsp_pa, rsp_size);
+               return PTR_ERR_OR_ZERO(priv->rsp);
+       }
+
+       /* According to the PTP specification, overlapping command and response
+        * buffer sizes must be identical.
+        */
+       if (cmd_size != rsp_size) {
+               dev_err(dev, FW_BUG "overlapping command and response buffer sizes are not identical");
+               return -EINVAL;
+       }
+
+       priv->rsp = priv->cmd;
+       return 0;
 }
 
 static int crb_acpi_add(struct acpi_device *device)