Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/linux-security

Pull security layer updates from James Morris:
 "There are a bunch of fixes to the TPM, IMA, and Keys code, with minor
  fixes scattered across the subsystem.

  IMA now requires signed policy, and that policy is also now measured
  and appraised"

* 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/linux-security: (67 commits)
  X.509: Make algo identifiers text instead of enum
  akcipher: Move the RSA DER encoding check to the crypto layer
  crypto: Add hash param to pkcs1pad
  sign-file: fix build with CMS support disabled
  MAINTAINERS: update tpmdd urls
  MODSIGN: linux/string.h should be #included to get memcpy()
  certs: Fix misaligned data in extra certificate list
  X.509: Handle midnight alternative notation in GeneralizedTime
  X.509: Support leap seconds
  Handle ISO 8601 leap seconds and encodings of midnight in mktime64()
  X.509: Fix leap year handling again
  PKCS#7: fix unitialized boolean 'want'
  firmware: change kernel read fail to dev_dbg()
  KEYS: Use the symbol value for list size, updated by scripts/insert-sys-cert
  KEYS: Reserve an extra certificate symbol for inserting without recompiling
  modsign: hide openssl output in silent builds
  tpm_tis: fix build warning with tpm_tis_resume
  ima: require signed IMA policy
  ima: measure and appraise the IMA policy itself
  ima: load policy using path
  ...

6 files changed, 297 insertions, 214 deletions

diff --git a/drivers/char/tpm/tpm-chip.c b/drivers/char/tpm/tpm-chip.c
index 45cc39aabeee..274dd0123237 100644
--- a/drivers/char/tpm/tpm-chip.c
+++ b/drivers/char/tpm/tpm-chip.c
@@ -88,6 +88,7 @@ struct tpm_chip *tpmm_chip_alloc(struct device *dev,
                                  const struct tpm_class_ops *ops)
 {
         struct tpm_chip *chip;
+        int rc;
 
         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
         if (chip == NULL)
@@ -136,11 +137,17 @@ struct tpm_chip *tpmm_chip_alloc(struct device *dev,
         chip->cdev.owner = chip->pdev->driver->owner;
         chip->cdev.kobj.parent = &chip->dev.kobj;
 
+        rc = devm_add_action(dev, (void (*)(void *)) put_device, &chip->dev);
+        if (rc) {
+                put_device(&chip->dev);
+                return ERR_PTR(rc);
+        }
+
         return chip;
 }
 EXPORT_SYMBOL_GPL(tpmm_chip_alloc);
 
-static int tpm_dev_add_device(struct tpm_chip *chip)
+static int tpm_add_char_device(struct tpm_chip *chip)
 {
         int rc;
 
@@ -151,7 +158,6 @@ static int tpm_dev_add_device(struct tpm_chip *chip)
                         chip->devname, MAJOR(chip->dev.devt),
                         MINOR(chip->dev.devt), rc);
 
-                device_unregister(&chip->dev);
                 return rc;
         }
 
@@ -162,16 +168,17 @@ static int tpm_dev_add_device(struct tpm_chip *chip)
                         chip->devname, MAJOR(chip->dev.devt),
                         MINOR(chip->dev.devt), rc);
 
+                cdev_del(&chip->cdev);
                 return rc;
         }
 
         return rc;
 }
 
-static void tpm_dev_del_device(struct tpm_chip *chip)
+static void tpm_del_char_device(struct tpm_chip *chip)
 {
         cdev_del(&chip->cdev);
-        device_unregister(&chip->dev);
+        device_del(&chip->dev);
 }
 
 static int tpm1_chip_register(struct tpm_chip *chip)
@@ -222,7 +229,7 @@ int tpm_chip_register(struct tpm_chip *chip)
 
         tpm_add_ppi(chip);
 
-        rc = tpm_dev_add_device(chip);
+        rc = tpm_add_char_device(chip);
         if (rc)
                 goto out_err;
 
@@ -274,6 +281,6 @@ void tpm_chip_unregister(struct tpm_chip *chip)
                 sysfs_remove_link(&chip->pdev->kobj, "ppi");
 
         tpm1_chip_unregister(chip);
-        tpm_dev_del_device(chip);
+        tpm_del_char_device(chip);
 }
 EXPORT_SYMBOL_GPL(tpm_chip_unregister);
diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h
index 542a80cbfd9c..28b477e8da6a 100644
--- a/drivers/char/tpm/tpm.h
+++ b/drivers/char/tpm/tpm.h
@@ -128,13 +128,6 @@ enum tpm2_startup_types {
         TPM2_SU_STATE   = 0x0001,
 };
 
-enum tpm2_start_method {
-        TPM2_START_ACPI = 2,
-        TPM2_START_FIFO = 6,
-        TPM2_START_CRB = 7,
-        TPM2_START_CRB_WITH_ACPI = 8,
-};
-
 struct tpm_chip;
 
 struct tpm_vendor_specific {
diff --git a/drivers/char/tpm/tpm2-cmd.c b/drivers/char/tpm/tpm2-cmd.c
index 45a634016f95..b28e4da3d2cf 100644
--- a/drivers/char/tpm/tpm2-cmd.c
+++ b/drivers/char/tpm/tpm2-cmd.c
@@ -20,7 +20,11 @@
 #include <keys/trusted-type.h>
 
 enum tpm2_object_attributes {
-        TPM2_ATTR_USER_WITH_AUTH        = BIT(6),
+        TPM2_OA_USER_WITH_AUTH          = BIT(6),
+};
+
+enum tpm2_session_attributes {
+        TPM2_SA_CONTINUE_SESSION        = BIT(0),
 };
 
 struct tpm2_startup_in {
@@ -478,22 +482,18 @@ int tpm2_seal_trusted(struct tpm_chip *chip,
         tpm_buf_append_u8(&buf, payload->migratable);
 
         /* public */
-        if (options->policydigest)
-                tpm_buf_append_u16(&buf, 14 + options->digest_len);
-        else
-                tpm_buf_append_u16(&buf, 14);
-
+        tpm_buf_append_u16(&buf, 14 + options->policydigest_len);
         tpm_buf_append_u16(&buf, TPM2_ALG_KEYEDHASH);
         tpm_buf_append_u16(&buf, hash);
 
         /* policy */
-        if (options->policydigest) {
+        if (options->policydigest_len) {
                 tpm_buf_append_u32(&buf, 0);
-                tpm_buf_append_u16(&buf, options->digest_len);
+                tpm_buf_append_u16(&buf, options->policydigest_len);
                 tpm_buf_append(&buf, options->policydigest,
-                               options->digest_len);
+                               options->policydigest_len);
         } else {
-                tpm_buf_append_u32(&buf, TPM2_ATTR_USER_WITH_AUTH);
+                tpm_buf_append_u32(&buf, TPM2_OA_USER_WITH_AUTH);
                 tpm_buf_append_u16(&buf, 0);
         }
 
@@ -631,7 +631,7 @@ static int tpm2_unseal(struct tpm_chip *chip,
                              options->policyhandle ?
                              options->policyhandle : TPM2_RS_PW,
                              NULL /* nonce */, 0,
-                             0 /* session_attributes */,
+                             TPM2_SA_CONTINUE_SESSION,
                              options->blobauth /* hmac */,
                              TPM_DIGEST_SIZE);
 
diff --git a/drivers/char/tpm/tpm_crb.c b/drivers/char/tpm/tpm_crb.c
index 8342cf51ffdc..a12b31940344 100644
--- a/drivers/char/tpm/tpm_crb.c
+++ b/drivers/char/tpm/tpm_crb.c
@@ -34,14 +34,6 @@ enum crb_defaults {
         CRB_ACPI_START_INDEX = 1,
 };
 
-struct acpi_tpm2 {
-        struct acpi_table_header hdr;
-        u16 platform_class;
-        u16 reserved;
-        u64 control_area_pa;
-        u32 start_method;
-} __packed;
-
 enum crb_ca_request {
         CRB_CA_REQ_GO_IDLE      = BIT(0),
         CRB_CA_REQ_CMD_READY    = BIT(1),
@@ -85,6 +77,8 @@ enum crb_flags {
 
 struct crb_priv {
         unsigned int flags;
+        struct resource res;
+        void __iomem *iobase;
         struct crb_control_area __iomem *cca;
         u8 __iomem *cmd;
         u8 __iomem *rsp;
@@ -97,7 +91,7 @@ static u8 crb_status(struct tpm_chip *chip)
         struct crb_priv *priv = chip->vendor.priv;
         u8 sts = 0;
 
-        if ((le32_to_cpu(ioread32(&priv->cca->start)) & CRB_START_INVOKE) !=
+        if ((ioread32(&priv->cca->start) & CRB_START_INVOKE) !=
             CRB_START_INVOKE)
                 sts |= CRB_STS_COMPLETE;
 
@@ -113,7 +107,7 @@ static int crb_recv(struct tpm_chip *chip, u8 *buf, size_t count)
         if (count < 6)
                 return -EIO;
 
-        if (le32_to_cpu(ioread32(&priv->cca->sts)) & CRB_CA_STS_ERROR)
+        if (ioread32(&priv->cca->sts) & CRB_CA_STS_ERROR)
                 return -EIO;
 
         memcpy_fromio(buf, priv->rsp, 6);
@@ -149,11 +143,11 @@ static int crb_send(struct tpm_chip *chip, u8 *buf, size_t len)
         struct crb_priv *priv = chip->vendor.priv;
         int rc = 0;
 
-        if (len > le32_to_cpu(ioread32(&priv->cca->cmd_size))) {
+        if (len > ioread32(&priv->cca->cmd_size)) {
                 dev_err(&chip->dev,
                         "invalid command count value %x %zx\n",
                         (unsigned int) len,
-                        (size_t) le32_to_cpu(ioread32(&priv->cca->cmd_size)));
+                        (size_t) ioread32(&priv->cca->cmd_size));
                 return -E2BIG;
         }
 
@@ -189,7 +183,7 @@ static void crb_cancel(struct tpm_chip *chip)
 static bool crb_req_canceled(struct tpm_chip *chip, u8 status)
 {
         struct crb_priv *priv = chip->vendor.priv;
-        u32 cancel = le32_to_cpu(ioread32(&priv->cca->cancel));
+        u32 cancel = ioread32(&priv->cca->cancel);
 
         return (cancel & CRB_CANCEL_INVOKE) == CRB_CANCEL_INVOKE;
 }
@@ -204,97 +198,145 @@ static const struct tpm_class_ops tpm_crb = {
         .req_complete_val = CRB_STS_COMPLETE,
 };
 
-static int crb_acpi_add(struct acpi_device *device)
+static int crb_init(struct acpi_device *device, struct crb_priv *priv)
 {
         struct tpm_chip *chip;
-        struct acpi_tpm2 *buf;
+        int rc;
+
+        chip = tpmm_chip_alloc(&device->dev, &tpm_crb);
+        if (IS_ERR(chip))
+                return PTR_ERR(chip);
+
+        chip->vendor.priv = 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);
+}
+
+static int crb_check_resource(struct acpi_resource *ares, void *data)
+{
+        struct crb_priv *priv = data;
+        struct resource res;
+
+        if (acpi_dev_resource_memory(ares, &res)) {
+                priv->res = res;
+                priv->res.name = NULL;
+        }
+
+        return 1;
+}
+
+static void __iomem *crb_map_res(struct device *dev, struct crb_priv *priv,
+                                 u64 start, u32 size)
+{
+        struct resource new_res = {
+                .start  = start,
+                .end    = start + size - 1,
+                .flags  = IORESOURCE_MEM,
+        };
+
+        /* Detect a 64 bit address on a 32 bit system */
+        if (start != new_res.start)
+                return ERR_PTR(-EINVAL);
+
+        if (!resource_contains(&priv->res, &new_res))
+                return devm_ioremap_resource(dev, &new_res);
+
+        return priv->iobase + (new_res.start - priv->res.start);
+}
+
+static int crb_map_io(struct acpi_device *device, struct crb_priv *priv,
+                      struct acpi_table_tpm2 *buf)
+{
+        struct list_head resources;
+        struct device *dev = &device->dev;
+        u64 pa;
+        int ret;
+
+        INIT_LIST_HEAD(&resources);
+        ret = acpi_dev_get_resources(device, &resources, crb_check_resource,
+                                     priv);
+        if (ret < 0)
+                return ret;
+        acpi_dev_free_resource_list(&resources);
+
+        if (resource_type(&priv->res) != IORESOURCE_MEM) {
+                dev_err(dev,
+                        FW_BUG "TPM2 ACPI table does not define a memory resource\n");
+                return -EINVAL;
+        }
+
+        priv->iobase = devm_ioremap_resource(dev, &priv->res);
+        if (IS_ERR(priv->iobase))
+                return PTR_ERR(priv->iobase);
+
+        priv->cca = crb_map_res(dev, priv, buf->control_address, 0x1000);
+        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, pa, ioread32(&priv->cca->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, pa, ioread32(&priv->cca->rsp_size));
+        return PTR_ERR_OR_ZERO(priv->rsp);
+}
+
+static int crb_acpi_add(struct acpi_device *device)
+{
+        struct acpi_table_tpm2 *buf;
         struct crb_priv *priv;
         struct device *dev = &device->dev;
         acpi_status status;
         u32 sm;
-        u64 pa;
         int rc;
 
         status = acpi_get_table(ACPI_SIG_TPM2, 1,
                                 (struct acpi_table_header **) &buf);
-        if (ACPI_FAILURE(status)) {
-                dev_err(dev, "failed to get TPM2 ACPI table\n");
-                return -ENODEV;
+        if (ACPI_FAILURE(status) || buf->header.length < sizeof(*buf)) {
+                dev_err(dev, FW_BUG "failed to get TPM2 ACPI table\n");
+                return -EINVAL;
         }
 
         /* Should the FIFO driver handle this? */
-        if (buf->start_method == TPM2_START_FIFO)
+        sm = buf->start_method;
+        if (sm == ACPI_TPM2_MEMORY_MAPPED)
                 return -ENODEV;
 
-        chip = tpmm_chip_alloc(dev, &tpm_crb);
-        if (IS_ERR(chip))
-                return PTR_ERR(chip);
-
-        chip->flags = TPM_CHIP_FLAG_TPM2;
-
-        if (buf->hdr.length < sizeof(struct acpi_tpm2)) {
-                dev_err(dev, "TPM2 ACPI table has wrong size");
-                return -EINVAL;
-        }
-
-        priv = (struct crb_priv *) devm_kzalloc(dev, sizeof(struct crb_priv),
-                                                GFP_KERNEL);
-        if (!priv) {
-                dev_err(dev, "failed to devm_kzalloc for private data\n");
+        priv = devm_kzalloc(dev, sizeof(struct crb_priv), GFP_KERNEL);
+        if (!priv)
                 return -ENOMEM;
-        }
-
-        sm = le32_to_cpu(buf->start_method);
 
         /* The reason for the extra quirk is that the PTT in 4th Gen Core CPUs
          * report only ACPI start but in practice seems to require both
          * ACPI start and CRB start.
          */
-        if (sm == TPM2_START_CRB || sm == TPM2_START_FIFO ||
+        if (sm == ACPI_TPM2_COMMAND_BUFFER || sm == ACPI_TPM2_MEMORY_MAPPED ||
             !strcmp(acpi_device_hid(device), "MSFT0101"))
                 priv->flags |= CRB_FL_CRB_START;
 
-        if (sm == TPM2_START_ACPI || sm == TPM2_START_CRB_WITH_ACPI)
+        if (sm == ACPI_TPM2_START_METHOD ||
+            sm == ACPI_TPM2_COMMAND_BUFFER_WITH_START_METHOD)
                 priv->flags |= CRB_FL_ACPI_START;
 
-        priv->cca = (struct crb_control_area __iomem *)
-                devm_ioremap_nocache(dev, buf->control_area_pa, 0x1000);
-        if (!priv->cca) {
-                dev_err(dev, "ioremap of the control area failed\n");
-                return -ENOMEM;
-        }
-
-        pa = ((u64) le32_to_cpu(ioread32(&priv->cca->cmd_pa_high)) << 32) |
-                (u64) le32_to_cpu(ioread32(&priv->cca->cmd_pa_low));
-        priv->cmd = devm_ioremap_nocache(dev, pa,
-                                         ioread32(&priv->cca->cmd_size));
-        if (!priv->cmd) {
-                dev_err(dev, "ioremap of the command buffer failed\n");
-                return -ENOMEM;
-        }
-
-        memcpy_fromio(&pa, &priv->cca->rsp_pa, 8);
-        pa = le64_to_cpu(pa);
-        priv->rsp = devm_ioremap_nocache(dev, pa,
-                                         ioread32(&priv->cca->rsp_size));
-        if (!priv->rsp) {
-                dev_err(dev, "ioremap of the response buffer failed\n");
-                return -ENOMEM;
-        }
-
-        chip->vendor.priv = priv;
-
-        rc = tpm_get_timeouts(chip);
+        rc = crb_map_io(device, priv, buf);
         if (rc)
                 return rc;
 
-        chip->acpi_dev_handle = device->handle;
-
-        rc = tpm2_do_selftest(chip);
-        if (rc)
-                return rc;
-
-        return tpm_chip_register(chip);
+        return crb_init(device, priv);
 }
 
 static int crb_acpi_remove(struct acpi_device *device)
@@ -302,11 +344,11 @@ static int crb_acpi_remove(struct acpi_device *device)
         struct device *dev = &device->dev;
         struct tpm_chip *chip = dev_get_drvdata(dev);
 
-        tpm_chip_unregister(chip);
-
         if (chip->flags & TPM_CHIP_FLAG_TPM2)
                 tpm2_shutdown(chip, TPM2_SU_CLEAR);
 
+        tpm_chip_unregister(chip);
+
         return 0;
 }
 
diff --git a/drivers/char/tpm/tpm_eventlog.c b/drivers/char/tpm/tpm_eventlog.c
index bd72fb04225e..4e6940acf639 100644
--- a/drivers/char/tpm/tpm_eventlog.c
+++ b/drivers/char/tpm/tpm_eventlog.c
@@ -232,7 +232,7 @@ static int tpm_binary_bios_measurements_show(struct seq_file *m, void *v)
 {
         struct tcpa_event *event = v;
         struct tcpa_event temp_event;
-        char *tempPtr;
+        char *temp_ptr;
         int i;
 
         memcpy(&temp_event, event, sizeof(struct tcpa_event));
@@ -242,10 +242,16 @@ static int tpm_binary_bios_measurements_show(struct seq_file *m, void *v)
         temp_event.event_type = do_endian_conversion(event->event_type);
         temp_event.event_size = do_endian_conversion(event->event_size);
 
-        tempPtr = (char *)&temp_event;
+        temp_ptr = (char *) &temp_event;
 
-        for (i = 0; i < sizeof(struct tcpa_event) + temp_event.event_size; i++)
-                seq_putc(m, tempPtr[i]);
+        for (i = 0; i < (sizeof(struct tcpa_event) - 1) ; i++)
+                seq_putc(m, temp_ptr[i]);
+
+        temp_ptr = (char *) v;
+
+        for (i = (sizeof(struct tcpa_event) - 1);
+             i < (sizeof(struct tcpa_event) + temp_event.event_size); i++)
+                seq_putc(m, temp_ptr[i]);
 
         return 0;
 
diff --git a/drivers/char/tpm/tpm_tis.c b/drivers/char/tpm/tpm_tis.c
index 8a3509cb10da..a507006728e0 100644
--- a/drivers/char/tpm/tpm_tis.c
+++ b/drivers/char/tpm/tpm_tis.c
@@ -28,7 +28,6 @@
 #include <linux/wait.h>
 #include <linux/acpi.h>
 #include <linux/freezer.h>
-#include <acpi/actbl2.h>
 #include "tpm.h"
 
 enum tis_access {
@@ -60,22 +59,18 @@ enum tis_int_flags {
 };
 
 enum tis_defaults {
-        TIS_MEM_BASE = 0xFED40000,
         TIS_MEM_LEN = 0x5000,
         TIS_SHORT_TIMEOUT = 750,        /* ms */
         TIS_LONG_TIMEOUT = 2000,        /* 2 sec */
 };
 
 struct tpm_info {
-        unsigned long start;
-        unsigned long len;
-        unsigned int irq;
-};
-
-static struct tpm_info tis_default_info = {
-        .start = TIS_MEM_BASE,
-        .len = TIS_MEM_LEN,
-        .irq = 0,
+        struct resource res;
+        /* irq > 0 means: use irq $irq;
+         * irq = 0 means: autoprobe for an irq;
+         * irq = -1 means: no irq support
+         */
+        int irq;
 };
 
 /* Some timeout values are needed before it is known whether the chip is
@@ -118,39 +113,11 @@ static inline int is_itpm(struct acpi_device *dev)
 {
         return has_hid(dev, "INTC0102");
 }
-
-static inline int is_fifo(struct acpi_device *dev)
-{
-        struct acpi_table_tpm2 *tbl;
-        acpi_status st;
-
-        /* TPM 1.2 FIFO */
-        if (!has_hid(dev, "MSFT0101"))
-                return 1;
-
-        st = acpi_get_table(ACPI_SIG_TPM2, 1,
-                            (struct acpi_table_header **) &tbl);
-        if (ACPI_FAILURE(st)) {
-                dev_err(&dev->dev, "failed to get TPM2 ACPI table\n");
-                return 0;
-        }
-
-        if (le32_to_cpu(tbl->start_method) != TPM2_START_FIFO)
-                return 0;
-
-        /* TPM 2.0 FIFO */
-        return 1;
-}
 #else
 static inline int is_itpm(struct acpi_device *dev)
 {
         return 0;
 }
-
-static inline int is_fifo(struct acpi_device *dev)
-{
-        return 1;
-}
 #endif
 
 /* Before we attempt to access the TPM we must see that the valid bit is set.
@@ -716,9 +683,9 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
         chip->acpi_dev_handle = acpi_dev_handle;
 #endif
 
-        chip->vendor.iobase = devm_ioremap(dev, tpm_info->start, tpm_info->len);
-        if (!chip->vendor.iobase)
-                return -EIO;
+        chip->vendor.iobase = devm_ioremap_resource(dev, &tpm_info->res);
+        if (IS_ERR(chip->vendor.iobase))
+                return PTR_ERR(chip->vendor.iobase);
 
         /* Maximum timeouts */
         chip->vendor.timeout_a = TIS_TIMEOUT_A_MAX;
@@ -807,7 +774,7 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
         /* INTERRUPT Setup */
         init_waitqueue_head(&chip->vendor.read_queue);
         init_waitqueue_head(&chip->vendor.int_queue);
-        if (interrupts) {
+        if (interrupts && tpm_info->irq != -1) {
                 if (tpm_info->irq) {
                         tpm_tis_probe_irq_single(chip, intmask, IRQF_SHARED,
                                                  tpm_info->irq);
@@ -893,29 +860,29 @@ static int tpm_tis_resume(struct device *dev)
 
 static SIMPLE_DEV_PM_OPS(tpm_tis_pm, tpm_pm_suspend, tpm_tis_resume);
 
-#ifdef CONFIG_PNP
 static int tpm_tis_pnp_init(struct pnp_dev *pnp_dev,
-                                      const struct pnp_device_id *pnp_id)
+                            const struct pnp_device_id *pnp_id)
 {
-        struct tpm_info tpm_info = tis_default_info;
+        struct tpm_info tpm_info = {};
         acpi_handle acpi_dev_handle = NULL;
+        struct resource *res;
 
-        tpm_info.start = pnp_mem_start(pnp_dev, 0);
-        tpm_info.len = pnp_mem_len(pnp_dev, 0);
+        res = pnp_get_resource(pnp_dev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+        tpm_info.res = *res;
 
         if (pnp_irq_valid(pnp_dev, 0))
                 tpm_info.irq = pnp_irq(pnp_dev, 0);
         else
-                interrupts = false;
+                tpm_info.irq = -1;
 
-#ifdef CONFIG_ACPI
         if (pnp_acpi_device(pnp_dev)) {
                 if (is_itpm(pnp_acpi_device(pnp_dev)))
                         itpm = true;
 
-                acpi_dev_handle = pnp_acpi_device(pnp_dev)->handle;
+                acpi_dev_handle = ACPI_HANDLE(&pnp_dev->dev);
         }
-#endif
 
         return tpm_tis_init(&pnp_dev->dev, &tpm_info, acpi_dev_handle);
 }
@@ -956,7 +923,6 @@ static struct pnp_driver tis_pnp_driver = {
 module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id,
                     sizeof(tpm_pnp_tbl[TIS_HID_USR_IDX].id), 0444);
 MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe");
-#endif
 
 #ifdef CONFIG_ACPI
 static int tpm_check_resource(struct acpi_resource *ares, void *data)
@@ -964,11 +930,11 @@ static int tpm_check_resource(struct acpi_resource *ares, void *data)
         struct tpm_info *tpm_info = (struct tpm_info *) data;
         struct resource res;
 
-        if (acpi_dev_resource_interrupt(ares, 0, &res)) {
+        if (acpi_dev_resource_interrupt(ares, 0, &res))
                 tpm_info->irq = res.start;
-        } else if (acpi_dev_resource_memory(ares, &res)) {
-                tpm_info->start = res.start;
-                tpm_info->len = resource_size(&res);
+        else if (acpi_dev_resource_memory(ares, &res)) {
+                tpm_info->res = res;
+                tpm_info->res.name = NULL;
         }
 
         return 1;
@@ -976,14 +942,25 @@ static int tpm_check_resource(struct acpi_resource *ares, void *data)
 
 static int tpm_tis_acpi_init(struct acpi_device *acpi_dev)
 {
+        struct acpi_table_tpm2 *tbl;
+        acpi_status st;
         struct list_head resources;
-        struct tpm_info tpm_info = tis_default_info;
+        struct tpm_info tpm_info = {};
         int ret;
 
-        if (!is_fifo(acpi_dev))
+        st = acpi_get_table(ACPI_SIG_TPM2, 1,
+                            (struct acpi_table_header **) &tbl);
+        if (ACPI_FAILURE(st) || tbl->header.length < sizeof(*tbl)) {
+                dev_err(&acpi_dev->dev,
+                        FW_BUG "failed to get TPM2 ACPI table\n");
+                return -EINVAL;
+        }
+
+        if (tbl->start_method != ACPI_TPM2_MEMORY_MAPPED)
                 return -ENODEV;
 
         INIT_LIST_HEAD(&resources);
+        tpm_info.irq = -1;
         ret = acpi_dev_get_resources(acpi_dev, &resources, tpm_check_resource,
                                      &tpm_info);
         if (ret < 0)
@@ -991,8 +968,11 @@ static int tpm_tis_acpi_init(struct acpi_device *acpi_dev)
 
         acpi_dev_free_resource_list(&resources);
 
-        if (!tpm_info.irq)
-                interrupts = false;
+        if (resource_type(&tpm_info.res) != IORESOURCE_MEM) {
+                dev_err(&acpi_dev->dev,
+                        FW_BUG "TPM2 ACPI table does not define a memory resource\n");
+                return -EINVAL;
+        }
 
         if (is_itpm(acpi_dev))
                 itpm = true;
@@ -1031,80 +1011,135 @@ static struct acpi_driver tis_acpi_driver = {
 };
 #endif
 
+static struct platform_device *force_pdev;
+
+static int tpm_tis_plat_probe(struct platform_device *pdev)
+{
+        struct tpm_info tpm_info = {};
+        struct resource *res;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "no memory resource defined\n");
+                return -ENODEV;
+        }
+        tpm_info.res = *res;
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (res) {
+                tpm_info.irq = res->start;
+        } else {
+                if (pdev == force_pdev)
+                        tpm_info.irq = -1;
+                else
+                        /* When forcing auto probe the IRQ */
+                        tpm_info.irq = 0;
+        }
+
+        return tpm_tis_init(&pdev->dev, &tpm_info, NULL);
+}
+
+static int tpm_tis_plat_remove(struct platform_device *pdev)
+{
+        struct tpm_chip *chip = dev_get_drvdata(&pdev->dev);
+
+        tpm_chip_unregister(chip);
+        tpm_tis_remove(chip);
+
+        return 0;
+}
+
 static struct platform_driver tis_drv = {
+        .probe = tpm_tis_plat_probe,
+        .remove = tpm_tis_plat_remove,
         .driver = {
                 .name           = "tpm_tis",
                 .pm             = &tpm_tis_pm,
         },
 };
 
-static struct platform_device *pdev;
-
 static bool force;
+#ifdef CONFIG_X86
 module_param(force, bool, 0444);
 MODULE_PARM_DESC(force, "Force device probe rather than using ACPI entry");
+#endif
+
+static int tpm_tis_force_device(void)
+{
+        struct platform_device *pdev;
+        static const struct resource x86_resources[] = {
+                {
+                        .start = 0xFED40000,
+                        .end = 0xFED40000 + TIS_MEM_LEN - 1,
+                        .flags = IORESOURCE_MEM,
+                },
+        };
+
+        if (!force)
+                return 0;
+
+        /* The driver core will match the name tpm_tis of the device to
+         * the tpm_tis platform driver and complete the setup via
+         * tpm_tis_plat_probe
+         */
+        pdev = platform_device_register_simple("tpm_tis", -1, x86_resources,
+                                               ARRAY_SIZE(x86_resources));
+        if (IS_ERR(pdev))
+                return PTR_ERR(pdev);
+        force_pdev = pdev;
+
+        return 0;
+}
+
 static int __init init_tis(void)
 {
         int rc;
-#ifdef CONFIG_PNP
-        if (!force) {
-                rc = pnp_register_driver(&tis_pnp_driver);
-                if (rc)
-                        return rc;
-        }
-#endif
+
+        rc = tpm_tis_force_device();
+        if (rc)
+                goto err_force;
+
+        rc = platform_driver_register(&tis_drv);
+        if (rc)
+                goto err_platform;
+
 #ifdef CONFIG_ACPI
-        if (!force) {
-                rc = acpi_bus_register_driver(&tis_acpi_driver);
-                if (rc) {
-#ifdef CONFIG_PNP
-                        pnp_unregister_driver(&tis_pnp_driver);
-#endif
-                        return rc;
-                }
-        }
+        rc = acpi_bus_register_driver(&tis_acpi_driver);
+        if (rc)
+                goto err_acpi;
 #endif
-        if (!force)
-                return 0;
 
-        rc = platform_driver_register(&tis_drv);
-        if (rc < 0)
-                return rc;
-        pdev = platform_device_register_simple("tpm_tis", -1, NULL, 0);
-        if (IS_ERR(pdev)) {
-                rc = PTR_ERR(pdev);
-                goto err_dev;
+        if (IS_ENABLED(CONFIG_PNP)) {
+                rc = pnp_register_driver(&tis_pnp_driver);
+                if (rc)
+                        goto err_pnp;
         }
-        rc = tpm_tis_init(&pdev->dev, &tis_default_info, NULL);
-        if (rc)
-                goto err_init;
+
         return 0;
-err_init:
-        platform_device_unregister(pdev);
-err_dev:
-        platform_driver_unregister(&tis_drv);
+
+err_pnp:
+#ifdef CONFIG_ACPI
+        acpi_bus_unregister_driver(&tis_acpi_driver);
+err_acpi:
+#endif
+        platform_device_unregister(force_pdev);
+err_platform:
+        if (force_pdev)
+                platform_device_unregister(force_pdev);
+err_force:
         return rc;
 }
 
 static void __exit cleanup_tis(void)
 {
-        struct tpm_chip *chip;
-#if defined(CONFIG_PNP) || defined(CONFIG_ACPI)
-        if (!force) {
+        pnp_unregister_driver(&tis_pnp_driver);
 #ifdef CONFIG_ACPI
-                acpi_bus_unregister_driver(&tis_acpi_driver);
-#endif
-#ifdef CONFIG_PNP
-                pnp_unregister_driver(&tis_pnp_driver);
+        acpi_bus_unregister_driver(&tis_acpi_driver);
 #endif
-                return;
-        }
-#endif
-        chip = dev_get_drvdata(&pdev->dev);
-        tpm_chip_unregister(chip);
-        tpm_tis_remove(chip);
-        platform_device_unregister(pdev);
         platform_driver_unregister(&tis_drv);
+
+        if (force_pdev)
+                platform_device_unregister(force_pdev);
 }
 
 module_init(init_tis);