Merge branch 'master' into for-next

Sync with Linus' tree to be able to apply patch to a newer
code (namely drivers/gpu/drm/gma500/psb_intel_lvds.c)

24 files changed, 323 insertions, 228 deletions

diff --git a/drivers/char/agp/amd64-agp.c b/drivers/char/agp/amd64-agp.c
index 780498d76581..444f8b6ab411 100644
--- a/drivers/char/agp/amd64-agp.c
+++ b/drivers/char/agp/amd64-agp.c
@@ -33,7 +33,7 @@
 #define ULI_X86_64_ENU_SCR_REG          0x54
 
 static struct resource *aperture_resource;
-static int __initdata agp_try_unsupported = 1;
+static bool __initdata agp_try_unsupported = 1;
 static int agp_bridges_found;
 
 static void amd64_tlbflush(struct agp_memory *temp)
diff --git a/drivers/char/agp/backend.c b/drivers/char/agp/backend.c
index 4b71647782d0..317c28ce8328 100644
--- a/drivers/char/agp/backend.c
+++ b/drivers/char/agp/backend.c
@@ -194,10 +194,10 @@ static int agp_backend_initialize(struct agp_bridge_data *bridge)
 
 err_out:
         if (bridge->driver->needs_scratch_page) {
-                void *va = page_address(bridge->scratch_page_page);
+                struct page *page = bridge->scratch_page_page;
 
-                bridge->driver->agp_destroy_page(va, AGP_PAGE_DESTROY_UNMAP);
-                bridge->driver->agp_destroy_page(va, AGP_PAGE_DESTROY_FREE);
+                bridge->driver->agp_destroy_page(page, AGP_PAGE_DESTROY_UNMAP);
+                bridge->driver->agp_destroy_page(page, AGP_PAGE_DESTROY_FREE);
         }
         if (got_gatt)
                 bridge->driver->free_gatt_table(bridge);
@@ -221,10 +221,10 @@ static void agp_backend_cleanup(struct agp_bridge_data *bridge)
 
         if (bridge->driver->agp_destroy_page &&
             bridge->driver->needs_scratch_page) {
-                void *va = page_address(bridge->scratch_page_page);
+                struct page *page = bridge->scratch_page_page;
 
-                bridge->driver->agp_destroy_page(va, AGP_PAGE_DESTROY_UNMAP);
-                bridge->driver->agp_destroy_page(va, AGP_PAGE_DESTROY_FREE);
+                bridge->driver->agp_destroy_page(page, AGP_PAGE_DESTROY_UNMAP);
+                bridge->driver->agp_destroy_page(page, AGP_PAGE_DESTROY_FREE);
         }
 }
 
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/agp/sis-agp.c b/drivers/char/agp/sis-agp.c
index 29aacd81de78..08704ae53956 100644
--- a/drivers/char/agp/sis-agp.c
+++ b/drivers/char/agp/sis-agp.c
@@ -17,7 +17,7 @@
 #define PCI_DEVICE_ID_SI_662    0x0662
 #define PCI_DEVICE_ID_SI_671    0x0671
 
-static int __devinitdata agp_sis_force_delay = 0;
+static bool __devinitdata agp_sis_force_delay = 0;
 static int __devinitdata agp_sis_agp_spec = -1;
 
 static int sis_fetch_size(void)
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/i8k.c b/drivers/char/i8k.c
index 6e40072fbf67..40cc0cf2ded6 100644
--- a/drivers/char/i8k.c
+++ b/drivers/char/i8k.c
@@ -69,19 +69,19 @@ MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)");
 MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops");
 MODULE_LICENSE("GPL");
 
-static int force;
+static bool force;
 module_param(force, bool, 0);
 MODULE_PARM_DESC(force, "Force loading without checking for supported models");
 
-static int ignore_dmi;
+static bool ignore_dmi;
 module_param(ignore_dmi, bool, 0);
 MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match");
 
-static int restricted;
+static bool restricted;
 module_param(restricted, bool, 0);
 MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set");
 
-static int power_status;
+static bool power_status;
 module_param(power_status, bool, 0600);
 MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k");
 
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 9397ab49b72e..50fcf9c04569 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -1227,7 +1227,7 @@ static int smi_num; /* Used to sequence the SMIs */
 #define DEFAULT_REGSPACING      1
 #define DEFAULT_REGSIZE         1
 
-static int           si_trydefaults = 1;
+static bool          si_trydefaults = 1;
 static char          *si_type[SI_MAX_PARMS];
 #define MAX_SI_TYPE_STR 30
 static char          si_type_str[MAX_SI_TYPE_STR];
diff --git a/drivers/char/lp.c b/drivers/char/lp.c
index 97c3edb95ae7..f43485607063 100644
--- a/drivers/char/lp.c
+++ b/drivers/char/lp.c
@@ -829,7 +829,7 @@ static struct console lpcons = {
 
 static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC };
 static char *parport[LP_NO];
-static int reset;
+static bool reset;
 
 module_param_array(parport, charp, NULL, 0);
 module_param(reset, bool, 0);
diff --git a/drivers/char/nwflash.c b/drivers/char/nwflash.c
index a12f52400dbc..bf586ae1ee83 100644
--- a/drivers/char/nwflash.c
+++ b/drivers/char/nwflash.c
@@ -51,7 +51,7 @@ static int write_block(unsigned long p, const char __user *buf, int count);
 #define KFLASH_ID       0x89A6          //Intel flash
 #define KFLASH_ID4      0xB0D4          //Intel flash 4Meg
 
-static int flashdebug;          //if set - we will display progress msgs
+static bool flashdebug;         //if set - we will display progress msgs
 
 static int gbWriteEnable;
 static int gbWriteBase64Enable;
diff --git a/drivers/char/pcmcia/synclink_cs.c b/drivers/char/pcmcia/synclink_cs.c
index 15781396af25..07f6a5abe372 100644
--- a/drivers/char/pcmcia/synclink_cs.c
+++ b/drivers/char/pcmcia/synclink_cs.c
@@ -439,7 +439,7 @@ static int mgslpc_device_count = 0;
  * .text section address and breakpoint on module load.
  * This is useful for use with gdb and add-symbol-file command.
  */
-static int break_on_load=0;
+static bool break_on_load=0;
 
 /*
  * Driver major number, defaults to zero to get auto
diff --git a/drivers/char/ramoops.c b/drivers/char/ramoops.c
index 7c7f42a1f880..9fec3232b736 100644
--- a/drivers/char/ramoops.c
+++ b/drivers/char/ramoops.c
@@ -83,8 +83,7 @@ static void ramoops_do_dump(struct kmsg_dumper *dumper,
         struct timeval timestamp;
 
         if (reason != KMSG_DUMP_OOPS &&
-            reason != KMSG_DUMP_PANIC &&
-            reason != KMSG_DUMP_KEXEC)
+            reason != KMSG_DUMP_PANIC)
                 return;
 
         /* Only dump oopses if dump_oops is set */
@@ -126,8 +125,8 @@ static int __init ramoops_probe(struct platform_device *pdev)
                 goto fail3;
         }
 
-        rounddown_pow_of_two(pdata->mem_size);
-        rounddown_pow_of_two(pdata->record_size);
+        pdata->mem_size = rounddown_pow_of_two(pdata->mem_size);
+        pdata->record_size = rounddown_pow_of_two(pdata->record_size);
 
         /* Check for the minimum memory size */
         if (pdata->mem_size < MIN_MEM_SIZE &&
@@ -148,14 +147,6 @@ static int __init ramoops_probe(struct platform_device *pdev)
         cxt->phys_addr = pdata->mem_address;
         cxt->record_size = pdata->record_size;
         cxt->dump_oops = pdata->dump_oops;
-        /*
-         * Update the module parameter variables as well so they are visible
-         * through /sys/module/ramoops/parameters/
-         */
-        mem_size = pdata->mem_size;
-        mem_address = pdata->mem_address;
-        record_size = pdata->record_size;
-        dump_oops = pdata->dump_oops;
 
         if (!request_mem_region(cxt->phys_addr, cxt->size, "ramoops")) {
                 pr_err("request mem region failed\n");
@@ -176,6 +167,15 @@ static int __init ramoops_probe(struct platform_device *pdev)
                 goto fail1;
         }
 
+        /*
+         * Update the module parameter variables as well so they are visible
+         * through /sys/module/ramoops/parameters/
+         */
+        mem_size = pdata->mem_size;
+        mem_address = pdata->mem_address;
+        record_size = pdata->record_size;
+        dump_oops = pdata->dump_oops;
+
         return 0;
 
 fail1:
diff --git a/drivers/char/random.c b/drivers/char/random.c
index 85da8740586b..54ca8b23cde3 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -387,7 +387,7 @@ static DECLARE_WAIT_QUEUE_HEAD(random_write_wait);
 static struct fasync_struct *fasync;
 
 #if 0
-static int debug;
+static bool debug;
 module_param(debug, bool, 0644);
 #define DEBUG_ENT(fmt, arg...) do { \
         if (debug) \
@@ -965,6 +965,7 @@ EXPORT_SYMBOL(get_random_bytes);
  */
 static void init_std_data(struct entropy_store *r)
 {
+        int i;
         ktime_t now;
         unsigned long flags;
 
@@ -974,6 +975,11 @@ static void init_std_data(struct entropy_store *r)
 
         now = ktime_get_real();
         mix_pool_bytes(r, &now, sizeof(now));
+        for (i = r->poolinfo->POOLBYTES; i > 0; i -= sizeof flags) {
+                if (!arch_get_random_long(&flags))
+                        break;
+                mix_pool_bytes(r, &flags, sizeof(flags));
+        }
         mix_pool_bytes(r, utsname(), sizeof(*(utsname())));
 }
 
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..32362cf35b8d 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,54 @@ 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_ERR_DISABLED || rc == TPM_ERR_DEACTIVATED) {
+                        dev_info(chip->dev,
+                                 "TPM is disabled/deactivated (0x%X)\n", rc);
+                        /* TPM is disabled and/or deactivated; driver can
+                         * proceed and TPM does handle commands for
+                         * suspend/resume correctly
+                         */
+                        return 0;
+                }
+                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 +1071,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..010547138281 100644
--- a/drivers/char/tpm/tpm.h
+++ b/drivers/char/tpm/tpm.h
@@ -38,6 +38,11 @@ enum tpm_addr {
         TPM_ADDR = 0x4E,
 };
 
+#define TPM_WARN_DOING_SELFTEST 0x802
+#define TPM_ERR_DEACTIVATED     0x6
+#define TPM_ERR_DISABLED        0x7
+
+#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 +284,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 +299,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..a1748621111b 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");
@@ -297,7 +255,7 @@ out:
         return size;
 }
 
-static int itpm;
+static bool itpm;
 module_param(itpm, bool, 0444);
 MODULE_PARM_DESC(itpm, "Force iTPM workarounds (found on some Lenovo laptops)");
 
@@ -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;
@@ -539,7 +500,7 @@ static irqreturn_t tis_int_handler(int dummy, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static int interrupts = 1;
+static bool interrupts = 1;
 module_param(interrupts, bool, 0444);
 MODULE_PARM_DESC(interrupts, "Enable interrupts");
 
@@ -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;
 }
@@ -858,7 +828,7 @@ static struct platform_driver tis_drv = {
 
 static struct platform_device *pdev;
 
-static int force;
+static bool force;
 module_param(force, bool, 0444);
 MODULE_PARM_DESC(force, "Force device probe rather than using ACPI entry");
 static int __init init_tis(void)
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)