14 files changed, 213 insertions, 99 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/agp/intel-gtt.c b/drivers/char/agp/intel-gtt.c
index 66cd0b8096ca..c92424ca1a55 100644
--- a/drivers/char/agp/intel-gtt.c
+++ b/drivers/char/agp/intel-gtt.c
@@ -1186,10 +1186,11 @@ static void gen6_cleanup(void)
 /* Certain Gen5 chipsets require require idling the GPU before
  * unmapping anything from the GTT when VT-d is enabled.
  */
-extern int intel_iommu_gfx_mapped;
 static inline int needs_idle_maps(void)
 {
+#ifdef CONFIG_INTEL_IOMMU
         const unsigned short gpu_devid = intel_private.pcidev->device;
+        extern int intel_iommu_gfx_mapped;
 
         /* Query intel_iommu to see if we need the workaround. Presumably that
          * was loaded first.
@@ -1198,7 +1199,7 @@ static inline int needs_idle_maps(void)
              gpu_devid == PCI_DEVICE_ID_INTEL_IRONLAKE_M_IG) &&
              intel_iommu_gfx_mapped)
                 return 1;
-
+#endif
         return 0;
 }
 
@@ -1236,7 +1237,7 @@ static int i9xx_setup(void)
                 intel_private.gtt_bus_addr = reg_addr + gtt_offset;
         }
 
-        if (needs_idle_maps());
+        if (needs_idle_maps())
                 intel_private.base.do_idle_maps = 1;
 
         intel_i9xx_setup_flush();
diff --git a/drivers/char/hw_random/nomadik-rng.c b/drivers/char/hw_random/nomadik-rng.c
index 52e08ca3ccd7..3d3c1e6703b4 100644
--- a/drivers/char/hw_random/nomadik-rng.c
+++ b/drivers/char/hw_random/nomadik-rng.c
@@ -95,6 +95,8 @@ static struct amba_id nmk_rng_ids[] = {
         {0, 0},
 };
 
+MODULE_DEVICE_TABLE(amba, nmk_rng_ids);
+
 static struct amba_driver nmk_rng_driver = {
         .drv = {
                 .owner = THIS_MODULE,
diff --git a/drivers/char/ipmi/ipmi_bt_sm.c b/drivers/char/ipmi/ipmi_bt_sm.c
index 3ed20e8abc0d..cdd4c09fda96 100644
--- a/drivers/char/ipmi/ipmi_bt_sm.c
+++ b/drivers/char/ipmi/ipmi_bt_sm.c
@@ -560,7 +560,7 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
                 BT_CONTROL(BT_H_BUSY);          /* set */
 
                 /*
-                 * Uncached, ordered writes should just proceeed serially but
+                 * Uncached, ordered writes should just proceed serially but
                  * some BMCs don't clear B2H_ATN with one hit.  Fast-path a
                  * workaround without too much penalty to the general case.
                  */
diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
index c2917ffad2c2..34767a6d7f42 100644
--- a/drivers/char/ipmi/ipmi_watchdog.c
+++ b/drivers/char/ipmi/ipmi_watchdog.c
@@ -139,6 +139,8 @@
 #define IPMI_WDOG_SET_TIMER             0x24
 #define IPMI_WDOG_GET_TIMER             0x25
 
+#define IPMI_WDOG_TIMER_NOT_INIT_RESP   0x80
+
 /* These are here until the real ones get into the watchdog.h interface. */
 #ifndef WDIOC_GETTIMEOUT
 #define WDIOC_GETTIMEOUT        _IOW(WATCHDOG_IOCTL_BASE, 20, int)
@@ -596,6 +598,7 @@ static int ipmi_heartbeat(void)
         struct kernel_ipmi_msg            msg;
         int                               rv;
         struct ipmi_system_interface_addr addr;
+        int                               timeout_retries = 0;
 
         if (ipmi_ignore_heartbeat)
                 return 0;
@@ -616,6 +619,7 @@ static int ipmi_heartbeat(void)
 
         mutex_lock(&heartbeat_lock);
 
+restart:
         atomic_set(&heartbeat_tofree, 2);
 
         /*
@@ -653,7 +657,33 @@ static int ipmi_heartbeat(void)
         /* Wait for the heartbeat to be sent. */
         wait_for_completion(&heartbeat_wait);
 
-        if (heartbeat_recv_msg.msg.data[0] != 0) {
+        if (heartbeat_recv_msg.msg.data[0] == IPMI_WDOG_TIMER_NOT_INIT_RESP)  {
+                timeout_retries++;
+                if (timeout_retries > 3) {
+                        printk(KERN_ERR PFX ": Unable to restore the IPMI"
+                               " watchdog's settings, giving up.\n");
+                        rv = -EIO;
+                        goto out_unlock;
+                }
+
+                /*
+                 * The timer was not initialized, that means the BMC was
+                 * probably reset and lost the watchdog information.  Attempt
+                 * to restore the timer's info.  Note that we still hold
+                 * the heartbeat lock, to keep a heartbeat from happening
+                 * in this process, so must say no heartbeat to avoid a
+                 * deadlock on this mutex.
+                 */
+                rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
+                if (rv) {
+                        printk(KERN_ERR PFX ": Unable to send the command to"
+                               " set the watchdog's settings, giving up.\n");
+                        goto out_unlock;
+                }
+
+                /* We might need a new heartbeat, so do it now */
+                goto restart;
+        } else if (heartbeat_recv_msg.msg.data[0] != 0) {
                 /*
                  * Got an error in the heartbeat response.  It was already
                  * reported in ipmi_wdog_msg_handler, but we should return
@@ -662,6 +692,7 @@ static int ipmi_heartbeat(void)
                 rv = -EINVAL;
         }
 
+out_unlock:
         mutex_unlock(&heartbeat_lock);
 
         return rv;
@@ -922,11 +953,15 @@ static struct miscdevice ipmi_wdog_miscdev = {
 static void ipmi_wdog_msg_handler(struct ipmi_recv_msg *msg,
                                   void                 *handler_data)
 {
-        if (msg->msg.data[0] != 0) {
+        if (msg->msg.cmd == IPMI_WDOG_RESET_TIMER &&
+                        msg->msg.data[0] == IPMI_WDOG_TIMER_NOT_INIT_RESP)
+                printk(KERN_INFO PFX "response: The IPMI controller appears"
+                       " to have been reset, will attempt to reinitialize"
+                       " the watchdog timer\n");
+        else if (msg->msg.data[0] != 0)
                 printk(KERN_ERR PFX "response: Error %x on cmd %x\n",
                        msg->msg.data[0],
                        msg->msg.cmd);
-        }
 
         ipmi_free_recv_msg(msg);
 }
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 145179033716..d6e9d081c8b1 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -847,7 +847,7 @@ static const struct file_operations kmsg_fops = {
 
 static const struct memdev {
         const char *name;
-        mode_t mode;
+        umode_t mode;
         const struct file_operations *fops;
         struct backing_dev_info *dev_info;
 } devlist[] = {
@@ -901,7 +901,7 @@ static const struct file_operations memory_fops = {
         .llseek = noop_llseek,
 };
 
-static char *mem_devnode(struct device *dev, mode_t *mode)
+static char *mem_devnode(struct device *dev, umode_t *mode)
 {
         if (mode && devlist[MINOR(dev->devt)].mode)
                 *mode = devlist[MINOR(dev->devt)].mode;
diff --git a/drivers/char/misc.c b/drivers/char/misc.c
index 778273c93242..522136d40843 100644
--- a/drivers/char/misc.c
+++ b/drivers/char/misc.c
@@ -258,7 +258,7 @@ int misc_deregister(struct miscdevice *misc)
 EXPORT_SYMBOL(misc_register);
 EXPORT_SYMBOL(misc_deregister);
 
-static char *misc_devnode(struct device *dev, mode_t *mode)
+static char *misc_devnode(struct device *dev, umode_t *mode)
 {
         struct miscdevice *c = dev_get_drvdata(dev);
 
diff --git a/drivers/char/random.c b/drivers/char/random.c
index 63e19ba56bbe..85da8740586b 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -624,8 +624,8 @@ static struct timer_rand_state input_timer_state;
 static void add_timer_randomness(struct timer_rand_state *state, unsigned num)
 {
         struct {
-                cycles_t cycles;
                 long jiffies;
+                unsigned cycles;
                 unsigned num;
         } sample;
         long delta, delta2, delta3;
@@ -637,7 +637,11 @@ static void add_timer_randomness(struct timer_rand_state *state, unsigned num)
                 goto out;
 
         sample.jiffies = jiffies;
-        sample.cycles = get_cycles();
+
+        /* Use arch random value, fall back to cycles */
+        if (!arch_get_random_int(&sample.cycles))
+                sample.cycles = get_cycles();
+
         sample.num = num;
         mix_pool_bytes(&input_pool, &sample, sizeof(sample));
 
@@ -941,7 +945,7 @@ void get_random_bytes(void *buf, int nbytes)
                 if (!arch_get_random_long(&v))
                         break;
                 
-                memcpy(buf, &v, chunk);
+                memcpy(p, &v, chunk);
                 p += chunk;
                 nbytes -= chunk;
         }
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index b6de2c047145..54a3a6d09819 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -308,7 +308,7 @@ static const struct file_operations raw_ctl_fops = {
 
 static struct cdev raw_cdev;
 
-static char *raw_devnode(struct device *dev, mode_t *mode)
+static char *raw_devnode(struct device *dev, umode_t *mode)
 {
         return kasprintf(GFP_KERNEL, "raw/%s", dev_name(dev));
 }
diff --git a/drivers/char/tile-srom.c b/drivers/char/tile-srom.c
index cf3ee008dca2..4dc019408fac 100644
--- a/drivers/char/tile-srom.c
+++ b/drivers/char/tile-srom.c
@@ -329,7 +329,7 @@ static struct device_attribute srom_dev_attrs[] = {
         __ATTR_NULL
 };
 
-static char *srom_devnode(struct device *dev, mode_t *mode)
+static char *srom_devnode(struct device *dev, umode_t *mode)
 {
         *mode = S_IRUGO | S_IWUSR;
         return kasprintf(GFP_KERNEL, "srom/%s", dev_name(dev));
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;
 }