14 files changed, 273 insertions, 196 deletions

diff --git a/drivers/char/agp/generic.c b/drivers/char/agp/generic.c
index b072648dc3f6..17e05d1076b3 100644
--- a/drivers/char/agp/generic.c
+++ b/drivers/char/agp/generic.c
@@ -514,12 +514,12 @@ static void agp_v2_parse_one(u32 *requested_mode, u32 *bridge_agpstat, u32 *vga_
         switch (*bridge_agpstat & 7) {
         case 4:
                 *bridge_agpstat |= (AGPSTAT2_2X | AGPSTAT2_1X);
-                printk(KERN_INFO PFX "BIOS bug. AGP bridge claims to only support x4 rate"
+                printk(KERN_INFO PFX "BIOS bug. AGP bridge claims to only support x4 rate. "
                         "Fixing up support for x2 & x1\n");
                 break;
         case 2:
                 *bridge_agpstat |= AGPSTAT2_1X;
-                printk(KERN_INFO PFX "BIOS bug. AGP bridge claims to only support x2 rate"
+                printk(KERN_INFO PFX "BIOS bug. AGP bridge claims to only support x2 rate. "
                         "Fixing up support for x1\n");
                 break;
         default:
@@ -693,7 +693,7 @@ static void agp_v3_parse_one(u32 *requested_mode, u32 *bridge_agpstat, u32 *vga_
                         *bridge_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
                         *vga_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
                 } else {
-                        printk(KERN_INFO PFX "Fell back to AGPx4 mode because");
+                        printk(KERN_INFO PFX "Fell back to AGPx4 mode because ");
                         if (!(*bridge_agpstat & AGPSTAT3_8X)) {
                                 printk(KERN_INFO PFX "bridge couldn't do x8. bridge_agpstat:%x (orig=%x)\n",
                                         *bridge_agpstat, origbridge);
@@ -956,7 +956,7 @@ int agp_generic_create_gatt_table(struct agp_bridge_data *bridge)
         bridge->driver->cache_flush();
 #ifdef CONFIG_X86
         if (set_memory_uc((unsigned long)table, 1 << page_order))
-                printk(KERN_WARNING "Could not set GATT table memory to UC!");
+                printk(KERN_WARNING "Could not set GATT table memory to UC!\n");
 
         bridge->gatt_table = (void *)table;
 #else
diff --git a/drivers/char/hw_random/atmel-rng.c b/drivers/char/hw_random/atmel-rng.c
index 241df2e76aba..f518b99f53f5 100644
--- a/drivers/char/hw_random/atmel-rng.c
+++ b/drivers/char/hw_random/atmel-rng.c
@@ -141,17 +141,7 @@ static struct platform_driver atmel_trng_driver = {
         },
 };
 
-static int __init atmel_trng_init(void)
-{
-        return platform_driver_register(&atmel_trng_driver);
-}
-module_init(atmel_trng_init);
-
-static void __exit atmel_trng_exit(void)
-{
-        platform_driver_unregister(&atmel_trng_driver);
-}
-module_exit(atmel_trng_exit);
+module_platform_driver(atmel_trng_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Peter Korsgaard <jacmet@sunsite.dk>");
diff --git a/drivers/char/hw_random/n2-drv.c b/drivers/char/hw_random/n2-drv.c
index c3de70de00d4..ebd48f0135da 100644
--- a/drivers/char/hw_random/n2-drv.c
+++ b/drivers/char/hw_random/n2-drv.c
@@ -770,15 +770,4 @@ static struct platform_driver n2rng_driver = {
         .remove         = __devexit_p(n2rng_remove),
 };
 
-static int __init n2rng_init(void)
-{
-        return platform_driver_register(&n2rng_driver);
-}
-
-static void __exit n2rng_exit(void)
-{
-        platform_driver_unregister(&n2rng_driver);
-}
-
-module_init(n2rng_init);
-module_exit(n2rng_exit);
+module_platform_driver(n2rng_driver);
diff --git a/drivers/char/hw_random/octeon-rng.c b/drivers/char/hw_random/octeon-rng.c
index 9cd0feca318c..0943edc782a1 100644
--- a/drivers/char/hw_random/octeon-rng.c
+++ b/drivers/char/hw_random/octeon-rng.c
@@ -131,18 +131,7 @@ static struct platform_driver octeon_rng_driver = {
         .remove         = __exit_p(octeon_rng_remove),
 };
 
-static int __init octeon_rng_mod_init(void)
-{
-        return platform_driver_register(&octeon_rng_driver);
-}
-
-static void __exit octeon_rng_mod_exit(void)
-{
-        platform_driver_unregister(&octeon_rng_driver);
-}
-
-module_init(octeon_rng_mod_init);
-module_exit(octeon_rng_mod_exit);
+module_platform_driver(octeon_rng_driver);
 
 MODULE_AUTHOR("David Daney");
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/hw_random/pasemi-rng.c b/drivers/char/hw_random/pasemi-rng.c
index 1d504815e6db..3a632673aed5 100644
--- a/drivers/char/hw_random/pasemi-rng.c
+++ b/drivers/char/hw_random/pasemi-rng.c
@@ -148,17 +148,7 @@ static struct platform_driver rng_driver = {
         .remove         = rng_remove,
 };
 
-static int __init rng_init(void)
-{
-        return platform_driver_register(&rng_driver);
-}
-module_init(rng_init);
-
-static void __exit rng_exit(void)
-{
-        platform_driver_unregister(&rng_driver);
-}
-module_exit(rng_exit);
+module_platform_driver(rng_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Egor Martovetsky <egor@pasemi.com>");
diff --git a/drivers/char/hw_random/picoxcell-rng.c b/drivers/char/hw_random/picoxcell-rng.c
index 990d55a5e3e8..97bd891422c7 100644
--- a/drivers/char/hw_random/picoxcell-rng.c
+++ b/drivers/char/hw_random/picoxcell-rng.c
@@ -191,17 +191,7 @@ static struct platform_driver picoxcell_trng_driver = {
         },
 };
 
-static int __init picoxcell_trng_init(void)
-{
-        return platform_driver_register(&picoxcell_trng_driver);
-}
-module_init(picoxcell_trng_init);
-
-static void __exit picoxcell_trng_exit(void)
-{
-        platform_driver_unregister(&picoxcell_trng_driver);
-}
-module_exit(picoxcell_trng_exit);
+module_platform_driver(picoxcell_trng_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Jamie Iles");
diff --git a/drivers/char/hw_random/ppc4xx-rng.c b/drivers/char/hw_random/ppc4xx-rng.c
index b8afa6a4ff67..c51762c13031 100644
--- a/drivers/char/hw_random/ppc4xx-rng.c
+++ b/drivers/char/hw_random/ppc4xx-rng.c
@@ -139,17 +139,7 @@ static struct platform_driver ppc4xx_rng_driver = {
         .remove = ppc4xx_rng_remove,
 };
 
-static int __init ppc4xx_rng_init(void)
-{
-        return platform_driver_register(&ppc4xx_rng_driver);
-}
-module_init(ppc4xx_rng_init);
-
-static void __exit ppc4xx_rng_exit(void)
-{
-        platform_driver_unregister(&ppc4xx_rng_driver);
-}
-module_exit(ppc4xx_rng_exit);
+module_platform_driver(ppc4xx_rng_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Josh Boyer <jwboyer@linux.vnet.ibm.com>");
diff --git a/drivers/char/hw_random/timeriomem-rng.c b/drivers/char/hw_random/timeriomem-rng.c
index a8428e6f64a9..f1a1618db1fb 100644
--- a/drivers/char/hw_random/timeriomem-rng.c
+++ b/drivers/char/hw_random/timeriomem-rng.c
@@ -149,18 +149,7 @@ static struct platform_driver timeriomem_rng_driver = {
         .remove         = __devexit_p(timeriomem_rng_remove),
 };
 
-static int __init timeriomem_rng_init(void)
-{
-        return platform_driver_register(&timeriomem_rng_driver);
-}
-
-static void __exit timeriomem_rng_exit(void)
-{
-        platform_driver_unregister(&timeriomem_rng_driver);
-}
-
-module_init(timeriomem_rng_init);
-module_exit(timeriomem_rng_exit);
+module_platform_driver(timeriomem_rng_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>");
diff --git a/drivers/char/hw_random/virtio-rng.c b/drivers/char/hw_random/virtio-rng.c
index fd699ccecf5b..723725bbb96b 100644
--- a/drivers/char/hw_random/virtio-rng.c
+++ b/drivers/char/hw_random/virtio-rng.c
@@ -47,7 +47,7 @@ static void register_buffer(u8 *buf, size_t size)
         sg_init_one(&sg, buf, size);
 
         /* There should always be room for one buffer. */
-        if (virtqueue_add_buf(vq, &sg, 0, 1, buf) < 0)
+        if (virtqueue_add_buf(vq, &sg, 0, 1, buf, GFP_KERNEL) < 0)
                 BUG();
 
         virtqueue_kick(vq);
diff --git a/drivers/char/tpm/Kconfig b/drivers/char/tpm/Kconfig
index fa567f1158c2..7fc75e47e6d0 100644
--- a/drivers/char/tpm/Kconfig
+++ b/drivers/char/tpm/Kconfig
@@ -27,6 +27,7 @@ if TCG_TPM
 
 config TCG_TIS
         tristate "TPM Interface Specification 1.2 Interface"
+        depends on X86
         ---help---
           If you have a TPM security chip that is compliant with the
           TCG TIS 1.2 TPM specification say Yes and it will be accessible
@@ -35,6 +36,7 @@ config TCG_TIS
 
 config TCG_NSC
         tristate "National Semiconductor TPM Interface"
+        depends on X86
         ---help---
           If you have a TPM security chip from National Semiconductor 
           say Yes and it will be accessible from within Linux.  To 
diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index 361a1dff8f77..6a8771f47a55 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -27,6 +27,7 @@
 #include <linux/slab.h>
 #include <linux/mutex.h>
 #include <linux/spinlock.h>
+#include <linux/freezer.h>
 
 #include "tpm.h"
 
@@ -440,7 +441,6 @@ out:
 }
 
 #define TPM_DIGEST_SIZE 20
-#define TPM_ERROR_SIZE 10
 #define TPM_RET_CODE_IDX 6
 
 enum tpm_capabilities {
@@ -469,12 +469,14 @@ static ssize_t transmit_cmd(struct tpm_chip *chip, struct tpm_cmd_t *cmd,
         len = tpm_transmit(chip,(u8 *) cmd, len);
         if (len <  0)
                 return len;
-        if (len == TPM_ERROR_SIZE) {
-                err = be32_to_cpu(cmd->header.out.return_code);
-                dev_dbg(chip->dev, "A TPM error (%d) occurred %s\n", err, desc);
-                return err;
-        }
-        return 0;
+        else if (len < TPM_HEADER_SIZE)
+                return -EFAULT;
+
+        err = be32_to_cpu(cmd->header.out.return_code);
+        if (err != 0)
+                dev_err(chip->dev, "A TPM error (%d) occurred %s\n", err, desc);
+
+        return err;
 }
 
 #define TPM_INTERNAL_RESULT_SIZE 200
@@ -530,7 +532,7 @@ void tpm_gen_interrupt(struct tpm_chip *chip)
 }
 EXPORT_SYMBOL_GPL(tpm_gen_interrupt);
 
-void tpm_get_timeouts(struct tpm_chip *chip)
+int tpm_get_timeouts(struct tpm_chip *chip)
 {
         struct tpm_cmd_t tpm_cmd;
         struct timeout_t *timeout_cap;
@@ -552,7 +554,7 @@ void tpm_get_timeouts(struct tpm_chip *chip)
         if (be32_to_cpu(tpm_cmd.header.out.return_code) != 0 ||
             be32_to_cpu(tpm_cmd.header.out.length)
             != sizeof(tpm_cmd.header.out) + sizeof(u32) + 4 * sizeof(u32))
-                return;
+                return -EINVAL;
 
         timeout_cap = &tpm_cmd.params.getcap_out.cap.timeout;
         /* Don't overwrite default if value is 0 */
@@ -583,12 +585,12 @@ duration:
         rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE,
                         "attempting to determine the durations");
         if (rc)
-                return;
+                return rc;
 
         if (be32_to_cpu(tpm_cmd.header.out.return_code) != 0 ||
             be32_to_cpu(tpm_cmd.header.out.length)
             != sizeof(tpm_cmd.header.out) + sizeof(u32) + 3 * sizeof(u32))
-                return;
+                return -EINVAL;
 
         duration_cap = &tpm_cmd.params.getcap_out.cap.duration;
         chip->vendor.duration[TPM_SHORT] =
@@ -610,20 +612,36 @@ duration:
                 chip->vendor.duration_adjusted = true;
                 dev_info(chip->dev, "Adjusting TPM timeout parameters.");
         }
+        return 0;
 }
 EXPORT_SYMBOL_GPL(tpm_get_timeouts);
 
-void tpm_continue_selftest(struct tpm_chip *chip)
+#define TPM_ORD_CONTINUE_SELFTEST 83
+#define CONTINUE_SELFTEST_RESULT_SIZE 10
+
+static struct tpm_input_header continue_selftest_header = {
+        .tag = TPM_TAG_RQU_COMMAND,
+        .length = cpu_to_be32(10),
+        .ordinal = cpu_to_be32(TPM_ORD_CONTINUE_SELFTEST),
+};
+
+/**
+ * tpm_continue_selftest -- run TPM's selftest
+ * @chip: TPM chip to use
+ *
+ * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
+ * a TPM error code.
+ */
+static int tpm_continue_selftest(struct tpm_chip *chip)
 {
-        u8 data[] = {
-                0, 193,                 /* TPM_TAG_RQU_COMMAND */
-                0, 0, 0, 10,            /* length */
-                0, 0, 0, 83,            /* TPM_ORD_ContinueSelfTest */
-        };
+        int rc;
+        struct tpm_cmd_t cmd;
 
-        tpm_transmit(chip, data, sizeof(data));
+        cmd.header.in = continue_selftest_header;
+        rc = transmit_cmd(chip, &cmd, CONTINUE_SELFTEST_RESULT_SIZE,
+                          "continue selftest");
+        return rc;
 }
-EXPORT_SYMBOL_GPL(tpm_continue_selftest);
 
 ssize_t tpm_show_enabled(struct device * dev, struct device_attribute * attr,
                         char *buf)
@@ -718,7 +736,7 @@ static struct tpm_input_header pcrread_header = {
         .ordinal = TPM_ORDINAL_PCRREAD
 };
 
-int __tpm_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf)
+static int __tpm_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf)
 {
         int rc;
         struct tpm_cmd_t cmd;
@@ -798,6 +816,45 @@ int tpm_pcr_extend(u32 chip_num, int pcr_idx, const u8 *hash)
 }
 EXPORT_SYMBOL_GPL(tpm_pcr_extend);
 
+/**
+ * tpm_do_selftest - have the TPM continue its selftest and wait until it
+ *                   can receive further commands
+ * @chip: TPM chip to use
+ *
+ * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
+ * a TPM error code.
+ */
+int tpm_do_selftest(struct tpm_chip *chip)
+{
+        int rc;
+        u8 digest[TPM_DIGEST_SIZE];
+        unsigned int loops;
+        unsigned int delay_msec = 1000;
+        unsigned long duration;
+
+        duration = tpm_calc_ordinal_duration(chip,
+                                             TPM_ORD_CONTINUE_SELFTEST);
+
+        loops = jiffies_to_msecs(duration) / delay_msec;
+
+        rc = tpm_continue_selftest(chip);
+        /* This may fail if there was no TPM driver during a suspend/resume
+         * cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST)
+         */
+        if (rc)
+                return rc;
+
+        do {
+                rc = __tpm_pcr_read(chip, 0, digest);
+                if (rc != TPM_WARN_DOING_SELFTEST)
+                        return rc;
+                msleep(delay_msec);
+        } while (--loops > 0);
+
+        return rc;
+}
+EXPORT_SYMBOL_GPL(tpm_do_selftest);
+
 int tpm_send(u32 chip_num, void *cmd, size_t buflen)
 {
         struct tpm_chip *chip;
@@ -1005,6 +1062,46 @@ ssize_t tpm_store_cancel(struct device *dev, struct device_attribute *attr,
 }
 EXPORT_SYMBOL_GPL(tpm_store_cancel);
 
+int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
+                         wait_queue_head_t *queue)
+{
+        unsigned long stop;
+        long rc;
+        u8 status;
+
+        /* check current status */
+        status = chip->vendor.status(chip);
+        if ((status & mask) == mask)
+                return 0;
+
+        stop = jiffies + timeout;
+
+        if (chip->vendor.irq) {
+again:
+                timeout = stop - jiffies;
+                if ((long)timeout <= 0)
+                        return -ETIME;
+                rc = wait_event_interruptible_timeout(*queue,
+                                                      ((chip->vendor.status(chip)
+                                                      & mask) == mask),
+                                                      timeout);
+                if (rc > 0)
+                        return 0;
+                if (rc == -ERESTARTSYS && freezing(current)) {
+                        clear_thread_flag(TIF_SIGPENDING);
+                        goto again;
+                }
+        } else {
+                do {
+                        msleep(TPM_TIMEOUT);
+                        status = chip->vendor.status(chip);
+                        if ((status & mask) == mask)
+                                return 0;
+                } while (time_before(jiffies, stop));
+        }
+        return -ETIME;
+}
+EXPORT_SYMBOL_GPL(wait_for_tpm_stat);
 /*
  * Device file system interface to the TPM
  *
diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h
index 9c4163cfa3ce..8c1df302fbb6 100644
--- a/drivers/char/tpm/tpm.h
+++ b/drivers/char/tpm/tpm.h
@@ -38,6 +38,8 @@ enum tpm_addr {
         TPM_ADDR = 0x4E,
 };
 
+#define TPM_WARN_DOING_SELFTEST 0x802
+#define TPM_HEADER_SIZE         10
 extern ssize_t tpm_show_pubek(struct device *, struct device_attribute *attr,
                                 char *);
 extern ssize_t tpm_show_pcrs(struct device *, struct device_attribute *attr,
@@ -279,9 +281,9 @@ struct tpm_cmd_t {
 
 ssize_t tpm_getcap(struct device *, __be32, cap_t *, const char *);
 
-extern void tpm_get_timeouts(struct tpm_chip *);
+extern int tpm_get_timeouts(struct tpm_chip *);
 extern void tpm_gen_interrupt(struct tpm_chip *);
-extern void tpm_continue_selftest(struct tpm_chip *);
+extern int tpm_do_selftest(struct tpm_chip *);
 extern unsigned long tpm_calc_ordinal_duration(struct tpm_chip *, u32);
 extern struct tpm_chip* tpm_register_hardware(struct device *,
                                  const struct tpm_vendor_specific *);
@@ -294,7 +296,8 @@ extern ssize_t tpm_read(struct file *, char __user *, size_t, loff_t *);
 extern void tpm_remove_hardware(struct device *);
 extern int tpm_pm_suspend(struct device *, pm_message_t);
 extern int tpm_pm_resume(struct device *);
-
+extern int wait_for_tpm_stat(struct tpm_chip *, u8, unsigned long,
+                             wait_queue_head_t *);
 #ifdef CONFIG_ACPI
 extern struct dentry ** tpm_bios_log_setup(char *);
 extern void tpm_bios_log_teardown(struct dentry **);
diff --git a/drivers/char/tpm/tpm_tis.c b/drivers/char/tpm/tpm_tis.c
index 3f4051a7c5a7..10cc44ceb5d1 100644
--- a/drivers/char/tpm/tpm_tis.c
+++ b/drivers/char/tpm/tpm_tis.c
@@ -29,8 +29,6 @@
 #include <linux/freezer.h>
 #include "tpm.h"
 
-#define TPM_HEADER_SIZE 10
-
 enum tis_access {
         TPM_ACCESS_VALID = 0x80,
         TPM_ACCESS_ACTIVE_LOCALITY = 0x20,
@@ -193,54 +191,14 @@ static int get_burstcount(struct tpm_chip *chip)
         return -EBUSY;
 }
 
-static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
-                         wait_queue_head_t *queue)
-{
-        unsigned long stop;
-        long rc;
-        u8 status;
-
-        /* check current status */
-        status = tpm_tis_status(chip);
-        if ((status & mask) == mask)
-                return 0;
-
-        stop = jiffies + timeout;
-
-        if (chip->vendor.irq) {
-again:
-                timeout = stop - jiffies;
-                if ((long)timeout <= 0)
-                        return -ETIME;
-                rc = wait_event_interruptible_timeout(*queue,
-                                                      ((tpm_tis_status
-                                                        (chip) & mask) ==
-                                                       mask), timeout);
-                if (rc > 0)
-                        return 0;
-                if (rc == -ERESTARTSYS && freezing(current)) {
-                        clear_thread_flag(TIF_SIGPENDING);
-                        goto again;
-                }
-        } else {
-                do {
-                        msleep(TPM_TIMEOUT);
-                        status = tpm_tis_status(chip);
-                        if ((status & mask) == mask)
-                                return 0;
-                } while (time_before(jiffies, stop));
-        }
-        return -ETIME;
-}
-
 static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
 {
         int size = 0, burstcnt;
         while (size < count &&
-               wait_for_stat(chip,
-                             TPM_STS_DATA_AVAIL | TPM_STS_VALID,
-                             chip->vendor.timeout_c,
-                             &chip->vendor.read_queue)
+               wait_for_tpm_stat(chip,
+                                 TPM_STS_DATA_AVAIL | TPM_STS_VALID,
+                                 chip->vendor.timeout_c,
+                                 &chip->vendor.read_queue)
                == 0) {
                 burstcnt = get_burstcount(chip);
                 for (; burstcnt > 0 && size < count; burstcnt--)
@@ -282,8 +240,8 @@ static int tpm_tis_recv(struct tpm_chip *chip, u8 *buf, size_t count)
                 goto out;
         }
 
-        wait_for_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
-                      &chip->vendor.int_queue);
+        wait_for_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
+                          &chip->vendor.int_queue);
         status = tpm_tis_status(chip);
         if (status & TPM_STS_DATA_AVAIL) {      /* retry? */
                 dev_err(chip->dev, "Error left over data\n");
@@ -317,7 +275,7 @@ static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len)
         status = tpm_tis_status(chip);
         if ((status & TPM_STS_COMMAND_READY) == 0) {
                 tpm_tis_ready(chip);
-                if (wait_for_stat
+                if (wait_for_tpm_stat
                     (chip, TPM_STS_COMMAND_READY, chip->vendor.timeout_b,
                      &chip->vendor.int_queue) < 0) {
                         rc = -ETIME;
@@ -333,8 +291,8 @@ static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len)
                         count++;
                 }
 
-                wait_for_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
-                              &chip->vendor.int_queue);
+                wait_for_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
+                                  &chip->vendor.int_queue);
                 status = tpm_tis_status(chip);
                 if (!itpm && (status & TPM_STS_DATA_EXPECT) == 0) {
                         rc = -EIO;
@@ -345,8 +303,8 @@ static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len)
         /* write last byte */
         iowrite8(buf[count],
                  chip->vendor.iobase + TPM_DATA_FIFO(chip->vendor.locality));
-        wait_for_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
-                      &chip->vendor.int_queue);
+        wait_for_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
+                          &chip->vendor.int_queue);
         status = tpm_tis_status(chip);
         if ((status & TPM_STS_DATA_EXPECT) != 0) {
                 rc = -EIO;
@@ -381,7 +339,7 @@ static int tpm_tis_send(struct tpm_chip *chip, u8 *buf, size_t len)
 
         if (chip->vendor.irq) {
                 ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
-                if (wait_for_stat
+                if (wait_for_tpm_stat
                     (chip, TPM_STS_DATA_AVAIL | TPM_STS_VALID,
                      tpm_calc_ordinal_duration(chip, ordinal),
                      &chip->vendor.read_queue) < 0) {
@@ -432,6 +390,9 @@ static int probe_itpm(struct tpm_chip *chip)
 out:
         itpm = rem_itpm;
         tpm_tis_ready(chip);
+        /* some TPMs need a break here otherwise they will not work
+         * correctly on the immediately subsequent command */
+        msleep(chip->vendor.timeout_b);
         release_locality(chip, chip->vendor.locality, 0);
 
         return rc;
@@ -614,7 +575,17 @@ static int tpm_tis_init(struct device *dev, resource_size_t start,
                 dev_dbg(dev, "\tData Avail Int Support\n");
 
         /* get the timeouts before testing for irqs */
-        tpm_get_timeouts(chip);
+        if (tpm_get_timeouts(chip)) {
+                dev_err(dev, "Could not get TPM timeouts and durations\n");
+                rc = -ENODEV;
+                goto out_err;
+        }
+
+        if (tpm_do_selftest(chip)) {
+                dev_err(dev, "TPM self test failed\n");
+                rc = -ENODEV;
+                goto out_err;
+        }
 
         /* INTERRUPT Setup */
         init_waitqueue_head(&chip->vendor.read_queue);
@@ -722,7 +693,6 @@ static int tpm_tis_init(struct device *dev, resource_size_t start,
         list_add(&chip->vendor.list, &tis_chips);
         spin_unlock(&tis_lock);
 
-        tpm_continue_selftest(chip);
 
         return 0;
 out_err:
@@ -790,7 +760,7 @@ static int tpm_tis_pnp_resume(struct pnp_dev *dev)
 
         ret = tpm_pm_resume(&dev->dev);
         if (!ret)
-                tpm_continue_selftest(chip);
+                tpm_do_selftest(chip);
 
         return ret;
 }
diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index 8e3c46d67cb3..b58b56187065 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
@@ -392,7 +392,7 @@ static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
 
         sg_init_one(sg, buf->buf, buf->size);
 
-        ret = virtqueue_add_buf(vq, sg, 0, 1, buf);
+        ret = virtqueue_add_buf(vq, sg, 0, 1, buf, GFP_ATOMIC);
         virtqueue_kick(vq);
         return ret;
 }
@@ -457,7 +457,7 @@ static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id,
         vq = portdev->c_ovq;
 
         sg_init_one(sg, &cpkt, sizeof(cpkt));
-        if (virtqueue_add_buf(vq, sg, 1, 0, &cpkt) >= 0) {
+        if (virtqueue_add_buf(vq, sg, 1, 0, &cpkt, GFP_ATOMIC) >= 0) {
                 virtqueue_kick(vq);
                 while (!virtqueue_get_buf(vq, &len))
                         cpu_relax();
@@ -506,7 +506,7 @@ static ssize_t send_buf(struct port *port, void *in_buf, size_t in_count,
         reclaim_consumed_buffers(port);
 
         sg_init_one(sg, in_buf, in_count);
-        ret = virtqueue_add_buf(out_vq, sg, 1, 0, in_buf);
+        ret = virtqueue_add_buf(out_vq, sg, 1, 0, in_buf, GFP_ATOMIC);
 
         /* Tell Host to go! */
         virtqueue_kick(out_vq);
@@ -1271,6 +1271,20 @@ static void remove_port(struct kref *kref)
         kfree(port);
 }
 
+static void remove_port_data(struct port *port)
+{
+        struct port_buffer *buf;
+
+        /* Remove unused data this port might have received. */
+        discard_port_data(port);
+
+        reclaim_consumed_buffers(port);
+
+        /* Remove buffers we queued up for the Host to send us data in. */
+        while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
+                free_buf(buf);
+}
+
 /*
  * Port got unplugged.  Remove port from portdev's list and drop the
  * kref reference.  If no userspace has this port opened, it will
@@ -1278,8 +1292,6 @@ static void remove_port(struct kref *kref)
  */
 static void unplug_port(struct port *port)
 {
-        struct port_buffer *buf;
-
         spin_lock_irq(&port->portdev->ports_lock);
         list_del(&port->list);
         spin_unlock_irq(&port->portdev->ports_lock);
@@ -1300,14 +1312,7 @@ static void unplug_port(struct port *port)
                 hvc_remove(port->cons.hvc);
         }
 
-        /* Remove unused data this port might have received. */
-        discard_port_data(port);
-
-        reclaim_consumed_buffers(port);
-
-        /* Remove buffers we queued up for the Host to send us data in. */
-        while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
-                free_buf(buf);
+        remove_port_data(port);
 
         /*
          * We should just assume the device itself has gone off --
@@ -1659,6 +1664,28 @@ static const struct file_operations portdev_fops = {
         .owner = THIS_MODULE,
 };
 
+static void remove_vqs(struct ports_device *portdev)
+{
+        portdev->vdev->config->del_vqs(portdev->vdev);
+        kfree(portdev->in_vqs);
+        kfree(portdev->out_vqs);
+}
+
+static void remove_controlq_data(struct ports_device *portdev)
+{
+        struct port_buffer *buf;
+        unsigned int len;
+
+        if (!use_multiport(portdev))
+                return;
+
+        while ((buf = virtqueue_get_buf(portdev->c_ivq, &len)))
+                free_buf(buf);
+
+        while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq)))
+                free_buf(buf);
+}
+
 /*
  * Once we're further in boot, we get probed like any other virtio
  * device.
@@ -1764,9 +1791,7 @@ free_vqs:
         /* The host might want to notify mgmt sw about device add failure */
         __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
                            VIRTIO_CONSOLE_DEVICE_READY, 0);
-        vdev->config->del_vqs(vdev);
-        kfree(portdev->in_vqs);
-        kfree(portdev->out_vqs);
+        remove_vqs(portdev);
 free_chrdev:
         unregister_chrdev(portdev->chr_major, "virtio-portsdev");
 free:
@@ -1804,21 +1829,8 @@ static void virtcons_remove(struct virtio_device *vdev)
          * have to just stop using the port, as the vqs are going
          * away.
          */
-        if (use_multiport(portdev)) {
-                struct port_buffer *buf;
-                unsigned int len;
-
-                while ((buf = virtqueue_get_buf(portdev->c_ivq, &len)))
-                        free_buf(buf);
-
-                while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq)))
-                        free_buf(buf);
-        }
-
-        vdev->config->del_vqs(vdev);
-        kfree(portdev->in_vqs);
-        kfree(portdev->out_vqs);
-
+        remove_controlq_data(portdev);
+        remove_vqs(portdev);
         kfree(portdev);
 }
 
@@ -1832,6 +1844,68 @@ static unsigned int features[] = {
         VIRTIO_CONSOLE_F_MULTIPORT,
 };
 
+#ifdef CONFIG_PM
+static int virtcons_freeze(struct virtio_device *vdev)
+{
+        struct ports_device *portdev;
+        struct port *port;
+
+        portdev = vdev->priv;
+
+        vdev->config->reset(vdev);
+
+        virtqueue_disable_cb(portdev->c_ivq);
+        cancel_work_sync(&portdev->control_work);
+        /*
+         * Once more: if control_work_handler() was running, it would
+         * enable the cb as the last step.
+         */
+        virtqueue_disable_cb(portdev->c_ivq);
+        remove_controlq_data(portdev);
+
+        list_for_each_entry(port, &portdev->ports, list) {
+                virtqueue_disable_cb(port->in_vq);
+                virtqueue_disable_cb(port->out_vq);
+                /*
+                 * We'll ask the host later if the new invocation has
+                 * the port opened or closed.
+                 */
+                port->host_connected = false;
+                remove_port_data(port);
+        }
+        remove_vqs(portdev);
+
+        return 0;
+}
+
+static int virtcons_restore(struct virtio_device *vdev)
+{
+        struct ports_device *portdev;
+        struct port *port;
+        int ret;
+
+        portdev = vdev->priv;
+
+        ret = init_vqs(portdev);
+        if (ret)
+                return ret;
+
+        if (use_multiport(portdev))
+                fill_queue(portdev->c_ivq, &portdev->cvq_lock);
+
+        list_for_each_entry(port, &portdev->ports, list) {
+                port->in_vq = portdev->in_vqs[port->id];
+                port->out_vq = portdev->out_vqs[port->id];
+
+                fill_queue(port->in_vq, &port->inbuf_lock);
+
+                /* Get port open/close status on the host */
+                send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
+        }
+        return 0;
+}
+#endif
+
 static struct virtio_driver virtio_console = {
         .feature_table = features,
         .feature_table_size = ARRAY_SIZE(features),
@@ -1841,6 +1915,10 @@ static struct virtio_driver virtio_console = {
         .probe =        virtcons_probe,
         .remove =       virtcons_remove,
         .config_changed = config_intr,
+#ifdef CONFIG_PM
+        .freeze =       virtcons_freeze,
+        .restore =      virtcons_restore,
+#endif
 };
 
 static int __init init(void)