Patched in Tegra support.

author: Jonathan Herman <hermanjl@cs.unc.edu> 2013-01-17 16:15:55 -0500
committer: Jonathan Herman <hermanjl@cs.unc.edu> 2013-01-17 16:15:55 -0500
commit: 8dea78da5cee153b8af9c07a2745f6c55057fe12 (patch)
tree: a8f4d49d63b1ecc92f2fddceba0655b2472c5bd9 /drivers/char
parent: 406089d01562f1e2bf9f089fd7637009ebaad589 (diff)
95 files changed, 1662 insertions, 5518 deletions
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 72bedad6bf8..b2aec046996 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -6,6 +6,19 @@ menu "Character devices"
 source "drivers/tty/Kconfig"
+config DEVMEM
+        bool "Memory device driver"
+        default y
+        help
+          The memory driver provides two character devices, mem and kmem, which
+          provide access to the system's memory. The mem device is a view of
+          physical memory, and each byte in the device corresponds to the
+          matching physical address. The kmem device is the same as mem, but
+          the addresses correspond to the kernel's virtual address space rather
+          than physical memory. These devices are standard parts of a Linux
+          system and most users should say Y here. You might say N if very
+          security conscience or memory is tight.
 config DEVKMEM
        bool "/dev/kmem virtual device support"
        default y
@@ -66,6 +79,21 @@ config TTY_PRINTK
          If unsure, say N.
+config BRIQ_PANEL
+        tristate 'Total Impact briQ front panel driver'
+        depends on PPC_CHRP
+        ---help---
+          The briQ is a small footprint CHRP computer with a frontpanel VFD, a
+          tristate led and two switches. It is the size of a CDROM drive.
+          If you have such one and want anything showing on the VFD then you
+          must answer Y here.
+          To compile this driver as a module, choose M here: the
+          module will be called briq_panel.
+          It's safe to say N here.
 config BFIN_OTP
        tristate "Blackfin On-Chip OTP Memory Support"
        depends on BLACKFIN && (BF51x || BF52x || BF54x)
@@ -283,7 +311,7 @@ if RTC_LIB=n
 config RTC
        tristate "Enhanced Real Time Clock Support (legacy PC RTC driver)"
        depends on !PPC && !PARISC && !IA64 && !M68K && !SPARC && !FRV \
-                        && !ARM && !SUPERH && !S390 && !AVR32 && !BLACKFIN && !UML
+                        && !ARM && !SUPERH && !S390 && !AVR32 && !BLACKFIN
        ---help---
          If you say Y here and create a character special file /dev/rtc with
          major number 10 and minor number 135 using mknod ("man mknod"), you
@@ -331,7 +359,7 @@ config JS_RTC
 config GEN_RTC
        tristate "Generic /dev/rtc emulation"
-        depends on RTC!=y && !IA64 && !ARM && !M32R && !MIPS && !SPARC && !FRV && !S390 && !SUPERH && !AVR32 && !BLACKFIN && !UML
+        depends on RTC!=y && !IA64 && !ARM && !M32R && !MIPS && !SPARC && !FRV && !S390 && !SUPERH && !AVR32 && !BLACKFIN
        ---help---
          If you say Y here and create a character special file /dev/rtc with
          major number 10 and minor number 135 using mknod ("man mknod"), you
@@ -418,8 +446,8 @@ config APPLICOM
          If unsure, say N.
 config SONYPI
-        tristate "Sony Vaio Programmable I/O Control Device support"
+        tristate "Sony Vaio Programmable I/O Control Device support (EXPERIMENTAL)"
-        depends on X86 && PCI && INPUT && !64BIT
+        depends on EXPERIMENTAL && X86 && PCI && INPUT && !64BIT
        ---help---
          This driver enables access to the Sony Programmable I/O Control
          Device which can be found in many (all ?) Sony Vaio laptops.
@@ -475,7 +503,7 @@ config SCx200_GPIO
 config PC8736x_GPIO
        tristate "NatSemi PC8736x GPIO Support"
-        depends on X86_32 && !UML
+        depends on X86_32
        default SCx200_GPIO     # mostly N
        select NSC_GPIO         # needed for support routines
        help
@@ -566,7 +594,7 @@ source "drivers/char/tpm/Kconfig"
 config TELCLOCK
        tristate "Telecom clock driver for ATCA SBC"
-        depends on X86
+        depends on EXPERIMENTAL && X86
        default n
        help
          The telecom clock device is specific to the MPCBL0010 and MPCBL0050
@@ -583,8 +611,20 @@ config DEVPORT
        depends on ISA || PCI
        default y
+config DCC_TTY
+        tristate "DCC tty driver"
+        depends on ARM
 source "drivers/s390/char/Kconfig"
+config RAMOOPS
+        tristate "Log panic/oops to a RAM buffer"
+        depends on HAS_IOMEM
+        default n
+        help
+          This enables panic and oops messages to be logged to a circular
+          buffer in RAM where it can be read back at some later point.
 config MSM_SMD_PKT
        bool "Enable device interface for some SMD packet ports"
        default n
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 7ff1d0d208a..5e2fd709702 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -16,6 +16,7 @@ obj-$(CONFIG_UV_MMTIMER)	+= uv_mmtimer.o
 obj-$(CONFIG_VIOTAPE)           += viotape.o
 obj-$(CONFIG_IBM_BSR)           += bsr.o
 obj-$(CONFIG_SGI_MBCS)          += mbcs.o
+obj-$(CONFIG_BRIQ_PANEL)        += briq_panel.o
 obj-$(CONFIG_BFIN_OTP)          += bfin-otp.o
 obj-$(CONFIG_PRINTER)           += lp.o
@@ -52,11 +53,14 @@ obj-$(CONFIG_TELCLOCK)		+= tlclk.o
 obj-$(CONFIG_MWAVE)             += mwave/
 obj-$(CONFIG_AGP)               += agp/
 obj-$(CONFIG_PCMCIA)            += pcmcia/
+obj-$(CONFIG_IPMI_HANDLER)      += ipmi/
 obj-$(CONFIG_HANGCHECK_TIMER)   += hangcheck-timer.o
 obj-$(CONFIG_TCG_TPM)           += tpm/
+obj-$(CONFIG_DCC_TTY)           += dcc_tty.o
 obj-$(CONFIG_PS3_FLASH)         += ps3flash.o
+obj-$(CONFIG_RAMOOPS)           += ramoops.o
 obj-$(CONFIG_JS_RTC)            += js-rtc.o
 js-rtc-y = rtc.o
diff --git a/drivers/char/agp/ali-agp.c b/drivers/char/agp/ali-agp.c
index 443cd6751ca..fd793519ea2 100644
--- a/drivers/char/agp/ali-agp.c
+++ b/drivers/char/agp/ali-agp.c
@@ -249,7 +249,7 @@ static const struct agp_bridge_driver ali_m1541_bridge = {
 };
-static struct agp_device_ids ali_agp_device_ids[] =
+static struct agp_device_ids ali_agp_device_ids[] __devinitdata =
 {
        {
                .device_id      = PCI_DEVICE_ID_AL_M1541,
@@ -299,7 +299,8 @@ static struct agp_device_ids ali_agp_device_ids[] =
        { }, /* dummy final entry, always present */
 };
-static int agp_ali_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
+static int __devinit agp_ali_probe(struct pci_dev *pdev,
+                                const struct pci_device_id *ent)
 {
        struct agp_device_ids *devs = ali_agp_device_ids;
        struct agp_bridge_data *bridge;
@@ -373,7 +374,7 @@ found:
        return agp_add_bridge(bridge);
 }
-static void agp_ali_remove(struct pci_dev *pdev)
+static void __devexit agp_ali_remove(struct pci_dev *pdev)
 {
        struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
diff --git a/drivers/char/agp/amd-k7-agp.c b/drivers/char/agp/amd-k7-agp.c
index 779f0ab845a..f7e88787af9 100644
--- a/drivers/char/agp/amd-k7-agp.c
+++ b/drivers/char/agp/amd-k7-agp.c
@@ -388,7 +388,7 @@ static const struct agp_bridge_driver amd_irongate_driver = {
        .agp_type_to_mask_type  = agp_generic_type_to_mask_type,
 };
-static struct agp_device_ids amd_agp_device_ids[] =
+static struct agp_device_ids amd_agp_device_ids[] __devinitdata =
 {
        {
                .device_id      = PCI_DEVICE_ID_AMD_FE_GATE_7006,
@@ -405,8 +405,8 @@ static struct agp_device_ids amd_agp_device_ids[] =
        { }, /* dummy final entry, always present */
 };
-static int agp_amdk7_probe(struct pci_dev *pdev,
+static int __devinit agp_amdk7_probe(struct pci_dev *pdev,
-                           const struct pci_device_id *ent)
+                                     const struct pci_device_id *ent)
 {
        struct agp_bridge_data *bridge;
        u8 cap_ptr;
@@ -480,7 +480,7 @@ static int agp_amdk7_probe(struct pci_dev *pdev,
        return agp_add_bridge(bridge);
 }
-static void agp_amdk7_remove(struct pci_dev *pdev)
+static void __devexit agp_amdk7_remove(struct pci_dev *pdev)
 {
        struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
diff --git a/drivers/char/agp/amd64-agp.c b/drivers/char/agp/amd64-agp.c
index d79d692d05b..780498d7658 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 bool __initdata agp_try_unsupported = 1;
+static int __initdata agp_try_unsupported = 1;
 static int agp_bridges_found;
 static void amd64_tlbflush(struct agp_memory *temp)
@@ -240,7 +240,7 @@ static const struct agp_bridge_driver amd_8151_driver = {
 };
 /* Some basic sanity checks for the aperture. */
-static int agp_aperture_valid(u64 aper, u32 size)
+static int __devinit agp_aperture_valid(u64 aper, u32 size)
 {
        if (!aperture_valid(aper, size, 32*1024*1024))
                return 0;
@@ -267,7 +267,8 @@ static int agp_aperture_valid(u64 aper, u32 size)
 * to allocate that much memory. But at least error out cleanly instead of
 * crashing.
 */
-static int fix_northbridge(struct pci_dev *nb, struct pci_dev *agp, u16 cap)
+static __devinit int fix_northbridge(struct pci_dev *nb, struct pci_dev *agp,
+                                                                 u16 cap)
 {
        u32 aper_low, aper_hi;
        u64 aper, nb_aper;
@@ -325,7 +326,7 @@ static int fix_northbridge(struct pci_dev *nb, struct pci_dev *agp, u16 cap)
        return 0;
 }
-static int cache_nbs(struct pci_dev *pdev, u32 cap_ptr)
+static __devinit int cache_nbs(struct pci_dev *pdev, u32 cap_ptr)
 {
        int i;
@@ -351,7 +352,7 @@ static int cache_nbs(struct pci_dev *pdev, u32 cap_ptr)
 }
 /* Handle AMD 8151 quirks */
-static void amd8151_init(struct pci_dev *pdev, struct agp_bridge_data *bridge)
+static void __devinit amd8151_init(struct pci_dev *pdev, struct agp_bridge_data *bridge)
 {
        char *revstring;
@@ -389,7 +390,7 @@ static const struct aper_size_info_32 uli_sizes[7] =
        {8, 2048, 1, 4},
        {4, 1024, 0, 3}
 };
-static int uli_agp_init(struct pci_dev *pdev)
+static int __devinit uli_agp_init(struct pci_dev *pdev)
 {
        u32 httfea,baseaddr,enuscr;
        struct pci_dev *dev1;
@@ -512,8 +513,8 @@ put:
        return ret;
 }
-static int agp_amd64_probe(struct pci_dev *pdev,
+static int __devinit agp_amd64_probe(struct pci_dev *pdev,
-                           const struct pci_device_id *ent)
+                                     const struct pci_device_id *ent)
 {
        struct agp_bridge_data *bridge;
        u8 cap_ptr;
@@ -578,7 +579,7 @@ static int agp_amd64_probe(struct pci_dev *pdev,
        return 0;
 }
-static void agp_amd64_remove(struct pci_dev *pdev)
+static void __devexit agp_amd64_remove(struct pci_dev *pdev)
 {
        struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
diff --git a/drivers/char/agp/ati-agp.c b/drivers/char/agp/ati-agp.c
index 0628d7b65c7..dc30e224349 100644
--- a/drivers/char/agp/ati-agp.c
+++ b/drivers/char/agp/ati-agp.c
@@ -445,7 +445,7 @@ static const struct agp_bridge_driver ati_generic_bridge = {
 };
-static struct agp_device_ids ati_agp_device_ids[] =
+static struct agp_device_ids ati_agp_device_ids[] __devinitdata =
 {
        {
                .device_id      = PCI_DEVICE_ID_ATI_RS100,
@@ -490,7 +490,8 @@ static struct agp_device_ids ati_agp_device_ids[] =
        { }, /* dummy final entry, always present */
 };
-static int agp_ati_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
+static int __devinit agp_ati_probe(struct pci_dev *pdev,
+                                   const struct pci_device_id *ent)
 {
        struct agp_device_ids *devs = ati_agp_device_ids;
        struct agp_bridge_data *bridge;
@@ -532,7 +533,7 @@ found:
        return agp_add_bridge(bridge);
 }
-static void agp_ati_remove(struct pci_dev *pdev)
+static void __devexit agp_ati_remove(struct pci_dev *pdev)
 {
        struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
diff --git a/drivers/char/agp/backend.c b/drivers/char/agp/backend.c
index 317c28ce832..f27d0d0816d 100644
--- a/drivers/char/agp/backend.c
+++ b/drivers/char/agp/backend.c
@@ -171,7 +171,7 @@ static int agp_backend_initialize(struct agp_bridge_data *bridge)
        }
        got_gatt = 1;
-        bridge->key_list = vzalloc(PAGE_SIZE * 4);
+        bridge->key_list = vmalloc(PAGE_SIZE * 4);
        if (bridge->key_list == NULL) {
                dev_err(&bridge->dev->dev,
                        "can't allocate memory for key lists\n");
@@ -181,6 +181,7 @@ static int agp_backend_initialize(struct agp_bridge_data *bridge)
        got_keylist = 1;
        /* FIXME vmalloc'd memory not guaranteed contiguous */
+        memset(bridge->key_list, 0, PAGE_SIZE * 4);
        if (bridge->driver->configure()) {
                dev_err(&bridge->dev->dev, "error configuring host chipset\n");
@@ -194,10 +195,10 @@ static int agp_backend_initialize(struct agp_bridge_data *bridge)
 err_out:
        if (bridge->driver->needs_scratch_page) {
-                struct page *page = bridge->scratch_page_page;
+                void *va = page_address(bridge->scratch_page_page);
-                bridge->driver->agp_destroy_page(page, AGP_PAGE_DESTROY_UNMAP);
+                bridge->driver->agp_destroy_page(va, AGP_PAGE_DESTROY_UNMAP);
-                bridge->driver->agp_destroy_page(page, AGP_PAGE_DESTROY_FREE);
+                bridge->driver->agp_destroy_page(va, AGP_PAGE_DESTROY_FREE);
        }
        if (got_gatt)
                bridge->driver->free_gatt_table(bridge);
@@ -221,10 +222,10 @@ static void agp_backend_cleanup(struct agp_bridge_data *bridge)
        if (bridge->driver->agp_destroy_page &&
            bridge->driver->needs_scratch_page) {
-                struct page *page = bridge->scratch_page_page;
+                void *va = page_address(bridge->scratch_page_page);
-                bridge->driver->agp_destroy_page(page, AGP_PAGE_DESTROY_UNMAP);
+                bridge->driver->agp_destroy_page(va, AGP_PAGE_DESTROY_UNMAP);
-                bridge->driver->agp_destroy_page(page, AGP_PAGE_DESTROY_FREE);
+                bridge->driver->agp_destroy_page(va, AGP_PAGE_DESTROY_FREE);
        }
 }
diff --git a/drivers/char/agp/efficeon-agp.c b/drivers/char/agp/efficeon-agp.c
index 6974d503205..d607f53d8af 100644
--- a/drivers/char/agp/efficeon-agp.c
+++ b/drivers/char/agp/efficeon-agp.c
@@ -343,8 +343,8 @@ static const struct agp_bridge_driver efficeon_driver = {
        .agp_type_to_mask_type  = agp_generic_type_to_mask_type,
 };
-static int agp_efficeon_probe(struct pci_dev *pdev,
+static int __devinit agp_efficeon_probe(struct pci_dev *pdev,
-                              const struct pci_device_id *ent)
+                                     const struct pci_device_id *ent)
 {
        struct agp_bridge_data *bridge;
        u8 cap_ptr;
@@ -407,7 +407,7 @@ static int agp_efficeon_probe(struct pci_dev *pdev,
        return agp_add_bridge(bridge);
 }
-static void agp_efficeon_remove(struct pci_dev *pdev)
+static void __devexit agp_efficeon_remove(struct pci_dev *pdev)
 {
        struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
diff --git a/drivers/char/agp/generic.c b/drivers/char/agp/generic.c
index a0df182f6f7..b072648dc3f 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,9 +956,9 @@ 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!\n");
+                printk(KERN_WARNING "Could not set GATT table memory to UC!");
-        bridge->gatt_table = (u32 __iomem *)table;
+        bridge->gatt_table = (void *)table;
 #else
        bridge->gatt_table = ioremap_nocache(virt_to_phys(table),
                                        (PAGE_SIZE * (1 << page_order)));
@@ -1010,6 +1010,7 @@ int agp_generic_free_gatt_table(struct agp_bridge_data *bridge)
        case LVL2_APER_SIZE:
                /* The generic routines can't deal with 2 level gatt's */
                return -EINVAL;
+                break;
        default:
                page_order = 0;
                break;
@@ -1076,6 +1077,7 @@ int agp_generic_insert_memory(struct agp_memory * mem, off_t pg_start, int type)
        case LVL2_APER_SIZE:
                /* The generic routines can't deal with 2 level gatt's */
                return -EINVAL;
+                break;
        default:
                num_entries = 0;
                break;
diff --git a/drivers/char/agp/hp-agp.c b/drivers/char/agp/hp-agp.c
index 3695773ce7c..056b289a1e8 100644
--- a/drivers/char/agp/hp-agp.c
+++ b/drivers/char/agp/hp-agp.c
@@ -336,8 +336,7 @@ hp_zx1_insert_memory (struct agp_memory *mem, off_t pg_start, int type)
        off_t j, io_pg_start;
        int io_pg_count;
-        if (type != mem->type ||
+        if (type != 0 || mem->type != 0) {
-                agp_bridge->driver->agp_type_to_mask_type(agp_bridge, type)) {
                return -EINVAL;
        }
@@ -381,8 +380,7 @@ hp_zx1_remove_memory (struct agp_memory *mem, off_t pg_start, int type)
        struct _hp_private *hp = &hp_private;
        int i, io_pg_start, io_pg_count;
-        if (type != mem->type ||
+        if (type != 0 || mem->type != 0) {
-                agp_bridge->driver->agp_type_to_mask_type(agp_bridge, type)) {
                return -EINVAL;
        }
diff --git a/drivers/char/agp/i460-agp.c b/drivers/char/agp/i460-agp.c
index 15b240ea484..75b763cb3ea 100644
--- a/drivers/char/agp/i460-agp.c
+++ b/drivers/char/agp/i460-agp.c
@@ -587,8 +587,8 @@ const struct agp_bridge_driver intel_i460_driver = {
        .cant_use_aperture      = true,
 };
-static int agp_intel_i460_probe(struct pci_dev *pdev,
+static int __devinit agp_intel_i460_probe(struct pci_dev *pdev,
-                                const struct pci_device_id *ent)
+                                          const struct pci_device_id *ent)
 {
        struct agp_bridge_data *bridge;
        u8 cap_ptr;
@@ -611,7 +611,7 @@ static int agp_intel_i460_probe(struct pci_dev *pdev,
        return agp_add_bridge(bridge);
 }
-static void agp_intel_i460_remove(struct pci_dev *pdev)
+static void __devexit agp_intel_i460_remove(struct pci_dev *pdev)
 {
        struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
@@ -637,7 +637,7 @@ static struct pci_driver agp_intel_i460_pci_driver = {
        .name           = "agpgart-intel-i460",
        .id_table       = agp_intel_i460_pci_table,
        .probe          = agp_intel_i460_probe,
-        .remove         = agp_intel_i460_remove,
+        .remove         = __devexit_p(agp_intel_i460_remove),
 };
 static int __init agp_intel_i460_init(void)
diff --git a/drivers/char/agp/intel-agp.c b/drivers/char/agp/intel-agp.c
index a426ee1f57a..b427711be4b 100644
--- a/drivers/char/agp/intel-agp.c
+++ b/drivers/char/agp/intel-agp.c
@@ -12,7 +12,6 @@
 #include <asm/smp.h>
 #include "agp.h"
 #include "intel-agp.h"
-#include <drm/intel-gtt.h>
 int intel_agp_enabled;
 EXPORT_SYMBOL(intel_agp_enabled);
@@ -732,8 +731,8 @@ static const struct intel_agp_driver_description {
        { 0, NULL, NULL }
 };
-static int agp_intel_probe(struct pci_dev *pdev,
+static int __devinit agp_intel_probe(struct pci_dev *pdev,
-                           const struct pci_device_id *ent)
+                                     const struct pci_device_id *ent)
 {
        struct agp_bridge_data *bridge;
        u8 cap_ptr = 0;
@@ -748,7 +747,7 @@ static int agp_intel_probe(struct pci_dev *pdev,
        bridge->capndx = cap_ptr;
-        if (intel_gmch_probe(pdev, NULL, bridge))
+        if (intel_gmch_probe(pdev, bridge))
                goto found_gmch;
        for (i = 0; intel_agp_chipsets[i].name != NULL; i++) {
@@ -819,13 +818,13 @@ found_gmch:
        return err;
 }
-static void agp_intel_remove(struct pci_dev *pdev)
+static void __devexit agp_intel_remove(struct pci_dev *pdev)
 {
        struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
        agp_remove_bridge(bridge);
-        intel_gmch_remove();
+        intel_gmch_remove(pdev);
        agp_put_bridge(bridge);
 }
@@ -851,7 +850,6 @@ static struct pci_device_id agp_intel_pci_table[] = {
        .subvendor      = PCI_ANY_ID,                   \
        .subdevice      = PCI_ANY_ID,                   \
        }
-        ID(PCI_DEVICE_ID_INTEL_82441), /* for HAS2 support */
        ID(PCI_DEVICE_ID_INTEL_82443LX_0),
        ID(PCI_DEVICE_ID_INTEL_82443BX_0),
        ID(PCI_DEVICE_ID_INTEL_82443GX_0),
@@ -899,10 +897,15 @@ static struct pci_device_id agp_intel_pci_table[] = {
        ID(PCI_DEVICE_ID_INTEL_B43_HB),
        ID(PCI_DEVICE_ID_INTEL_B43_1_HB),
        ID(PCI_DEVICE_ID_INTEL_IRONLAKE_D_HB),
-        ID(PCI_DEVICE_ID_INTEL_IRONLAKE_D2_HB),
        ID(PCI_DEVICE_ID_INTEL_IRONLAKE_M_HB),
        ID(PCI_DEVICE_ID_INTEL_IRONLAKE_MA_HB),
        ID(PCI_DEVICE_ID_INTEL_IRONLAKE_MC2_HB),
+        ID(PCI_DEVICE_ID_INTEL_SANDYBRIDGE_HB),
+        ID(PCI_DEVICE_ID_INTEL_SANDYBRIDGE_M_HB),
+        ID(PCI_DEVICE_ID_INTEL_SANDYBRIDGE_S_HB),
+        ID(PCI_DEVICE_ID_INTEL_IVYBRIDGE_HB),
+        ID(PCI_DEVICE_ID_INTEL_IVYBRIDGE_M_HB),
+        ID(PCI_DEVICE_ID_INTEL_IVYBRIDGE_S_HB),
        { }
 };
@@ -912,7 +915,7 @@ static struct pci_driver agp_intel_pci_driver = {
        .name           = "agpgart-intel",
        .id_table       = agp_intel_pci_table,
        .probe          = agp_intel_probe,
-        .remove         = agp_intel_remove,
+        .remove         = __devexit_p(agp_intel_remove),
 #ifdef CONFIG_PM
        .resume         = agp_intel_resume,
 #endif
diff --git a/drivers/char/agp/intel-agp.h b/drivers/char/agp/intel-agp.h
index 1042c1b9037..5da67f165af 100644
--- a/drivers/char/agp/intel-agp.h
+++ b/drivers/char/agp/intel-agp.h
@@ -62,6 +62,11 @@
 #define I810_PTE_LOCAL          0x00000002
 #define I810_PTE_VALID          0x00000001
 #define I830_PTE_SYSTEM_CACHED  0x00000006
+/* GT PTE cache control fields */
+#define GEN6_PTE_UNCACHED       0x00000002
+#define GEN6_PTE_LLC            0x00000004
+#define GEN6_PTE_LLC_MLC        0x00000006
+#define GEN6_PTE_GFDT           0x00000008
 #define I810_SMRAM_MISCC        0x70
 #define I810_GFX_MEM_WIN_SIZE   0x00010000
@@ -141,6 +146,29 @@
 #define INTEL_I7505_AGPCTRL     0x70
 #define INTEL_I7505_MCHCFG      0x50
+#define SNB_GMCH_CTRL   0x50
+#define SNB_GMCH_GMS_STOLEN_MASK        0xF8
+#define SNB_GMCH_GMS_STOLEN_32M         (1 << 3)
+#define SNB_GMCH_GMS_STOLEN_64M         (2 << 3)
+#define SNB_GMCH_GMS_STOLEN_96M         (3 << 3)
+#define SNB_GMCH_GMS_STOLEN_128M        (4 << 3)
+#define SNB_GMCH_GMS_STOLEN_160M        (5 << 3)
+#define SNB_GMCH_GMS_STOLEN_192M        (6 << 3)
+#define SNB_GMCH_GMS_STOLEN_224M        (7 << 3)
+#define SNB_GMCH_GMS_STOLEN_256M        (8 << 3)
+#define SNB_GMCH_GMS_STOLEN_288M        (9 << 3)
+#define SNB_GMCH_GMS_STOLEN_320M        (0xa << 3)
+#define SNB_GMCH_GMS_STOLEN_352M        (0xb << 3)
+#define SNB_GMCH_GMS_STOLEN_384M        (0xc << 3)
+#define SNB_GMCH_GMS_STOLEN_416M        (0xd << 3)
+#define SNB_GMCH_GMS_STOLEN_448M        (0xe << 3)
+#define SNB_GMCH_GMS_STOLEN_480M        (0xf << 3)
+#define SNB_GMCH_GMS_STOLEN_512M        (0x10 << 3)
+#define SNB_GTT_SIZE_0M                 (0 << 8)
+#define SNB_GTT_SIZE_1M                 (1 << 8)
+#define SNB_GTT_SIZE_2M                 (2 << 8)
+#define SNB_GTT_SIZE_MASK               (3 << 8)
 /* pci devices ids */
 #define PCI_DEVICE_ID_INTEL_E7221_HB    0x2588
 #define PCI_DEVICE_ID_INTEL_E7221_IG    0x258a
@@ -183,11 +211,31 @@
 #define PCI_DEVICE_ID_INTEL_G41_HB          0x2E30
 #define PCI_DEVICE_ID_INTEL_G41_IG          0x2E32
 #define PCI_DEVICE_ID_INTEL_IRONLAKE_D_HB           0x0040
-#define PCI_DEVICE_ID_INTEL_IRONLAKE_D2_HB          0x0069
 #define PCI_DEVICE_ID_INTEL_IRONLAKE_D_IG           0x0042
 #define PCI_DEVICE_ID_INTEL_IRONLAKE_M_HB           0x0044
 #define PCI_DEVICE_ID_INTEL_IRONLAKE_MA_HB          0x0062
 #define PCI_DEVICE_ID_INTEL_IRONLAKE_MC2_HB    0x006a
 #define PCI_DEVICE_ID_INTEL_IRONLAKE_M_IG           0x0046
+#define PCI_DEVICE_ID_INTEL_SANDYBRIDGE_HB              0x0100  /* Desktop */
+#define PCI_DEVICE_ID_INTEL_SANDYBRIDGE_GT1_IG          0x0102
+#define PCI_DEVICE_ID_INTEL_SANDYBRIDGE_GT2_IG          0x0112
+#define PCI_DEVICE_ID_INTEL_SANDYBRIDGE_GT2_PLUS_IG     0x0122
+#define PCI_DEVICE_ID_INTEL_SANDYBRIDGE_M_HB            0x0104  /* Mobile */
+#define PCI_DEVICE_ID_INTEL_SANDYBRIDGE_M_GT1_IG        0x0106
+#define PCI_DEVICE_ID_INTEL_SANDYBRIDGE_M_GT2_IG        0x0116
+#define PCI_DEVICE_ID_INTEL_SANDYBRIDGE_M_GT2_PLUS_IG   0x0126
+#define PCI_DEVICE_ID_INTEL_SANDYBRIDGE_S_HB            0x0108  /* Server */
+#define PCI_DEVICE_ID_INTEL_SANDYBRIDGE_S_IG            0x010A
+#define PCI_DEVICE_ID_INTEL_IVYBRIDGE_HB                0x0150  /* Desktop */
+#define PCI_DEVICE_ID_INTEL_IVYBRIDGE_GT1_IG            0x0152
+#define PCI_DEVICE_ID_INTEL_IVYBRIDGE_GT2_IG            0x0162
+#define PCI_DEVICE_ID_INTEL_IVYBRIDGE_M_HB              0x0154  /* Mobile */
+#define PCI_DEVICE_ID_INTEL_IVYBRIDGE_M_GT1_IG          0x0156
+#define PCI_DEVICE_ID_INTEL_IVYBRIDGE_M_GT2_IG          0x0166
+#define PCI_DEVICE_ID_INTEL_IVYBRIDGE_S_HB              0x0158  /* Server */
+#define PCI_DEVICE_ID_INTEL_IVYBRIDGE_S_GT1_IG          0x015A
+int intel_gmch_probe(struct pci_dev *pdev,
+                               struct agp_bridge_data *bridge);
+void intel_gmch_remove(struct pci_dev *pdev);
 #endif
diff --git a/drivers/char/agp/intel-gtt.c b/drivers/char/agp/intel-gtt.c
index dbd901e94ea..2774ac1086d 100644
--- a/drivers/char/agp/intel-gtt.c
+++ b/drivers/char/agp/intel-gtt.c
@@ -66,6 +66,7 @@ static struct _intel_private {
        struct pci_dev *bridge_dev;
        u8 __iomem *registers;
        phys_addr_t gtt_bus_addr;
+        phys_addr_t gma_bus_addr;
        u32 PGETBL_save;
        u32 __iomem *gtt;               /* I915G */
        bool clear_fake_agp; /* on first access via agp, fill with scratch */
@@ -75,7 +76,7 @@ static struct _intel_private {
        struct resource ifp_resource;
        int resource_valid;
        struct page *scratch_page;
-        int refcount;
+        dma_addr_t scratch_page_dma;
 } intel_private;
 #define INTEL_GTT_GEN   intel_private.driver->gen
@@ -84,33 +85,40 @@ static struct _intel_private {
 #define IS_IRONLAKE     intel_private.driver->is_ironlake
 #define HAS_PGTBL_EN    intel_private.driver->has_pgtbl_enable
-static int intel_gtt_map_memory(struct page **pages,
+int intel_gtt_map_memory(struct page **pages, unsigned int num_entries,
-                                unsigned int num_entries,
+                         struct scatterlist **sg_list, int *num_sg)
-                                struct sg_table *st)
 {
+        struct sg_table st;
        struct scatterlist *sg;
        int i;
+        if (*sg_list)
+                return 0; /* already mapped (for e.g. resume */
        DBG("try mapping %lu pages\n", (unsigned long)num_entries);
-        if (sg_alloc_table(st, num_entries, GFP_KERNEL))
+        if (sg_alloc_table(&st, num_entries, GFP_KERNEL))
                goto err;
-        for_each_sg(st->sgl, sg, num_entries, i)
+        *sg_list = sg = st.sgl;
+        for (i = 0 ; i < num_entries; i++, sg = sg_next(sg))
                sg_set_page(sg, pages[i], PAGE_SIZE, 0);
-        if (!pci_map_sg(intel_private.pcidev,
+        *num_sg = pci_map_sg(intel_private.pcidev, *sg_list,
-                        st->sgl, st->nents, PCI_DMA_BIDIRECTIONAL))
+                                 num_entries, PCI_DMA_BIDIRECTIONAL);
+        if (unlikely(!*num_sg))
                goto err;
        return 0;
 err:
-        sg_free_table(st);
+        sg_free_table(&st);
        return -ENOMEM;
 }
+EXPORT_SYMBOL(intel_gtt_map_memory);
-static void intel_gtt_unmap_memory(struct scatterlist *sg_list, int num_sg)
+void intel_gtt_unmap_memory(struct scatterlist *sg_list, int num_sg)
 {
        struct sg_table st;
        DBG("try unmapping %lu pages\n", (unsigned long)mem->page_count);
@@ -123,6 +131,7 @@ static void intel_gtt_unmap_memory(struct scatterlist *sg_list, int num_sg)
        sg_free_table(&st);
 }
+EXPORT_SYMBOL(intel_gtt_unmap_memory);
 static void intel_fake_agp_enable(struct agp_bridge_data *bridge, u32 mode)
 {
@@ -297,9 +306,9 @@ static int intel_gtt_setup_scratch_page(void)
                if (pci_dma_mapping_error(intel_private.pcidev, dma_addr))
                        return -EINVAL;
-                intel_private.base.scratch_page_dma = dma_addr;
+                intel_private.scratch_page_dma = dma_addr;
        } else
-                intel_private.base.scratch_page_dma = page_to_phys(page);
+                intel_private.scratch_page_dma = page_to_phys(page);
        intel_private.scratch_page = page;
@@ -367,6 +376,62 @@ static unsigned int intel_gtt_stolen_size(void)
                        stolen_size = 0;
                        break;
                }
+        } else if (INTEL_GTT_GEN == 6) {
+                /*
+                 * SandyBridge has new memory control reg at 0x50.w
+                 */
+                u16 snb_gmch_ctl;
+                pci_read_config_word(intel_private.pcidev, SNB_GMCH_CTRL, &snb_gmch_ctl);
+                switch (snb_gmch_ctl & SNB_GMCH_GMS_STOLEN_MASK) {
+                case SNB_GMCH_GMS_STOLEN_32M:
+                        stolen_size = MB(32);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_64M:
+                        stolen_size = MB(64);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_96M:
+                        stolen_size = MB(96);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_128M:
+                        stolen_size = MB(128);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_160M:
+                        stolen_size = MB(160);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_192M:
+                        stolen_size = MB(192);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_224M:
+                        stolen_size = MB(224);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_256M:
+                        stolen_size = MB(256);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_288M:
+                        stolen_size = MB(288);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_320M:
+                        stolen_size = MB(320);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_352M:
+                        stolen_size = MB(352);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_384M:
+                        stolen_size = MB(384);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_416M:
+                        stolen_size = MB(416);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_448M:
+                        stolen_size = MB(448);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_480M:
+                        stolen_size = MB(480);
+                        break;
+                case SNB_GMCH_GMS_STOLEN_512M:
+                        stolen_size = MB(512);
+                        break;
+                }
        } else {
                switch (gmch_ctrl & I855_GMCH_GMS_MASK) {
                case I855_GMCH_GMS_STOLEN_1M:
@@ -500,9 +565,29 @@ static unsigned int i965_gtt_total_entries(void)
 static unsigned int intel_gtt_total_entries(void)
 {
+        int size;
        if (IS_G33 || INTEL_GTT_GEN == 4 || INTEL_GTT_GEN == 5)
                return i965_gtt_total_entries();
-        else {
+        else if (INTEL_GTT_GEN == 6) {
+                u16 snb_gmch_ctl;
+                pci_read_config_word(intel_private.pcidev, SNB_GMCH_CTRL, &snb_gmch_ctl);
+                switch (snb_gmch_ctl & SNB_GTT_SIZE_MASK) {
+                default:
+                case SNB_GTT_SIZE_0M:
+                        printk(KERN_ERR "Bad GTT size mask: 0x%04x.\n", snb_gmch_ctl);
+                        size = MB(0);
+                        break;
+                case SNB_GTT_SIZE_1M:
+                        size = MB(1);
+                        break;
+                case SNB_GTT_SIZE_2M:
+                        size = MB(2);
+                        break;
+                }
+                return size/4;
+        } else {
                /* On previous hardware, the GTT size was just what was
                 * required to map the aperture.
                 */
@@ -546,7 +631,7 @@ static unsigned int intel_gtt_mappable_entries(void)
 static void intel_gtt_teardown_scratch_page(void)
 {
        set_pages_wb(intel_private.scratch_page, 1);
-        pci_unmap_page(intel_private.pcidev, intel_private.base.scratch_page_dma,
+        pci_unmap_page(intel_private.pcidev, intel_private.scratch_page_dma,
                       PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
        put_page(intel_private.scratch_page);
        __free_page(intel_private.scratch_page);
@@ -564,7 +649,6 @@ static void intel_gtt_cleanup(void)
 static int intel_gtt_init(void)
 {
-        u32 gma_addr;
        u32 gtt_map_size;
        int ret;
@@ -590,19 +674,13 @@ static int intel_gtt_init(void)
        gtt_map_size = intel_private.base.gtt_total_entries * 4;
-        intel_private.gtt = NULL;
+        intel_private.gtt = ioremap(intel_private.gtt_bus_addr,
-        if (INTEL_GTT_GEN < 6 && INTEL_GTT_GEN > 2)
+                                    gtt_map_size);
-                intel_private.gtt = ioremap_wc(intel_private.gtt_bus_addr,
+        if (!intel_private.gtt) {
-                                               gtt_map_size);
-        if (intel_private.gtt == NULL)
-                intel_private.gtt = ioremap(intel_private.gtt_bus_addr,
-                                            gtt_map_size);
-        if (intel_private.gtt == NULL) {
                intel_private.driver->cleanup();
                iounmap(intel_private.registers);
                return -ENOMEM;
        }
-        intel_private.base.gtt = intel_private.gtt;
        global_cache_flush();   /* FIXME: ? */
@@ -616,15 +694,6 @@ static int intel_gtt_init(void)
                return ret;
        }
-        if (INTEL_GTT_GEN <= 2)
-                pci_read_config_dword(intel_private.pcidev, I810_GMADDR,
-                                      &gma_addr);
-        else
-                pci_read_config_dword(intel_private.pcidev, I915_GMADDR,
-                                      &gma_addr);
-        intel_private.base.gma_bus_addr = (gma_addr & PCI_BASE_ADDRESS_MEM_MASK);
        return 0;
 }
@@ -698,10 +767,23 @@ static void i830_write_entry(dma_addr_t addr, unsigned int entry,
        writel(addr | pte_flags, intel_private.gtt + entry);
 }
-bool intel_enable_gtt(void)
+static bool intel_enable_gtt(void)
 {
+        u32 gma_addr;
        u8 __iomem *reg;
+        if (INTEL_GTT_GEN <= 2)
+                pci_read_config_dword(intel_private.pcidev, I810_GMADDR,
+                                      &gma_addr);
+        else
+                pci_read_config_dword(intel_private.pcidev, I915_GMADDR,
+                                      &gma_addr);
+        intel_private.gma_bus_addr = (gma_addr & PCI_BASE_ADDRESS_MEM_MASK);
+        if (INTEL_GTT_GEN >= 6)
+            return true;
        if (INTEL_GTT_GEN == 2) {
                u16 gmch_ctrl;
@@ -741,7 +823,6 @@ bool intel_enable_gtt(void)
        return true;
 }
-EXPORT_SYMBOL(intel_enable_gtt);
 static int i830_setup(void)
 {
@@ -779,7 +860,7 @@ static int intel_fake_agp_configure(void)
            return -EIO;
        intel_private.clear_fake_agp = true;
-        agp_bridge->gart_bus_addr = intel_private.base.gma_bus_addr;
+        agp_bridge->gart_bus_addr = intel_private.gma_bus_addr;
        return 0;
 }
@@ -797,7 +878,8 @@ static bool i830_check_flags(unsigned int flags)
        return false;
 }
-void intel_gtt_insert_sg_entries(struct sg_table *st,
+void intel_gtt_insert_sg_entries(struct scatterlist *sg_list,
+                                 unsigned int sg_len,
                                 unsigned int pg_start,
                                 unsigned int flags)
 {
@@ -809,11 +891,12 @@ void intel_gtt_insert_sg_entries(struct sg_table *st,
        /* sg may merge pages, but we have to separate
         * per-page addr for GTT */
-        for_each_sg(st->sgl, sg, st->nents, i) {
+        for_each_sg(sg_list, sg, sg_len, i) {
                len = sg_dma_len(sg) >> PAGE_SHIFT;
                for (m = 0; m < len; m++) {
                        dma_addr_t addr = sg_dma_address(sg) + (m << PAGE_SHIFT);
-                        intel_private.driver->write_entry(addr, j, flags);
+                        intel_private.driver->write_entry(addr,
+                                                          j, flags);
                        j++;
                }
        }
@@ -821,10 +904,8 @@ void intel_gtt_insert_sg_entries(struct sg_table *st,
 }
 EXPORT_SYMBOL(intel_gtt_insert_sg_entries);
-static void intel_gtt_insert_pages(unsigned int first_entry,
+void intel_gtt_insert_pages(unsigned int first_entry, unsigned int num_entries,
-                                   unsigned int num_entries,
+                            struct page **pages, unsigned int flags)
-                                   struct page **pages,
-                                   unsigned int flags)
 {
        int i, j;
@@ -835,15 +916,13 @@ static void intel_gtt_insert_pages(unsigned int first_entry,
        }
        readl(intel_private.gtt+j-1);
 }
+EXPORT_SYMBOL(intel_gtt_insert_pages);
 static int intel_fake_agp_insert_entries(struct agp_memory *mem,
                                         off_t pg_start, int type)
 {
        int ret = -EINVAL;
-        if (intel_private.base.do_idle_maps)
-                return -ENODEV;
        if (intel_private.clear_fake_agp) {
                int start = intel_private.base.stolen_size / PAGE_SIZE;
                int end = intel_private.base.gtt_mappable_entries;
@@ -870,15 +949,13 @@ static int intel_fake_agp_insert_entries(struct agp_memory *mem,
                global_cache_flush();
        if (intel_private.base.needs_dmar) {
-                struct sg_table st;
+                ret = intel_gtt_map_memory(mem->pages, mem->page_count,
+                                           &mem->sg_list, &mem->num_sg);
-                ret = intel_gtt_map_memory(mem->pages, mem->page_count, &st);
                if (ret != 0)
                        return ret;
-                intel_gtt_insert_sg_entries(&st, pg_start, type);
+                intel_gtt_insert_sg_entries(mem->sg_list, mem->num_sg,
-                mem->sg_list = st.sgl;
+                                            pg_start, type);
-                mem->num_sg = st.nents;
        } else
                intel_gtt_insert_pages(pg_start, mem->page_count, mem->pages,
                                       type);
@@ -895,7 +972,7 @@ void intel_gtt_clear_range(unsigned int first_entry, unsigned int num_entries)
        unsigned int i;
        for (i = first_entry; i < (first_entry + num_entries); i++) {
-                intel_private.driver->write_entry(intel_private.base.scratch_page_dma,
+                intel_private.driver->write_entry(intel_private.scratch_page_dma,
                                                  i, 0);
        }
        readl(intel_private.gtt+i-1);
@@ -908,9 +985,6 @@ static int intel_fake_agp_remove_entries(struct agp_memory *mem,
        if (mem->page_count == 0)
                return 0;
-        if (intel_private.base.do_idle_maps)
-                return -ENODEV;
        intel_gtt_clear_range(pg_start, mem->page_count);
        if (intel_private.base.needs_dmar) {
@@ -1070,54 +1144,72 @@ static void i965_write_entry(dma_addr_t addr,
        writel(addr | pte_flags, intel_private.gtt + entry);
 }
-/* Certain Gen5 chipsets require require idling the GPU before
+static bool gen6_check_flags(unsigned int flags)
- * unmapping anything from the GTT when VT-d is enabled.
- */
-static inline int needs_idle_maps(void)
 {
-#ifdef CONFIG_INTEL_IOMMU
+        return true;
-        const unsigned short gpu_devid = intel_private.pcidev->device;
+}
-        /* Query intel_iommu to see if we need the workaround. Presumably that
+static void gen6_write_entry(dma_addr_t addr, unsigned int entry,
-         * was loaded first.
+                             unsigned int flags)
-         */
+{
-        if ((gpu_devid == PCI_DEVICE_ID_INTEL_IRONLAKE_M_HB ||
+        unsigned int type_mask = flags & ~AGP_USER_CACHED_MEMORY_GFDT;
-             gpu_devid == PCI_DEVICE_ID_INTEL_IRONLAKE_M_IG) &&
+        unsigned int gfdt = flags & AGP_USER_CACHED_MEMORY_GFDT;
-             intel_iommu_gfx_mapped)
+        u32 pte_flags;
-                return 1;
-#endif
+        if (type_mask == AGP_USER_MEMORY)
-        return 0;
+                pte_flags = GEN6_PTE_UNCACHED | I810_PTE_VALID;
+        else if (type_mask == AGP_USER_CACHED_MEMORY_LLC_MLC) {
+                pte_flags = GEN6_PTE_LLC_MLC | I810_PTE_VALID;
+                if (gfdt)
+                        pte_flags |= GEN6_PTE_GFDT;
+        } else { /* set 'normal'/'cached' to LLC by default */
+                pte_flags = GEN6_PTE_LLC | I810_PTE_VALID;
+                if (gfdt)
+                        pte_flags |= GEN6_PTE_GFDT;
+        }
+        /* gen6 has bit11-4 for physical addr bit39-32 */
+        addr |= (addr >> 28) & 0xff0;
+        writel(addr | pte_flags, intel_private.gtt + entry);
+}
+static void gen6_cleanup(void)
+{
 }
 static int i9xx_setup(void)
 {
-        u32 reg_addr, gtt_addr;
+        u32 reg_addr;
-        int size = KB(512);
        pci_read_config_dword(intel_private.pcidev, I915_MMADDR, &reg_addr);
        reg_addr &= 0xfff80000;
-        intel_private.registers = ioremap(reg_addr, size);
+        intel_private.registers = ioremap(reg_addr, 128 * 4096);
        if (!intel_private.registers)
                return -ENOMEM;
-        switch (INTEL_GTT_GEN) {
+        if (INTEL_GTT_GEN == 3) {
-        case 3:
+                u32 gtt_addr;
                pci_read_config_dword(intel_private.pcidev,
                                      I915_PTEADDR, &gtt_addr);
                intel_private.gtt_bus_addr = gtt_addr;
-                break;
+        } else {
-        case 5:
+                u32 gtt_offset;
-                intel_private.gtt_bus_addr = reg_addr + MB(2);
-                break;
-        default:
-                intel_private.gtt_bus_addr = reg_addr + KB(512);
-                break;
-        }
-        if (needs_idle_maps())
+                switch (INTEL_GTT_GEN) {
-                intel_private.base.do_idle_maps = 1;
+                case 5:
+                case 6:
+                        gtt_offset = MB(2);
+                        break;
+                case 4:
+                default:
+                        gtt_offset =  KB(512);
+                        break;
+                }
+                intel_private.gtt_bus_addr = reg_addr + gtt_offset;
+        }
        intel_i9xx_setup_flush();
@@ -1225,6 +1317,15 @@ static const struct intel_gtt_driver ironlake_gtt_driver = {
        .check_flags = i830_check_flags,
        .chipset_flush = i9xx_chipset_flush,
 };
+static const struct intel_gtt_driver sandybridge_gtt_driver = {
+        .gen = 6,
+        .setup = i9xx_setup,
+        .cleanup = gen6_cleanup,
+        .write_entry = gen6_write_entry,
+        .dma_mask_size = 40,
+        .check_flags = gen6_check_flags,
+        .chipset_flush = i9xx_chipset_flush,
+};
 /* Table to describe Intel GMCH and AGP/PCIE GART drivers.  At least one of
 * driver and gmch_driver must be non-null, and find_gmch will determine
@@ -1305,6 +1406,30 @@ static const struct intel_gtt_driver_description {
            "HD Graphics", &ironlake_gtt_driver },
        { PCI_DEVICE_ID_INTEL_IRONLAKE_M_IG,
            "HD Graphics", &ironlake_gtt_driver },
+        { PCI_DEVICE_ID_INTEL_SANDYBRIDGE_GT1_IG,
+            "Sandybridge", &sandybridge_gtt_driver },
+        { PCI_DEVICE_ID_INTEL_SANDYBRIDGE_GT2_IG,
+            "Sandybridge", &sandybridge_gtt_driver },
+        { PCI_DEVICE_ID_INTEL_SANDYBRIDGE_GT2_PLUS_IG,
+            "Sandybridge", &sandybridge_gtt_driver },
+        { PCI_DEVICE_ID_INTEL_SANDYBRIDGE_M_GT1_IG,
+            "Sandybridge", &sandybridge_gtt_driver },
+        { PCI_DEVICE_ID_INTEL_SANDYBRIDGE_M_GT2_IG,
+            "Sandybridge", &sandybridge_gtt_driver },
+        { PCI_DEVICE_ID_INTEL_SANDYBRIDGE_M_GT2_PLUS_IG,
+            "Sandybridge", &sandybridge_gtt_driver },
+        { PCI_DEVICE_ID_INTEL_SANDYBRIDGE_S_IG,
+            "Sandybridge", &sandybridge_gtt_driver },
+        { PCI_DEVICE_ID_INTEL_IVYBRIDGE_GT1_IG,
+            "Ivybridge", &sandybridge_gtt_driver },
+        { PCI_DEVICE_ID_INTEL_IVYBRIDGE_GT2_IG,
+            "Ivybridge", &sandybridge_gtt_driver },
+        { PCI_DEVICE_ID_INTEL_IVYBRIDGE_M_GT1_IG,
+            "Ivybridge", &sandybridge_gtt_driver },
+        { PCI_DEVICE_ID_INTEL_IVYBRIDGE_M_GT2_IG,
+            "Ivybridge", &sandybridge_gtt_driver },
+        { PCI_DEVICE_ID_INTEL_IVYBRIDGE_S_GT1_IG,
+            "Ivybridge", &sandybridge_gtt_driver },
        { 0, NULL, NULL }
 };
@@ -1325,32 +1450,14 @@ static int find_gmch(u16 device)
        return 1;
 }
-int intel_gmch_probe(struct pci_dev *bridge_pdev, struct pci_dev *gpu_pdev,
+int intel_gmch_probe(struct pci_dev *pdev,
-                     struct agp_bridge_data *bridge)
+                                      struct agp_bridge_data *bridge)
 {
        int i, mask;
+        intel_private.driver = NULL;
-        /*
-         * Can be called from the fake agp driver but also directly from
-         * drm/i915.ko. Hence we need to check whether everything is set up
-         * already.
-         */
-        if (intel_private.driver) {
-                intel_private.refcount++;
-                return 1;
-        }
        for (i = 0; intel_gtt_chipsets[i].name != NULL; i++) {
-                if (gpu_pdev) {
+                if (find_gmch(intel_gtt_chipsets[i].gmch_chip_id)) {
-                        if (gpu_pdev->device ==
-                            intel_gtt_chipsets[i].gmch_chip_id) {
-                                intel_private.pcidev = pci_dev_get(gpu_pdev);
-                                intel_private.driver =
-                                        intel_gtt_chipsets[i].gtt_driver;
-                                break;
-                        }
-                } else if (find_gmch(intel_gtt_chipsets[i].gmch_chip_id)) {
                        intel_private.driver =
                                intel_gtt_chipsets[i].gtt_driver;
                        break;
@@ -1360,17 +1467,13 @@ int intel_gmch_probe(struct pci_dev *bridge_pdev, struct pci_dev *gpu_pdev,
        if (!intel_private.driver)
                return 0;
-        intel_private.refcount++;
+        bridge->driver = &intel_fake_agp_driver;
+        bridge->dev_private_data = &intel_private;
+        bridge->dev = pdev;
-        if (bridge) {
+        intel_private.bridge_dev = pci_dev_get(pdev);
-                bridge->driver = &intel_fake_agp_driver;
-                bridge->dev_private_data = &intel_private;
-                bridge->dev = bridge_pdev;
-        }
-        intel_private.bridge_dev = pci_dev_get(bridge_pdev);
-        dev_info(&bridge_pdev->dev, "Intel %s Chipset\n", intel_gtt_chipsets[i].name);
+        dev_info(&pdev->dev, "Intel %s Chipset\n", intel_gtt_chipsets[i].name);
        mask = intel_private.driver->dma_mask_size;
        if (pci_set_dma_mask(intel_private.pcidev, DMA_BIT_MASK(mask)))
@@ -1380,17 +1483,17 @@ int intel_gmch_probe(struct pci_dev *bridge_pdev, struct pci_dev *gpu_pdev,
                pci_set_consistent_dma_mask(intel_private.pcidev,
                                            DMA_BIT_MASK(mask));
-        if (intel_gtt_init() != 0) {
+        /*if (bridge->driver == &intel_810_driver)
-                intel_gmch_remove();
+                return 1;*/
+        if (intel_gtt_init() != 0)
                return 0;
-        }
        return 1;
 }
 EXPORT_SYMBOL(intel_gmch_probe);
-struct intel_gtt *intel_gtt_get(void)
+const struct intel_gtt *intel_gtt_get(void)
 {
        return &intel_private.base;
 }
@@ -1403,16 +1506,12 @@ void intel_gtt_chipset_flush(void)
 }
 EXPORT_SYMBOL(intel_gtt_chipset_flush);
-void intel_gmch_remove(void)
+void intel_gmch_remove(struct pci_dev *pdev)
 {
-        if (--intel_private.refcount)
-                return;
        if (intel_private.pcidev)
                pci_dev_put(intel_private.pcidev);
        if (intel_private.bridge_dev)
                pci_dev_put(intel_private.bridge_dev);
-        intel_private.driver = NULL;
 }
 EXPORT_SYMBOL(intel_gmch_remove);
diff --git a/drivers/char/agp/nvidia-agp.c b/drivers/char/agp/nvidia-agp.c
index 62be3ec0da4..b9734a97818 100644
--- a/drivers/char/agp/nvidia-agp.c
+++ b/drivers/char/agp/nvidia-agp.c
@@ -332,8 +332,8 @@ static const struct agp_bridge_driver nvidia_driver = {
        .agp_type_to_mask_type  = agp_generic_type_to_mask_type,
 };
-static int agp_nvidia_probe(struct pci_dev *pdev,
+static int __devinit agp_nvidia_probe(struct pci_dev *pdev,
-                            const struct pci_device_id *ent)
+                                      const struct pci_device_id *ent)
 {
        struct agp_bridge_data *bridge;
        u8 cap_ptr;
@@ -388,7 +388,7 @@ static int agp_nvidia_probe(struct pci_dev *pdev,
        return agp_add_bridge(bridge);
 }
-static void agp_nvidia_remove(struct pci_dev *pdev)
+static void __devexit agp_nvidia_remove(struct pci_dev *pdev)
 {
        struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
diff --git a/drivers/char/agp/sgi-agp.c b/drivers/char/agp/sgi-agp.c
index 05b8d0241bd..ffa888cd1c8 100644
--- a/drivers/char/agp/sgi-agp.c
+++ b/drivers/char/agp/sgi-agp.c
@@ -158,6 +158,7 @@ static int sgi_tioca_insert_memory(struct agp_memory *mem, off_t pg_start,
                break;
        case LVL2_APER_SIZE:
                return -EINVAL;
+                break;
        default:
                num_entries = 0;
                break;
@@ -270,7 +271,7 @@ const struct agp_bridge_driver sgi_tioca_driver = {
        .num_aperture_sizes = 1,
 };
-static int agp_sgi_init(void)
+static int __devinit agp_sgi_init(void)
 {
        unsigned int j;
        struct tioca_kernel *info;
@@ -289,11 +290,12 @@ static int agp_sgi_init(void)
        j = 0;
        list_for_each_entry(info, &tioca_list, ca_list) {
+                struct list_head *tmp;
                if (list_empty(info->ca_devices))
                        continue;
-                list_for_each_entry(pdev, info->ca_devices, bus_list) {
+                list_for_each(tmp, info->ca_devices) {
                        u8 cap_ptr;
+                        pdev = pci_dev_b(tmp);
                        if (pdev->class != (PCI_CLASS_DISPLAY_VGA << 8))
                                continue;
                        cap_ptr = pci_find_capability(pdev, PCI_CAP_ID_AGP);
@@ -327,7 +329,7 @@ static int agp_sgi_init(void)
        return 0;
 }
-static void agp_sgi_cleanup(void)
+static void __devexit agp_sgi_cleanup(void)
 {
        kfree(sgi_tioca_agp_bridges);
        sgi_tioca_agp_bridges = NULL;
diff --git a/drivers/char/agp/sis-agp.c b/drivers/char/agp/sis-agp.c
index 79c838c434b..29aacd81de7 100644
--- a/drivers/char/agp/sis-agp.c
+++ b/drivers/char/agp/sis-agp.c
@@ -17,8 +17,8 @@
 #define PCI_DEVICE_ID_SI_662    0x0662
 #define PCI_DEVICE_ID_SI_671    0x0671
-static bool agp_sis_force_delay = 0;
+static int __devinitdata agp_sis_force_delay = 0;
-static int agp_sis_agp_spec = -1;
+static int __devinitdata agp_sis_agp_spec = -1;
 static int sis_fetch_size(void)
 {
@@ -148,13 +148,13 @@ static struct agp_bridge_driver sis_driver = {
 };
 // chipsets that require the 'delay hack'
-static int sis_broken_chipsets[] = {
+static int sis_broken_chipsets[] __devinitdata = {
        PCI_DEVICE_ID_SI_648,
        PCI_DEVICE_ID_SI_746,
        0 // terminator
 };
-static void sis_get_driver(struct agp_bridge_data *bridge)
+static void __devinit sis_get_driver(struct agp_bridge_data *bridge)
 {
        int i;
@@ -180,7 +180,8 @@ static void sis_get_driver(struct agp_bridge_data *bridge)
 }
-static int agp_sis_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
+static int __devinit agp_sis_probe(struct pci_dev *pdev,
+                                   const struct pci_device_id *ent)
 {
        struct agp_bridge_data *bridge;
        u8 cap_ptr;
@@ -210,7 +211,7 @@ static int agp_sis_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        return agp_add_bridge(bridge);
 }
-static void agp_sis_remove(struct pci_dev *pdev)
+static void __devexit agp_sis_remove(struct pci_dev *pdev)
 {
        struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
diff --git a/drivers/char/agp/sworks-agp.c b/drivers/char/agp/sworks-agp.c
index 9b163b49d97..f02f9b07fd4 100644
--- a/drivers/char/agp/sworks-agp.c
+++ b/drivers/char/agp/sworks-agp.c
@@ -445,8 +445,8 @@ static const struct agp_bridge_driver sworks_driver = {
        .agp_type_to_mask_type  = agp_generic_type_to_mask_type,
 };
-static int agp_serverworks_probe(struct pci_dev *pdev,
+static int __devinit agp_serverworks_probe(struct pci_dev *pdev,
-                                 const struct pci_device_id *ent)
+                                           const struct pci_device_id *ent)
 {
        struct agp_bridge_data *bridge;
        struct pci_dev *bridge_dev;
@@ -518,7 +518,7 @@ static int agp_serverworks_probe(struct pci_dev *pdev,
        return agp_add_bridge(bridge);
 }
-static void agp_serverworks_remove(struct pci_dev *pdev)
+static void __devexit agp_serverworks_remove(struct pci_dev *pdev)
 {
        struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
diff --git a/drivers/char/agp/uninorth-agp.c b/drivers/char/agp/uninorth-agp.c
index a56ee9bedd1..a32c492baf5 100644
--- a/drivers/char/agp/uninorth-agp.c
+++ b/drivers/char/agp/uninorth-agp.c
@@ -557,7 +557,7 @@ const struct agp_bridge_driver u3_agp_driver = {
        .needs_scratch_page     = true,
 };
-static struct agp_device_ids uninorth_agp_device_ids[] = {
+static struct agp_device_ids uninorth_agp_device_ids[] __devinitdata = {
        {
                .device_id      = PCI_DEVICE_ID_APPLE_UNI_N_AGP,
                .chipset_name   = "UniNorth",
@@ -592,8 +592,8 @@ static struct agp_device_ids uninorth_agp_device_ids[] = {
        },
 };
-static int agp_uninorth_probe(struct pci_dev *pdev,
+static int __devinit agp_uninorth_probe(struct pci_dev *pdev,
-                              const struct pci_device_id *ent)
+                                        const struct pci_device_id *ent)
 {
        struct agp_device_ids *devs = uninorth_agp_device_ids;
        struct agp_bridge_data *bridge;
@@ -663,7 +663,7 @@ static int agp_uninorth_probe(struct pci_dev *pdev,
        return agp_add_bridge(bridge);
 }
-static void agp_uninorth_remove(struct pci_dev *pdev)
+static void __devexit agp_uninorth_remove(struct pci_dev *pdev)
 {
        struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
diff --git a/drivers/char/agp/via-agp.c b/drivers/char/agp/via-agp.c
index 74d3aa3773b..8bc38493740 100644
--- a/drivers/char/agp/via-agp.c
+++ b/drivers/char/agp/via-agp.c
@@ -224,7 +224,7 @@ static const struct agp_bridge_driver via_driver = {
        .agp_type_to_mask_type  = agp_generic_type_to_mask_type,
 };
-static struct agp_device_ids via_agp_device_ids[] =
+static struct agp_device_ids via_agp_device_ids[] __devinitdata =
 {
        {
                .device_id      = PCI_DEVICE_ID_VIA_82C597_0,
@@ -438,7 +438,8 @@ static void check_via_agp3 (struct agp_bridge_data *bridge)
 }
-static int agp_via_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
+static int __devinit agp_via_probe(struct pci_dev *pdev,
+                                   const struct pci_device_id *ent)
 {
        struct agp_device_ids *devs = via_agp_device_ids;
        struct agp_bridge_data *bridge;
@@ -484,7 +485,7 @@ static int agp_via_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        return agp_add_bridge(bridge);
 }
-static void agp_via_remove(struct pci_dev *pdev)
+static void __devexit agp_via_remove(struct pci_dev *pdev)
 {
        struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
diff --git a/drivers/char/apm-emulation.c b/drivers/char/apm-emulation.c
index 46118f84594..a7346ab97a3 100644
--- a/drivers/char/apm-emulation.c
+++ b/drivers/char/apm-emulation.c
@@ -31,6 +31,7 @@
 #include <linux/kthread.h>
 #include <linux/delay.h>
+#include <asm/system.h>
 /*
 * The apm_bios device is one of the misc char devices.
@@ -39,7 +40,10 @@
 #define APM_MINOR_DEV   134
 /*
- * One option can be changed at boot time as follows:
+ * See Documentation/Config.help for the configuration options.
+ *
+ * Various options can be changed at boot time as follows:
+ * (We allow underscores for compatibility with the modules code)
 *      apm=on/off                      enable/disable APM
 */
@@ -296,13 +300,17 @@ apm_ioctl(struct file *filp, u_int cmd, u_long arg)
                        /*
                         * Wait for the suspend/resume to complete.  If there
                         * are pending acknowledges, we wait here for them.
-                         * wait_event_freezable() is interruptible and pending
-                         * signal can cause busy looping.  We aren't doing
-                         * anything critical, chill a bit on each iteration.
                         */
-                        while (wait_event_freezable(apm_suspend_waitqueue,
+                        freezer_do_not_count();
-                                        as->suspend_state != SUSPEND_ACKED))
-                                msleep(10);
+                        wait_event(apm_suspend_waitqueue,
+                                   as->suspend_state == SUSPEND_DONE);
+                        /*
+                         * Since we are waiting until the suspend is done, the
+                         * try_to_freeze() in freezer_count() will not trigger
+                         */
+                        freezer_count();
                        break;
                case SUSPEND_ACKTO:
                        as->suspend_result = -ETIMEDOUT;
diff --git a/drivers/char/bsr.c b/drivers/char/bsr.c
index 97467053a01..0c688232aab 100644
--- a/drivers/char/bsr.c
+++ b/drivers/char/bsr.c
@@ -297,6 +297,7 @@ static int __init bsr_init(void)
        struct device_node *np;
        dev_t bsr_dev;
        int ret = -ENODEV;
+        int result;
        np = of_find_compatible_node(NULL, NULL, "ibm,bsr");
        if (!np)
@@ -305,14 +306,13 @@ static int __init bsr_init(void)
        bsr_class = class_create(THIS_MODULE, "bsr");
        if (IS_ERR(bsr_class)) {
                printk(KERN_ERR "class_create() failed for bsr_class\n");
-                ret = PTR_ERR(bsr_class);
                goto out_err_1;
        }
        bsr_class->dev_attrs = bsr_dev_attrs;
-        ret = alloc_chrdev_region(&bsr_dev, 0, BSR_MAX_DEVS, "bsr");
+        result = alloc_chrdev_region(&bsr_dev, 0, BSR_MAX_DEVS, "bsr");
        bsr_major = MAJOR(bsr_dev);
-        if (ret < 0) {
+        if (result < 0) {
                printk(KERN_ERR "alloc_chrdev_region() failed for bsr\n");
                goto out_err_2;
        }
diff --git a/drivers/char/ds1302.c b/drivers/char/ds1302.c
index 7d34b203718..ed8303f9890 100644
--- a/drivers/char/ds1302.c
+++ b/drivers/char/ds1302.c
@@ -24,6 +24,7 @@
 #include <linux/uaccess.h>
 #include <linux/io.h>
+#include <asm/system.h>
 #include <asm/rtc.h>
 #if defined(CONFIG_M32R)
 #include <asm/m32r.h>
diff --git a/drivers/char/ds1620.c b/drivers/char/ds1620.c
index 24ffd8cec51..aab9605f0b4 100644
--- a/drivers/char/ds1620.c
+++ b/drivers/char/ds1620.c
@@ -74,21 +74,21 @@ static inline void netwinder_ds1620_reset(void)
 static inline void netwinder_lock(unsigned long *flags)
 {
-        raw_spin_lock_irqsave(&nw_gpio_lock, *flags);
+        spin_lock_irqsave(&nw_gpio_lock, *flags);
 }
 static inline void netwinder_unlock(unsigned long *flags)
 {
-        raw_spin_unlock_irqrestore(&nw_gpio_lock, *flags);
+        spin_unlock_irqrestore(&nw_gpio_lock, *flags);
 }
 static inline void netwinder_set_fan(int i)
 {
        unsigned long flags;
-        raw_spin_lock_irqsave(&nw_gpio_lock, flags);
+        spin_lock_irqsave(&nw_gpio_lock, flags);
        nw_gpio_modify_op(GPIO_FAN, i ? GPIO_FAN : 0);
-        raw_spin_unlock_irqrestore(&nw_gpio_lock, flags);
+        spin_unlock_irqrestore(&nw_gpio_lock, flags);
 }
 static inline int netwinder_get_fan(void)
diff --git a/drivers/char/efirtc.c b/drivers/char/efirtc.c
index a082d00b0f1..53c524e7b82 100644
--- a/drivers/char/efirtc.c
+++ b/drivers/char/efirtc.c
@@ -37,6 +37,7 @@
 #include <linux/efi.h>
 #include <linux/uaccess.h>
+#include <asm/system.h>
 #define EFI_RTC_VERSION         "0.4"
diff --git a/drivers/char/genrtc.c b/drivers/char/genrtc.c
index 21cb980f115..f773a9dd14f 100644
--- a/drivers/char/genrtc.c
+++ b/drivers/char/genrtc.c
@@ -56,6 +56,7 @@
 #include <linux/workqueue.h>
 #include <asm/uaccess.h>
+#include <asm/system.h>
 #include <asm/rtc.h>
 /*
diff --git a/drivers/char/hpet.c b/drivers/char/hpet.c
index fe6d4be4829..0833896cf6f 100644
--- a/drivers/char/hpet.c
+++ b/drivers/char/hpet.c
@@ -36,6 +36,7 @@
 #include <linux/io.h>
 #include <asm/current.h>
+#include <asm/system.h>
 #include <asm/irq.h>
 #include <asm/div64.h>
@@ -816,7 +817,7 @@ static unsigned long __hpet_calibrate(struct hpets *hpetp)
 static unsigned long hpet_calibrate(struct hpets *hpetp)
 {
-        unsigned long ret = ~0UL;
+        unsigned long ret = -1;
        unsigned long tmp;
        /*
@@ -906,8 +907,8 @@ int hpet_alloc(struct hpet_data *hdp)
                hpetp->hp_which, hdp->hd_phys_address,
                hpetp->hp_ntimer > 1 ? "s" : "");
        for (i = 0; i < hpetp->hp_ntimer; i++)
-                printk(KERN_CONT "%s %d", i > 0 ? "," : "", hdp->hd_irq[i]);
+                printk("%s %d", i > 0 ? "," : "", hdp->hd_irq[i]);
-        printk(KERN_CONT "\n");
+        printk("\n");
        temp = hpetp->hp_tick_freq;
        remainder = do_div(temp, 1000000);
@@ -1001,9 +1002,6 @@ static acpi_status hpet_resources(struct acpi_resource *res, void *data)
                irqp = &res->data.extended_irq;
                for (i = 0; i < irqp->interrupt_count; i++) {
-                        if (hdp->hd_nirqs >= HPET_MAX_TIMERS)
-                                break;
                        irq = acpi_register_gsi(NULL, irqp->interrupts[i],
                                      irqp->triggering, irqp->polarity);
                        if (irq < 0)
diff --git a/drivers/char/hw_random/Kconfig b/drivers/char/hw_random/Kconfig
index c5a0262251b..1d2ebc7a494 100644
--- a/drivers/char/hw_random/Kconfig
+++ b/drivers/char/hw_random/Kconfig
@@ -60,33 +60,6 @@ config HW_RANDOM_AMD
          If unsure, say Y.
-config HW_RANDOM_ATMEL
-        tristate "Atmel Random Number Generator support"
-        depends on HW_RANDOM && HAVE_CLK
-        default (HW_RANDOM && ARCH_AT91)
-        ---help---
-          This driver provides kernel-side support for the Random Number
-          Generator hardware found on Atmel AT91 devices.
-          To compile this driver as a module, choose M here: the
-          module will be called atmel-rng.
-          If unsure, say Y.
-config HW_RANDOM_BCM63XX
-        tristate "Broadcom BCM63xx Random Number Generator support"
-        depends on HW_RANDOM && BCM63XX
-        default HW_RANDOM
-        ---help---
-          This driver provides kernel-side support for the Random Number
-          Generator hardware found on the Broadcom BCM63xx SoCs.
-          To compile this driver as a module, choose M here: the
-          module will be called bcm63xx-rng
-          If unusure, say Y.
 config HW_RANDOM_GEODE
        tristate "AMD Geode HW Random Number Generator support"
        depends on HW_RANDOM && X86_32 && PCI
@@ -127,12 +100,12 @@ config HW_RANDOM_VIA
          If unsure, say Y.
 config HW_RANDOM_IXP4XX
-        tristate "Intel IXP4xx NPU HW Pseudo-Random Number Generator support"
+        tristate "Intel IXP4xx NPU HW Random Number Generator support"
        depends on HW_RANDOM && ARCH_IXP4XX
        default HW_RANDOM
        ---help---
-          This driver provides kernel-side support for the Pseudo-Random
+          This driver provides kernel-side support for the Random
-          Number Generator hardware found on the Intel IXP45x/46x NPU.
+          Number Generator hardware found on the Intel IXP4xx NPU.
          To compile this driver as a module, choose M here: the
          module will be called ixp4xx-rng.
@@ -216,7 +189,7 @@ config HW_RANDOM_MXC_RNGA
 config HW_RANDOM_NOMADIK
        tristate "ST-Ericsson Nomadik Random Number Generator support"
-        depends on HW_RANDOM && ARCH_NOMADIK
+        depends on HW_RANDOM && PLAT_NOMADIK
        ---help---
          This driver provides kernel-side support for the Random Number
          Generator hardware found on ST-Ericsson SoCs (8815 and 8500).
@@ -249,56 +222,3 @@ config HW_RANDOM_PPC4XX
         module will be called ppc4xx-rng.
         If unsure, say N.
-config UML_RANDOM
-        depends on UML
-        tristate "Hardware random number generator"
-        help
-          This option enables UML's "hardware" random number generator.  It
-          attaches itself to the host's /dev/random, supplying as much entropy
-          as the host has, rather than the small amount the UML gets from its
-          own drivers.  It registers itself as a standard hardware random number
-          generator, major 10, minor 183, and the canonical device name is
-          /dev/hwrng.
-          The way to make use of this is to install the rng-tools package
-          (check your distro, or download from
-          http://sourceforge.net/projects/gkernel/).  rngd periodically reads
-          /dev/hwrng and injects the entropy into /dev/random.
-config HW_RANDOM_PSERIES
-        tristate "pSeries HW Random Number Generator support"
-        depends on HW_RANDOM && PPC64 && IBMVIO
-        default HW_RANDOM
-        ---help---
-          This driver provides kernel-side support for the Random Number
-          Generator hardware found on POWER7+ machines and above
-          To compile this driver as a module, choose M here: the
-          module will be called pseries-rng.
-          If unsure, say Y.
-config HW_RANDOM_EXYNOS
-        tristate "EXYNOS HW random number generator support"
-        depends on HW_RANDOM && HAS_IOMEM && HAVE_CLK
-        ---help---
-          This driver provides kernel-side support for the Random Number
-          Generator hardware found on EXYNOS SOCs.
-          To compile this driver as a module, choose M here: the
-          module will be called exynos-rng.
-          If unsure, say Y.
-config HW_RANDOM_TPM
-        tristate "TPM HW Random Number Generator support"
-        depends on HW_RANDOM && TCG_TPM
-        default HW_RANDOM
-        ---help---
-          This driver provides kernel-side support for the Random Number
-          Generator in the Trusted Platform Module
-          To compile this driver as a module, choose M here: the
-          module will be called tpm-rng.
-          If unsure, say Y.
diff --git a/drivers/char/hw_random/Makefile b/drivers/char/hw_random/Makefile
index 1fd7eec9fbf..c88f244c8a7 100644
--- a/drivers/char/hw_random/Makefile
+++ b/drivers/char/hw_random/Makefile
@@ -7,8 +7,6 @@ rng-core-y := core.o
 obj-$(CONFIG_HW_RANDOM_TIMERIOMEM) += timeriomem-rng.o
 obj-$(CONFIG_HW_RANDOM_INTEL) += intel-rng.o
 obj-$(CONFIG_HW_RANDOM_AMD) += amd-rng.o
-obj-$(CONFIG_HW_RANDOM_ATMEL) += atmel-rng.o
-obj-$(CONFIG_HW_RANDOM_BCM63XX) += bcm63xx-rng.o
 obj-$(CONFIG_HW_RANDOM_GEODE) += geode-rng.o
 obj-$(CONFIG_HW_RANDOM_N2RNG) += n2-rng.o
 n2-rng-y := n2-drv.o n2-asm.o
@@ -23,6 +21,3 @@ obj-$(CONFIG_HW_RANDOM_OCTEON) += octeon-rng.o
 obj-$(CONFIG_HW_RANDOM_NOMADIK) += nomadik-rng.o
 obj-$(CONFIG_HW_RANDOM_PICOXCELL) += picoxcell-rng.o
 obj-$(CONFIG_HW_RANDOM_PPC4XX) += ppc4xx-rng.o
-obj-$(CONFIG_HW_RANDOM_PSERIES) += pseries-rng.o
-obj-$(CONFIG_HW_RANDOM_EXYNOS)  += exynos-rng.o
-obj-$(CONFIG_HW_RANDOM_TPM) += tpm-rng.o
diff --git a/drivers/char/hw_random/atmel-rng.c b/drivers/char/hw_random/atmel-rng.c
deleted file mode 100644
index 7c73d4aca36..00000000000
--- a/drivers/char/hw_random/atmel-rng.c
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * Copyright (c) 2011 Peter Korsgaard <jacmet@sunsite.dk>
- *
- * This file is licensed under  the terms of the GNU General Public
- * License version 2. This program is licensed "as is" without any
- * warranty of any kind, whether express or implied.
- */
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/err.h>
-#include <linux/clk.h>
-#include <linux/io.h>
-#include <linux/hw_random.h>
-#include <linux/platform_device.h>
-#define TRNG_CR         0x00
-#define TRNG_ISR        0x1c
-#define TRNG_ODATA      0x50
-#define TRNG_KEY        0x524e4700 /* RNG */
-struct atmel_trng {
-        struct clk *clk;
-        void __iomem *base;
-        struct hwrng rng;
-};
-static int atmel_trng_read(struct hwrng *rng, void *buf, size_t max,
-                           bool wait)
-{
-        struct atmel_trng *trng = container_of(rng, struct atmel_trng, rng);
-        u32 *data = buf;
-        /* data ready? */
-        if (readl(trng->base + TRNG_ISR) & 1) {
-                *data = readl(trng->base + TRNG_ODATA);
-                /*
-                  ensure data ready is only set again AFTER the next data
-                  word is ready in case it got set between checking ISR
-                  and reading ODATA, so we don't risk re-reading the
-                  same word
-                */
-                readl(trng->base + TRNG_ISR);
-                return 4;
-        } else
-                return 0;
-}
-static int atmel_trng_probe(struct platform_device *pdev)
-{
-        struct atmel_trng *trng;
-        struct resource *res;
-        int ret;
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res)
-                return -EINVAL;
-        trng = devm_kzalloc(&pdev->dev, sizeof(*trng), GFP_KERNEL);
-        if (!trng)
-                return -ENOMEM;
-        if (!devm_request_mem_region(&pdev->dev, res->start,
-                                     resource_size(res), pdev->name))
-                return -EBUSY;
-        trng->base = devm_ioremap(&pdev->dev, res->start, resource_size(res));
-        if (!trng->base)
-                return -EBUSY;
-        trng->clk = clk_get(&pdev->dev, NULL);
-        if (IS_ERR(trng->clk))
-                return PTR_ERR(trng->clk);
-        ret = clk_enable(trng->clk);
-        if (ret)
-                goto err_enable;
-        writel(TRNG_KEY | 1, trng->base + TRNG_CR);
-        trng->rng.name = pdev->name;
-        trng->rng.read = atmel_trng_read;
-        ret = hwrng_register(&trng->rng);
-        if (ret)
-                goto err_register;
-        platform_set_drvdata(pdev, trng);
-        return 0;
-err_register:
-        clk_disable(trng->clk);
-err_enable:
-        clk_put(trng->clk);
-        return ret;
-}
-static int atmel_trng_remove(struct platform_device *pdev)
-{
-        struct atmel_trng *trng = platform_get_drvdata(pdev);
-        hwrng_unregister(&trng->rng);
-        writel(TRNG_KEY, trng->base + TRNG_CR);
-        clk_disable(trng->clk);
-        clk_put(trng->clk);
-        platform_set_drvdata(pdev, NULL);
-        return 0;
-}
-#ifdef CONFIG_PM
-static int atmel_trng_suspend(struct device *dev)
-{
-        struct atmel_trng *trng = dev_get_drvdata(dev);
-        clk_disable(trng->clk);
-        return 0;
-}
-static int atmel_trng_resume(struct device *dev)
-{
-        struct atmel_trng *trng = dev_get_drvdata(dev);
-        return clk_enable(trng->clk);
-}
-static const struct dev_pm_ops atmel_trng_pm_ops = {
-        .suspend        = atmel_trng_suspend,
-        .resume         = atmel_trng_resume,
-};
-#endif /* CONFIG_PM */
-static struct platform_driver atmel_trng_driver = {
-        .probe          = atmel_trng_probe,
-        .remove         = atmel_trng_remove,
-        .driver         = {
-                .name   = "atmel-trng",
-                .owner  = THIS_MODULE,
-#ifdef CONFIG_PM
-                .pm     = &atmel_trng_pm_ops,
-#endif /* CONFIG_PM */
-        },
-};
-module_platform_driver(atmel_trng_driver);
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Peter Korsgaard <jacmet@sunsite.dk>");
-MODULE_DESCRIPTION("Atmel true random number generator driver");
diff --git a/drivers/char/hw_random/bcm63xx-rng.c b/drivers/char/hw_random/bcm63xx-rng.c
deleted file mode 100644
index f343b7d0dfa..00000000000
--- a/drivers/char/hw_random/bcm63xx-rng.c
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * Broadcom BCM63xx Random Number Generator support
- *
- * Copyright (C) 2011, Florian Fainelli <florian@openwrt.org>
- * Copyright (C) 2009, Broadcom Corporation
- *
- */
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/io.h>
-#include <linux/err.h>
-#include <linux/clk.h>
-#include <linux/platform_device.h>
-#include <linux/hw_random.h>
-#include <bcm63xx_io.h>
-#include <bcm63xx_regs.h>
-struct bcm63xx_rng_priv {
-        struct clk *clk;
-        void __iomem *regs;
-};
-#define to_rng_priv(rng)        ((struct bcm63xx_rng_priv *)rng->priv)
-static int bcm63xx_rng_init(struct hwrng *rng)
-{
-        struct bcm63xx_rng_priv *priv = to_rng_priv(rng);
-        u32 val;
-        val = bcm_readl(priv->regs + RNG_CTRL);
-        val |= RNG_EN;
-        bcm_writel(val, priv->regs + RNG_CTRL);
-        return 0;
-}
-static void bcm63xx_rng_cleanup(struct hwrng *rng)
-{
-        struct bcm63xx_rng_priv *priv = to_rng_priv(rng);
-        u32 val;
-        val = bcm_readl(priv->regs + RNG_CTRL);
-        val &= ~RNG_EN;
-        bcm_writel(val, priv->regs + RNG_CTRL);
-}
-static int bcm63xx_rng_data_present(struct hwrng *rng, int wait)
-{
-        struct bcm63xx_rng_priv *priv = to_rng_priv(rng);
-        return bcm_readl(priv->regs + RNG_STAT) & RNG_AVAIL_MASK;
-}
-static int bcm63xx_rng_data_read(struct hwrng *rng, u32 *data)
-{
-        struct bcm63xx_rng_priv *priv = to_rng_priv(rng);
-        *data = bcm_readl(priv->regs + RNG_DATA);
-        return 4;
-}
-static int bcm63xx_rng_probe(struct platform_device *pdev)
-{
-        struct resource *r;
-        struct clk *clk;
-        int ret;
-        struct bcm63xx_rng_priv *priv;
-        struct hwrng *rng;
-        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!r) {
-                dev_err(&pdev->dev, "no iomem resource\n");
-                ret = -ENXIO;
-                goto out;
-        }
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv) {
-                dev_err(&pdev->dev, "no memory for private structure\n");
-                ret = -ENOMEM;
-                goto out;
-        }
-        rng = kzalloc(sizeof(*rng), GFP_KERNEL);
-        if (!rng) {
-                dev_err(&pdev->dev, "no memory for rng structure\n");
-                ret = -ENOMEM;
-                goto out_free_priv;
-        }
-        platform_set_drvdata(pdev, rng);
-        rng->priv = (unsigned long)priv;
-        rng->name = pdev->name;
-        rng->init = bcm63xx_rng_init;
-        rng->cleanup = bcm63xx_rng_cleanup;
-        rng->data_present = bcm63xx_rng_data_present;
-        rng->data_read = bcm63xx_rng_data_read;
-        clk = clk_get(&pdev->dev, "ipsec");
-        if (IS_ERR(clk)) {
-                dev_err(&pdev->dev, "no clock for device\n");
-                ret = PTR_ERR(clk);
-                goto out_free_rng;
-        }
-        priv->clk = clk;
-        if (!devm_request_mem_region(&pdev->dev, r->start,
-                                        resource_size(r), pdev->name)) {
-                dev_err(&pdev->dev, "request mem failed");
-                ret = -ENOMEM;
-                goto out_free_rng;
-        }
-        priv->regs = devm_ioremap_nocache(&pdev->dev, r->start,
-                                        resource_size(r));
-        if (!priv->regs) {
-                dev_err(&pdev->dev, "ioremap failed");
-                ret = -ENOMEM;
-                goto out_free_rng;
-        }
-        clk_enable(clk);
-        ret = hwrng_register(rng);
-        if (ret) {
-                dev_err(&pdev->dev, "failed to register rng device\n");
-                goto out_clk_disable;
-        }
-        dev_info(&pdev->dev, "registered RNG driver\n");
-        return 0;
-out_clk_disable:
-        clk_disable(clk);
-out_free_rng:
-        platform_set_drvdata(pdev, NULL);
-        kfree(rng);
-out_free_priv:
-        kfree(priv);
-out:
-        return ret;
-}
-static int bcm63xx_rng_remove(struct platform_device *pdev)
-{
-        struct hwrng *rng = platform_get_drvdata(pdev);
-        struct bcm63xx_rng_priv *priv = to_rng_priv(rng);
-        hwrng_unregister(rng);
-        clk_disable(priv->clk);
-        kfree(priv);
-        kfree(rng);
-        platform_set_drvdata(pdev, NULL);
-        return 0;
-}
-static struct platform_driver bcm63xx_rng_driver = {
-        .probe          = bcm63xx_rng_probe,
-        .remove         = bcm63xx_rng_remove,
-        .driver         = {
-                .name   = "bcm63xx-rng",
-                .owner  = THIS_MODULE,
-        },
-};
-module_platform_driver(bcm63xx_rng_driver);
-MODULE_AUTHOR("Florian Fainelli <florian@openwrt.org>");
-MODULE_DESCRIPTION("Broadcom BCM63xx RNG driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/char/hw_random/exynos-rng.c b/drivers/char/hw_random/exynos-rng.c
deleted file mode 100644
index 48bbfeca4b5..00000000000
--- a/drivers/char/hw_random/exynos-rng.c
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * exynos-rng.c - Random Number Generator driver for the exynos
- *
- * Copyright (C) 2012 Samsung Electronics
- * Jonghwa Lee <jonghwa3.lee@smasung.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation;
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- */
-#include <linux/hw_random.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/io.h>
-#include <linux/platform_device.h>
-#include <linux/clk.h>
-#include <linux/pm_runtime.h>
-#include <linux/err.h>
-#define EXYNOS_PRNG_STATUS_OFFSET       0x10
-#define EXYNOS_PRNG_SEED_OFFSET         0x140
-#define EXYNOS_PRNG_OUT1_OFFSET         0x160
-#define SEED_SETTING_DONE               BIT(1)
-#define PRNG_START                      0x18
-#define PRNG_DONE                       BIT(5)
-#define EXYNOS_AUTOSUSPEND_DELAY        100
-struct exynos_rng {
-        struct device *dev;
-        struct hwrng rng;
-        void __iomem *mem;
-        struct clk *clk;
-};
-static u32 exynos_rng_readl(struct exynos_rng *rng, u32 offset)
-{
-        return  __raw_readl(rng->mem + offset);
-}
-static void exynos_rng_writel(struct exynos_rng *rng, u32 val, u32 offset)
-{
-        __raw_writel(val, rng->mem + offset);
-}
-static int exynos_init(struct hwrng *rng)
-{
-        struct exynos_rng *exynos_rng = container_of(rng,
-                                                struct exynos_rng, rng);
-        int i;
-        int ret = 0;
-        pm_runtime_get_sync(exynos_rng->dev);
-        for (i = 0 ; i < 5 ; i++)
-                exynos_rng_writel(exynos_rng, jiffies,
-                                EXYNOS_PRNG_SEED_OFFSET + 4*i);
-        if (!(exynos_rng_readl(exynos_rng, EXYNOS_PRNG_STATUS_OFFSET)
-                                                 & SEED_SETTING_DONE))
-                ret = -EIO;
-        pm_runtime_put_noidle(exynos_rng->dev);
-        return ret;
-}
-static int exynos_read(struct hwrng *rng, void *buf,
-                                        size_t max, bool wait)
-{
-        struct exynos_rng *exynos_rng = container_of(rng,
-                                                struct exynos_rng, rng);
-        u32 *data = buf;
-        pm_runtime_get_sync(exynos_rng->dev);
-        exynos_rng_writel(exynos_rng, PRNG_START, 0);
-        while (!(exynos_rng_readl(exynos_rng,
-                        EXYNOS_PRNG_STATUS_OFFSET) & PRNG_DONE))
-                cpu_relax();
-        exynos_rng_writel(exynos_rng, PRNG_DONE, EXYNOS_PRNG_STATUS_OFFSET);
-        *data = exynos_rng_readl(exynos_rng, EXYNOS_PRNG_OUT1_OFFSET);
-        pm_runtime_mark_last_busy(exynos_rng->dev);
-        pm_runtime_autosuspend(exynos_rng->dev);
-        return 4;
-}
-static int exynos_rng_probe(struct platform_device *pdev)
-{
-        struct exynos_rng *exynos_rng;
-        exynos_rng = devm_kzalloc(&pdev->dev, sizeof(struct exynos_rng),
-                                        GFP_KERNEL);
-        if (!exynos_rng)
-                return -ENOMEM;
-        exynos_rng->dev = &pdev->dev;
-        exynos_rng->rng.name = "exynos";
-        exynos_rng->rng.init =  exynos_init;
-        exynos_rng->rng.read = exynos_read;
-        exynos_rng->clk = devm_clk_get(&pdev->dev, "secss");
-        if (IS_ERR(exynos_rng->clk)) {
-                dev_err(&pdev->dev, "Couldn't get clock.\n");
-                return -ENOENT;
-        }
-        exynos_rng->mem = devm_request_and_ioremap(&pdev->dev,
-                        platform_get_resource(pdev, IORESOURCE_MEM, 0));
-        if (!exynos_rng->mem)
-                return -EBUSY;
-        platform_set_drvdata(pdev, exynos_rng);
-        pm_runtime_set_autosuspend_delay(&pdev->dev, EXYNOS_AUTOSUSPEND_DELAY);
-        pm_runtime_use_autosuspend(&pdev->dev);
-        pm_runtime_enable(&pdev->dev);
-        return hwrng_register(&exynos_rng->rng);
-}
-static int exynos_rng_remove(struct platform_device *pdev)
-{
-        struct exynos_rng *exynos_rng = platform_get_drvdata(pdev);
-        hwrng_unregister(&exynos_rng->rng);
-        return 0;
-}
-static int exynos_rng_runtime_suspend(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct exynos_rng *exynos_rng = platform_get_drvdata(pdev);
-        clk_disable_unprepare(exynos_rng->clk);
-        return 0;
-}
-static int exynos_rng_runtime_resume(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct exynos_rng *exynos_rng = platform_get_drvdata(pdev);
-        return clk_prepare_enable(exynos_rng->clk);
-}
-UNIVERSAL_DEV_PM_OPS(exynos_rng_pm_ops, exynos_rng_runtime_suspend,
-                                        exynos_rng_runtime_resume, NULL);
-static struct platform_driver exynos_rng_driver = {
-        .driver         = {
-                .name   = "exynos-rng",
-                .owner  = THIS_MODULE,
-                .pm     = &exynos_rng_pm_ops,
-        },
-        .probe          = exynos_rng_probe,
-        .remove         = exynos_rng_remove,
-};
-module_platform_driver(exynos_rng_driver);
-MODULE_DESCRIPTION("EXYNOS 4 H/W Random Number Generator driver");
-MODULE_AUTHOR("Jonghwa Lee <jonghwa3.lee@samsung.com>");
-MODULE_LICENSE("GPL");
diff --git a/drivers/char/hw_random/ixp4xx-rng.c b/drivers/char/hw_random/ixp4xx-rng.c
index beec1627db3..263567f5f39 100644
--- a/drivers/char/hw_random/ixp4xx-rng.c
+++ b/drivers/char/hw_random/ixp4xx-rng.c
@@ -45,9 +45,6 @@ static int __init ixp4xx_rng_init(void)
        void __iomem * rng_base;
        int err;
-        if (!cpu_is_ixp46x()) /* includes IXP455 */
-                return -ENOSYS;
        rng_base = ioremap(0x70002100, 4);
        if (!rng_base)
                return -ENOMEM;
@@ -71,5 +68,5 @@ module_init(ixp4xx_rng_init);
 module_exit(ixp4xx_rng_exit);
 MODULE_AUTHOR("Deepak Saxena <dsaxena@plexity.net>");
-MODULE_DESCRIPTION("H/W Pseudo-Random Number Generator (RNG) driver for IXP45x/46x");
+MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver for IXP4xx");
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/hw_random/mxc-rnga.c b/drivers/char/hw_random/mxc-rnga.c
index f05d85713fd..187c6be80f4 100644
--- a/drivers/char/hw_random/mxc-rnga.c
+++ b/drivers/char/hw_random/mxc-rnga.c
@@ -24,7 +24,6 @@
 #include <linux/ioport.h>
 #include <linux/platform_device.h>
 #include <linux/hw_random.h>
-#include <linux/delay.h>
 #include <linux/io.h>
 /* RNGA Registers */
@@ -59,47 +58,38 @@
 #define RNGA_STATUS_LAST_READ_STATUS    0x00000002
 #define RNGA_STATUS_SECURITY_VIOLATION  0x00000001
-struct mxc_rng {
+static struct platform_device *rng_dev;
-        struct device *dev;
-        struct hwrng rng;
-        void __iomem *mem;
-        struct clk *clk;
-};
-static int mxc_rnga_data_present(struct hwrng *rng, int wait)
+static int mxc_rnga_data_present(struct hwrng *rng)
 {
-        int i;
+        int level;
-        struct mxc_rng *mxc_rng = container_of(rng, struct mxc_rng, rng);
+        void __iomem *rng_base = (void __iomem *)rng->priv;
-        for (i = 0; i < 20; i++) {
+        /* how many random numbers is in FIFO? [0-16] */
-                /* how many random numbers are in FIFO? [0-16] */
+        level = ((__raw_readl(rng_base + RNGA_STATUS) &
-                int level = (__raw_readl(mxc_rng->mem + RNGA_STATUS) &
+                        RNGA_STATUS_LEVEL_MASK) >> 8);
-                                RNGA_STATUS_LEVEL_MASK) >> 8;
-                if (level || !wait)
+        return level > 0 ? 1 : 0;
-                        return !!level;
-                udelay(10);
-        }
-        return 0;
 }
 static int mxc_rnga_data_read(struct hwrng *rng, u32 * data)
 {
        int err;
        u32 ctrl;
-        struct mxc_rng *mxc_rng = container_of(rng, struct mxc_rng, rng);
+        void __iomem *rng_base = (void __iomem *)rng->priv;
        /* retrieve a random number from FIFO */
-        *data = __raw_readl(mxc_rng->mem + RNGA_OUTPUT_FIFO);
+        *data = __raw_readl(rng_base + RNGA_OUTPUT_FIFO);
        /* some error while reading this random number? */
-        err = __raw_readl(mxc_rng->mem + RNGA_STATUS) & RNGA_STATUS_ERROR_INT;
+        err = __raw_readl(rng_base + RNGA_STATUS) & RNGA_STATUS_ERROR_INT;
        /* if error: clear error interrupt, but doesn't return random number */
        if (err) {
-                dev_dbg(mxc_rng->dev, "Error while reading random number!\n");
+                dev_dbg(&rng_dev->dev, "Error while reading random number!\n");
-                ctrl = __raw_readl(mxc_rng->mem + RNGA_CONTROL);
+                ctrl = __raw_readl(rng_base + RNGA_CONTROL);
                __raw_writel(ctrl | RNGA_CONTROL_CLEAR_INT,
-                                        mxc_rng->mem + RNGA_CONTROL);
+                                        rng_base + RNGA_CONTROL);
                return 0;
        } else
                return 4;
@@ -108,22 +98,22 @@ static int mxc_rnga_data_read(struct hwrng *rng, u32 * data)
 static int mxc_rnga_init(struct hwrng *rng)
 {
        u32 ctrl, osc;
-        struct mxc_rng *mxc_rng = container_of(rng, struct mxc_rng, rng);
+        void __iomem *rng_base = (void __iomem *)rng->priv;
        /* wake up */
-        ctrl = __raw_readl(mxc_rng->mem + RNGA_CONTROL);
+        ctrl = __raw_readl(rng_base + RNGA_CONTROL);
-        __raw_writel(ctrl & ~RNGA_CONTROL_SLEEP, mxc_rng->mem + RNGA_CONTROL);
+        __raw_writel(ctrl & ~RNGA_CONTROL_SLEEP, rng_base + RNGA_CONTROL);
        /* verify if oscillator is working */
-        osc = __raw_readl(mxc_rng->mem + RNGA_STATUS);
+        osc = __raw_readl(rng_base + RNGA_STATUS);
        if (osc & RNGA_STATUS_OSC_DEAD) {
-                dev_err(mxc_rng->dev, "RNGA Oscillator is dead!\n");
+                dev_err(&rng_dev->dev, "RNGA Oscillator is dead!\n");
                return -ENODEV;
        }
        /* go running */
-        ctrl = __raw_readl(mxc_rng->mem + RNGA_CONTROL);
+        ctrl = __raw_readl(rng_base + RNGA_CONTROL);
-        __raw_writel(ctrl | RNGA_CONTROL_GO, mxc_rng->mem + RNGA_CONTROL);
+        __raw_writel(ctrl | RNGA_CONTROL_GO, rng_base + RNGA_CONTROL);
        return 0;
 }
@@ -131,40 +121,40 @@ static int mxc_rnga_init(struct hwrng *rng)
 static void mxc_rnga_cleanup(struct hwrng *rng)
 {
        u32 ctrl;
-        struct mxc_rng *mxc_rng = container_of(rng, struct mxc_rng, rng);
+        void __iomem *rng_base = (void __iomem *)rng->priv;
-        ctrl = __raw_readl(mxc_rng->mem + RNGA_CONTROL);
+        ctrl = __raw_readl(rng_base + RNGA_CONTROL);
        /* stop rnga */
-        __raw_writel(ctrl & ~RNGA_CONTROL_GO, mxc_rng->mem + RNGA_CONTROL);
+        __raw_writel(ctrl & ~RNGA_CONTROL_GO, rng_base + RNGA_CONTROL);
 }
+static struct hwrng mxc_rnga = {
+        .name = "mxc-rnga",
+        .init = mxc_rnga_init,
+        .cleanup = mxc_rnga_cleanup,
+        .data_present = mxc_rnga_data_present,
+        .data_read = mxc_rnga_data_read
+};
 static int __init mxc_rnga_probe(struct platform_device *pdev)
 {
        int err = -ENODEV;
+        struct clk *clk;
        struct resource *res, *mem;
-        struct mxc_rng *mxc_rng;
+        void __iomem *rng_base = NULL;
-        mxc_rng = devm_kzalloc(&pdev->dev, sizeof(struct mxc_rng),
+        if (rng_dev)
-                                        GFP_KERNEL);
+                return -EBUSY;
-        if (!mxc_rng)
-                return -ENOMEM;
+        clk = clk_get(&pdev->dev, "rng");
+        if (IS_ERR(clk)) {
-        mxc_rng->dev = &pdev->dev;
-        mxc_rng->rng.name = "mxc-rnga";
-        mxc_rng->rng.init = mxc_rnga_init;
-        mxc_rng->rng.cleanup = mxc_rnga_cleanup,
-        mxc_rng->rng.data_present = mxc_rnga_data_present,
-        mxc_rng->rng.data_read = mxc_rnga_data_read,
-        mxc_rng->clk = devm_clk_get(&pdev->dev, NULL);
-        if (IS_ERR(mxc_rng->clk)) {
                dev_err(&pdev->dev, "Could not get rng_clk!\n");
-                err = PTR_ERR(mxc_rng->clk);
+                err = PTR_ERR(clk);
                goto out;
        }
-        clk_prepare_enable(mxc_rng->clk);
+        clk_enable(clk);
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!res) {
@@ -178,27 +168,36 @@ static int __init mxc_rnga_probe(struct platform_device *pdev)
                goto err_region;
        }
-        mxc_rng->mem = ioremap(res->start, resource_size(res));
+        rng_base = ioremap(res->start, resource_size(res));
-        if (!mxc_rng->mem) {
+        if (!rng_base) {
                err = -ENOMEM;
                goto err_ioremap;
        }
-        err = hwrng_register(&mxc_rng->rng);
+        mxc_rnga.priv = (unsigned long)rng_base;
+        err = hwrng_register(&mxc_rnga);
        if (err) {
                dev_err(&pdev->dev, "MXC RNGA registering failed (%d)\n", err);
-                goto err_ioremap;
+                goto err_register;
        }
+        rng_dev = pdev;
        dev_info(&pdev->dev, "MXC RNGA Registered.\n");
        return 0;
+err_register:
+        iounmap(rng_base);
+        rng_base = NULL;
 err_ioremap:
        release_mem_region(res->start, resource_size(res));
 err_region:
-        clk_disable_unprepare(mxc_rng->clk);
+        clk_disable(clk);
+        clk_put(clk);
 out:
        return err;
@@ -207,15 +206,17 @@ out:
 static int __exit mxc_rnga_remove(struct platform_device *pdev)
 {
        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        struct mxc_rng *mxc_rng = platform_get_drvdata(pdev);
+        void __iomem *rng_base = (void __iomem *)mxc_rnga.priv;
+        struct clk *clk = clk_get(&pdev->dev, "rng");
-        hwrng_unregister(&mxc_rng->rng);
+        hwrng_unregister(&mxc_rnga);
-        iounmap(mxc_rng->mem);
+        iounmap(rng_base);
        release_mem_region(res->start, resource_size(res));
-        clk_disable_unprepare(mxc_rng->clk);
+        clk_disable(clk);
+        clk_put(clk);
        return 0;
 }
diff --git a/drivers/char/hw_random/n2-drv.c b/drivers/char/hw_random/n2-drv.c
index 20b962e1d83..c3de70de00d 100644
--- a/drivers/char/hw_random/n2-drv.c
+++ b/drivers/char/hw_random/n2-drv.c
@@ -25,7 +25,7 @@
 #define DRV_MODULE_VERSION      "0.2"
 #define DRV_MODULE_RELDATE      "July 27, 2011"
-static char version[] =
+static char version[] __devinitdata =
        DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
 MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
@@ -611,7 +611,7 @@ static void n2rng_work(struct work_struct *work)
                schedule_delayed_work(&np->work, HZ * 2);
 }
-static void n2rng_driver_version(void)
+static void __devinit n2rng_driver_version(void)
 {
        static int n2rng_version_printed;
@@ -620,7 +620,7 @@ static void n2rng_driver_version(void)
 }
 static const struct of_device_id n2rng_match[];
-static int n2rng_probe(struct platform_device *op)
+static int __devinit n2rng_probe(struct platform_device *op)
 {
        const struct of_device_id *match;
        int multi_capable;
@@ -719,7 +719,7 @@ out:
        return err;
 }
-static int n2rng_remove(struct platform_device *op)
+static int __devexit n2rng_remove(struct platform_device *op)
 {
        struct n2rng *np = dev_get_drvdata(&op->dev);
@@ -767,7 +767,18 @@ static struct platform_driver n2rng_driver = {
                .of_match_table = n2rng_match,
        },
        .probe          = n2rng_probe,
-        .remove         = n2rng_remove,
+        .remove         = __devexit_p(n2rng_remove),
 };
-module_platform_driver(n2rng_driver);
+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);
diff --git a/drivers/char/hw_random/nomadik-rng.c b/drivers/char/hw_random/nomadik-rng.c
index 96de0249e59..52e08ca3ccd 100644
--- a/drivers/char/hw_random/nomadik-rng.c
+++ b/drivers/char/hw_random/nomadik-rng.c
@@ -95,8 +95,6 @@ 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,
@@ -107,6 +105,17 @@ static struct amba_driver nmk_rng_driver = {
        .id_table = nmk_rng_ids,
 };
-module_amba_driver(nmk_rng_driver);
+static int __init nmk_rng_init(void)
+{
+        return amba_driver_register(&nmk_rng_driver);
+}
+static void __devexit nmk_rng_exit(void)
+{
+        amba_driver_unregister(&nmk_rng_driver);
+}
+module_init(nmk_rng_init);
+module_exit(nmk_rng_exit);
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/hw_random/octeon-rng.c b/drivers/char/hw_random/octeon-rng.c
index 1eada566ca7..9cd0feca318 100644
--- a/drivers/char/hw_random/octeon-rng.c
+++ b/drivers/char/hw_random/octeon-rng.c
@@ -56,7 +56,7 @@ static int octeon_rng_data_read(struct hwrng *rng, u32 *data)
        return sizeof(u32);
 }
-static int octeon_rng_probe(struct platform_device *pdev)
+static int __devinit octeon_rng_probe(struct platform_device *pdev)
 {
        struct resource *res_ports;
        struct resource *res_result;
@@ -75,35 +75,42 @@ static int octeon_rng_probe(struct platform_device *pdev)
        res_ports = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!res_ports)
-                return -ENOENT;
+                goto err_ports;
        res_result = platform_get_resource(pdev, IORESOURCE_MEM, 1);
        if (!res_result)
-                return -ENOENT;
+                goto err_ports;
        rng->control_status = devm_ioremap_nocache(&pdev->dev,
                                                   res_ports->start,
                                                   sizeof(u64));
        if (!rng->control_status)
-                return -ENOENT;
+                goto err_ports;
        rng->result = devm_ioremap_nocache(&pdev->dev,
                                           res_result->start,
                                           sizeof(u64));
        if (!rng->result)
-                return -ENOENT;
+                goto err_r;
        rng->ops = ops;
        dev_set_drvdata(&pdev->dev, &rng->ops);
        ret = hwrng_register(&rng->ops);
        if (ret)
-                return -ENOENT;
+                goto err;
        dev_info(&pdev->dev, "Octeon Random Number Generator\n");
        return 0;
+err:
+        devm_iounmap(&pdev->dev, rng->control_status);
+err_r:
+        devm_iounmap(&pdev->dev, rng->result);
+err_ports:
+        devm_kfree(&pdev->dev, rng);
+        return -ENOENT;
 }
 static int __exit octeon_rng_remove(struct platform_device *pdev)
@@ -124,7 +131,18 @@ static struct platform_driver octeon_rng_driver = {
        .remove         = __exit_p(octeon_rng_remove),
 };
-module_platform_driver(octeon_rng_driver);
+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_AUTHOR("David Daney");
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/hw_random/omap-rng.c b/drivers/char/hw_random/omap-rng.c
index d8c54e25376..b757fac3cd1 100644
--- a/drivers/char/hw_random/omap-rng.c
+++ b/drivers/char/hw_random/omap-rng.c
@@ -18,12 +18,11 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/random.h>
+#include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/platform_device.h>
 #include <linux/hw_random.h>
 #include <linux/delay.h>
-#include <linux/slab.h>
-#include <linux/pm_runtime.h>
 #include <asm/io.h>
@@ -45,36 +44,26 @@
 #define RNG_SYSSTATUS           0x44            /* System status
                                                        [0] = RESETDONE */
-/**
+static void __iomem *rng_base;
- * struct omap_rng_private_data - RNG IP block-specific data
+static struct clk *rng_ick;
- * @base: virtual address of the beginning of the RNG IP block registers
+static struct platform_device *rng_dev;
- * @mem_res: struct resource * for the IP block registers physical memory
- */
-struct omap_rng_private_data {
-        void __iomem *base;
-        struct resource *mem_res;
-};
-static inline u32 omap_rng_read_reg(struct omap_rng_private_data *priv, int reg)
+static inline u32 omap_rng_read_reg(int reg)
 {
-        return __raw_readl(priv->base + reg);
+        return __raw_readl(rng_base + reg);
 }
-static inline void omap_rng_write_reg(struct omap_rng_private_data *priv,
+static inline void omap_rng_write_reg(int reg, u32 val)
-                                      int reg, u32 val)
 {
-        __raw_writel(val, priv->base + reg);
+        __raw_writel(val, rng_base + reg);
 }
 static int omap_rng_data_present(struct hwrng *rng, int wait)
 {
-        struct omap_rng_private_data *priv;
        int data, i;
-        priv = (struct omap_rng_private_data *)rng->priv;
        for (i = 0; i < 20; i++) {
-                data = omap_rng_read_reg(priv, RNG_STAT_REG) ? 0 : 1;
+                data = omap_rng_read_reg(RNG_STAT_REG) ? 0 : 1;
                if (data || !wait)
                        break;
                /* RNG produces data fast enough (2+ MBit/sec, even
@@ -89,13 +78,9 @@ static int omap_rng_data_present(struct hwrng *rng, int wait)
 static int omap_rng_data_read(struct hwrng *rng, u32 *data)
 {
-        struct omap_rng_private_data *priv;
+        *data = omap_rng_read_reg(RNG_OUT_REG);
-        priv = (struct omap_rng_private_data *)rng->priv;
-        *data = omap_rng_read_reg(priv, RNG_OUT_REG);
-        return sizeof(u32);
+        return 4;
 }
 static struct hwrng omap_rng_ops = {
@@ -104,102 +89,111 @@ static struct hwrng omap_rng_ops = {
        .data_read      = omap_rng_data_read,
 };
-static int omap_rng_probe(struct platform_device *pdev)
+static int __devinit omap_rng_probe(struct platform_device *pdev)
 {
-        struct omap_rng_private_data *priv;
+        struct resource *res;
        int ret;
-        priv = kzalloc(sizeof(struct omap_rng_private_data), GFP_KERNEL);
+        /*
-        if (!priv) {
+         * A bit ugly, and it will never actually happen but there can
-                dev_err(&pdev->dev, "could not allocate memory\n");
+         * be only one RNG and this catches any bork
-                return -ENOMEM;
+         */
-        };
+        if (rng_dev)
+                return -EBUSY;
+        if (cpu_is_omap24xx()) {
+                rng_ick = clk_get(&pdev->dev, "ick");
+                if (IS_ERR(rng_ick)) {
+                        dev_err(&pdev->dev, "Could not get rng_ick\n");
+                        ret = PTR_ERR(rng_ick);
+                        return ret;
+                } else
+                        clk_enable(rng_ick);
+        }
-        omap_rng_ops.priv = (unsigned long)priv;
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        dev_set_drvdata(&pdev->dev, priv);
-        priv->mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
-        if (!priv->mem_res) {
                ret = -ENOENT;
-                goto err_ioremap;
+                goto err_region;
        }
-        priv->base = devm_request_and_ioremap(&pdev->dev, priv->mem_res);
+        if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
-        if (!priv->base) {
+                ret = -EBUSY;
+                goto err_region;
+        }
+        dev_set_drvdata(&pdev->dev, res);
+        rng_base = ioremap(res->start, resource_size(res));
+        if (!rng_base) {
                ret = -ENOMEM;
                goto err_ioremap;
        }
-        dev_set_drvdata(&pdev->dev, priv);
-        pm_runtime_enable(&pdev->dev);
-        pm_runtime_get_sync(&pdev->dev);
        ret = hwrng_register(&omap_rng_ops);
        if (ret)
                goto err_register;
        dev_info(&pdev->dev, "OMAP Random Number Generator ver. %02x\n",
-                 omap_rng_read_reg(priv, RNG_REV_REG));
+                omap_rng_read_reg(RNG_REV_REG));
+        omap_rng_write_reg(RNG_MASK_REG, 0x1);
-        omap_rng_write_reg(priv, RNG_MASK_REG, 0x1);
+        rng_dev = pdev;
        return 0;
 err_register:
-        priv->base = NULL;
+        iounmap(rng_base);
-        pm_runtime_disable(&pdev->dev);
+        rng_base = NULL;
 err_ioremap:
-        kfree(priv);
+        release_mem_region(res->start, resource_size(res));
+err_region:
+        if (cpu_is_omap24xx()) {
+                clk_disable(rng_ick);
+                clk_put(rng_ick);
+        }
        return ret;
 }
 static int __exit omap_rng_remove(struct platform_device *pdev)
 {
-        struct omap_rng_private_data *priv = dev_get_drvdata(&pdev->dev);
+        struct resource *res = dev_get_drvdata(&pdev->dev);
        hwrng_unregister(&omap_rng_ops);
-        omap_rng_write_reg(priv, RNG_MASK_REG, 0x0);
+        omap_rng_write_reg(RNG_MASK_REG, 0x0);
-        pm_runtime_put_sync(&pdev->dev);
+        iounmap(rng_base);
-        pm_runtime_disable(&pdev->dev);
-        release_mem_region(priv->mem_res->start, resource_size(priv->mem_res));
+        if (cpu_is_omap24xx()) {
+                clk_disable(rng_ick);
+                clk_put(rng_ick);
+        }
-        kfree(priv);
+        release_mem_region(res->start, resource_size(res));
+        rng_base = NULL;
        return 0;
 }
-#ifdef CONFIG_PM_SLEEP
+#ifdef CONFIG_PM
-static int omap_rng_suspend(struct device *dev)
+static int omap_rng_suspend(struct platform_device *pdev, pm_message_t message)
 {
-        struct omap_rng_private_data *priv = dev_get_drvdata(dev);
+        omap_rng_write_reg(RNG_MASK_REG, 0x0);
-        omap_rng_write_reg(priv, RNG_MASK_REG, 0x0);
-        pm_runtime_put_sync(dev);
        return 0;
 }
-static int omap_rng_resume(struct device *dev)
+static int omap_rng_resume(struct platform_device *pdev)
 {
-        struct omap_rng_private_data *priv = dev_get_drvdata(dev);
+        omap_rng_write_reg(RNG_MASK_REG, 0x1);
-        pm_runtime_get_sync(dev);
-        omap_rng_write_reg(priv, RNG_MASK_REG, 0x1);
        return 0;
 }
-static SIMPLE_DEV_PM_OPS(omap_rng_pm, omap_rng_suspend, omap_rng_resume);
-#define OMAP_RNG_PM     (&omap_rng_pm)
 #else
-#define OMAP_RNG_PM     NULL
+#define omap_rng_suspend        NULL
+#define omap_rng_resume         NULL
 #endif
@@ -210,14 +204,18 @@ static struct platform_driver omap_rng_driver = {
        .driver = {
                .name           = "omap_rng",
                .owner          = THIS_MODULE,
-                .pm             = OMAP_RNG_PM,
        },
        .probe          = omap_rng_probe,
        .remove         = __exit_p(omap_rng_remove),
+        .suspend        = omap_rng_suspend,
+        .resume         = omap_rng_resume
 };
 static int __init omap_rng_init(void)
 {
+        if (!cpu_is_omap16xx() && !cpu_is_omap24xx())
+                return -ENODEV;
        return platform_driver_register(&omap_rng_driver);
 }
diff --git a/drivers/char/hw_random/pasemi-rng.c b/drivers/char/hw_random/pasemi-rng.c
index c6df5b29af0..1d504815e6d 100644
--- a/drivers/char/hw_random/pasemi-rng.c
+++ b/drivers/char/hw_random/pasemi-rng.c
@@ -94,7 +94,7 @@ static struct hwrng pasemi_rng = {
        .data_read      = pasemi_rng_data_read,
 };
-static int rng_probe(struct platform_device *ofdev)
+static int __devinit rng_probe(struct platform_device *ofdev)
 {
        void __iomem *rng_regs;
        struct device_node *rng_np = ofdev->dev.of_node;
@@ -122,7 +122,7 @@ static int rng_probe(struct platform_device *ofdev)
        return err;
 }
-static int rng_remove(struct platform_device *dev)
+static int __devexit rng_remove(struct platform_device *dev)
 {
        void __iomem *rng_regs = (void __iomem *)pasemi_rng.priv;
@@ -148,7 +148,17 @@ static struct platform_driver rng_driver = {
        .remove         = rng_remove,
 };
-module_platform_driver(rng_driver);
+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_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 973b95113ed..990d55a5e3e 100644
--- a/drivers/char/hw_random/picoxcell-rng.c
+++ b/drivers/char/hw_random/picoxcell-rng.c
@@ -151,7 +151,7 @@ err_enable:
        return ret;
 }
-static int picoxcell_trng_remove(struct platform_device *pdev)
+static int __devexit picoxcell_trng_remove(struct platform_device *pdev)
 {
        hwrng_unregister(&picoxcell_trng);
        clk_disable(rng_clk);
@@ -181,7 +181,7 @@ static const struct dev_pm_ops picoxcell_trng_pm_ops = {
 static struct platform_driver picoxcell_trng_driver = {
        .probe          = picoxcell_trng_probe,
-        .remove         = picoxcell_trng_remove,
+        .remove         = __devexit_p(picoxcell_trng_remove),
        .driver         = {
                .name   = "picoxcell-trng",
                .owner  = THIS_MODULE,
@@ -191,7 +191,17 @@ static struct platform_driver picoxcell_trng_driver = {
        },
 };
-module_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_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 732c330805f..b8afa6a4ff6 100644
--- a/drivers/char/hw_random/ppc4xx-rng.c
+++ b/drivers/char/hw_random/ppc4xx-rng.c
@@ -90,7 +90,7 @@ static struct hwrng ppc4xx_rng = {
        .data_read = ppc4xx_rng_data_read,
 };
-static int ppc4xx_rng_probe(struct platform_device *dev)
+static int __devinit ppc4xx_rng_probe(struct platform_device *dev)
 {
        void __iomem *rng_regs;
        int err = 0;
@@ -111,7 +111,7 @@ static int ppc4xx_rng_probe(struct platform_device *dev)
        return err;
 }
-static int ppc4xx_rng_remove(struct platform_device *dev)
+static int __devexit ppc4xx_rng_remove(struct platform_device *dev)
 {
        void __iomem *rng_regs = (void __iomem *) ppc4xx_rng.priv;
@@ -139,7 +139,17 @@ static struct platform_driver ppc4xx_rng_driver = {
        .remove = ppc4xx_rng_remove,
 };
-module_platform_driver(ppc4xx_rng_driver);
+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_LICENSE("GPL");
 MODULE_AUTHOR("Josh Boyer <jwboyer@linux.vnet.ibm.com>");
diff --git a/drivers/char/hw_random/pseries-rng.c b/drivers/char/hw_random/pseries-rng.c
deleted file mode 100644
index 5f1197929f0..00000000000
--- a/drivers/char/hw_random/pseries-rng.c
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (C) 2010 Michael Neuling IBM Corporation
- *
- * Driver for the pseries hardware RNG for POWER7+ and above
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- */
-#include <linux/module.h>
-#include <linux/hw_random.h>
-#include <asm/vio.h>
-#define MODULE_NAME "pseries-rng"
-static int pseries_rng_data_read(struct hwrng *rng, u32 *data)
-{
-        if (plpar_hcall(H_RANDOM, (unsigned long *)data) != H_SUCCESS) {
-                printk(KERN_ERR "pseries rng hcall error\n");
-                return 0;
-        }
-        return 8;
-}
-/**
- * pseries_rng_get_desired_dma - Return desired DMA allocate for CMO operations
- *
- * This is a required function for a driver to operate in a CMO environment
- * but this device does not make use of DMA allocations, return 0.
- *
- * Return value:
- *      Number of bytes of IO data the driver will need to perform well -> 0
- */
-static unsigned long pseries_rng_get_desired_dma(struct vio_dev *vdev)
-{
-        return 0;
-};
-static struct hwrng pseries_rng = {
-        .name           = MODULE_NAME,
-        .data_read      = pseries_rng_data_read,
-};
-static int __init pseries_rng_probe(struct vio_dev *dev,
-                const struct vio_device_id *id)
-{
-        return hwrng_register(&pseries_rng);
-}
-static int __exit pseries_rng_remove(struct vio_dev *dev)
-{
-        hwrng_unregister(&pseries_rng);
-        return 0;
-}
-static struct vio_device_id pseries_rng_driver_ids[] = {
-        { "ibm,random-v1", "ibm,random"},
-        { "", "" }
-};
-MODULE_DEVICE_TABLE(vio, pseries_rng_driver_ids);
-static struct vio_driver pseries_rng_driver = {
-        .name = MODULE_NAME,
-        .probe = pseries_rng_probe,
-        .remove = pseries_rng_remove,
-        .get_desired_dma = pseries_rng_get_desired_dma,
-        .id_table = pseries_rng_driver_ids
-};
-static int __init rng_init(void)
-{
-        printk(KERN_INFO "Registering IBM pSeries RNG driver\n");
-        return vio_register_driver(&pseries_rng_driver);
-}
-module_init(rng_init);
-static void __exit rng_exit(void)
-{
-        vio_unregister_driver(&pseries_rng_driver);
-}
-module_exit(rng_exit);
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Michael Neuling <mikey@neuling.org>");
-MODULE_DESCRIPTION("H/W RNG driver for IBM pSeries processors");
diff --git a/drivers/char/hw_random/timeriomem-rng.c b/drivers/char/hw_random/timeriomem-rng.c
index 849db199c02..a8428e6f64a 100644
--- a/drivers/char/hw_random/timeriomem-rng.c
+++ b/drivers/char/hw_random/timeriomem-rng.c
@@ -88,7 +88,7 @@ static struct hwrng timeriomem_rng_ops = {
        .priv           = 0,
 };
-static int timeriomem_rng_probe(struct platform_device *pdev)
+static int __devinit timeriomem_rng_probe(struct platform_device *pdev)
 {
        struct resource *res;
        int ret;
@@ -130,7 +130,7 @@ failed:
        return ret;
 }
-static int timeriomem_rng_remove(struct platform_device *pdev)
+static int __devexit timeriomem_rng_remove(struct platform_device *pdev)
 {
        del_timer_sync(&timeriomem_rng_timer);
        hwrng_unregister(&timeriomem_rng_ops);
@@ -146,10 +146,21 @@ static struct platform_driver timeriomem_rng_driver = {
                .owner          = THIS_MODULE,
        },
        .probe          = timeriomem_rng_probe,
-        .remove         = timeriomem_rng_remove,
+        .remove         = __devexit_p(timeriomem_rng_remove),
 };
-module_platform_driver(timeriomem_rng_driver);
+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_LICENSE("GPL");
 MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>");
diff --git a/drivers/char/hw_random/tpm-rng.c b/drivers/char/hw_random/tpm-rng.c
deleted file mode 100644
index d6d448266f0..00000000000
--- a/drivers/char/hw_random/tpm-rng.c
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (C) 2012 Kent Yoder IBM Corporation
- *
- * HWRNG interfaces to pull RNG data from a TPM
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- */
-#include <linux/module.h>
-#include <linux/hw_random.h>
-#include <linux/tpm.h>
-#define MODULE_NAME "tpm-rng"
-static int tpm_rng_read(struct hwrng *rng, void *data, size_t max, bool wait)
-{
-        return tpm_get_random(TPM_ANY_NUM, data, max);
-}
-static struct hwrng tpm_rng = {
-        .name = MODULE_NAME,
-        .read = tpm_rng_read,
-};
-static int __init rng_init(void)
-{
-        return hwrng_register(&tpm_rng);
-}
-module_init(rng_init);
-static void __exit rng_exit(void)
-{
-        hwrng_unregister(&tpm_rng);
-}
-module_exit(rng_exit);
-MODULE_LICENSE("GPL v2");
-MODULE_AUTHOR("Kent Yoder <key@linux.vnet.ibm.com>");
-MODULE_DESCRIPTION("RNG driver for TPM devices");
diff --git a/drivers/char/hw_random/tx4939-rng.c b/drivers/char/hw_random/tx4939-rng.c
index de473ef3882..0bc0cb70210 100644
--- a/drivers/char/hw_random/tx4939-rng.c
+++ b/drivers/char/hw_random/tx4939-rng.c
@@ -115,7 +115,10 @@ static int __init tx4939_rng_probe(struct platform_device *dev)
        rngdev = devm_kzalloc(&dev->dev, sizeof(*rngdev), GFP_KERNEL);
        if (!rngdev)
                return -ENOMEM;
-        rngdev->base = devm_request_and_ioremap(&dev->dev, r);
+        if (!devm_request_mem_region(&dev->dev, r->start, resource_size(r),
+                                     dev_name(&dev->dev)))
+                return -EBUSY;
+        rngdev->base = devm_ioremap(&dev->dev, r->start, resource_size(r));
        if (!rngdev->base)
                return -EBUSY;
diff --git a/drivers/char/hw_random/virtio-rng.c b/drivers/char/hw_random/virtio-rng.c
index b65c1039595..75f1cbd61c1 100644
--- a/drivers/char/hw_random/virtio-rng.c
+++ b/drivers/char/hw_random/virtio-rng.c
@@ -23,7 +23,6 @@
 #include <linux/spinlock.h>
 #include <linux/virtio.h>
 #include <linux/virtio_rng.h>
-#include <linux/module.h>
 static struct virtqueue *vq;
 static unsigned int data_avail;
@@ -47,7 +46,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, GFP_KERNEL) < 0)
+        if (virtqueue_add_buf(vq, &sg, 0, 1, buf) < 0)
                BUG();
        virtqueue_kick(vq);
@@ -55,7 +54,6 @@ static void register_buffer(u8 *buf, size_t size)
 static int virtio_read(struct hwrng *rng, void *buf, size_t size, bool wait)
 {
-        int ret;
        if (!busy) {
                busy = true;
@@ -66,9 +64,7 @@ static int virtio_read(struct hwrng *rng, void *buf, size_t size, bool wait)
        if (!wait)
                return 0;
-        ret = wait_for_completion_killable(&have_data);
+        wait_for_completion(&have_data);
-        if (ret < 0)
-                return ret;
        busy = false;
@@ -88,7 +84,7 @@ static struct hwrng virtio_hwrng = {
        .read           = virtio_read,
 };
-static int probe_common(struct virtio_device *vdev)
+static int virtrng_probe(struct virtio_device *vdev)
 {
        int err;
@@ -106,37 +102,13 @@ static int probe_common(struct virtio_device *vdev)
        return 0;
 }
-static void remove_common(struct virtio_device *vdev)
+static void __devexit virtrng_remove(struct virtio_device *vdev)
 {
        vdev->config->reset(vdev);
-        busy = false;
        hwrng_unregister(&virtio_hwrng);
        vdev->config->del_vqs(vdev);
 }
-static int virtrng_probe(struct virtio_device *vdev)
-{
-        return probe_common(vdev);
-}
-static void virtrng_remove(struct virtio_device *vdev)
-{
-        remove_common(vdev);
-}
-#ifdef CONFIG_PM
-static int virtrng_freeze(struct virtio_device *vdev)
-{
-        remove_common(vdev);
-        return 0;
-}
-static int virtrng_restore(struct virtio_device *vdev)
-{
-        return probe_common(vdev);
-}
-#endif
 static struct virtio_device_id id_table[] = {
        { VIRTIO_ID_RNG, VIRTIO_DEV_ANY_ID },
        { 0 },
@@ -147,11 +119,7 @@ static struct virtio_driver virtio_rng_driver = {
        .driver.owner = THIS_MODULE,
        .id_table =     id_table,
        .probe =        virtrng_probe,
-        .remove =       virtrng_remove,
+        .remove =       __devexit_p(virtrng_remove),
-#ifdef CONFIG_PM
-        .freeze =       virtrng_freeze,
-        .restore =      virtrng_restore,
-#endif
 };
 static int __init init(void)
diff --git a/drivers/char/i8k.c b/drivers/char/i8k.c
index 40cc0cf2ded..6e40072fbf6 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 bool force;
+static int force;
 module_param(force, bool, 0);
 MODULE_PARM_DESC(force, "Force loading without checking for supported models");
-static bool ignore_dmi;
+static int ignore_dmi;
 module_param(ignore_dmi, bool, 0);
 MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match");
-static bool restricted;
+static int restricted;
 module_param(restricted, bool, 0);
 MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set");
-static bool power_status;
+static int 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_bt_sm.c b/drivers/char/ipmi/ipmi_bt_sm.c
index cdd4c09fda9..3ed20e8abc0 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 proceed serially but
+                 * Uncached, ordered writes should just proceeed 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_devintf.c b/drivers/char/ipmi/ipmi_devintf.c
index 9eb360ff8ca..2aa3977aae5 100644
--- a/drivers/char/ipmi/ipmi_devintf.c
+++ b/drivers/char/ipmi/ipmi_devintf.c
@@ -34,6 +34,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/errno.h>
+#include <asm/system.h>
 #include <linux/poll.h>
 #include <linux/sched.h>
 #include <linux/spinlock.h>
diff --git a/drivers/char/ipmi/ipmi_kcs_sm.c b/drivers/char/ipmi/ipmi_kcs_sm.c
index e53fc24c6af..cf82fedae09 100644
--- a/drivers/char/ipmi/ipmi_kcs_sm.c
+++ b/drivers/char/ipmi/ipmi_kcs_sm.c
@@ -118,8 +118,8 @@ enum kcs_states {
 #define MAX_KCS_WRITE_SIZE IPMI_MAX_MSG_LENGTH
 /* Timeouts in microseconds. */
-#define IBF_RETRY_TIMEOUT 5000000
+#define IBF_RETRY_TIMEOUT 1000000
-#define OBF_RETRY_TIMEOUT 5000000
+#define OBF_RETRY_TIMEOUT 1000000
 #define MAX_ERROR_RETRIES 10
 #define ERROR0_OBF_WAIT_JIFFIES (2*HZ)
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index 053201b062a..58c0e6387cf 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -33,6 +33,7 @@
 #include <linux/module.h>
 #include <linux/errno.h>
+#include <asm/system.h>
 #include <linux/poll.h>
 #include <linux/sched.h>
 #include <linux/seq_file.h>
@@ -45,7 +46,6 @@
 #include <linux/init.h>
 #include <linux/proc_fs.h>
 #include <linux/rcupdate.h>
-#include <linux/interrupt.h>
 #define PFX "IPMI message handler: "
@@ -53,8 +53,6 @@
 static struct ipmi_recv_msg *ipmi_alloc_recv_msg(void);
 static int ipmi_init_msghandler(void);
-static void smi_recv_tasklet(unsigned long);
-static void handle_new_recv_msgs(ipmi_smi_t intf);
 static int initialized;
@@ -357,15 +355,12 @@ struct ipmi_smi {
        int curr_seq;
        /*
-         * Messages queued for delivery.  If delivery fails (out of memory
+         * Messages that were delayed for some reason (out of memory,
-         * for instance), They will stay in here to be processed later in a
+         * for instance), will go in here to be processed later in a
-         * periodic timer interrupt.  The tasklet is for handling received
+         * periodic timer interrupt.
-         * messages directly from the handler.
         */
        spinlock_t       waiting_msgs_lock;
        struct list_head waiting_msgs;
-        atomic_t         watchdog_pretimeouts_to_deliver;
-        struct tasklet_struct recv_tasklet;
        /*
         * The list of command receivers that are registered for commands
@@ -498,8 +493,6 @@ static void clean_up_interface_data(ipmi_smi_t intf)
        struct cmd_rcvr  *rcvr, *rcvr2;
        struct list_head list;
-        tasklet_kill(&intf->recv_tasklet);
        free_smi_msg_list(&intf->waiting_msgs);
        free_recv_msg_list(&intf->waiting_events);
@@ -1880,7 +1873,7 @@ int ipmi_request_supply_msgs(ipmi_user_t          user,
                             struct ipmi_recv_msg *supplied_recv,
                             int                  priority)
 {
-        unsigned char saddr = 0, lun = 0;
+        unsigned char saddr, lun;
        int           rv;
        if (!user)
@@ -2793,17 +2786,12 @@ channel_handler(ipmi_smi_t intf, struct ipmi_recv_msg *msg)
        return;
 }
-static void ipmi_poll(ipmi_smi_t intf)
+void ipmi_poll_interface(ipmi_user_t user)
 {
+        ipmi_smi_t intf = user->intf;
        if (intf->handlers->poll)
                intf->handlers->poll(intf->send_info);
-        /* In case something came in */
-        handle_new_recv_msgs(intf);
-}
-void ipmi_poll_interface(ipmi_user_t user)
-{
-        ipmi_poll(user->intf);
 }
 EXPORT_SYMBOL(ipmi_poll_interface);
@@ -2872,10 +2860,6 @@ int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
 #endif
        spin_lock_init(&intf->waiting_msgs_lock);
        INIT_LIST_HEAD(&intf->waiting_msgs);
-        tasklet_init(&intf->recv_tasklet,
-                     smi_recv_tasklet,
-                     (unsigned long) intf);
-        atomic_set(&intf->watchdog_pretimeouts_to_deliver, 0);
        spin_lock_init(&intf->events_lock);
        INIT_LIST_HEAD(&intf->waiting_events);
        intf->waiting_events_count = 0;
@@ -3638,11 +3622,11 @@ static int handle_bmc_rsp(ipmi_smi_t          intf,
 }
 /*
- * Handle a received message.  Return 1 if the message should be requeued,
+ * Handle a new message.  Return 1 if the message should be requeued,
 * 0 if the message should be freed, or -1 if the message should not
 * be freed or requeued.
 */
-static int handle_one_recv_msg(ipmi_smi_t          intf,
+static int handle_new_recv_msg(ipmi_smi_t          intf,
                               struct ipmi_smi_msg *msg)
 {
        int requeue;
@@ -3789,7 +3773,7 @@ static int handle_one_recv_msg(ipmi_smi_t          intf,
        } else if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2))
                   && (msg->rsp[1] == IPMI_READ_EVENT_MSG_BUFFER_CMD)) {
-                /* It's an asynchronous event. */
+                /* It's an asyncronous event. */
                requeue = handle_read_event_rsp(intf, msg);
        } else {
                /* It's a response from the local BMC. */
@@ -3800,72 +3784,12 @@ static int handle_one_recv_msg(ipmi_smi_t          intf,
        return requeue;
 }
-/*
- * If there are messages in the queue or pretimeouts, handle them.
- */
-static void handle_new_recv_msgs(ipmi_smi_t intf)
-{
-        struct ipmi_smi_msg  *smi_msg;
-        unsigned long        flags = 0;
-        int                  rv;
-        int                  run_to_completion = intf->run_to_completion;
-        /* See if any waiting messages need to be processed. */
-        if (!run_to_completion)
-                spin_lock_irqsave(&intf->waiting_msgs_lock, flags);
-        while (!list_empty(&intf->waiting_msgs)) {
-                smi_msg = list_entry(intf->waiting_msgs.next,
-                                     struct ipmi_smi_msg, link);
-                list_del(&smi_msg->link);
-                if (!run_to_completion)
-                        spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
-                rv = handle_one_recv_msg(intf, smi_msg);
-                if (!run_to_completion)
-                        spin_lock_irqsave(&intf->waiting_msgs_lock, flags);
-                if (rv == 0) {
-                        /* Message handled */
-                        ipmi_free_smi_msg(smi_msg);
-                } else if (rv < 0) {
-                        /* Fatal error on the message, del but don't free. */
-                } else {
-                        /*
-                         * To preserve message order, quit if we
-                         * can't handle a message.
-                         */
-                        list_add(&smi_msg->link, &intf->waiting_msgs);
-                        break;
-                }
-        }
-        if (!run_to_completion)
-                spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
-        /*
-         * If the pretimout count is non-zero, decrement one from it and
-         * deliver pretimeouts to all the users.
-         */
-        if (atomic_add_unless(&intf->watchdog_pretimeouts_to_deliver, -1, 0)) {
-                ipmi_user_t user;
-                rcu_read_lock();
-                list_for_each_entry_rcu(user, &intf->users, link) {
-                        if (user->handler->ipmi_watchdog_pretimeout)
-                                user->handler->ipmi_watchdog_pretimeout(
-                                        user->handler_data);
-                }
-                rcu_read_unlock();
-        }
-}
-static void smi_recv_tasklet(unsigned long val)
-{
-        handle_new_recv_msgs((ipmi_smi_t) val);
-}
 /* Handle a new message from the lower layer. */
 void ipmi_smi_msg_received(ipmi_smi_t          intf,
                           struct ipmi_smi_msg *msg)
 {
        unsigned long flags = 0; /* keep us warning-free. */
+        int           rv;
        int           run_to_completion;
@@ -3919,11 +3843,31 @@ void ipmi_smi_msg_received(ipmi_smi_t          intf,
        run_to_completion = intf->run_to_completion;
        if (!run_to_completion)
                spin_lock_irqsave(&intf->waiting_msgs_lock, flags);
-        list_add_tail(&msg->link, &intf->waiting_msgs);
+        if (!list_empty(&intf->waiting_msgs)) {
+                list_add_tail(&msg->link, &intf->waiting_msgs);
+                if (!run_to_completion)
+                        spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
+                goto out;
+        }
        if (!run_to_completion)
                spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
-        tasklet_schedule(&intf->recv_tasklet);
+        rv = handle_new_recv_msg(intf, msg);
+        if (rv > 0) {
+                /*
+                 * Could not handle the message now, just add it to a
+                 * list to handle later.
+                 */
+                run_to_completion = intf->run_to_completion;
+                if (!run_to_completion)
+                        spin_lock_irqsave(&intf->waiting_msgs_lock, flags);
+                list_add_tail(&msg->link, &intf->waiting_msgs);
+                if (!run_to_completion)
+                        spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
+        } else if (rv == 0) {
+                ipmi_free_smi_msg(msg);
+        }
 out:
        return;
 }
@@ -3931,8 +3875,16 @@ EXPORT_SYMBOL(ipmi_smi_msg_received);
 void ipmi_smi_watchdog_pretimeout(ipmi_smi_t intf)
 {
-        atomic_set(&intf->watchdog_pretimeouts_to_deliver, 1);
+        ipmi_user_t user;
-        tasklet_schedule(&intf->recv_tasklet);
+        rcu_read_lock();
+        list_for_each_entry_rcu(user, &intf->users, link) {
+                if (!user->handler->ipmi_watchdog_pretimeout)
+                        continue;
+                user->handler->ipmi_watchdog_pretimeout(user->handler_data);
+        }
+        rcu_read_unlock();
 }
 EXPORT_SYMBOL(ipmi_smi_watchdog_pretimeout);
@@ -4046,12 +3998,28 @@ static void ipmi_timeout_handler(long timeout_period)
        ipmi_smi_t           intf;
        struct list_head     timeouts;
        struct ipmi_recv_msg *msg, *msg2;
+        struct ipmi_smi_msg  *smi_msg, *smi_msg2;
        unsigned long        flags;
        int                  i;
        rcu_read_lock();
        list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
-                tasklet_schedule(&intf->recv_tasklet);
+                /* See if any waiting messages need to be processed. */
+                spin_lock_irqsave(&intf->waiting_msgs_lock, flags);
+                list_for_each_entry_safe(smi_msg, smi_msg2,
+                                         &intf->waiting_msgs, link) {
+                        if (!handle_new_recv_msg(intf, smi_msg)) {
+                                list_del(&smi_msg->link);
+                                ipmi_free_smi_msg(smi_msg);
+                        } else {
+                                /*
+                                 * To preserve message order, quit if we
+                                 * can't handle a message.
+                                 */
+                                break;
+                        }
+                }
+                spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
                /*
                 * Go through the seq table and find any messages that
@@ -4205,48 +4173,12 @@ EXPORT_SYMBOL(ipmi_free_recv_msg);
 #ifdef CONFIG_IPMI_PANIC_EVENT
-static atomic_t panic_done_count = ATOMIC_INIT(0);
 static void dummy_smi_done_handler(struct ipmi_smi_msg *msg)
 {
-        atomic_dec(&panic_done_count);
 }
 static void dummy_recv_done_handler(struct ipmi_recv_msg *msg)
 {
-        atomic_dec(&panic_done_count);
-}
-/*
- * Inside a panic, send a message and wait for a response.
- */
-static void ipmi_panic_request_and_wait(ipmi_smi_t           intf,
-                                        struct ipmi_addr     *addr,
-                                        struct kernel_ipmi_msg *msg)
-{
-        struct ipmi_smi_msg  smi_msg;
-        struct ipmi_recv_msg recv_msg;
-        int rv;
-        smi_msg.done = dummy_smi_done_handler;
-        recv_msg.done = dummy_recv_done_handler;
-        atomic_add(2, &panic_done_count);
-        rv = i_ipmi_request(NULL,
-                            intf,
-                            addr,
-                            0,
-                            msg,
-                            intf,
-                            &smi_msg,
-                            &recv_msg,
-                            0,
-                            intf->channels[0].address,
-                            intf->channels[0].lun,
-                            0, 1); /* Don't retry, and don't wait. */
-        if (rv)
-                atomic_sub(2, &panic_done_count);
-        while (atomic_read(&panic_done_count) != 0)
-                ipmi_poll(intf);
 }
 #ifdef CONFIG_IPMI_PANIC_STRING
@@ -4285,6 +4217,8 @@ static void send_panic_events(char *str)
        unsigned char                     data[16];
        struct ipmi_system_interface_addr *si;
        struct ipmi_addr                  addr;
+        struct ipmi_smi_msg               smi_msg;
+        struct ipmi_recv_msg              recv_msg;
        si = (struct ipmi_system_interface_addr *) &addr;
        si->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
@@ -4312,6 +4246,9 @@ static void send_panic_events(char *str)
                data[7] = str[2];
        }
+        smi_msg.done = dummy_smi_done_handler;
+        recv_msg.done = dummy_recv_done_handler;
        /* For every registered interface, send the event. */
        list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
                if (!intf->handlers)
@@ -4321,7 +4258,18 @@ static void send_panic_events(char *str)
                intf->run_to_completion = 1;
                /* Send the event announcing the panic. */
                intf->handlers->set_run_to_completion(intf->send_info, 1);
-                ipmi_panic_request_and_wait(intf, &addr, &msg);
+                i_ipmi_request(NULL,
+                               intf,
+                               &addr,
+                               0,
+                               &msg,
+                               intf,
+                               &smi_msg,
+                               &recv_msg,
+                               0,
+                               intf->channels[0].address,
+                               intf->channels[0].lun,
+                               0, 1); /* Don't retry, and don't wait. */
        }
 #ifdef CONFIG_IPMI_PANIC_STRING
@@ -4369,7 +4317,18 @@ static void send_panic_events(char *str)
                msg.data = NULL;
                msg.data_len = 0;
                intf->null_user_handler = device_id_fetcher;
-                ipmi_panic_request_and_wait(intf, &addr, &msg);
+                i_ipmi_request(NULL,
+                               intf,
+                               &addr,
+                               0,
+                               &msg,
+                               intf,
+                               &smi_msg,
+                               &recv_msg,
+                               0,
+                               intf->channels[0].address,
+                               intf->channels[0].lun,
+                               0, 1); /* Don't retry, and don't wait. */
                if (intf->local_event_generator) {
                        /* Request the event receiver from the local MC. */
@@ -4378,7 +4337,18 @@ static void send_panic_events(char *str)
                        msg.data = NULL;
                        msg.data_len = 0;
                        intf->null_user_handler = event_receiver_fetcher;
-                        ipmi_panic_request_and_wait(intf, &addr, &msg);
+                        i_ipmi_request(NULL,
+                                       intf,
+                                       &addr,
+                                       0,
+                                       &msg,
+                                       intf,
+                                       &smi_msg,
+                                       &recv_msg,
+                                       0,
+                                       intf->channels[0].address,
+                                       intf->channels[0].lun,
+                                       0, 1); /* no retry, and no wait. */
                }
                intf->null_user_handler = NULL;
@@ -4435,7 +4405,18 @@ static void send_panic_events(char *str)
                        strncpy(data+5, p, 11);
                        p += size;
-                        ipmi_panic_request_and_wait(intf, &addr, &msg);
+                        i_ipmi_request(NULL,
+                                       intf,
+                                       &addr,
+                                       0,
+                                       &msg,
+                                       intf,
+                                       &smi_msg,
+                                       &recv_msg,
+                                       0,
+                                       intf->channels[0].address,
+                                       intf->channels[0].lun,
+                                       0, 1); /* no retry, and no wait. */
                }
        }
 #endif /* CONFIG_IPMI_PANIC_STRING */
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 1c7fdcd22a9..9397ab49b72 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -41,6 +41,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <asm/system.h>
 #include <linux/sched.h>
 #include <linux/seq_file.h>
 #include <linux/timer.h>
@@ -155,7 +156,7 @@ enum si_stat_indexes {
        /* Number of watchdog pretimeouts. */
        SI_STAT_watchdog_pretimeouts,
-        /* Number of asynchronous messages received. */
+        /* Number of asyncronous messages received. */
        SI_STAT_incoming_messages,
@@ -170,6 +171,7 @@ struct smi_info {
        struct si_sm_handlers  *handlers;
        enum si_type           si_type;
        spinlock_t             si_lock;
+        spinlock_t             msg_lock;
        struct list_head       xmit_msgs;
        struct list_head       hp_xmit_msgs;
        struct ipmi_smi_msg    *curr_msg;
@@ -318,8 +320,16 @@ static int register_xaction_notifier(struct notifier_block *nb)
 static void deliver_recv_msg(struct smi_info *smi_info,
                             struct ipmi_smi_msg *msg)
 {
-        /* Deliver the message to the upper layer. */
+        /* Deliver the message to the upper layer with the lock
-        ipmi_smi_msg_received(smi_info->intf, msg);
+           released. */
+        if (smi_info->run_to_completion) {
+                ipmi_smi_msg_received(smi_info->intf, msg);
+        } else {
+                spin_unlock(&(smi_info->si_lock));
+                ipmi_smi_msg_received(smi_info->intf, msg);
+                spin_lock(&(smi_info->si_lock));
+        }
 }
 static void return_hosed_msg(struct smi_info *smi_info, int cCode)
@@ -348,6 +358,13 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
        struct timeval t;
 #endif
+        /*
+         * No need to save flags, we aleady have interrupts off and we
+         * already hold the SMI lock.
+         */
+        if (!smi_info->run_to_completion)
+                spin_lock(&(smi_info->msg_lock));
        /* Pick the high priority queue first. */
        if (!list_empty(&(smi_info->hp_xmit_msgs))) {
                entry = smi_info->hp_xmit_msgs.next;
@@ -385,6 +402,9 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
                rv = SI_SM_CALL_WITHOUT_DELAY;
        }
 out:
+        if (!smi_info->run_to_completion)
+                spin_unlock(&(smi_info->msg_lock));
        return rv;
 }
@@ -461,7 +481,9 @@ static void handle_flags(struct smi_info *smi_info)
                start_clear_flags(smi_info);
                smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
+                spin_unlock(&(smi_info->si_lock));
                ipmi_smi_watchdog_pretimeout(smi_info->intf);
+                spin_lock(&(smi_info->si_lock));
        } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
                /* Messages available. */
                smi_info->curr_msg = ipmi_alloc_smi_msg();
@@ -867,6 +889,19 @@ static void sender(void                *send_info,
        printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 #endif
+        /*
+         * last_timeout_jiffies is updated here to avoid
+         * smi_timeout() handler passing very large time_diff
+         * value to smi_event_handler() that causes
+         * the send command to abort.
+         */
+        smi_info->last_timeout_jiffies = jiffies;
+        mod_timer(&smi_info->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
+        if (smi_info->thread)
+                wake_up_process(smi_info->thread);
        if (smi_info->run_to_completion) {
                /*
                 * If we are running to completion, then throw it in
@@ -889,29 +924,16 @@ static void sender(void                *send_info,
                return;
        }
-        spin_lock_irqsave(&smi_info->si_lock, flags);
+        spin_lock_irqsave(&smi_info->msg_lock, flags);
        if (priority > 0)
                list_add_tail(&msg->link, &smi_info->hp_xmit_msgs);
        else
                list_add_tail(&msg->link, &smi_info->xmit_msgs);
+        spin_unlock_irqrestore(&smi_info->msg_lock, flags);
-        if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL) {
+        spin_lock_irqsave(&smi_info->si_lock, flags);
-                /*
+        if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL)
-                 * last_timeout_jiffies is updated here to avoid
-                 * smi_timeout() handler passing very large time_diff
-                 * value to smi_event_handler() that causes
-                 * the send command to abort.
-                 */
-                smi_info->last_timeout_jiffies = jiffies;
-                mod_timer(&smi_info->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
-                if (smi_info->thread)
-                        wake_up_process(smi_info->thread);
                start_next_msg(smi_info);
-                smi_event_handler(smi_info, 0);
-        }
        spin_unlock_irqrestore(&smi_info->si_lock, flags);
 }
@@ -1012,19 +1034,16 @@ static int ipmi_thread(void *data)
 static void poll(void *send_info)
 {
        struct smi_info *smi_info = send_info;
-        unsigned long flags = 0;
+        unsigned long flags;
-        int run_to_completion = smi_info->run_to_completion;
        /*
         * Make sure there is some delay in the poll loop so we can
         * drive time forward and timeout things.
         */
        udelay(10);
-        if (!run_to_completion)
+        spin_lock_irqsave(&smi_info->si_lock, flags);
-                spin_lock_irqsave(&smi_info->si_lock, flags);
        smi_event_handler(smi_info, 10);
-        if (!run_to_completion)
+        spin_unlock_irqrestore(&smi_info->si_lock, flags);
-                spin_unlock_irqrestore(&smi_info->si_lock, flags);
 }
 static void request_events(void *send_info)
@@ -1208,7 +1227,7 @@ static int smi_num; /* Used to sequence the SMIs */
 #define DEFAULT_REGSPACING      1
 #define DEFAULT_REGSIZE         1
-static bool          si_trydefaults = 1;
+static int           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];
@@ -1661,8 +1680,10 @@ static struct smi_info *smi_info_alloc(void)
 {
        struct smi_info *info = kzalloc(sizeof(*info), GFP_KERNEL);
-        if (info)
+        if (info) {
                spin_lock_init(&info->si_lock);
+                spin_lock_init(&info->msg_lock);
+        }
        return info;
 }
@@ -1836,7 +1857,7 @@ static int hotmod_handler(const char *val, struct kernel_param *kp)
        return rv;
 }
-static int hardcode_find_bmc(void)
+static int __devinit hardcode_find_bmc(void)
 {
        int ret = -ENODEV;
        int             i;
@@ -2023,7 +2044,7 @@ struct SPMITable {
        s8      spmi_id[1]; /* A '\0' terminated array starts here. */
 };
-static int try_init_spmi(struct SPMITable *spmi)
+static int __devinit try_init_spmi(struct SPMITable *spmi)
 {
        struct smi_info  *info;
@@ -2106,7 +2127,7 @@ static int try_init_spmi(struct SPMITable *spmi)
        return 0;
 }
-static void spmi_find_bmc(void)
+static void __devinit spmi_find_bmc(void)
 {
        acpi_status      status;
        struct SPMITable *spmi;
@@ -2128,7 +2149,7 @@ static void spmi_find_bmc(void)
        }
 }
-static int ipmi_pnp_probe(struct pnp_dev *dev,
+static int __devinit ipmi_pnp_probe(struct pnp_dev *dev,
                                    const struct pnp_device_id *dev_id)
 {
        struct acpi_device *acpi_dev;
@@ -2228,7 +2249,7 @@ err_free:
        return -EINVAL;
 }
-static void ipmi_pnp_remove(struct pnp_dev *dev)
+static void __devexit ipmi_pnp_remove(struct pnp_dev *dev)
 {
        struct smi_info *info = pnp_get_drvdata(dev);
@@ -2243,7 +2264,7 @@ static const struct pnp_device_id pnp_dev_table[] = {
 static struct pnp_driver ipmi_pnp_driver = {
        .name           = DEVICE_NAME,
        .probe          = ipmi_pnp_probe,
-        .remove         = ipmi_pnp_remove,
+        .remove         = __devexit_p(ipmi_pnp_remove),
        .id_table       = pnp_dev_table,
 };
 #endif
@@ -2258,7 +2279,7 @@ struct dmi_ipmi_data {
        u8              slave_addr;
 };
-static int decode_dmi(const struct dmi_header *dm,
+static int __devinit decode_dmi(const struct dmi_header *dm,
                                struct dmi_ipmi_data *dmi)
 {
        const u8        *data = (const u8 *)dm;
@@ -2320,7 +2341,7 @@ static int decode_dmi(const struct dmi_header *dm,
        return 0;
 }
-static void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
+static void __devinit try_init_dmi(struct dmi_ipmi_data *ipmi_data)
 {
        struct smi_info *info;
@@ -2388,7 +2409,7 @@ static void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
                kfree(info);
 }
-static void dmi_find_bmc(void)
+static void __devinit dmi_find_bmc(void)
 {
        const struct dmi_device *dev = NULL;
        struct dmi_ipmi_data data;
@@ -2424,39 +2445,7 @@ static void ipmi_pci_cleanup(struct smi_info *info)
        pci_disable_device(pdev);
 }
-static int ipmi_pci_probe_regspacing(struct smi_info *info)
+static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
-{
-        if (info->si_type == SI_KCS) {
-                unsigned char   status;
-                int             regspacing;
-                info->io.regsize = DEFAULT_REGSIZE;
-                info->io.regshift = 0;
-                info->io_size = 2;
-                info->handlers = &kcs_smi_handlers;
-                /* detect 1, 4, 16byte spacing */
-                for (regspacing = DEFAULT_REGSPACING; regspacing <= 16;) {
-                        info->io.regspacing = regspacing;
-                        if (info->io_setup(info)) {
-                                dev_err(info->dev,
-                                        "Could not setup I/O space\n");
-                                return DEFAULT_REGSPACING;
-                        }
-                        /* write invalid cmd */
-                        info->io.outputb(&info->io, 1, 0x10);
-                        /* read status back */
-                        status = info->io.inputb(&info->io, 1);
-                        info->io_cleanup(info);
-                        if (status)
-                                return regspacing;
-                        regspacing *= 4;
-                }
-        }
-        return DEFAULT_REGSPACING;
-}
-static int ipmi_pci_probe(struct pci_dev *pdev,
                                    const struct pci_device_id *ent)
 {
        int rv;
@@ -2508,8 +2497,8 @@ static int ipmi_pci_probe(struct pci_dev *pdev,
        }
        info->io.addr_data = pci_resource_start(pdev, 0);
-        info->io.regspacing = ipmi_pci_probe_regspacing(info);
+        info->io.regspacing = DEFAULT_REGSPACING;
-        info->io.regsize = DEFAULT_REGSIZE;
+        info->io.regsize = DEFAULT_REGSPACING;
        info->io.regshift = 0;
        info->irq = pdev->irq;
@@ -2529,12 +2518,24 @@ static int ipmi_pci_probe(struct pci_dev *pdev,
        return 0;
 }
-static void ipmi_pci_remove(struct pci_dev *pdev)
+static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
 {
        struct smi_info *info = pci_get_drvdata(pdev);
        cleanup_one_si(info);
 }
+#ifdef CONFIG_PM
+static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
+{
+        return 0;
+}
+static int ipmi_pci_resume(struct pci_dev *pdev)
+{
+        return 0;
+}
+#endif
 static struct pci_device_id ipmi_pci_devices[] = {
        { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
        { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) },
@@ -2546,12 +2547,16 @@ static struct pci_driver ipmi_pci_driver = {
        .name =         DEVICE_NAME,
        .id_table =     ipmi_pci_devices,
        .probe =        ipmi_pci_probe,
-        .remove =       ipmi_pci_remove,
+        .remove =       __devexit_p(ipmi_pci_remove),
+#ifdef CONFIG_PM
+        .suspend =      ipmi_pci_suspend,
+        .resume =       ipmi_pci_resume,
+#endif
 };
 #endif /* CONFIG_PCI */
 static struct of_device_id ipmi_match[];
-static int ipmi_probe(struct platform_device *dev)
+static int __devinit ipmi_probe(struct platform_device *dev)
 {
 #ifdef CONFIG_OF
        const struct of_device_id *match;
@@ -2635,7 +2640,7 @@ static int ipmi_probe(struct platform_device *dev)
        return 0;
 }
-static int ipmi_remove(struct platform_device *dev)
+static int __devexit ipmi_remove(struct platform_device *dev)
 {
 #ifdef CONFIG_OF
        cleanup_one_si(dev_get_drvdata(&dev->dev));
@@ -2661,7 +2666,7 @@ static struct platform_driver ipmi_driver = {
                .of_match_table = ipmi_match,
        },
        .probe          = ipmi_probe,
-        .remove         = ipmi_remove,
+        .remove         = __devexit_p(ipmi_remove),
 };
 static int wait_for_msg_done(struct smi_info *smi_info)
@@ -3047,7 +3052,7 @@ static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
        }
 }
-static struct ipmi_default_vals
+static __devinitdata struct ipmi_default_vals
 {
        int type;
        int port;
@@ -3059,7 +3064,7 @@ static struct ipmi_default_vals
        { .port = 0 }
 };
-static void default_find_bmc(void)
+static void __devinit default_find_bmc(void)
 {
        struct smi_info *info;
        int             i;
@@ -3359,7 +3364,7 @@ static int try_smi_init(struct smi_info *new_smi)
        return rv;
 }
-static int init_ipmi_si(void)
+static int __devinit init_ipmi_si(void)
 {
        int  i;
        char *str;
diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
index 37b8be7cba9..3302586655c 100644
--- a/drivers/char/ipmi/ipmi_watchdog.c
+++ b/drivers/char/ipmi/ipmi_watchdog.c
@@ -65,7 +65,6 @@
 * mechanism for it at that time.
 */
 #include <asm/kdebug.h>
-#include <asm/nmi.h>
 #define HAVE_DIE_NMI
 #endif
@@ -139,10 +138,19 @@
 #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)
+#endif
+#ifndef WDIOC_SET_PRETIMEOUT
+#define WDIOC_SET_PRETIMEOUT     _IOW(WATCHDOG_IOCTL_BASE, 21, int)
+#endif
+#ifndef WDIOC_GET_PRETIMEOUT
+#define WDIOC_GET_PRETIMEOUT     _IOW(WATCHDOG_IOCTL_BASE, 22, int)
+#endif
 static DEFINE_MUTEX(ipmi_watchdog_mutex);
-static bool nowayout = WATCHDOG_NOWAYOUT;
+static int nowayout = WATCHDOG_NOWAYOUT;
 static ipmi_user_t watchdog_user;
 static int watchdog_ifnum;
@@ -309,7 +317,7 @@ module_param(start_now, int, 0444);
 MODULE_PARM_DESC(start_now, "Set to 1 to start the watchdog as"
                 "soon as the driver is loaded.");
-module_param(nowayout, bool, 0644);
+module_param(nowayout, int, 0644);
 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
                 "(default=CONFIG_WATCHDOG_NOWAYOUT)");
@@ -509,7 +517,6 @@ static void panic_halt_ipmi_heartbeat(void)
        msg.cmd = IPMI_WDOG_RESET_TIMER;
        msg.data = NULL;
        msg.data_len = 0;
-        atomic_add(2, &panic_done_count);
        rv = ipmi_request_supply_msgs(watchdog_user,
                                      (struct ipmi_addr *) &addr,
                                      0,
@@ -518,8 +525,8 @@ static void panic_halt_ipmi_heartbeat(void)
                                      &panic_halt_heartbeat_smi_msg,
                                      &panic_halt_heartbeat_recv_msg,
                                      1);
-        if (rv)
+        if (!rv)
-                atomic_sub(2, &panic_done_count);
+                atomic_add(2, &panic_done_count);
 }
 static struct ipmi_smi_msg panic_halt_smi_msg = {
@@ -543,18 +550,16 @@ static void panic_halt_ipmi_set_timeout(void)
        /* Wait for the messages to be free. */
        while (atomic_read(&panic_done_count) != 0)
                ipmi_poll_interface(watchdog_user);
-        atomic_add(2, &panic_done_count);
        rv = i_ipmi_set_timeout(&panic_halt_smi_msg,
                                &panic_halt_recv_msg,
                                &send_heartbeat_now);
-        if (rv) {
+        if (!rv) {
-                atomic_sub(2, &panic_done_count);
+                atomic_add(2, &panic_done_count);
-                printk(KERN_WARNING PFX
-                       "Unable to extend the watchdog timeout.");
-        } else {
                if (send_heartbeat_now)
                        panic_halt_ipmi_heartbeat();
-        }
+        } else
+                printk(KERN_WARNING PFX
+                       "Unable to extend the watchdog timeout.");
        while (atomic_read(&panic_done_count) != 0)
                ipmi_poll_interface(watchdog_user);
 }
@@ -590,7 +595,6 @@ 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;
@@ -611,7 +615,6 @@ static int ipmi_heartbeat(void)
        mutex_lock(&heartbeat_lock);
-restart:
        atomic_set(&heartbeat_tofree, 2);
        /*
@@ -649,33 +652,7 @@ restart:
        /* Wait for the heartbeat to be sent. */
        wait_for_completion(&heartbeat_wait);
-        if (heartbeat_recv_msg.msg.data[0] == IPMI_WDOG_TIMER_NOT_INIT_RESP)  {
+        if (heartbeat_recv_msg.msg.data[0] != 0) {
-                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
@@ -684,7 +661,6 @@ restart:
                rv = -EINVAL;
        }
-out_unlock:
        mutex_unlock(&heartbeat_lock);
        return rv;
@@ -721,6 +697,7 @@ static int ipmi_ioctl(struct file *file,
                        return -EFAULT;
                return 0;
+        case WDIOC_SET_PRETIMEOUT:
        case WDIOC_SETPRETIMEOUT:
                i = copy_from_user(&val, argp, sizeof(int));
                if (i)
@@ -728,6 +705,7 @@ static int ipmi_ioctl(struct file *file,
                pretimeout = val;
                return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
+        case WDIOC_GET_PRETIMEOUT:
        case WDIOC_GETPRETIMEOUT:
                i = copy_to_user(argp, &pretimeout, sizeof(pretimeout));
                if (i)
@@ -943,15 +921,11 @@ static struct miscdevice ipmi_wdog_miscdev = {
 static void ipmi_wdog_msg_handler(struct ipmi_recv_msg *msg,
                                  void                 *handler_data)
 {
-        if (msg->msg.cmd == IPMI_WDOG_RESET_TIMER &&
+        if (msg->msg.data[0] != 0) {
-                        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);
 }
@@ -1103,8 +1077,17 @@ static void ipmi_unregister_watchdog(int ipmi_intf)
 #ifdef HAVE_DIE_NMI
 static int
-ipmi_nmi(unsigned int val, struct pt_regs *regs)
+ipmi_nmi(struct notifier_block *self, unsigned long val, void *data)
 {
+        struct die_args *args = data;
+        if (val != DIE_NMIUNKNOWN)
+                return NOTIFY_OK;
+        /* Hack, if it's a memory or I/O error, ignore it. */
+        if (args->err & 0xc0)
+                return NOTIFY_OK;
        /*
         * If we get here, it's an NMI that's not a memory or I/O
         * error.  We can't truly tell if it's from IPMI or not
@@ -1114,15 +1097,15 @@ ipmi_nmi(unsigned int val, struct pt_regs *regs)
        if (testing_nmi) {
                testing_nmi = 2;
-                return NMI_HANDLED;
+                return NOTIFY_STOP;
        }
        /* If we are not expecting a timeout, ignore it. */
        if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
-                return NMI_DONE;
+                return NOTIFY_OK;
        if (preaction_val != WDOG_PRETIMEOUT_NMI)
-                return NMI_DONE;
+                return NOTIFY_OK;
        /*
         * If no one else handled the NMI, we assume it was the IPMI
@@ -1137,8 +1120,12 @@ ipmi_nmi(unsigned int val, struct pt_regs *regs)
                        panic(PFX "pre-timeout");
        }
-        return NMI_HANDLED;
+        return NOTIFY_STOP;
 }
+static struct notifier_block ipmi_nmi_handler = {
+        .notifier_call = ipmi_nmi
+};
 #endif
 static int wdog_reboot_handler(struct notifier_block *this,
@@ -1154,7 +1141,7 @@ static int wdog_reboot_handler(struct notifier_block *this,
                if (code == SYS_POWER_OFF || code == SYS_HALT) {
                        /* Disable the WDT if we are shutting down. */
                        ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
-                        ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
+                        panic_halt_ipmi_set_timeout();
                } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
                        /* Set a long timer to let the reboot happens, but
                           reboot if it hangs, but only if the watchdog
@@ -1162,7 +1149,7 @@ static int wdog_reboot_handler(struct notifier_block *this,
                        timeout = 120;
                        pretimeout = 0;
                        ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
-                        ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
+                        panic_halt_ipmi_set_timeout();
                }
        }
        return NOTIFY_OK;
@@ -1303,8 +1290,7 @@ static void check_parms(void)
                }
        }
        if (do_nmi && !nmi_handler_registered) {
-                rv = register_nmi_handler(NMI_UNKNOWN, ipmi_nmi, 0,
+                rv = register_die_notifier(&ipmi_nmi_handler);
-                                                "ipmi");
                if (rv) {
                        printk(KERN_WARNING PFX
                               "Can't register nmi handler\n");
@@ -1312,7 +1298,7 @@ static void check_parms(void)
                } else
                        nmi_handler_registered = 1;
        } else if (!do_nmi && nmi_handler_registered) {
-                unregister_nmi_handler(NMI_UNKNOWN, "ipmi");
+                unregister_die_notifier(&ipmi_nmi_handler);
                nmi_handler_registered = 0;
        }
 #endif
@@ -1350,7 +1336,7 @@ static int __init ipmi_wdog_init(void)
        if (rv) {
 #ifdef HAVE_DIE_NMI
                if (nmi_handler_registered)
-                        unregister_nmi_handler(NMI_UNKNOWN, "ipmi");
+                        unregister_die_notifier(&ipmi_nmi_handler);
 #endif
                atomic_notifier_chain_unregister(&panic_notifier_list,
                                                 &wdog_panic_notifier);
@@ -1371,7 +1357,7 @@ static void __exit ipmi_wdog_exit(void)
 #ifdef HAVE_DIE_NMI
        if (nmi_handler_registered)
-                unregister_nmi_handler(NMI_UNKNOWN, "ipmi");
+                unregister_die_notifier(&ipmi_nmi_handler);
 #endif
        atomic_notifier_chain_unregister(&panic_notifier_list,
diff --git a/drivers/char/lp.c b/drivers/char/lp.c
index a741e418b45..97c3edb95ae 100644
--- a/drivers/char/lp.c
+++ b/drivers/char/lp.c
@@ -135,6 +135,7 @@
 #include <asm/irq.h>
 #include <asm/uaccess.h>
+#include <asm/system.h>
 /* if you have more than 8 printers, remember to increase LP_NO */
 #define LP_NO 8
@@ -705,13 +706,16 @@ static long lp_compat_ioctl(struct file *file, unsigned int cmd,
 {
        unsigned int minor;
        struct timeval par_timeout;
+        struct compat_timeval __user *tc;
        int ret;
        minor = iminor(file->f_path.dentry->d_inode);
        mutex_lock(&lp_mutex);
        switch (cmd) {
        case LPSETTIMEOUT:
-                if (compat_get_timeval(&par_timeout, compat_ptr(arg))) {
+                tc = compat_ptr(arg);
+                if (get_user(par_timeout.tv_sec, &tc->tv_sec) ||
+                    get_user(par_timeout.tv_usec, &tc->tv_usec)) {
                        ret = -EFAULT;
                        break;
                }
@@ -825,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 bool reset;
+static int reset;
 module_param_array(parport, charp, NULL, 0);
 module_param(reset, bool, 0);
diff --git a/drivers/char/mbcs.c b/drivers/char/mbcs.c
index e5d3e3f7a49..1aeaaba680d 100644
--- a/drivers/char/mbcs.c
+++ b/drivers/char/mbcs.c
@@ -28,6 +28,7 @@
 #include <linux/slab.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
+#include <asm/system.h>
 #include <asm/pgtable.h>
 #include <asm/sn/addrs.h>
 #include <asm/sn/intr.h>
@@ -507,7 +508,7 @@ static int mbcs_gscr_mmap(struct file *fp, struct vm_area_struct *vma)
        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
-        /* Remap-pfn-range will mark the range VM_IO */
+        /* Remap-pfn-range will mark the range VM_IO and VM_RESERVED */
        if (remap_pfn_range(vma,
                            vma->vm_start,
                            __pa(soft->gscr_addr) >> PAGE_SHIFT,
@@ -799,7 +800,7 @@ static int mbcs_remove(struct cx_dev *dev)
        return 0;
 }
-static const struct cx_device_id mbcs_id_table[] = {
+static const struct cx_device_id __devinitdata mbcs_id_table[] = {
        {
         .part_num = MBCS_PART_NUM,
         .mfg_num = MBCS_MFG_NUM,
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index c6fa3bc2baa..9b1eb188acd 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -26,17 +26,14 @@
 #include <linux/bootmem.h>
 #include <linux/splice.h>
 #include <linux/pfn.h>
-#include <linux/export.h>
-#include <linux/io.h>
 #include <asm/uaccess.h>
+#include <asm/io.h>
 #ifdef CONFIG_IA64
 # include <linux/efi.h>
 #endif
-#define DEVPORT_MINOR   4
 static inline unsigned long size_inside_page(unsigned long start,
                                             unsigned long size)
 {
@@ -48,7 +45,7 @@ static inline unsigned long size_inside_page(unsigned long start,
 }
 #ifndef ARCH_HAS_VALID_PHYS_ADDR_RANGE
-static inline int valid_phys_addr_range(phys_addr_t addr, size_t count)
+static inline int valid_phys_addr_range(unsigned long addr, size_t count)
 {
        return addr + count <= __pa(high_memory);
 }
@@ -59,6 +56,7 @@ static inline int valid_mmap_phys_addr_range(unsigned long pfn, size_t size)
 }
 #endif
+#if defined(CONFIG_DEVMEM) || defined(CONFIG_DEVKMEM)
 #ifdef CONFIG_STRICT_DEVMEM
 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
 {
@@ -84,7 +82,9 @@ static inline int range_is_allowed(unsigned long pfn, unsigned long size)
        return 1;
 }
 #endif
+#endif
+#ifdef CONFIG_DEVMEM
 void __weak unxlate_dev_mem_ptr(unsigned long phys, void *addr)
 {
 }
@@ -96,7 +96,7 @@ void __weak unxlate_dev_mem_ptr(unsigned long phys, void *addr)
 static ssize_t read_mem(struct file *file, char __user *buf,
                        size_t count, loff_t *ppos)
 {
-        phys_addr_t p = *ppos;
+        unsigned long p = *ppos;
        ssize_t read, sz;
        char *ptr;
@@ -153,7 +153,7 @@ static ssize_t read_mem(struct file *file, char __user *buf,
 static ssize_t write_mem(struct file *file, const char __user *buf,
                         size_t count, loff_t *ppos)
 {
-        phys_addr_t p = *ppos;
+        unsigned long p = *ppos;
        ssize_t written, sz;
        unsigned long copied;
        void *ptr;
@@ -211,6 +211,9 @@ static ssize_t write_mem(struct file *file, const char __user *buf,
        *ppos += written;
        return written;
 }
+#endif  /* CONFIG_DEVMEM */
+#if defined(CONFIG_DEVMEM) || defined(CONFIG_DEVKMEM)
 int __weak phys_mem_access_prot_allowed(struct file *file,
        unsigned long pfn, unsigned long size, pgprot_t *vma_prot)
@@ -226,7 +229,7 @@ int __weak phys_mem_access_prot_allowed(struct file *file,
 *
 */
 #ifdef pgprot_noncached
-static int uncached_access(struct file *file, phys_addr_t addr)
+static int uncached_access(struct file *file, unsigned long addr)
 {
 #if defined(CONFIG_IA64)
        /*
@@ -258,7 +261,7 @@ static pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
                                     unsigned long size, pgprot_t vma_prot)
 {
 #ifdef pgprot_noncached
-        phys_addr_t offset = pfn << PAGE_SHIFT;
+        unsigned long offset = pfn << PAGE_SHIFT;
        if (uncached_access(file, offset))
                return pgprot_noncached(vma_prot);
@@ -322,7 +325,7 @@ static int mmap_mem(struct file *file, struct vm_area_struct *vma)
        vma->vm_ops = &mmap_mem_ops;
-        /* Remap-pfn-range will mark the range VM_IO */
+        /* Remap-pfn-range will mark the range VM_IO and VM_RESERVED */
        if (remap_pfn_range(vma,
                            vma->vm_start,
                            vma->vm_pgoff,
@@ -332,6 +335,7 @@ static int mmap_mem(struct file *file, struct vm_area_struct *vma)
        }
        return 0;
 }
+#endif  /* CONFIG_DEVMEM */
 #ifdef CONFIG_DEVKMEM
 static int mmap_kmem(struct file *file, struct vm_area_struct *vma)
@@ -696,6 +700,8 @@ static loff_t null_lseek(struct file *file, loff_t offset, int orig)
        return file->f_pos = 0;
 }
+#if defined(CONFIG_DEVMEM) || defined(CONFIG_DEVKMEM) || defined(CONFIG_DEVPORT)
 /*
 * The memory devices use the full 32/64 bits of the offset, and so we cannot
 * check against negative addresses: they are ok. The return value is weird,
@@ -729,10 +735,14 @@ static loff_t memory_lseek(struct file *file, loff_t offset, int orig)
        return ret;
 }
+#endif
+#if defined(CONFIG_DEVMEM) || defined(CONFIG_DEVKMEM) || defined(CONFIG_DEVPORT)
 static int open_port(struct inode * inode, struct file * filp)
 {
        return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
 }
+#endif
 #define zero_lseek      null_lseek
 #define full_lseek      null_lseek
@@ -742,6 +752,7 @@ static int open_port(struct inode * inode, struct file * filp)
 #define open_kmem       open_mem
 #define open_oldmem     open_mem
+#ifdef CONFIG_DEVMEM
 static const struct file_operations mem_fops = {
        .llseek         = memory_lseek,
        .read           = read_mem,
@@ -750,6 +761,7 @@ static const struct file_operations mem_fops = {
        .open           = open_mem,
        .get_unmapped_area = get_unmapped_area_mem,
 };
+#endif
 #ifdef CONFIG_DEVKMEM
 static const struct file_operations kmem_fops = {
@@ -809,13 +821,53 @@ static const struct file_operations oldmem_fops = {
 };
 #endif
+static ssize_t kmsg_writev(struct kiocb *iocb, const struct iovec *iv,
+                           unsigned long count, loff_t pos)
+{
+        char *line, *p;
+        int i;
+        ssize_t ret = -EFAULT;
+        size_t len = iov_length(iv, count);
+        line = kmalloc(len + 1, GFP_KERNEL);
+        if (line == NULL)
+                return -ENOMEM;
+        /*
+         * copy all vectors into a single string, to ensure we do
+         * not interleave our log line with other printk calls
+         */
+        p = line;
+        for (i = 0; i < count; i++) {
+                if (copy_from_user(p, iv[i].iov_base, iv[i].iov_len))
+                        goto out;
+                p += iv[i].iov_len;
+        }
+        p[0] = '\0';
+        ret = printk("%s", line);
+        /* printk can add a prefix */
+        if (ret > len)
+                ret = len;
+out:
+        kfree(line);
+        return ret;
+}
+static const struct file_operations kmsg_fops = {
+        .aio_write = kmsg_writev,
+        .llseek = noop_llseek,
+};
 static const struct memdev {
        const char *name;
-        umode_t mode;
+        mode_t mode;
        const struct file_operations *fops;
        struct backing_dev_info *dev_info;
 } devlist[] = {
+#ifdef CONFIG_DEVMEM
         [1] = { "mem", 0, &mem_fops, &directly_mappable_cdev_bdi },
+#endif
 #ifdef CONFIG_DEVKMEM
         [2] = { "kmem", 0, &kmem_fops, &directly_mappable_cdev_bdi },
 #endif
@@ -827,9 +879,7 @@ static const struct memdev {
         [7] = { "full", 0666, &full_fops, NULL },
         [8] = { "random", 0666, &random_fops, NULL },
         [9] = { "urandom", 0666, &urandom_fops, NULL },
-#ifdef CONFIG_PRINTK
+        [11] = { "kmsg", 0, &kmsg_fops, NULL },
-        [11] = { "kmsg", 0644, &kmsg_fops, NULL },
-#endif
 #ifdef CONFIG_CRASH_DUMP
        [12] = { "oldmem", 0, &oldmem_fops, NULL },
 #endif
@@ -867,7 +917,7 @@ static const struct file_operations memory_fops = {
        .llseek = noop_llseek,
 };
-static char *mem_devnode(struct device *dev, umode_t *mode)
+static char *mem_devnode(struct device *dev, mode_t *mode)
 {
        if (mode && devlist[MINOR(dev->devt)].mode)
                *mode = devlist[MINOR(dev->devt)].mode;
@@ -896,13 +946,6 @@ static int __init chr_dev_init(void)
        for (minor = 1; minor < ARRAY_SIZE(devlist); minor++) {
                if (!devlist[minor].name)
                        continue;
-                /*
-                 * Create /dev/port? 
-                 */
-                if ((minor == DEVPORT_MINOR) && !arch_has_dev_port())
-                        continue;
                device_create(mem_class, NULL, MKDEV(MEM_MAJOR, minor),
                              NULL, devlist[minor].name);
        }
diff --git a/drivers/char/misc.c b/drivers/char/misc.c
index 522136d4084..778273c9324 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, umode_t *mode)
+static char *misc_devnode(struct device *dev, mode_t *mode)
 {
        struct miscdevice *c = dev_get_drvdata(dev);
diff --git a/drivers/char/mmtimer.c b/drivers/char/mmtimer.c
index 3d6c0671e99..33dc2298af7 100644
--- a/drivers/char/mmtimer.c
+++ b/drivers/char/mmtimer.c
@@ -826,7 +826,7 @@ static int __init mmtimer_init(void)
        /* Allocate list of node ptrs to mmtimer_t's */
        timers = kzalloc(sizeof(struct mmtimer_node)*maxn, GFP_KERNEL);
-        if (!timers) {
+        if (timers == NULL) {
                printk(KERN_ERR "%s: failed to allocate memory for device\n",
                                MMTIMER_NAME);
                goto out3;
@@ -848,6 +848,7 @@ static int __init mmtimer_init(void)
        return 0;
 out3:
+        kfree(timers);
        misc_deregister(&mmtimer_miscdev);
 out2:
        free_irq(SGI_MMTIMER_VECTOR, NULL);
diff --git a/drivers/char/mspec.c b/drivers/char/mspec.c
index e1f60f968fd..5c0d96a820f 100644
--- a/drivers/char/mspec.c
+++ b/drivers/char/mspec.c
@@ -44,6 +44,7 @@
 #include <linux/slab.h>
 #include <linux/numa.h>
 #include <asm/page.h>
+#include <asm/system.h>
 #include <asm/pgtable.h>
 #include <linux/atomic.h>
 #include <asm/tlbflush.h>
@@ -283,10 +284,10 @@ mspec_mmap(struct file *file, struct vm_area_struct *vma,
        vdata->flags = flags;
        vdata->type = type;
        spin_lock_init(&vdata->lock);
-        atomic_set(&vdata->refcnt, 1);
+        vdata->refcnt = ATOMIC_INIT(1);
        vma->vm_private_data = vdata;
-        vma->vm_flags |= VM_IO | VM_PFNMAP | VM_DONTEXPAND | VM_DONTDUMP;
+        vma->vm_flags |= (VM_IO | VM_RESERVED | VM_PFNMAP | VM_DONTEXPAND);
        if (vdata->type == MSPEC_FETCHOP || vdata->type == MSPEC_UNCACHED)
                vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
        vma->vm_ops = &mspec_vm_ops;
diff --git a/drivers/char/mwave/3780i.c b/drivers/char/mwave/3780i.c
index 881c9e59593..492dbfb2efd 100644
--- a/drivers/char/mwave/3780i.c
+++ b/drivers/char/mwave/3780i.c
@@ -56,6 +56,7 @@
 #include <asm/io.h>
 #include <asm/uaccess.h>
+#include <asm/system.h>
 #include <asm/irq.h>
 #include "smapi.h"
 #include "mwavedd.h"
diff --git a/drivers/char/mwave/mwavedd.c b/drivers/char/mwave/mwavedd.c
index 164544afd68..1d82d5838f0 100644
--- a/drivers/char/mwave/mwavedd.c
+++ b/drivers/char/mwave/mwavedd.c
@@ -430,7 +430,7 @@ static ssize_t mwave_write(struct file *file, const char __user *buf,
 static int register_serial_portandirq(unsigned int port, int irq)
 {
-        struct uart_8250_port uart;
+        struct uart_port uart;
        
        switch ( port ) {
                case 0x3f8:
@@ -462,14 +462,14 @@ static int register_serial_portandirq(unsigned int port, int irq)
        } /* switch */
        /* irq is okay */
-        memset(&uart, 0, sizeof(uart));
+        memset(&uart, 0, sizeof(struct uart_port));
        
-        uart.port.uartclk =  1843200;
+        uart.uartclk =  1843200;
-        uart.port.iobase = port;
+        uart.iobase = port;
-        uart.port.irq = irq;
+        uart.irq = irq;
-        uart.port.iotype = UPIO_PORT;
+        uart.iotype = UPIO_PORT;
-        uart.port.flags =  UPF_SHARE_IRQ;
+        uart.flags =  UPF_SHARE_IRQ;
-        return serial8250_register_8250_port(&uart);
+        return serial8250_register_port(&uart);
 }
diff --git a/drivers/char/nvram.c b/drivers/char/nvram.c
index 9df78e2cc45..da3cfee782d 100644
--- a/drivers/char/nvram.c
+++ b/drivers/char/nvram.c
@@ -94,7 +94,7 @@
 /* Note that *all* calls to CMOS_READ and CMOS_WRITE must be done with
 * rtc_lock held. Due to the index-port/data-port design of the RTC, we
 * don't want two different things trying to get to it at once. (e.g. the
- * periodic 11 min sync from kernel/time/ntp.c vs. this driver.)
+ * periodic 11 min sync from time.c vs. this driver.)
 */
 #include <linux/types.h>
@@ -111,6 +111,7 @@
 #include <linux/uaccess.h>
 #include <linux/mutex.h>
+#include <asm/system.h>
 static DEFINE_MUTEX(nvram_mutex);
 static DEFINE_SPINLOCK(nvram_state_lock);
diff --git a/drivers/char/nwbutton.c b/drivers/char/nwbutton.c
index cfdfe493c6a..04a480f86c6 100644
--- a/drivers/char/nwbutton.c
+++ b/drivers/char/nwbutton.c
@@ -93,9 +93,9 @@ int button_del_callback (void (*callback) (void))
                        button_callback_list [lp].count = 0;
                        callback_count--;
                        return 0;
-                }
+                };
                lp--;
-        }
+        };
        return -EINVAL;
 }
diff --git a/drivers/char/nwflash.c b/drivers/char/nwflash.c
index e371480d363..a12f52400db 100644
--- a/drivers/char/nwflash.c
+++ b/drivers/char/nwflash.c
@@ -30,7 +30,9 @@
 #include <asm/hardware/dec21285.h>
 #include <asm/io.h>
+#include <asm/leds.h>
 #include <asm/mach-types.h>
+#include <asm/system.h>
 #include <asm/uaccess.h>
 /*****************************************************************************/
@@ -49,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 bool flashdebug;         //if set - we will display progress msgs
+static int flashdebug;          //if set - we will display progress msgs
 static int gbWriteEnable;
 static int gbWriteBase64Enable;
@@ -178,6 +180,9 @@ static ssize_t flash_write(struct file *file, const char __user *buf,
        written = 0;
+        leds_event(led_claim);
+        leds_event(led_green_on);
        nBlock = (int) p >> 16; //block # of 64K bytes
        /*
@@ -254,6 +259,11 @@ static ssize_t flash_write(struct file *file, const char __user *buf,
                        printk(KERN_DEBUG "flash_write: written 0x%X bytes OK.\n", written);
        }
+        /*
+         * restore reg on exit
+         */
+        leds_event(led_release);
        mutex_unlock(&nwflash_mutex);
        return written;
@@ -325,6 +335,11 @@ static int erase_block(int nBlock)
        int temp, temp1;
        /*
+         * orange LED == erase
+         */
+        leds_event(led_amber_on);
+        /*
         * reset footbridge to the correct offset 0 (...0..3)
         */
        *CSR_ROMWRITEREG = 0;
@@ -432,6 +447,12 @@ static int write_block(unsigned long p, const char __user *buf, int count)
        unsigned long timeout;
        unsigned long timeout1;
+        /*
+         * red LED == write
+         */
+        leds_event(led_amber_off);
+        leds_event(led_red_on);
        pWritePtr = (unsigned char *) ((unsigned int) (FLASH_BASE + p));
        /*
@@ -538,9 +559,17 @@ static int write_block(unsigned long p, const char __user *buf, int count)
                                               pWritePtr - FLASH_BASE);
                                /*
+                                 * no LED == waiting
+                                 */
+                                leds_event(led_amber_off);
+                                /*
                                 * wait couple ms
                                 */
                                msleep(10);
+                                /*
+                                 * red LED == write
+                                 */
+                                leds_event(led_red_on);
                                goto WriteRetry;
                        } else {
@@ -555,6 +584,12 @@ static int write_block(unsigned long p, const char __user *buf, int count)
                }
        }
+        /*
+         * green LED == read/verify
+         */
+        leds_event(led_amber_off);
+        leds_event(led_green_on);
        msleep(10);
        pWritePtr = (unsigned char *) ((unsigned int) (FLASH_BASE + p));
@@ -583,9 +618,9 @@ static void kick_open(void)
         * we want to write a bit pattern XXX1 to Xilinx to enable
         * the write gate, which will be open for about the next 2ms.
         */
-        raw_spin_lock_irqsave(&nw_gpio_lock, flags);
+        spin_lock_irqsave(&nw_gpio_lock, flags);
        nw_cpld_modify(CPLD_FLASH_WR_ENABLE, CPLD_FLASH_WR_ENABLE);
-        raw_spin_unlock_irqrestore(&nw_gpio_lock, flags);
+        spin_unlock_irqrestore(&nw_gpio_lock, flags);
        /*
         * let the ISA bus to catch on...
diff --git a/drivers/char/pc8736x_gpio.c b/drivers/char/pc8736x_gpio.c
index 3f79a9fb6b1..b304ec05250 100644
--- a/drivers/char/pc8736x_gpio.c
+++ b/drivers/char/pc8736x_gpio.c
@@ -345,7 +345,8 @@ static void __exit pc8736x_gpio_cleanup(void)
        unregister_chrdev_region(MKDEV(major,0), PC8736X_GPIO_CT);
        release_region(pc8736x_gpio_base, PC8736X_GPIO_RANGE);
-        platform_device_unregister(pdev);
+        platform_device_del(pdev);
+        platform_device_put(pdev);
 }
 module_init(pc8736x_gpio_init);
diff --git a/drivers/char/pcmcia/synclink_cs.c b/drivers/char/pcmcia/synclink_cs.c
index b66eaa04f8c..15781396af2 100644
--- a/drivers/char/pcmcia/synclink_cs.c
+++ b/drivers/char/pcmcia/synclink_cs.c
@@ -60,6 +60,7 @@
 #include <linux/ioctl.h>
 #include <linux/synclink.h>
+#include <asm/system.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/dma.h>
@@ -438,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 bool break_on_load=0;
+static int break_on_load=0;
 /*
 * Driver major number, defaults to zero to get auto
@@ -549,10 +550,8 @@ static int mgslpc_probe(struct pcmcia_device *link)
    /* Initialize the struct pcmcia_device structure */
    ret = mgslpc_config(link);
-    if (ret) {
+    if (ret)
-            tty_port_destroy(&info->port);
            return ret;
-    }
    mgslpc_add_device(info);
@@ -893,14 +892,6 @@ static void rx_ready_async(MGSLPC_INFO *info, int tcd, struct tty_struct *tty)
        int work = 0;
        struct mgsl_icount *icount = &info->icount;
-        if (!tty) {
-                /* tty is not available anymore */
-                issue_command(info, CHA, CMD_RXRESET);
-                if (debug_level >= DEBUG_LEVEL_ISR)
-                        printk("%s(%d):rx_ready_async(tty=NULL)\n",__FILE__,__LINE__);
-                return;
-        }
        if (tcd) {
                /* early termination, get FIFO count from RBCL register */
                fifo_count = (unsigned char)(read_reg(info, CHA+RBCL) & 0x1f);
@@ -990,7 +981,7 @@ static void tx_done(MGSLPC_INFO *info, struct tty_struct *tty)
        else
 #endif
        {
-                if (tty && (tty->stopped || tty->hw_stopped)) {
+                if (tty->stopped || tty->hw_stopped) {
                        tx_stop(info);
                        return;
                }
@@ -1010,7 +1001,7 @@ static void tx_ready(MGSLPC_INFO *info, struct tty_struct *tty)
                if (!info->tx_active)
                        return;
        } else {
-                if (tty && (tty->stopped || tty->hw_stopped)) {
+                if (tty->stopped || tty->hw_stopped) {
                        tx_stop(info);
                        return;
                }
@@ -1060,12 +1051,13 @@ static void cts_change(MGSLPC_INFO *info, struct tty_struct *tty)
        wake_up_interruptible(&info->status_event_wait_q);
        wake_up_interruptible(&info->event_wait_q);
-        if (tty && tty_port_cts_enabled(&info->port)) {
+        if (info->port.flags & ASYNC_CTS_FLOW) {
                if (tty->hw_stopped) {
                        if (info->serial_signals & SerialSignal_CTS) {
                                if (debug_level >= DEBUG_LEVEL_ISR)
                                        printk("CTS tx start...");
-                                tty->hw_stopped = 0;
+                                if (tty)
+                                        tty->hw_stopped = 0;
                                tx_start(info, tty);
                                info->pending_bh |= BH_TRANSMIT;
                                return;
@@ -1074,7 +1066,8 @@ static void cts_change(MGSLPC_INFO *info, struct tty_struct *tty)
                        if (!(info->serial_signals & SerialSignal_CTS)) {
                                if (debug_level >= DEBUG_LEVEL_ISR)
                                        printk("CTS tx stop...");
-                                tty->hw_stopped = 1;
+                                if (tty)
+                                        tty->hw_stopped = 1;
                                tx_stop(info);
                        }
                }
@@ -1352,7 +1345,7 @@ static void shutdown(MGSLPC_INFO * info, struct tty_struct *tty)
        /* TODO:disable interrupts instead of reset to preserve signal states */
        reset_device(info);
-        if (!tty || tty->termios.c_cflag & HUPCL) {
+        if (!tty || tty->termios->c_cflag & HUPCL) {
                info->serial_signals &= ~(SerialSignal_DTR + SerialSignal_RTS);
                set_signals(info);
        }
@@ -1393,7 +1386,7 @@ static void mgslpc_program_hw(MGSLPC_INFO *info, struct tty_struct *tty)
        port_irq_enable(info, (unsigned char) PVR_DSR | PVR_RI);
        get_signals(info);
-        if (info->netcount || (tty && (tty->termios.c_cflag & CREAD)))
+        if (info->netcount || (tty && (tty->termios->c_cflag & CREAD)))
                rx_start(info);
        spin_unlock_irqrestore(&info->lock,flags);
@@ -1406,14 +1399,14 @@ static void mgslpc_change_params(MGSLPC_INFO *info, struct tty_struct *tty)
        unsigned cflag;
        int bits_per_char;
-        if (!tty)
+        if (!tty || !tty->termios)
                return;
        if (debug_level >= DEBUG_LEVEL_INFO)
                printk("%s(%d):mgslpc_change_params(%s)\n",
                         __FILE__,__LINE__, info->device_name );
-        cflag = tty->termios.c_cflag;
+        cflag = tty->termios->c_cflag;
        /* if B0 rate (hangup) specified then negate DTR and RTS */
        /* otherwise assert DTR and RTS */
@@ -1736,7 +1729,7 @@ static void mgslpc_throttle(struct tty_struct * tty)
        if (I_IXOFF(tty))
                mgslpc_send_xchar(tty, STOP_CHAR(tty));
-        if (tty->termios.c_cflag & CRTSCTS) {
+        if (tty->termios->c_cflag & CRTSCTS) {
                spin_lock_irqsave(&info->lock,flags);
                info->serial_signals &= ~SerialSignal_RTS;
                set_signals(info);
@@ -1765,7 +1758,7 @@ static void mgslpc_unthrottle(struct tty_struct * tty)
                        mgslpc_send_xchar(tty, START_CHAR(tty));
        }
-        if (tty->termios.c_cflag & CRTSCTS) {
+        if (tty->termios->c_cflag & CRTSCTS) {
                spin_lock_irqsave(&info->lock,flags);
                info->serial_signals |= SerialSignal_RTS;
                set_signals(info);
@@ -2301,8 +2294,8 @@ static void mgslpc_set_termios(struct tty_struct *tty, struct ktermios *old_term
                        tty->driver->name );
        /* just return if nothing has changed */
-        if ((tty->termios.c_cflag == old_termios->c_cflag)
+        if ((tty->termios->c_cflag == old_termios->c_cflag)
-            && (RELEVANT_IFLAG(tty->termios.c_iflag)
+            && (RELEVANT_IFLAG(tty->termios->c_iflag)
                == RELEVANT_IFLAG(old_termios->c_iflag)))
          return;
@@ -2310,7 +2303,7 @@ static void mgslpc_set_termios(struct tty_struct *tty, struct ktermios *old_term
        /* Handle transition to B0 status */
        if (old_termios->c_cflag & CBAUD &&
-            !(tty->termios.c_cflag & CBAUD)) {
+            !(tty->termios->c_cflag & CBAUD)) {
                info->serial_signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
                spin_lock_irqsave(&info->lock,flags);
                set_signals(info);
@@ -2319,9 +2312,9 @@ static void mgslpc_set_termios(struct tty_struct *tty, struct ktermios *old_term
        /* Handle transition away from B0 status */
        if (!(old_termios->c_cflag & CBAUD) &&
-            tty->termios.c_cflag & CBAUD) {
+            tty->termios->c_cflag & CBAUD) {
                info->serial_signals |= SerialSignal_DTR;
-                if (!(tty->termios.c_cflag & CRTSCTS) ||
+                if (!(tty->termios->c_cflag & CRTSCTS) ||
                    !test_bit(TTY_THROTTLED, &tty->flags)) {
                        info->serial_signals |= SerialSignal_RTS;
                }
@@ -2332,7 +2325,7 @@ static void mgslpc_set_termios(struct tty_struct *tty, struct ktermios *old_term
        /* Handle turning off CRTSCTS */
        if (old_termios->c_cflag & CRTSCTS &&
-            !(tty->termios.c_cflag & CRTSCTS)) {
+            !(tty->termios->c_cflag & CRTSCTS)) {
                tty->hw_stopped = 0;
                tx_release(tty);
        }
@@ -2491,7 +2484,7 @@ static int mgslpc_open(struct tty_struct *tty, struct file * filp)
        /* verify range of specified line number */
        line = tty->index;
-        if (line >= mgslpc_device_count) {
+        if ((line < 0) || (line >= mgslpc_device_count)) {
                printk("%s(%d):mgslpc_open with invalid line #%d.\n",
                        __FILE__,__LINE__,line);
                return -ENODEV;
@@ -2739,8 +2732,6 @@ static void mgslpc_add_device(MGSLPC_INFO *info)
 #if SYNCLINK_GENERIC_HDLC
        hdlcdev_init(info);
 #endif
-        tty_port_register_device(&info->port, serial_driver, info->line,
-                        &info->p_dev->dev);
 }
 static void mgslpc_remove_device(MGSLPC_INFO *remove_info)
@@ -2754,12 +2745,10 @@ static void mgslpc_remove_device(MGSLPC_INFO *remove_info)
                                last->next_device = info->next_device;
                        else
                                mgslpc_device_list = info->next_device;
-                        tty_unregister_device(serial_driver, info->line);
 #if SYNCLINK_GENERIC_HDLC
                        hdlcdev_exit(info);
 #endif
                        release_resources(info);
-                        tty_port_destroy(&info->port);
                        kfree(info);
                        mgslpc_device_count--;
                        return;
@@ -2810,63 +2799,78 @@ static const struct tty_operations mgslpc_ops = {
        .proc_fops = &mgslpc_proc_fops,
 };
-static int __init synclink_cs_init(void)
+static void synclink_cs_cleanup(void)
 {
        int rc;
-        if (break_on_load) {
+        while(mgslpc_device_list)
-                mgslpc_get_text_ptr();
+                mgslpc_remove_device(mgslpc_device_list);
-                BREAKPOINT();
-        }
-        serial_driver = tty_alloc_driver(MAX_DEVICE_COUNT,
+        if (serial_driver) {
-                        TTY_DRIVER_REAL_RAW |
+                if ((rc = tty_unregister_driver(serial_driver)))
-                        TTY_DRIVER_DYNAMIC_DEV);
+                        printk("%s(%d) failed to unregister tty driver err=%d\n",
-        if (IS_ERR(serial_driver)) {
+                               __FILE__,__LINE__,rc);
-                rc = PTR_ERR(serial_driver);
+                put_tty_driver(serial_driver);
-                goto err;
        }
-        /* Initialize the tty_driver structure */
+        pcmcia_unregister_driver(&mgslpc_driver);
-        serial_driver->driver_name = "synclink_cs";
+}
-        serial_driver->name = "ttySLP";
-        serial_driver->major = ttymajor;
-        serial_driver->minor_start = 64;
-        serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
-        serial_driver->subtype = SERIAL_TYPE_NORMAL;
-        serial_driver->init_termios = tty_std_termios;
-        serial_driver->init_termios.c_cflag =
-        B9600 | CS8 | CREAD | HUPCL | CLOCAL;
-        tty_set_operations(serial_driver, &mgslpc_ops);
-        rc = tty_register_driver(serial_driver);
-        if (rc < 0) {
-                printk(KERN_ERR "%s(%d):Couldn't register serial driver\n",
-                                __FILE__, __LINE__);
-                goto err_put_tty;
-        }
-        rc = pcmcia_register_driver(&mgslpc_driver);
+static int __init synclink_cs_init(void)
-        if (rc < 0)
+{
-                goto err_unreg_tty;
+    int rc;
-        printk(KERN_INFO "%s %s, tty major#%d\n", driver_name, driver_version,
+    if (break_on_load) {
-                        serial_driver->major);
+            mgslpc_get_text_ptr();
+            BREAKPOINT();
+    }
-        return 0;
+    if ((rc = pcmcia_register_driver(&mgslpc_driver)) < 0)
-err_unreg_tty:
+            return rc;
-        tty_unregister_driver(serial_driver);
-err_put_tty:
+    serial_driver = alloc_tty_driver(MAX_DEVICE_COUNT);
-        put_tty_driver(serial_driver);
+    if (!serial_driver) {
-err:
+            rc = -ENOMEM;
-        return rc;
+            goto error;
+    }
+    /* Initialize the tty_driver structure */
+    serial_driver->owner = THIS_MODULE;
+    serial_driver->driver_name = "synclink_cs";
+    serial_driver->name = "ttySLP";
+    serial_driver->major = ttymajor;
+    serial_driver->minor_start = 64;
+    serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
+    serial_driver->subtype = SERIAL_TYPE_NORMAL;
+    serial_driver->init_termios = tty_std_termios;
+    serial_driver->init_termios.c_cflag =
+            B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+    serial_driver->flags = TTY_DRIVER_REAL_RAW;
+    tty_set_operations(serial_driver, &mgslpc_ops);
+    if ((rc = tty_register_driver(serial_driver)) < 0) {
+            printk("%s(%d):Couldn't register serial driver\n",
+                   __FILE__,__LINE__);
+            put_tty_driver(serial_driver);
+            serial_driver = NULL;
+            goto error;
+    }
+    printk("%s %s, tty major#%d\n",
+           driver_name, driver_version,
+           serial_driver->major);
+    return 0;
+error:
+    synclink_cs_cleanup();
+    return rc;
 }
 static void __exit synclink_cs_exit(void)
 {
-        pcmcia_unregister_driver(&mgslpc_driver);
+        synclink_cs_cleanup();
-        tty_unregister_driver(serial_driver);
-        put_tty_driver(serial_driver);
 }
 module_init(synclink_cs_init);
diff --git a/drivers/char/ppdev.c b/drivers/char/ppdev.c
index 1cd49241e60..3fcf80ff12f 100644
--- a/drivers/char/ppdev.c
+++ b/drivers/char/ppdev.c
@@ -251,8 +251,12 @@ static ssize_t pp_write (struct file * file, const char __user * buf,
                        break;
                }
-                if (signal_pending (current))
+                if (signal_pending (current)) {
+                        if (!bytes_written) {
+                                bytes_written = -EINTR;
+                        }
                        break;
+                }
                cond_resched();
        }
@@ -779,8 +783,7 @@ static int __init ppdev_init (void)
                err = PTR_ERR(ppdev_class);
                goto out_chrdev;
        }
-        err = parport_register_driver(&pp_driver);
+        if (parport_register_driver(&pp_driver)) {
-        if (err < 0) {
                printk (KERN_WARNING CHRDEV ": unable to register with parport\n");
                goto out_class;
        }
diff --git a/drivers/char/ps3flash.c b/drivers/char/ps3flash.c
index 588063ac951..d0c57c2e290 100644
--- a/drivers/char/ps3flash.c
+++ b/drivers/char/ps3flash.c
@@ -22,7 +22,6 @@
 #include <linux/miscdevice.h>
 #include <linux/slab.h>
 #include <linux/uaccess.h>
-#include <linux/module.h>
 #include <asm/lv1call.h>
 #include <asm/ps3stor.h>
@@ -363,7 +362,7 @@ static struct miscdevice ps3flash_misc = {
        .fops   = &ps3flash_fops,
 };
-static int ps3flash_probe(struct ps3_system_bus_device *_dev)
+static int __devinit ps3flash_probe(struct ps3_system_bus_device *_dev)
 {
        struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
        struct ps3flash_private *priv;
diff --git a/drivers/char/random.c b/drivers/char/random.c
index 85e81ec1451..c35a785005b 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -125,26 +125,21 @@
 * The current exported interfaces for gathering environmental noise
 * from the devices are:
 *
- *      void add_device_randomness(const void *buf, unsigned int size);
 *      void add_input_randomness(unsigned int type, unsigned int code,
 *                                unsigned int value);
- *      void add_interrupt_randomness(int irq, int irq_flags);
+ *      void add_interrupt_randomness(int irq);
 *      void add_disk_randomness(struct gendisk *disk);
 *
- * add_device_randomness() is for adding data to the random pool that
- * is likely to differ between two devices (or possibly even per boot).
- * This would be things like MAC addresses or serial numbers, or the
- * read-out of the RTC. This does *not* add any actual entropy to the
- * pool, but it initializes the pool to different values for devices
- * that might otherwise be identical and have very little entropy
- * available to them (particularly common in the embedded world).
- *
 * add_input_randomness() uses the input layer interrupt timing, as well as
 * the event type information from the hardware.
 *
- * add_interrupt_randomness() uses the interrupt timing as random
+ * add_interrupt_randomness() uses the inter-interrupt timing as random
- * inputs to the entropy pool. Using the cycle counters and the irq source
+ * inputs to the entropy pool.  Note that not all interrupts are good
- * as inputs, it feeds the randomness roughly once a second.
+ * sources of randomness!  For example, the timer interrupts is not a
+ * good choice, because the periodicity of the interrupts is too
+ * regular, and hence predictable to an attacker.  Network Interface
+ * Controller interrupts are a better measure, since the timing of the
+ * NIC interrupts are more unpredictable.
 *
 * add_disk_randomness() uses what amounts to the seek time of block
 * layer request events, on a per-disk_devt basis, as input to the
@@ -253,8 +248,6 @@
 #include <linux/percpu.h>
 #include <linux/cryptohash.h>
 #include <linux/fips.h>
-#include <linux/ptrace.h>
-#include <linux/kmemcheck.h>
 #ifdef CONFIG_GENERIC_HARDIRQS
 # include <linux/irq.h>
@@ -263,12 +256,8 @@
 #include <asm/processor.h>
 #include <asm/uaccess.h>
 #include <asm/irq.h>
-#include <asm/irq_regs.h>
 #include <asm/io.h>
-#define CREATE_TRACE_POINTS
-#include <trace/events/random.h>
 /*
 * Configuration information
 */
@@ -277,8 +266,6 @@
 #define SEC_XFER_SIZE 512
 #define EXTRACT_SIZE 10
-#define LONGS(x) (((x) + sizeof(unsigned long) - 1)/sizeof(unsigned long))
 /*
 * The minimum number of bits of entropy before we wake up a read on
 * /dev/random.  Should be enough to do a significant reseed.
@@ -399,7 +386,8 @@ static DECLARE_WAIT_QUEUE_HEAD(random_read_wait);
 static DECLARE_WAIT_QUEUE_HEAD(random_write_wait);
 static struct fasync_struct *fasync;
-static bool debug;
+#if 0
+static int debug;
 module_param(debug, bool, 0644);
 #define DEBUG_ENT(fmt, arg...) do { \
        if (debug) \
@@ -409,6 +397,9 @@ module_param(debug, bool, 0644);
                blocking_pool.entropy_count,\
                nonblocking_pool.entropy_count,\
                ## arg); } while (0)
+#else
+#define DEBUG_ENT(fmt, arg...) do {} while (0)
+#endif
 /**********************************************************************
 *
@@ -429,11 +420,8 @@ struct entropy_store {
        /* read-write data: */
        spinlock_t lock;
        unsigned add_ptr;
-        unsigned input_rotate;
        int entropy_count;
-        int entropy_total;
+        int input_rotate;
-        unsigned int initialized:1;
-        bool last_data_init;
        __u8 last_data[EXTRACT_SIZE];
 };
@@ -466,10 +454,6 @@ static struct entropy_store nonblocking_pool = {
        .pool = nonblocking_pool_data
 };
-static __u32 const twist_table[8] = {
-        0x00000000, 0x3b6e20c8, 0x76dc4190, 0x4db26158,
-        0xedb88320, 0xd6d6a3e8, 0x9b64c2b0, 0xa00ae278 };
 /*
 * This function adds bytes into the entropy "pool".  It does not
 * update the entropy estimate.  The caller should call
@@ -480,24 +464,29 @@ static __u32 const twist_table[8] = {
 * it's cheap to do so and helps slightly in the expected case where
 * the entropy is concentrated in the low-order bits.
 */
-static void _mix_pool_bytes(struct entropy_store *r, const void *in,
+static void mix_pool_bytes_extract(struct entropy_store *r, const void *in,
-                            int nbytes, __u8 out[64])
+                                   int nbytes, __u8 out[64])
 {
+        static __u32 const twist_table[8] = {
+                0x00000000, 0x3b6e20c8, 0x76dc4190, 0x4db26158,
+                0xedb88320, 0xd6d6a3e8, 0x9b64c2b0, 0xa00ae278 };
        unsigned long i, j, tap1, tap2, tap3, tap4, tap5;
        int input_rotate;
        int wordmask = r->poolinfo->poolwords - 1;
        const char *bytes = in;
        __u32 w;
+        unsigned long flags;
+        /* Taps are constant, so we can load them without holding r->lock.  */
        tap1 = r->poolinfo->tap1;
        tap2 = r->poolinfo->tap2;
        tap3 = r->poolinfo->tap3;
        tap4 = r->poolinfo->tap4;
        tap5 = r->poolinfo->tap5;
-        smp_rmb();
+        spin_lock_irqsave(&r->lock, flags);
-        input_rotate = ACCESS_ONCE(r->input_rotate);
+        input_rotate = r->input_rotate;
-        i = ACCESS_ONCE(r->add_ptr);
+        i = r->add_ptr;
        /* mix one byte at a time to simplify size handling and churn faster */
        while (nbytes--) {
@@ -524,61 +513,19 @@ static void _mix_pool_bytes(struct entropy_store *r, const void *in,
                input_rotate += i ? 7 : 14;
        }
-        ACCESS_ONCE(r->input_rotate) = input_rotate;
+        r->input_rotate = input_rotate;
-        ACCESS_ONCE(r->add_ptr) = i;
+        r->add_ptr = i;
-        smp_wmb();
        if (out)
                for (j = 0; j < 16; j++)
                        ((__u32 *)out)[j] = r->pool[(i - j) & wordmask];
-}
-static void __mix_pool_bytes(struct entropy_store *r, const void *in,
-                             int nbytes, __u8 out[64])
-{
-        trace_mix_pool_bytes_nolock(r->name, nbytes, _RET_IP_);
-        _mix_pool_bytes(r, in, nbytes, out);
-}
-static void mix_pool_bytes(struct entropy_store *r, const void *in,
-                           int nbytes, __u8 out[64])
-{
-        unsigned long flags;
-        trace_mix_pool_bytes(r->name, nbytes, _RET_IP_);
-        spin_lock_irqsave(&r->lock, flags);
-        _mix_pool_bytes(r, in, nbytes, out);
        spin_unlock_irqrestore(&r->lock, flags);
 }
-struct fast_pool {
+static void mix_pool_bytes(struct entropy_store *r, const void *in, int bytes)
-        __u32           pool[4];
-        unsigned long   last;
-        unsigned short  count;
-        unsigned char   rotate;
-        unsigned char   last_timer_intr;
-};
-/*
- * This is a fast mixing routine used by the interrupt randomness
- * collector.  It's hardcoded for an 128 bit pool and assumes that any
- * locks that might be needed are taken by the caller.
- */
-static void fast_mix(struct fast_pool *f, const void *in, int nbytes)
 {
-        const char      *bytes = in;
+       mix_pool_bytes_extract(r, in, bytes, NULL);
-        __u32           w;
-        unsigned        i = f->count;
-        unsigned        input_rotate = f->rotate;
-        while (nbytes--) {
-                w = rol32(*bytes++, input_rotate & 31) ^ f->pool[i & 3] ^
-                        f->pool[(i + 1) & 3];
-                f->pool[i & 3] = (w >> 3) ^ twist_table[w & 7];
-                input_rotate += (i++ & 3) ? 7 : 14;
-        }
-        f->count = i;
-        f->rotate = input_rotate;
 }
 /*
@@ -586,38 +533,30 @@ static void fast_mix(struct fast_pool *f, const void *in, int nbytes)
 */
 static void credit_entropy_bits(struct entropy_store *r, int nbits)
 {
-        int entropy_count, orig;
+        unsigned long flags;
+        int entropy_count;
        if (!nbits)
                return;
+        spin_lock_irqsave(&r->lock, flags);
        DEBUG_ENT("added %d entropy credits to %s\n", nbits, r->name);
-retry:
+        entropy_count = r->entropy_count;
-        entropy_count = orig = ACCESS_ONCE(r->entropy_count);
        entropy_count += nbits;
        if (entropy_count < 0) {
                DEBUG_ENT("negative entropy/overflow\n");
                entropy_count = 0;
        } else if (entropy_count > r->poolinfo->POOLBITS)
                entropy_count = r->poolinfo->POOLBITS;
-        if (cmpxchg(&r->entropy_count, orig, entropy_count) != orig)
+        r->entropy_count = entropy_count;
-                goto retry;
-        if (!r->initialized && nbits > 0) {
-                r->entropy_total += nbits;
-                if (r->entropy_total > 128)
-                        r->initialized = 1;
-        }
-        trace_credit_entropy_bits(r->name, nbits, entropy_count,
-                                  r->entropy_total, _RET_IP_);
        /* should we wake readers? */
        if (r == &input_pool && entropy_count >= random_read_wakeup_thresh) {
                wake_up_interruptible(&random_read_wait);
                kill_fasync(&fasync, SIGIO, POLL_IN);
        }
+        spin_unlock_irqrestore(&r->lock, flags);
 }
 /*********************************************************************
@@ -633,24 +572,42 @@ struct timer_rand_state {
        unsigned dont_count_entropy:1;
 };
-/*
+#ifndef CONFIG_GENERIC_HARDIRQS
- * Add device- or boot-specific data to the input and nonblocking
- * pools to help initialize them to unique values.
+static struct timer_rand_state *irq_timer_state[NR_IRQS];
- *
- * None of this adds any entropy, it is meant to avoid the
+static struct timer_rand_state *get_timer_rand_state(unsigned int irq)
- * problem of the nonblocking pool having similar initial state
+{
- * across largely identical devices.
+        return irq_timer_state[irq];
- */
+}
-void add_device_randomness(const void *buf, unsigned int size)
+static void set_timer_rand_state(unsigned int irq,
+                                 struct timer_rand_state *state)
+{
+        irq_timer_state[irq] = state;
+}
+#else
+static struct timer_rand_state *get_timer_rand_state(unsigned int irq)
 {
-        unsigned long time = get_cycles() ^ jiffies;
+        struct irq_desc *desc;
+        desc = irq_to_desc(irq);
-        mix_pool_bytes(&input_pool, buf, size, NULL);
+        return desc->timer_rand_state;
-        mix_pool_bytes(&input_pool, &time, sizeof(time), NULL);
-        mix_pool_bytes(&nonblocking_pool, buf, size, NULL);
-        mix_pool_bytes(&nonblocking_pool, &time, sizeof(time), NULL);
 }
-EXPORT_SYMBOL(add_device_randomness);
+static void set_timer_rand_state(unsigned int irq,
+                                 struct timer_rand_state *state)
+{
+        struct irq_desc *desc;
+        desc = irq_to_desc(irq);
+        desc->timer_rand_state = state;
+}
+#endif
 static struct timer_rand_state input_timer_state;
@@ -667,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;
@@ -682,7 +639,7 @@ static void add_timer_randomness(struct timer_rand_state *state, unsigned num)
        sample.jiffies = jiffies;
        sample.cycles = get_cycles();
        sample.num = num;
-        mix_pool_bytes(&input_pool, &sample, sizeof(sample), NULL);
+        mix_pool_bytes(&input_pool, &sample, sizeof(sample));
        /*
         * Calculate number of bits of randomness we probably added.
@@ -739,48 +696,17 @@ void add_input_randomness(unsigned int type, unsigned int code,
 }
 EXPORT_SYMBOL_GPL(add_input_randomness);
-static DEFINE_PER_CPU(struct fast_pool, irq_randomness);
+void add_interrupt_randomness(int irq)
-void add_interrupt_randomness(int irq, int irq_flags)
 {
-        struct entropy_store    *r;
+        struct timer_rand_state *state;
-        struct fast_pool        *fast_pool = &__get_cpu_var(irq_randomness);
-        struct pt_regs          *regs = get_irq_regs();
-        unsigned long           now = jiffies;
-        __u32                   input[4], cycles = get_cycles();
-        input[0] = cycles ^ jiffies;
-        input[1] = irq;
-        if (regs) {
-                __u64 ip = instruction_pointer(regs);
-                input[2] = ip;
-                input[3] = ip >> 32;
-        }
-        fast_mix(fast_pool, input, sizeof(input));
+        state = get_timer_rand_state(irq);
-        if ((fast_pool->count & 1023) &&
+        if (state == NULL)
-            !time_after(now, fast_pool->last + HZ))
                return;
-        fast_pool->last = now;
+        DEBUG_ENT("irq event %d\n", irq);
+        add_timer_randomness(state, 0x100 + irq);
-        r = nonblocking_pool.initialized ? &input_pool : &nonblocking_pool;
-        __mix_pool_bytes(r, &fast_pool->pool, sizeof(fast_pool->pool), NULL);
-        /*
-         * If we don't have a valid cycle counter, and we see
-         * back-to-back timer interrupts, then skip giving credit for
-         * any entropy.
-         */
-        if (cycles == 0) {
-                if (irq_flags & __IRQF_TIMER) {
-                        if (fast_pool->last_timer_intr)
-                                return;
-                        fast_pool->last_timer_intr = 1;
-                } else
-                        fast_pool->last_timer_intr = 0;
-        }
-        credit_entropy_bits(r, 1);
 }
 #ifdef CONFIG_BLOCK
@@ -812,7 +738,7 @@ static ssize_t extract_entropy(struct entropy_store *r, void *buf,
 */
 static void xfer_secondary_pool(struct entropy_store *r, size_t nbytes)
 {
-        __u32   tmp[OUTPUT_POOL_WORDS];
+        __u32 tmp[OUTPUT_POOL_WORDS];
        if (r->pull && r->entropy_count < nbytes * 8 &&
            r->entropy_count < r->poolinfo->POOLBITS) {
@@ -826,12 +752,12 @@ static void xfer_secondary_pool(struct entropy_store *r, size_t nbytes)
                bytes = min_t(int, bytes, sizeof(tmp));
                DEBUG_ENT("going to reseed %s with %d bits "
-                          "(%zu of %d requested)\n",
+                          "(%d of %d requested)\n",
                          r->name, bytes * 8, nbytes * 8, r->entropy_count);
                bytes = extract_entropy(r->pull, tmp, bytes,
                                        random_read_wakeup_thresh / 8, rsvd);
-                mix_pool_bytes(r, tmp, bytes, NULL);
+                mix_pool_bytes(r, tmp, bytes);
                credit_entropy_bits(r, bytes*8);
        }
 }
@@ -857,7 +783,7 @@ static size_t account(struct entropy_store *r, size_t nbytes, int min,
        spin_lock_irqsave(&r->lock, flags);
        BUG_ON(r->entropy_count > r->poolinfo->POOLBITS);
-        DEBUG_ENT("trying to extract %zu bits from %s\n",
+        DEBUG_ENT("trying to extract %d bits from %s\n",
                  nbytes * 8, r->name);
        /* Can we pull enough? */
@@ -879,7 +805,7 @@ static size_t account(struct entropy_store *r, size_t nbytes, int min,
                }
        }
-        DEBUG_ENT("debiting %zu entropy credits from %s%s\n",
+        DEBUG_ENT("debiting %d entropy credits from %s%s\n",
                  nbytes * 8, r->name, r->limit ? "" : " (unlimited)");
        spin_unlock_irqrestore(&r->lock, flags);
@@ -890,19 +816,13 @@ static size_t account(struct entropy_store *r, size_t nbytes, int min,
 static void extract_buf(struct entropy_store *r, __u8 *out)
 {
        int i;
-        union {
+        __u32 hash[5], workspace[SHA_WORKSPACE_WORDS];
-                __u32 w[5];
-                unsigned long l[LONGS(EXTRACT_SIZE)];
-        } hash;
-        __u32 workspace[SHA_WORKSPACE_WORDS];
        __u8 extract[64];
-        unsigned long flags;
        /* Generate a hash across the pool, 16 words (512 bits) at a time */
-        sha_init(hash.w);
+        sha_init(hash);
-        spin_lock_irqsave(&r->lock, flags);
        for (i = 0; i < r->poolinfo->poolwords; i += 16)
-                sha_transform(hash.w, (__u8 *)(r->pool + i), workspace);
+                sha_transform(hash, (__u8 *)(r->pool + i), workspace);
        /*
         * We mix the hash back into the pool to prevent backtracking
@@ -913,14 +833,13 @@ static void extract_buf(struct entropy_store *r, __u8 *out)
         * brute-forcing the feedback as hard as brute-forcing the
         * hash.
         */
-        __mix_pool_bytes(r, hash.w, sizeof(hash.w), extract);
+        mix_pool_bytes_extract(r, hash, sizeof(hash), extract);
-        spin_unlock_irqrestore(&r->lock, flags);
        /*
         * To avoid duplicates, we atomically extract a portion of the
         * pool while mixing, and hash one final time.
         */
-        sha_transform(hash.w, extract, workspace);
+        sha_transform(hash, extract, workspace);
        memset(extract, 0, sizeof(extract));
        memset(workspace, 0, sizeof(workspace));
@@ -929,36 +848,20 @@ static void extract_buf(struct entropy_store *r, __u8 *out)
         * pattern, we fold it in half. Thus, we always feed back
         * twice as much data as we output.
         */
-        hash.w[0] ^= hash.w[3];
+        hash[0] ^= hash[3];
-        hash.w[1] ^= hash.w[4];
+        hash[1] ^= hash[4];
-        hash.w[2] ^= rol32(hash.w[2], 16);
+        hash[2] ^= rol32(hash[2], 16);
+        memcpy(out, hash, EXTRACT_SIZE);
-        /*
+        memset(hash, 0, sizeof(hash));
-         * If we have a architectural hardware random number
-         * generator, mix that in, too.
-         */
-        for (i = 0; i < LONGS(EXTRACT_SIZE); i++) {
-                unsigned long v;
-                if (!arch_get_random_long(&v))
-                        break;
-                hash.l[i] ^= v;
-        }
-        memcpy(out, &hash, EXTRACT_SIZE);
-        memset(&hash, 0, sizeof(hash));
 }
 static ssize_t extract_entropy(struct entropy_store *r, void *buf,
-                                 size_t nbytes, int min, int reserved)
+                               size_t nbytes, int min, int reserved)
 {
        ssize_t ret = 0, i;
        __u8 tmp[EXTRACT_SIZE];
+        unsigned long flags;
-        /* if last_data isn't primed, we need EXTRACT_SIZE extra bytes */
-        if (fips_enabled && !r->last_data_init)
-                nbytes += EXTRACT_SIZE;
-        trace_extract_entropy(r->name, nbytes, r->entropy_count, _RET_IP_);
        xfer_secondary_pool(r, nbytes);
        nbytes = account(r, nbytes, min, reserved);
@@ -966,19 +869,6 @@ static ssize_t extract_entropy(struct entropy_store *r, void *buf,
                extract_buf(r, tmp);
                if (fips_enabled) {
-                        unsigned long flags;
-                        /* prime last_data value if need be, per fips 140-2 */
-                        if (!r->last_data_init) {
-                                spin_lock_irqsave(&r->lock, flags);
-                                memcpy(r->last_data, tmp, EXTRACT_SIZE);
-                                r->last_data_init = true;
-                                nbytes -= EXTRACT_SIZE;
-                                spin_unlock_irqrestore(&r->lock, flags);
-                                extract_buf(r, tmp);
-                        }
                        spin_lock_irqsave(&r->lock, flags);
                        if (!memcmp(tmp, r->last_data, EXTRACT_SIZE))
                                panic("Hardware RNG duplicated output!\n");
@@ -1004,7 +894,6 @@ static ssize_t extract_entropy_user(struct entropy_store *r, void __user *buf,
        ssize_t ret = 0, i;
        __u8 tmp[EXTRACT_SIZE];
-        trace_extract_entropy_user(r->name, nbytes, r->entropy_count, _RET_IP_);
        xfer_secondary_pool(r, nbytes);
        nbytes = account(r, nbytes, 0, 0);
@@ -1038,9 +927,8 @@ static ssize_t extract_entropy_user(struct entropy_store *r, void __user *buf,
 /*
 * This function is the exported kernel interface.  It returns some
- * number of good random numbers, suitable for key generation, seeding
+ * number of good random numbers, suitable for seeding TCP sequence
- * TCP sequence numbers, etc.  It does not use the hw random number
+ * numbers, etc.
- * generator, if available; use get_random_bytes_arch() for that.
 */
 void get_random_bytes(void *buf, int nbytes)
 {
@@ -1049,39 +937,6 @@ void get_random_bytes(void *buf, int nbytes)
 EXPORT_SYMBOL(get_random_bytes);
 /*
- * This function will use the architecture-specific hardware random
- * number generator if it is available.  The arch-specific hw RNG will
- * almost certainly be faster than what we can do in software, but it
- * is impossible to verify that it is implemented securely (as
- * opposed, to, say, the AES encryption of a sequence number using a
- * key known by the NSA).  So it's useful if we need the speed, but
- * only if we're willing to trust the hardware manufacturer not to
- * have put in a back door.
- */
-void get_random_bytes_arch(void *buf, int nbytes)
-{
-        char *p = buf;
-        trace_get_random_bytes(nbytes, _RET_IP_);
-        while (nbytes) {
-                unsigned long v;
-                int chunk = min(nbytes, (int)sizeof(unsigned long));
-                if (!arch_get_random_long(&v))
-                        break;
-                
-                memcpy(p, &v, chunk);
-                p += chunk;
-                nbytes -= chunk;
-        }
-        if (nbytes)
-                extract_entropy(&nonblocking_pool, p, nbytes, 0, 0);
-}
-EXPORT_SYMBOL(get_random_bytes_arch);
-/*
 * init_std_data - initialize pool with system data
 *
 * @r: pool to initialize
@@ -1092,32 +947,18 @@ EXPORT_SYMBOL(get_random_bytes_arch);
 */
 static void init_std_data(struct entropy_store *r)
 {
-        int i;
+        ktime_t now;
-        ktime_t now = ktime_get_real();
+        unsigned long flags;
-        unsigned long rv;
+        spin_lock_irqsave(&r->lock, flags);
        r->entropy_count = 0;
-        r->entropy_total = 0;
+        spin_unlock_irqrestore(&r->lock, flags);
-        r->last_data_init = false;
-        mix_pool_bytes(r, &now, sizeof(now), NULL);
+        now = ktime_get_real();
-        for (i = r->poolinfo->POOLBYTES; i > 0; i -= sizeof(rv)) {
+        mix_pool_bytes(r, &now, sizeof(now));
-                if (!arch_get_random_long(&rv))
+        mix_pool_bytes(r, utsname(), sizeof(*(utsname())));
-                        break;
-                mix_pool_bytes(r, &rv, sizeof(rv), NULL);
-        }
-        mix_pool_bytes(r, utsname(), sizeof(*(utsname())), NULL);
 }
-/*
- * Note that setup_arch() may call add_device_randomness()
- * long before we get here. This allows seeding of the pools
- * with some platform dependent data very early in the boot
- * process. But it limits our options here. We must use
- * statically allocated structures that already have all
- * initializations complete at compile time. We should also
- * take care not to overwrite the precious per platform data
- * we were given.
- */
 static int rand_initialize(void)
 {
        init_std_data(&input_pool);
@@ -1127,6 +968,24 @@ static int rand_initialize(void)
 }
 module_init(rand_initialize);
+void rand_initialize_irq(int irq)
+{
+        struct timer_rand_state *state;
+        state = get_timer_rand_state(irq);
+        if (state)
+                return;
+        /*
+         * If kzalloc returns null, we just won't use that entropy
+         * source.
+         */
+        state = kzalloc(sizeof(struct timer_rand_state), GFP_KERNEL);
+        if (state)
+                set_timer_rand_state(irq, state);
+}
 #ifdef CONFIG_BLOCK
 void rand_initialize_disk(struct gendisk *disk)
 {
@@ -1155,16 +1014,11 @@ random_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
                if (n > SEC_XFER_SIZE)
                        n = SEC_XFER_SIZE;
-                DEBUG_ENT("reading %zu bits\n", n*8);
+                DEBUG_ENT("reading %d bits\n", n*8);
                n = extract_entropy_user(&blocking_pool, buf, n);
-                if (n < 0) {
+                DEBUG_ENT("read got %d bits (%d still needed)\n",
-                        retval = n;
-                        break;
-                }
-                DEBUG_ENT("read got %zd bits (%zd still needed)\n",
                          n*8, (nbytes-n)*8);
                if (n == 0) {
@@ -1189,6 +1043,10 @@ random_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
                        continue;
                }
+                if (n < 0) {
+                        retval = n;
+                        break;
+                }
                count += n;
                buf += n;
                nbytes -= n;
@@ -1235,7 +1093,7 @@ write_pool(struct entropy_store *r, const char __user *buffer, size_t count)
                count -= bytes;
                p += bytes;
-                mix_pool_bytes(r, buf, bytes, NULL);
+                mix_pool_bytes(r, buf, bytes);
                cond_resched();
        }
@@ -1378,15 +1236,10 @@ static int proc_do_uuid(ctl_table *table, int write,
        uuid = table->data;
        if (!uuid) {
                uuid = tmp_uuid;
-                generate_random_uuid(uuid);
+                uuid[8] = 0;
-        } else {
-                static DEFINE_SPINLOCK(bootid_spinlock);
-                spin_lock(&bootid_spinlock);
-                if (!uuid[8])
-                        generate_random_uuid(uuid);
-                spin_unlock(&bootid_spinlock);
        }
+        if (uuid[8] == 0)
+                generate_random_uuid(uuid);
        sprintf(buf, "%pU", uuid);
@@ -1397,7 +1250,6 @@ static int proc_do_uuid(ctl_table *table, int write,
 }
 static int sysctl_poolsize = INPUT_POOL_WORDS * 32;
-extern ctl_table random_table[];
 ctl_table random_table[] = {
        {
                .procname       = "poolsize",
@@ -1463,17 +1315,12 @@ late_initcall(random_int_secret_init);
 * value is not cryptographically secure but for several uses the cost of
 * depleting entropy is too high
 */
-static DEFINE_PER_CPU(__u32 [MD5_DIGEST_WORDS], get_random_int_hash);
+DEFINE_PER_CPU(__u32 [MD5_DIGEST_WORDS], get_random_int_hash);
 unsigned int get_random_int(void)
 {
-        __u32 *hash;
+        __u32 *hash = get_cpu_var(get_random_int_hash);
        unsigned int ret;
-        if (arch_get_random_int(&ret))
-                return ret;
-        hash = get_cpu_var(get_random_int_hash);
        hash[0] += current->pid + jiffies + get_cycles();
        md5_transform(hash, random_int_secret);
        ret = hash[0];
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index 54a3a6d0981..b33e8ea314e 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, umode_t *mode)
+static char *raw_devnode(struct device *dev, mode_t *mode)
 {
        return kasprintf(GFP_KERNEL, "raw/%s", dev_name(dev));
 }
@@ -324,12 +324,13 @@ static int __init raw_init(void)
                max_raw_minors = MAX_RAW_MINORS;
        }
-        raw_devices = vzalloc(sizeof(struct raw_device_data) * max_raw_minors);
+        raw_devices = vmalloc(sizeof(struct raw_device_data) * max_raw_minors);
        if (!raw_devices) {
                printk(KERN_ERR "Not enough memory for raw device structures\n");
                ret = -ENOMEM;
                goto error;
        }
+        memset(raw_devices, 0, sizeof(struct raw_device_data) * max_raw_minors);
        ret = register_chrdev_region(dev, max_raw_minors, "raw");
        if (ret)
diff --git a/drivers/char/rtc.c b/drivers/char/rtc.c
index 91470fdbab2..dfa8b3062fd 100644
--- a/drivers/char/rtc.c
+++ b/drivers/char/rtc.c
@@ -57,8 +57,8 @@
 *      Note that *all* calls to CMOS_READ and CMOS_WRITE are done with
 *      interrupts disabled. Due to the index-port/data-port (0x70/0x71)
 *      design of the RTC, we don't want two different things trying to
- *      get to it at once. (e.g. the periodic 11 min sync from
+ *      get to it at once. (e.g. the periodic 11 min sync from time.c vs.
- *      kernel/time/ntp.c vs. this driver.)
+ *      this driver.)
 */
 #include <linux/interrupt.h>
@@ -80,9 +80,9 @@
 #include <linux/bcd.h>
 #include <linux/delay.h>
 #include <linux/uaccess.h>
-#include <linux/ratelimit.h>
 #include <asm/current.h>
+#include <asm/system.h>
 #ifdef CONFIG_X86
 #include <asm/hpet.h>
@@ -411,7 +411,7 @@ static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
                case RTC_IRQP_READ:
                case RTC_IRQP_SET:
                        return -EINVAL;
-                }
+                };
        }
 #endif
@@ -1195,8 +1195,10 @@ static void rtc_dropped_irq(unsigned long data)
        spin_unlock_irq(&rtc_lock);
-        printk_ratelimited(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n",
+        if (printk_ratelimit()) {
-                           freq);
+                printk(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n",
+                        freq);
+        }
        /* Now we have new data */
        wake_up_interruptible(&rtc_wait);
diff --git a/drivers/char/sonypi.c b/drivers/char/sonypi.c
index d780295a147..1ee8ce7d276 100644
--- a/drivers/char/sonypi.c
+++ b/drivers/char/sonypi.c
@@ -54,6 +54,7 @@
 #include <asm/uaccess.h>
 #include <asm/io.h>
+#include <asm/system.h>
 #include <linux/sonypi.h>
@@ -1164,7 +1165,7 @@ static struct acpi_driver sonypi_acpi_driver = {
 };
 #endif
-static int sonypi_create_input_devices(struct platform_device *pdev)
+static int __devinit sonypi_create_input_devices(struct platform_device *pdev)
 {
        struct input_dev *jog_dev;
        struct input_dev *key_dev;
@@ -1225,7 +1226,7 @@ static int sonypi_create_input_devices(struct platform_device *pdev)
        return error;
 }
-static int sonypi_setup_ioports(struct sonypi_device *dev,
+static int __devinit sonypi_setup_ioports(struct sonypi_device *dev,
                                const struct sonypi_ioport_list *ioport_list)
 {
        /* try to detect if sony-laptop is being used and thus
@@ -1265,7 +1266,7 @@ static int sonypi_setup_ioports(struct sonypi_device *dev,
        return -EBUSY;
 }
-static int sonypi_setup_irq(struct sonypi_device *dev,
+static int __devinit sonypi_setup_irq(struct sonypi_device *dev,
                                      const struct sonypi_irq_list *irq_list)
 {
        while (irq_list->irq) {
@@ -1282,7 +1283,7 @@ static int sonypi_setup_irq(struct sonypi_device *dev,
        return -EBUSY;
 }
-static void sonypi_display_info(void)
+static void __devinit sonypi_display_info(void)
 {
        printk(KERN_INFO "sonypi: detected type%d model, "
               "verbose = %d, fnkeyinit = %s, camera = %s, "
@@ -1304,7 +1305,7 @@ static void sonypi_display_info(void)
                       sonypi_misc_device.minor);
 }
-static int sonypi_probe(struct platform_device *dev)
+static int __devinit sonypi_probe(struct platform_device *dev)
 {
        const struct sonypi_ioport_list *ioport_list;
        const struct sonypi_irq_list *irq_list;
@@ -1428,12 +1429,12 @@ static int sonypi_probe(struct platform_device *dev)
        return error;
 }
-static int sonypi_remove(struct platform_device *dev)
+static int __devexit sonypi_remove(struct platform_device *dev)
 {
        sonypi_disable();
        synchronize_irq(sonypi_device.irq);
-        flush_work(&sonypi_device.input_work);
+        flush_work_sync(&sonypi_device.input_work);
        if (useinput) {
                input_unregister_device(sonypi_device.input_key_dev);
@@ -1456,10 +1457,10 @@ static int sonypi_remove(struct platform_device *dev)
        return 0;
 }
-#ifdef CONFIG_PM_SLEEP
+#ifdef CONFIG_PM
 static int old_camera_power;
-static int sonypi_suspend(struct device *dev)
+static int sonypi_suspend(struct platform_device *dev, pm_message_t state)
 {
        old_camera_power = sonypi_device.camera_power;
        sonypi_disable();
@@ -1467,16 +1468,14 @@ static int sonypi_suspend(struct device *dev)
        return 0;
 }
-static int sonypi_resume(struct device *dev)
+static int sonypi_resume(struct platform_device *dev)
 {
        sonypi_enable(old_camera_power);
        return 0;
 }
-static SIMPLE_DEV_PM_OPS(sonypi_pm, sonypi_suspend, sonypi_resume);
-#define SONYPI_PM       (&sonypi_pm)
 #else
-#define SONYPI_PM       NULL
+#define sonypi_suspend  NULL
+#define sonypi_resume   NULL
 #endif
 static void sonypi_shutdown(struct platform_device *dev)
@@ -1488,11 +1487,12 @@ static struct platform_driver sonypi_driver = {
        .driver         = {
                .name   = "sonypi",
                .owner  = THIS_MODULE,
-                .pm     = SONYPI_PM,
        },
        .probe          = sonypi_probe,
-        .remove         = sonypi_remove,
+        .remove         = __devexit_p(sonypi_remove),
        .shutdown       = sonypi_shutdown,
+        .suspend        = sonypi_suspend,
+        .resume         = sonypi_resume,
 };
 static struct platform_device *sonypi_platform_device;
diff --git a/drivers/char/tb0219.c b/drivers/char/tb0219.c
index 34c63f85104..ad264185eb1 100644
--- a/drivers/char/tb0219.c
+++ b/drivers/char/tb0219.c
@@ -284,7 +284,7 @@ static void tb0219_pci_irq_init(void)
        vr41xx_set_irq_level(TB0219_PCI_SLOT3_PIN, IRQ_LEVEL_LOW);
 }
-static int tb0219_probe(struct platform_device *dev)
+static int __devinit tb0219_probe(struct platform_device *dev)
 {
        int retval;
@@ -318,7 +318,7 @@ static int tb0219_probe(struct platform_device *dev)
        return 0;
 }
-static int tb0219_remove(struct platform_device *dev)
+static int __devexit tb0219_remove(struct platform_device *dev)
 {
        _machine_restart = old_machine_restart;
@@ -334,7 +334,7 @@ static struct platform_device *tb0219_platform_device;
 static struct platform_driver tb0219_device_driver = {
        .probe          = tb0219_probe,
-        .remove         = tb0219_remove,
+        .remove         = __devexit_p(tb0219_remove),
        .driver         = {
                .name   = "TB0219",
                .owner  = THIS_MODULE,
diff --git a/drivers/char/tile-srom.c b/drivers/char/tile-srom.c
index 3b22a606f79..cf3ee008dca 100644
--- a/drivers/char/tile-srom.c
+++ b/drivers/char/tile-srom.c
@@ -194,17 +194,17 @@ static ssize_t srom_read(struct file *filp, char __user *buf,
                hv_retval = _srom_read(srom->hv_devhdl, kernbuf,
                                       *f_pos, bytes_this_pass);
-                if (hv_retval <= 0) {
+                if (hv_retval > 0) {
+                        if (copy_to_user(buf, kernbuf, hv_retval) != 0) {
+                                retval = -EFAULT;
+                                break;
+                        }
+                } else if (hv_retval <= 0) {
                        if (retval == 0)
                                retval = hv_retval;
                        break;
                }
-                if (copy_to_user(buf, kernbuf, hv_retval) != 0) {
-                        retval = -EFAULT;
-                        break;
-                }
                retval += hv_retval;
                *f_pos += hv_retval;
                buf += hv_retval;
@@ -329,7 +329,7 @@ static struct device_attribute srom_dev_attrs[] = {
        __ATTR_NULL
 };
-static char *srom_devnode(struct device *dev, umode_t *mode)
+static char *srom_devnode(struct device *dev, mode_t *mode)
 {
        *mode = S_IRUGO | S_IWUSR;
        return kasprintf(GFP_KERNEL, "srom/%s", dev_name(dev));
diff --git a/drivers/char/tlclk.c b/drivers/char/tlclk.c
index e95e0ab0bd8..0c964cdcc22 100644
--- a/drivers/char/tlclk.c
+++ b/drivers/char/tlclk.c
@@ -784,10 +784,8 @@ static int __init tlclk_init(void)
        }
        tlclk_major = ret;
        alarm_events = kzalloc( sizeof(struct tlclk_alarms), GFP_KERNEL);
-        if (!alarm_events) {
+        if (!alarm_events)
-                ret = -ENOMEM;
                goto out1;
-        }
        /* Read telecom clock IRQ number (Set by BIOS) */
        if (!request_region(TLCLK_BASE, 8, "telco_clock")) {
@@ -799,7 +797,7 @@ static int __init tlclk_init(void)
        telclk_interrupt = (inb(TLCLK_REG7) & 0x0f);
        if (0x0F == telclk_interrupt ) { /* not MCPBL0010 ? */
-                printk(KERN_ERR "telclk_interrupt = 0x%x non-mcpbl0010 hw.\n",
+                printk(KERN_ERR "telclk_interrup = 0x%x non-mcpbl0010 hw.\n",
                        telclk_interrupt);
                ret = -ENXIO;
                goto out3;
diff --git a/drivers/char/tpm/Kconfig b/drivers/char/tpm/Kconfig
index 915875e431d..fa567f1158c 100644
--- a/drivers/char/tpm/Kconfig
+++ b/drivers/char/tpm/Kconfig
@@ -5,6 +5,7 @@
 menuconfig TCG_TPM
        tristate "TPM Hardware Support"
        depends on HAS_IOMEM
+        depends on EXPERIMENTAL
        select SECURITYFS
        ---help---
          If you have a TPM security chip in your system, which
@@ -26,27 +27,14 @@ 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
          from within Linux.  To compile this driver as a module, choose
          M here; the module will be called tpm_tis.
-config TCG_TIS_I2C_INFINEON
-        tristate "TPM Interface Specification 1.2 Interface (I2C - Infineon)"
-        depends on I2C
-        ---help---
-          If you have a TPM security chip that is compliant with the
-          TCG TIS 1.2 TPM specification and Infineon's I2C Protocol Stack
-          Specification 0.20 say Yes and it will be accessible from within
-          Linux.
-          To compile this driver as a module, choose M here; the module
-          will be called tpm_tis_i2c_infineon.
 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 
@@ -73,12 +61,4 @@ config TCG_INFINEON
          Further information on this driver and the supported hardware
          can be found at http://www.trust.rub.de/projects/linux-device-driver-infineon-tpm/ 
-config TCG_IBMVTPM
-        tristate "IBM VTPM Interface"
-        depends on PPC64
-        ---help---
-          If you have IBM virtual TPM (VTPM) support say Yes and it
-          will be accessible from within Linux.  To compile this driver
-          as a module, choose M here; the module will be called tpm_ibmvtpm.
 endif # TCG_TPM
diff --git a/drivers/char/tpm/Makefile b/drivers/char/tpm/Makefile
index 5b3fc8bc6c1..ea3a1e02a82 100644
--- a/drivers/char/tpm/Makefile
+++ b/drivers/char/tpm/Makefile
@@ -4,16 +4,8 @@
 obj-$(CONFIG_TCG_TPM) += tpm.o
 ifdef CONFIG_ACPI
        obj-$(CONFIG_TCG_TPM) += tpm_bios.o
-        tpm_bios-objs += tpm_eventlog.o tpm_acpi.o tpm_ppi.o
-else
-ifdef CONFIG_TCG_IBMVTPM
-        obj-$(CONFIG_TCG_TPM) += tpm_bios.o
-        tpm_bios-objs += tpm_eventlog.o tpm_of.o
-endif
 endif
 obj-$(CONFIG_TCG_TIS) += tpm_tis.o
-obj-$(CONFIG_TCG_TIS_I2C_INFINEON) += tpm_i2c_infineon.o
 obj-$(CONFIG_TCG_NSC) += tpm_nsc.o
 obj-$(CONFIG_TCG_ATMEL) += tpm_atmel.o
 obj-$(CONFIG_TCG_INFINEON) += tpm_infineon.o
-obj-$(CONFIG_TCG_IBMVTPM) += tpm_ibmvtpm.o
diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index 93211df52aa..9ca5c021d0b 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -27,10 +27,14 @@
 #include <linux/slab.h>
 #include <linux/mutex.h>
 #include <linux/spinlock.h>
-#include <linux/freezer.h>
 #include "tpm.h"
-#include "tpm_eventlog.h"
+enum tpm_const {
+        TPM_MINOR = 224,        /* officially assigned */
+        TPM_BUFSIZE = 4096,
+        TPM_NUM_DEVICES = 256,
+};
 enum tpm_duration {
        TPM_SHORT = 0,
@@ -436,6 +440,7 @@ out:
 }
 #define TPM_DIGEST_SIZE 20
+#define TPM_ERROR_SIZE 10
 #define TPM_RET_CODE_IDX 6
 enum tpm_capabilities {
@@ -464,20 +469,17 @@ 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;
-        else if (len < TPM_HEADER_SIZE)
+        if (len == TPM_ERROR_SIZE) {
-                return -EFAULT;
+                err = be32_to_cpu(cmd->header.out.return_code);
+                dev_dbg(chip->dev, "A TPM error (%d) occurred %s\n", err, desc);
-        err = be32_to_cpu(cmd->header.out.return_code);
+                return err;
-        if (err != 0)
+        }
-                dev_err(chip->dev, "A TPM error (%d) occurred %s\n", err, desc);
+        return 0;
-        return err;
 }
 #define TPM_INTERNAL_RESULT_SIZE 200
 #define TPM_TAG_RQU_COMMAND cpu_to_be16(193)
 #define TPM_ORD_GET_CAP cpu_to_be32(101)
-#define TPM_ORD_GET_RANDOM cpu_to_be32(70)
 static const struct tpm_input_header tpm_getcap_header = {
        .tag = TPM_TAG_RQU_COMMAND,
@@ -528,7 +530,7 @@ void tpm_gen_interrupt(struct tpm_chip *chip)
 }
 EXPORT_SYMBOL_GPL(tpm_gen_interrupt);
-int tpm_get_timeouts(struct tpm_chip *chip)
+void tpm_get_timeouts(struct tpm_chip *chip)
 {
        struct tpm_cmd_t tpm_cmd;
        struct timeout_t *timeout_cap;
@@ -550,7 +552,7 @@ int 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 -EINVAL;
+                return;
        timeout_cap = &tpm_cmd.params.getcap_out.cap.timeout;
        /* Don't overwrite default if value is 0 */
@@ -581,12 +583,12 @@ duration:
        rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE,
                        "attempting to determine the durations");
        if (rc)
-                return rc;
+                return;
        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 -EINVAL;
+                return;
        duration_cap = &tpm_cmd.params.getcap_out.cap.duration;
        chip->vendor.duration[TPM_SHORT] =
@@ -608,36 +610,20 @@ duration:
                chip->vendor.duration_adjusted = true;
                dev_info(chip->dev, "Adjusting TPM timeout parameters.");
        }
-        return 0;
 }
 EXPORT_SYMBOL_GPL(tpm_get_timeouts);
-#define TPM_ORD_CONTINUE_SELFTEST 83
+void tpm_continue_selftest(struct tpm_chip *chip)
-#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)
 {
-        int rc;
+        u8 data[] = {
-        struct tpm_cmd_t cmd;
+                0, 193,                 /* TPM_TAG_RQU_COMMAND */
+                0, 0, 0, 10,            /* length */
+                0, 0, 0, 83,            /* TPM_ORD_ContinueSelfTest */
+        };
-        cmd.header.in = continue_selftest_header;
+        tpm_transmit(chip, data, sizeof(data));
-        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)
@@ -732,7 +718,7 @@ static struct tpm_input_header pcrread_header = {
        .ordinal = TPM_ORDINAL_PCRREAD
 };
-static int __tpm_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf)
+int __tpm_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf)
 {
        int rc;
        struct tpm_cmd_t cmd;
@@ -812,62 +798,6 @@ 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;
-        unsigned int loops;
-        unsigned int delay_msec = 1000;
-        unsigned long duration;
-        struct tpm_cmd_t cmd;
-        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 {
-                /* Attempt to read a PCR value */
-                cmd.header.in = pcrread_header;
-                cmd.params.pcrread_in.pcr_idx = cpu_to_be32(0);
-                rc = tpm_transmit(chip, (u8 *) &cmd, READ_PCR_RESULT_SIZE);
-                if (rc < TPM_HEADER_SIZE)
-                        return -EFAULT;
-                rc = be32_to_cpu(cmd.header.out.return_code);
-                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;
@@ -915,7 +845,7 @@ EXPORT_SYMBOL_GPL(tpm_show_pcrs);
 #define  READ_PUBEK_RESULT_SIZE 314
 #define TPM_ORD_READPUBEK cpu_to_be32(124)
-static struct tpm_input_header tpm_readpubek_header = {
+struct tpm_input_header tpm_readpubek_header = {
        .tag = TPM_TAG_RQU_COMMAND,
        .length = cpu_to_be32(30),
        .ordinal = TPM_ORD_READPUBEK
@@ -1036,9 +966,6 @@ ssize_t tpm_show_durations(struct device *dev, struct device_attribute *attr,
 {
        struct tpm_chip *chip = dev_get_drvdata(dev);
-        if (chip->vendor.duration[TPM_LONG] == 0)
-                return 0;
        return sprintf(buf, "%d %d %d [%s]\n",
                       jiffies_to_usecs(chip->vendor.duration[TPM_SHORT]),
                       jiffies_to_usecs(chip->vendor.duration[TPM_MEDIUM]),
@@ -1075,46 +1002,6 @@ 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
 *
@@ -1168,10 +1055,10 @@ int tpm_release(struct inode *inode, struct file *file)
        struct tpm_chip *chip = file->private_data;
        del_singleshot_timer_sync(&chip->user_read_timer);
-        flush_work(&chip->work);
+        flush_work_sync(&chip->work);
        file->private_data = NULL;
        atomic_set(&chip->data_pending, 0);
-        kzfree(chip->data_buffer);
+        kfree(chip->data_buffer);
        clear_bit(0, &chip->is_open);
        put_device(chip->dev);
        return 0;
@@ -1182,21 +1069,18 @@ ssize_t tpm_write(struct file *file, const char __user *buf,
                  size_t size, loff_t *off)
 {
        struct tpm_chip *chip = file->private_data;
-        size_t in_size = size;
+        size_t in_size = size, out_size;
-        ssize_t out_size;
        /* cannot perform a write until the read has cleared
-           either via tpm_read or a user_read_timer timeout.
+           either via tpm_read or a user_read_timer timeout */
-           This also prevents splitted buffered writes from blocking here.
+        while (atomic_read(&chip->data_pending) != 0)
-        */
+                msleep(TPM_TIMEOUT);
-        if (atomic_read(&chip->data_pending) != 0)
-                return -EBUSY;
-        if (in_size > TPM_BUFSIZE)
-                return -E2BIG;
        mutex_lock(&chip->buffer_mutex);
+        if (in_size > TPM_BUFSIZE)
+                in_size = TPM_BUFSIZE;
        if (copy_from_user
            (chip->data_buffer, (void __user *) buf, in_size)) {
                mutex_unlock(&chip->buffer_mutex);
@@ -1205,10 +1089,6 @@ ssize_t tpm_write(struct file *file, const char __user *buf,
        /* atomic tpm command send and result receive */
        out_size = tpm_transmit(chip, chip->data_buffer, TPM_BUFSIZE);
-        if (out_size < 0) {
-                mutex_unlock(&chip->buffer_mutex);
-                return out_size;
-        }
        atomic_set(&chip->data_pending, out_size);
        mutex_unlock(&chip->buffer_mutex);
@@ -1228,24 +1108,22 @@ ssize_t tpm_read(struct file *file, char __user *buf,
        int rc;
        del_singleshot_timer_sync(&chip->user_read_timer);
-        flush_work(&chip->work);
+        flush_work_sync(&chip->work);
        ret_size = atomic_read(&chip->data_pending);
+        atomic_set(&chip->data_pending, 0);
        if (ret_size > 0) {     /* relay data */
-                ssize_t orig_ret_size = ret_size;
                if (size < ret_size)
                        ret_size = size;
                mutex_lock(&chip->buffer_mutex);
                rc = copy_to_user(buf, chip->data_buffer, ret_size);
-                memset(chip->data_buffer, 0, orig_ret_size);
+                memset(chip->data_buffer, 0, ret_size);
                if (rc)
                        ret_size = -EFAULT;
                mutex_unlock(&chip->buffer_mutex);
        }
-        atomic_set(&chip->data_pending, 0);
        return ret_size;
 }
 EXPORT_SYMBOL_GPL(tpm_read);
@@ -1266,7 +1144,6 @@ void tpm_remove_hardware(struct device *dev)
        misc_deregister(&chip->vendor.miscdev);
        sysfs_remove_group(&dev->kobj, chip->vendor.attr_group);
-        tpm_remove_ppi(&dev->kobj);
        tpm_bios_log_teardown(chip->bios_dir);
        /* write it this way to be explicit (chip->dev == dev) */
@@ -1287,7 +1164,7 @@ static struct tpm_input_header savestate_header = {
 * We are about to suspend. Save the TPM state
 * so that it can be restored.
 */
-int tpm_pm_suspend(struct device *dev)
+int tpm_pm_suspend(struct device *dev, pm_message_t pm_state)
 {
        struct tpm_chip *chip = dev_get_drvdata(dev);
        struct tpm_cmd_t cmd;
@@ -1331,65 +1208,10 @@ int tpm_pm_resume(struct device *dev)
 }
 EXPORT_SYMBOL_GPL(tpm_pm_resume);
-#define TPM_GETRANDOM_RESULT_SIZE       18
-static struct tpm_input_header tpm_getrandom_header = {
-        .tag = TPM_TAG_RQU_COMMAND,
-        .length = cpu_to_be32(14),
-        .ordinal = TPM_ORD_GET_RANDOM
-};
-/**
- * tpm_get_random() - Get random bytes from the tpm's RNG
- * @chip_num: A specific chip number for the request or TPM_ANY_NUM
- * @out: destination buffer for the random bytes
- * @max: the max number of bytes to write to @out
- *
- * Returns < 0 on error and the number of bytes read on success
- */
-int tpm_get_random(u32 chip_num, u8 *out, size_t max)
-{
-        struct tpm_chip *chip;
-        struct tpm_cmd_t tpm_cmd;
-        u32 recd, num_bytes = min_t(u32, max, TPM_MAX_RNG_DATA);
-        int err, total = 0, retries = 5;
-        u8 *dest = out;
-        chip = tpm_chip_find_get(chip_num);
-        if (chip == NULL)
-                return -ENODEV;
-        if (!out || !num_bytes || max > TPM_MAX_RNG_DATA)
-                return -EINVAL;
-        do {
-                tpm_cmd.header.in = tpm_getrandom_header;
-                tpm_cmd.params.getrandom_in.num_bytes = cpu_to_be32(num_bytes);
-                err = transmit_cmd(chip, &tpm_cmd,
-                                   TPM_GETRANDOM_RESULT_SIZE + num_bytes,
-                                   "attempting get random");
-                if (err)
-                        break;
-                recd = be32_to_cpu(tpm_cmd.params.getrandom_out.rng_data_len);
-                memcpy(dest, tpm_cmd.params.getrandom_out.rng_data, recd);
-                dest += recd;
-                total += recd;
-                num_bytes -= recd;
-        } while (retries-- && total < max);
-        return total ? total : -EIO;
-}
-EXPORT_SYMBOL_GPL(tpm_get_random);
 /* In case vendor provided release function, call it too.*/
 void tpm_dev_vendor_release(struct tpm_chip *chip)
 {
-        if (!chip)
-                return;
        if (chip->vendor.release)
                chip->vendor.release(chip->dev);
@@ -1403,13 +1225,10 @@ EXPORT_SYMBOL_GPL(tpm_dev_vendor_release);
 * Once all references to platform device are down to 0,
 * release all allocated structures.
 */
-static void tpm_dev_release(struct device *dev)
+void tpm_dev_release(struct device *dev)
 {
        struct tpm_chip *chip = dev_get_drvdata(dev);
-        if (!chip)
-                return;
        tpm_dev_vendor_release(chip);
        chip->release(dev);
@@ -1476,17 +1295,15 @@ struct tpm_chip *tpm_register_hardware(struct device *dev,
                        "unable to misc_register %s, minor %d\n",
                        chip->vendor.miscdev.name,
                        chip->vendor.miscdev.minor);
-                goto put_device;
+                put_device(chip->dev);
+                return NULL;
        }
        if (sysfs_create_group(&dev->kobj, chip->vendor.attr_group)) {
                misc_deregister(&chip->vendor.miscdev);
-                goto put_device;
+                put_device(chip->dev);
-        }
-        if (tpm_add_ppi(&dev->kobj)) {
+                return NULL;
-                misc_deregister(&chip->vendor.miscdev);
-                goto put_device;
        }
        chip->bios_dir = tpm_bios_log_setup(devname);
@@ -1498,8 +1315,6 @@ struct tpm_chip *tpm_register_hardware(struct device *dev,
        return chip;
-put_device:
-        put_device(chip->dev);
 out_free:
        kfree(chip);
        kfree(devname);
diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h
index 8ef7649a50a..9c4163cfa3c 100644
--- a/drivers/char/tpm/tpm.h
+++ b/drivers/char/tpm/tpm.h
@@ -28,12 +28,6 @@
 #include <linux/io.h>
 #include <linux/tpm.h>
-enum tpm_const {
-        TPM_MINOR = 224,        /* officially assigned */
-        TPM_BUFSIZE = 4096,
-        TPM_NUM_DEVICES = 256,
-};
 enum tpm_timeout {
        TPM_TIMEOUT = 5,        /* msecs */
 };
@@ -44,11 +38,6 @@ 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,
@@ -100,14 +89,11 @@ struct tpm_vendor_specific {
        bool timeout_adjusted;
        unsigned long duration[3]; /* jiffies */
        bool duration_adjusted;
-        void *data;
        wait_queue_head_t read_queue;
        wait_queue_head_t int_queue;
 };
-#define TPM_VID_INTEL    0x8086
 struct tpm_chip {
        struct device *dev;     /* Device stuff */
@@ -276,21 +262,6 @@ struct tpm_pcrextend_in {
        u8      hash[TPM_DIGEST_SIZE];
 }__attribute__((packed));
-/* 128 bytes is an arbitrary cap. This could be as large as TPM_BUFSIZE - 18
- * bytes, but 128 is still a relatively large number of random bytes and
- * anything much bigger causes users of struct tpm_cmd_t to start getting
- * compiler warnings about stack frame size. */
-#define TPM_MAX_RNG_DATA        128
-struct tpm_getrandom_out {
-        __be32 rng_data_len;
-        u8     rng_data[TPM_MAX_RNG_DATA];
-}__attribute__((packed));
-struct tpm_getrandom_in {
-        __be32 num_bytes;
-}__attribute__((packed));
 typedef union {
        struct  tpm_getcap_params_out getcap_out;
        struct  tpm_readpubek_params_out readpubek_out;
@@ -299,8 +270,6 @@ typedef union {
        struct  tpm_pcrread_in  pcrread_in;
        struct  tpm_pcrread_out pcrread_out;
        struct  tpm_pcrextend_in pcrextend_in;
-        struct  tpm_getrandom_in getrandom_in;
-        struct  tpm_getrandom_out getrandom_out;
 } tpm_cmd_params;
 struct tpm_cmd_t {
@@ -310,9 +279,9 @@ struct tpm_cmd_t {
 ssize_t tpm_getcap(struct device *, __be32, cap_t *, const char *);
-extern int tpm_get_timeouts(struct tpm_chip *);
+extern void tpm_get_timeouts(struct tpm_chip *);
 extern void tpm_gen_interrupt(struct tpm_chip *);
-extern int tpm_do_selftest(struct tpm_chip *);
+extern void tpm_continue_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 *);
@@ -323,21 +292,18 @@ extern ssize_t tpm_write(struct file *, const char __user *, size_t,
                         loff_t *);
 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 *);
+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 int tpm_add_ppi(struct kobject *);
+extern struct dentry ** tpm_bios_log_setup(char *);
-extern void tpm_remove_ppi(struct kobject *);
+extern void tpm_bios_log_teardown(struct dentry **);
 #else
-static inline int tpm_add_ppi(struct kobject *parent)
+static inline struct dentry ** tpm_bios_log_setup(char *name)
 {
-        return 0;
+        return NULL;
 }
+static inline void tpm_bios_log_teardown(struct dentry **dir)
-static inline void tpm_remove_ppi(struct kobject *parent)
 {
 }
 #endif
diff --git a/drivers/char/tpm/tpm_acpi.c b/drivers/char/tpm/tpm_acpi.c
deleted file mode 100644
index 56051d0c97a..00000000000
--- a/drivers/char/tpm/tpm_acpi.c
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Copyright (C) 2005 IBM Corporation
- *
- * Authors:
- *      Seiji Munetoh <munetoh@jp.ibm.com>
- *      Stefan Berger <stefanb@us.ibm.com>
- *      Reiner Sailer <sailer@watson.ibm.com>
- *      Kylene Hall <kjhall@us.ibm.com>
- *
- * Maintained by: <tpmdd-devel@lists.sourceforge.net>
- *
- * Access to the eventlog extended by the TCG BIOS of PC platform
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- *
- */
-#include <linux/seq_file.h>
-#include <linux/fs.h>
-#include <linux/security.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <acpi/acpi.h>
-#include "tpm.h"
-#include "tpm_eventlog.h"
-struct acpi_tcpa {
-        struct acpi_table_header hdr;
-        u16 platform_class;
-        union {
-                struct client_hdr {
-                        u32 log_max_len __attribute__ ((packed));
-                        u64 log_start_addr __attribute__ ((packed));
-                } client;
-                struct server_hdr {
-                        u16 reserved;
-                        u64 log_max_len __attribute__ ((packed));
-                        u64 log_start_addr __attribute__ ((packed));
-                } server;
-        };
-};
-/* read binary bios log */
-int read_log(struct tpm_bios_log *log)
-{
-        struct acpi_tcpa *buff;
-        acpi_status status;
-        void __iomem *virt;
-        u64 len, start;
-        if (log->bios_event_log != NULL) {
-                printk(KERN_ERR
-                       "%s: ERROR - Eventlog already initialized\n",
-                       __func__);
-                return -EFAULT;
-        }
-        /* Find TCPA entry in RSDT (ACPI_LOGICAL_ADDRESSING) */
-        status = acpi_get_table(ACPI_SIG_TCPA, 1,
-                                (struct acpi_table_header **)&buff);
-        if (ACPI_FAILURE(status)) {
-                printk(KERN_ERR "%s: ERROR - Could not get TCPA table\n",
-                       __func__);
-                return -EIO;
-        }
-        switch(buff->platform_class) {
-        case BIOS_SERVER:
-                len = buff->server.log_max_len;
-                start = buff->server.log_start_addr;
-                break;
-        case BIOS_CLIENT:
-        default:
-                len = buff->client.log_max_len;
-                start = buff->client.log_start_addr;
-                break;
-        }
-        if (!len) {
-                printk(KERN_ERR "%s: ERROR - TCPA log area empty\n", __func__);
-                return -EIO;
-        }
-        /* malloc EventLog space */
-        log->bios_event_log = kmalloc(len, GFP_KERNEL);
-        if (!log->bios_event_log) {
-                printk("%s: ERROR - Not enough  Memory for BIOS measurements\n",
-                        __func__);
-                return -ENOMEM;
-        }
-        log->bios_event_log_end = log->bios_event_log + len;
-        virt = acpi_os_map_memory(start, len);
-        if (!virt) {
-                kfree(log->bios_event_log);
-                printk("%s: ERROR - Unable to map memory\n", __func__);
-                return -EIO;
-        }
-        memcpy_fromio(log->bios_event_log, virt, len);
-        acpi_os_unmap_memory(virt, len);
-        return 0;
-}
diff --git a/drivers/char/tpm/tpm_atmel.c b/drivers/char/tpm/tpm_atmel.c
index 678d57019dc..c64a1bc6534 100644
--- a/drivers/char/tpm/tpm_atmel.c
+++ b/drivers/char/tpm/tpm_atmel.c
@@ -168,14 +168,22 @@ static void atml_plat_remove(void)
        }
 }
-static SIMPLE_DEV_PM_OPS(tpm_atml_pm, tpm_pm_suspend, tpm_pm_resume);
+static int tpm_atml_suspend(struct platform_device *dev, pm_message_t msg)
+{
+        return tpm_pm_suspend(&dev->dev, msg);
+}
+static int tpm_atml_resume(struct platform_device *dev)
+{
+        return tpm_pm_resume(&dev->dev);
+}
 static struct platform_driver atml_drv = {
        .driver = {
                .name = "tpm_atmel",
                .owner          = THIS_MODULE,
-                .pm             = &tpm_atml_pm,
        },
+        .suspend = tpm_atml_suspend,
+        .resume = tpm_atml_resume,
 };
 static int __init init_atmel(void)
diff --git a/drivers/char/tpm/tpm_eventlog.c b/drivers/char/tpm/tpm_eventlog.c
deleted file mode 100644
index 84ddc557b8f..00000000000
--- a/drivers/char/tpm/tpm_eventlog.c
+++ /dev/null
@@ -1,419 +0,0 @@
-/*
- * Copyright (C) 2005, 2012 IBM Corporation
- *
- * Authors:
- *      Kent Yoder <key@linux.vnet.ibm.com>
- *      Seiji Munetoh <munetoh@jp.ibm.com>
- *      Stefan Berger <stefanb@us.ibm.com>
- *      Reiner Sailer <sailer@watson.ibm.com>
- *      Kylene Hall <kjhall@us.ibm.com>
- *
- * Maintained by: <tpmdd-devel@lists.sourceforge.net>
- *
- * Access to the eventlog created by a system's firmware / BIOS
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- *
- */
-#include <linux/seq_file.h>
-#include <linux/fs.h>
-#include <linux/security.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-#include "tpm.h"
-#include "tpm_eventlog.h"
-static const char* tcpa_event_type_strings[] = {
-        "PREBOOT",
-        "POST CODE",
-        "",
-        "NO ACTION",
-        "SEPARATOR",
-        "ACTION",
-        "EVENT TAG",
-        "S-CRTM Contents",
-        "S-CRTM Version",
-        "CPU Microcode",
-        "Platform Config Flags",
-        "Table of Devices",
-        "Compact Hash",
-        "IPL",
-        "IPL Partition Data",
-        "Non-Host Code",
-        "Non-Host Config",
-        "Non-Host Info"
-};
-static const char* tcpa_pc_event_id_strings[] = {
-        "",
-        "SMBIOS",
-        "BIS Certificate",
-        "POST BIOS ",
-        "ESCD ",
-        "CMOS",
-        "NVRAM",
-        "Option ROM",
-        "Option ROM config",
-        "",
-        "Option ROM microcode ",
-        "S-CRTM Version",
-        "S-CRTM Contents ",
-        "POST Contents ",
-        "Table of Devices",
-};
-/* returns pointer to start of pos. entry of tcg log */
-static void *tpm_bios_measurements_start(struct seq_file *m, loff_t *pos)
-{
-        loff_t i;
-        struct tpm_bios_log *log = m->private;
-        void *addr = log->bios_event_log;
-        void *limit = log->bios_event_log_end;
-        struct tcpa_event *event;
-        /* read over *pos measurements */
-        for (i = 0; i < *pos; i++) {
-                event = addr;
-                if ((addr + sizeof(struct tcpa_event)) < limit) {
-                        if (event->event_type == 0 && event->event_size == 0)
-                                return NULL;
-                        addr += sizeof(struct tcpa_event) + event->event_size;
-                }
-        }
-        /* now check if current entry is valid */
-        if ((addr + sizeof(struct tcpa_event)) >= limit)
-                return NULL;
-        event = addr;
-        if ((event->event_type == 0 && event->event_size == 0) ||
-            ((addr + sizeof(struct tcpa_event) + event->event_size) >= limit))
-                return NULL;
-        return addr;
-}
-static void *tpm_bios_measurements_next(struct seq_file *m, void *v,
-                                        loff_t *pos)
-{
-        struct tcpa_event *event = v;
-        struct tpm_bios_log *log = m->private;
-        void *limit = log->bios_event_log_end;
-        v += sizeof(struct tcpa_event) + event->event_size;
-        /* now check if current entry is valid */
-        if ((v + sizeof(struct tcpa_event)) >= limit)
-                return NULL;
-        event = v;
-        if (event->event_type == 0 && event->event_size == 0)
-                return NULL;
-        if ((event->event_type == 0 && event->event_size == 0) ||
-            ((v + sizeof(struct tcpa_event) + event->event_size) >= limit))
-                return NULL;
-        (*pos)++;
-        return v;
-}
-static void tpm_bios_measurements_stop(struct seq_file *m, void *v)
-{
-}
-static int get_event_name(char *dest, struct tcpa_event *event,
-                        unsigned char * event_entry)
-{
-        const char *name = "";
-        /* 41 so there is room for 40 data and 1 nul */
-        char data[41] = "";
-        int i, n_len = 0, d_len = 0;
-        struct tcpa_pc_event *pc_event;
-        switch(event->event_type) {
-        case PREBOOT:
-        case POST_CODE:
-        case UNUSED:
-        case NO_ACTION:
-        case SCRTM_CONTENTS:
-        case SCRTM_VERSION:
-        case CPU_MICROCODE:
-        case PLATFORM_CONFIG_FLAGS:
-        case TABLE_OF_DEVICES:
-        case COMPACT_HASH:
-        case IPL:
-        case IPL_PARTITION_DATA:
-        case NONHOST_CODE:
-        case NONHOST_CONFIG:
-        case NONHOST_INFO:
-                name = tcpa_event_type_strings[event->event_type];
-                n_len = strlen(name);
-                break;
-        case SEPARATOR:
-        case ACTION:
-                if (MAX_TEXT_EVENT > event->event_size) {
-                        name = event_entry;
-                        n_len = event->event_size;
-                }
-                break;
-        case EVENT_TAG:
-                pc_event = (struct tcpa_pc_event *)event_entry;
-                /* ToDo Row data -> Base64 */
-                switch (pc_event->event_id) {
-                case SMBIOS:
-                case BIS_CERT:
-                case CMOS:
-                case NVRAM:
-                case OPTION_ROM_EXEC:
-                case OPTION_ROM_CONFIG:
-                case S_CRTM_VERSION:
-                        name = tcpa_pc_event_id_strings[pc_event->event_id];
-                        n_len = strlen(name);
-                        break;
-                /* hash data */
-                case POST_BIOS_ROM:
-                case ESCD:
-                case OPTION_ROM_MICROCODE:
-                case S_CRTM_CONTENTS:
-                case POST_CONTENTS:
-                        name = tcpa_pc_event_id_strings[pc_event->event_id];
-                        n_len = strlen(name);
-                        for (i = 0; i < 20; i++)
-                                d_len += sprintf(&data[2*i], "%02x",
-                                                pc_event->event_data[i]);
-                        break;
-                default:
-                        break;
-                }
-        default:
-                break;
-        }
-        return snprintf(dest, MAX_TEXT_EVENT, "[%.*s%.*s]",
-                        n_len, name, d_len, data);
-}
-static int tpm_binary_bios_measurements_show(struct seq_file *m, void *v)
-{
-        struct tcpa_event *event = v;
-        char *data = v;
-        int i;
-        for (i = 0; i < sizeof(struct tcpa_event) + event->event_size; i++)
-                seq_putc(m, data[i]);
-        return 0;
-}
-static int tpm_bios_measurements_release(struct inode *inode,
-                                         struct file *file)
-{
-        struct seq_file *seq = file->private_data;
-        struct tpm_bios_log *log = seq->private;
-        if (log) {
-                kfree(log->bios_event_log);
-                kfree(log);
-        }
-        return seq_release(inode, file);
-}
-static int tpm_ascii_bios_measurements_show(struct seq_file *m, void *v)
-{
-        int len = 0;
-        int i;
-        char *eventname;
-        struct tcpa_event *event = v;
-        unsigned char *event_entry =
-            (unsigned char *) (v + sizeof(struct tcpa_event));
-        eventname = kmalloc(MAX_TEXT_EVENT, GFP_KERNEL);
-        if (!eventname) {
-                printk(KERN_ERR "%s: ERROR - No Memory for event name\n ",
-                       __func__);
-                return -EFAULT;
-        }
-        seq_printf(m, "%2d ", event->pcr_index);
-        /* 2nd: SHA1 */
-        for (i = 0; i < 20; i++)
-                seq_printf(m, "%02x", event->pcr_value[i]);
-        /* 3rd: event type identifier */
-        seq_printf(m, " %02x", event->event_type);
-        len += get_event_name(eventname, event, event_entry);
-        /* 4th: eventname <= max + \'0' delimiter */
-        seq_printf(m, " %s\n", eventname);
-        kfree(eventname);
-        return 0;
-}
-static const struct seq_operations tpm_ascii_b_measurments_seqops = {
-        .start = tpm_bios_measurements_start,
-        .next = tpm_bios_measurements_next,
-        .stop = tpm_bios_measurements_stop,
-        .show = tpm_ascii_bios_measurements_show,
-};
-static const struct seq_operations tpm_binary_b_measurments_seqops = {
-        .start = tpm_bios_measurements_start,
-        .next = tpm_bios_measurements_next,
-        .stop = tpm_bios_measurements_stop,
-        .show = tpm_binary_bios_measurements_show,
-};
-static int tpm_ascii_bios_measurements_open(struct inode *inode,
-                                            struct file *file)
-{
-        int err;
-        struct tpm_bios_log *log;
-        struct seq_file *seq;
-        log = kzalloc(sizeof(struct tpm_bios_log), GFP_KERNEL);
-        if (!log)
-                return -ENOMEM;
-        if ((err = read_log(log)))
-                goto out_free;
-        /* now register seq file */
-        err = seq_open(file, &tpm_ascii_b_measurments_seqops);
-        if (!err) {
-                seq = file->private_data;
-                seq->private = log;
-        } else {
-                goto out_free;
-        }
-out:
-        return err;
-out_free:
-        kfree(log->bios_event_log);
-        kfree(log);
-        goto out;
-}
-static const struct file_operations tpm_ascii_bios_measurements_ops = {
-        .open = tpm_ascii_bios_measurements_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = tpm_bios_measurements_release,
-};
-static int tpm_binary_bios_measurements_open(struct inode *inode,
-                                             struct file *file)
-{
-        int err;
-        struct tpm_bios_log *log;
-        struct seq_file *seq;
-        log = kzalloc(sizeof(struct tpm_bios_log), GFP_KERNEL);
-        if (!log)
-                return -ENOMEM;
-        if ((err = read_log(log)))
-                goto out_free;
-        /* now register seq file */
-        err = seq_open(file, &tpm_binary_b_measurments_seqops);
-        if (!err) {
-                seq = file->private_data;
-                seq->private = log;
-        } else {
-                goto out_free;
-        }
-out:
-        return err;
-out_free:
-        kfree(log->bios_event_log);
-        kfree(log);
-        goto out;
-}
-static const struct file_operations tpm_binary_bios_measurements_ops = {
-        .open = tpm_binary_bios_measurements_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = tpm_bios_measurements_release,
-};
-static int is_bad(void *p)
-{
-        if (!p)
-                return 1;
-        if (IS_ERR(p) && (PTR_ERR(p) != -ENODEV))
-                return 1;
-        return 0;
-}
-struct dentry **tpm_bios_log_setup(char *name)
-{
-        struct dentry **ret = NULL, *tpm_dir, *bin_file, *ascii_file;
-        tpm_dir = securityfs_create_dir(name, NULL);
-        if (is_bad(tpm_dir))
-                goto out;
-        bin_file =
-            securityfs_create_file("binary_bios_measurements",
-                                   S_IRUSR | S_IRGRP, tpm_dir, NULL,
-                                   &tpm_binary_bios_measurements_ops);
-        if (is_bad(bin_file))
-                goto out_tpm;
-        ascii_file =
-            securityfs_create_file("ascii_bios_measurements",
-                                   S_IRUSR | S_IRGRP, tpm_dir, NULL,
-                                   &tpm_ascii_bios_measurements_ops);
-        if (is_bad(ascii_file))
-                goto out_bin;
-        ret = kmalloc(3 * sizeof(struct dentry *), GFP_KERNEL);
-        if (!ret)
-                goto out_ascii;
-        ret[0] = ascii_file;
-        ret[1] = bin_file;
-        ret[2] = tpm_dir;
-        return ret;
-out_ascii:
-        securityfs_remove(ascii_file);
-out_bin:
-        securityfs_remove(bin_file);
-out_tpm:
-        securityfs_remove(tpm_dir);
-out:
-        return NULL;
-}
-EXPORT_SYMBOL_GPL(tpm_bios_log_setup);
-void tpm_bios_log_teardown(struct dentry **lst)
-{
-        int i;
-        for (i = 0; i < 3; i++)
-                securityfs_remove(lst[i]);
-}
-EXPORT_SYMBOL_GPL(tpm_bios_log_teardown);
-MODULE_LICENSE("GPL");
diff --git a/drivers/char/tpm/tpm_eventlog.h b/drivers/char/tpm/tpm_eventlog.h
deleted file mode 100644
index e7da086d692..00000000000
--- a/drivers/char/tpm/tpm_eventlog.h
+++ /dev/null
@@ -1,86 +0,0 @@
-#ifndef __TPM_EVENTLOG_H__
-#define __TPM_EVENTLOG_H__
-#define TCG_EVENT_NAME_LEN_MAX  255
-#define MAX_TEXT_EVENT          1000    /* Max event string length */
-#define ACPI_TCPA_SIG           "TCPA"  /* 0x41504354 /'TCPA' */
-enum bios_platform_class {
-        BIOS_CLIENT = 0x00,
-        BIOS_SERVER = 0x01,
-};
-struct tpm_bios_log {
-        void *bios_event_log;
-        void *bios_event_log_end;
-};
-struct tcpa_event {
-        u32 pcr_index;
-        u32 event_type;
-        u8 pcr_value[20];       /* SHA1 */
-        u32 event_size;
-        u8 event_data[0];
-};
-enum tcpa_event_types {
-        PREBOOT = 0,
-        POST_CODE,
-        UNUSED,
-        NO_ACTION,
-        SEPARATOR,
-        ACTION,
-        EVENT_TAG,
-        SCRTM_CONTENTS,
-        SCRTM_VERSION,
-        CPU_MICROCODE,
-        PLATFORM_CONFIG_FLAGS,
-        TABLE_OF_DEVICES,
-        COMPACT_HASH,
-        IPL,
-        IPL_PARTITION_DATA,
-        NONHOST_CODE,
-        NONHOST_CONFIG,
-        NONHOST_INFO,
-};
-struct tcpa_pc_event {
-        u32 event_id;
-        u32 event_size;
-        u8 event_data[0];
-};
-enum tcpa_pc_event_ids {
-        SMBIOS = 1,
-        BIS_CERT,
-        POST_BIOS_ROM,
-        ESCD,
-        CMOS,
-        NVRAM,
-        OPTION_ROM_EXEC,
-        OPTION_ROM_CONFIG,
-        OPTION_ROM_MICROCODE = 10,
-        S_CRTM_VERSION,
-        S_CRTM_CONTENTS,
-        POST_CONTENTS,
-        HOST_TABLE_OF_DEVICES,
-};
-int read_log(struct tpm_bios_log *log);
-#if defined(CONFIG_TCG_IBMVTPM) || defined(CONFIG_TCG_IBMVTPM_MODULE) || \
-        defined(CONFIG_ACPI)
-extern struct dentry **tpm_bios_log_setup(char *);
-extern void tpm_bios_log_teardown(struct dentry **);
-#else
-static inline struct dentry **tpm_bios_log_setup(char *name)
-{
-        return NULL;
-}
-static inline void tpm_bios_log_teardown(struct dentry **dir)
-{
-}
-#endif
-#endif
diff --git a/drivers/char/tpm/tpm_i2c_infineon.c b/drivers/char/tpm/tpm_i2c_infineon.c
deleted file mode 100644
index fb447bd0cb6..00000000000
--- a/drivers/char/tpm/tpm_i2c_infineon.c
+++ /dev/null
@@ -1,695 +0,0 @@
-/*
- * Copyright (C) 2012 Infineon Technologies
- *
- * Authors:
- * Peter Huewe <peter.huewe@infineon.com>
- *
- * Device driver for TCG/TCPA TPM (trusted platform module).
- * Specifications at www.trustedcomputinggroup.org
- *
- * This device driver implements the TPM interface as defined in
- * the TCG TPM Interface Spec version 1.2, revision 1.0 and the
- * Infineon I2C Protocol Stack Specification v0.20.
- *
- * It is based on the original tpm_tis device driver from Leendert van
- * Dorn and Kyleen Hall.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation, version 2 of the
- * License.
- *
- *
- */
-#include <linux/init.h>
-#include <linux/i2c.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/wait.h>
-#include "tpm.h"
-/* max. buffer size supported by our TPM */
-#define TPM_BUFSIZE 1260
-/* max. number of iterations after I2C NAK */
-#define MAX_COUNT 3
-#define SLEEP_DURATION_LOW 55
-#define SLEEP_DURATION_HI 65
-/* max. number of iterations after I2C NAK for 'long' commands
- * we need this especially for sending TPM_READY, since the cleanup after the
- * transtion to the ready state may take some time, but it is unpredictable
- * how long it will take.
- */
-#define MAX_COUNT_LONG 50
-#define SLEEP_DURATION_LONG_LOW 200
-#define SLEEP_DURATION_LONG_HI 220
-/* After sending TPM_READY to 'reset' the TPM we have to sleep even longer */
-#define SLEEP_DURATION_RESET_LOW 2400
-#define SLEEP_DURATION_RESET_HI 2600
-/* we want to use usleep_range instead of msleep for the 5ms TPM_TIMEOUT */
-#define TPM_TIMEOUT_US_LOW (TPM_TIMEOUT * 1000)
-#define TPM_TIMEOUT_US_HI  (TPM_TIMEOUT_US_LOW + 2000)
-/* expected value for DIDVID register */
-#define TPM_TIS_I2C_DID_VID 0x000b15d1L
-/* Structure to store I2C TPM specific stuff */
-struct tpm_inf_dev {
-        struct i2c_client *client;
-        u8 buf[TPM_BUFSIZE + sizeof(u8)]; /* max. buffer size + addr */
-        struct tpm_chip *chip;
-};
-static struct tpm_inf_dev tpm_dev;
-static struct i2c_driver tpm_tis_i2c_driver;
-/*
- * iic_tpm_read() - read from TPM register
- * @addr: register address to read from
- * @buffer: provided by caller
- * @len: number of bytes to read
- *
- * Read len bytes from TPM register and put them into
- * buffer (little-endian format, i.e. first byte is put into buffer[0]).
- *
- * NOTE: TPM is big-endian for multi-byte values. Multi-byte
- * values have to be swapped.
- *
- * NOTE: We can't unfortunately use the combined read/write functions
- * provided by the i2c core as the TPM currently does not support the
- * repeated start condition and due to it's special requirements.
- * The i2c_smbus* functions do not work for this chip.
- *
- * Return -EIO on error, 0 on success.
- */
-static int iic_tpm_read(u8 addr, u8 *buffer, size_t len)
-{
-        struct i2c_msg msg1 = { tpm_dev.client->addr, 0, 1, &addr };
-        struct i2c_msg msg2 = { tpm_dev.client->addr, I2C_M_RD, len, buffer };
-        int rc;
-        int count;
-        /* Lock the adapter for the duration of the whole sequence. */
-        if (!tpm_dev.client->adapter->algo->master_xfer)
-                return -EOPNOTSUPP;
-        i2c_lock_adapter(tpm_dev.client->adapter);
-        for (count = 0; count < MAX_COUNT; count++) {
-                rc = __i2c_transfer(tpm_dev.client->adapter, &msg1, 1);
-                if (rc > 0)
-                        break;  /* break here to skip sleep */
-                usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI);
-        }
-        if (rc <= 0)
-                goto out;
-        /* After the TPM has successfully received the register address it needs
-         * some time, thus we're sleeping here again, before retrieving the data
-         */
-        for (count = 0; count < MAX_COUNT; count++) {
-                usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI);
-                rc = __i2c_transfer(tpm_dev.client->adapter, &msg2, 1);
-                if (rc > 0)
-                        break;
-        }
-out:
-        i2c_unlock_adapter(tpm_dev.client->adapter);
-        if (rc <= 0)
-                return -EIO;
-        return 0;
-}
-static int iic_tpm_write_generic(u8 addr, u8 *buffer, size_t len,
-                                 unsigned int sleep_low,
-                                 unsigned int sleep_hi, u8 max_count)
-{
-        int rc = -EIO;
-        int count;
-        struct i2c_msg msg1 = { tpm_dev.client->addr, 0, len + 1, tpm_dev.buf };
-        if (len > TPM_BUFSIZE)
-                return -EINVAL;
-        if (!tpm_dev.client->adapter->algo->master_xfer)
-                return -EOPNOTSUPP;
-        i2c_lock_adapter(tpm_dev.client->adapter);
-        /* prepend the 'register address' to the buffer */
-        tpm_dev.buf[0] = addr;
-        memcpy(&(tpm_dev.buf[1]), buffer, len);
-        /*
-         * NOTE: We have to use these special mechanisms here and unfortunately
-         * cannot rely on the standard behavior of i2c_transfer.
-         */
-        for (count = 0; count < max_count; count++) {
-                rc = __i2c_transfer(tpm_dev.client->adapter, &msg1, 1);
-                if (rc > 0)
-                        break;
-                usleep_range(sleep_low, sleep_hi);
-        }
-        i2c_unlock_adapter(tpm_dev.client->adapter);
-        if (rc <= 0)
-                return -EIO;
-        return 0;
-}
-/*
- * iic_tpm_write() - write to TPM register
- * @addr: register address to write to
- * @buffer: containing data to be written
- * @len: number of bytes to write
- *
- * Write len bytes from provided buffer to TPM register (little
- * endian format, i.e. buffer[0] is written as first byte).
- *
- * NOTE: TPM is big-endian for multi-byte values. Multi-byte
- * values have to be swapped.
- *
- * NOTE: use this function instead of the iic_tpm_write_generic function.
- *
- * Return -EIO on error, 0 on success
- */
-static int iic_tpm_write(u8 addr, u8 *buffer, size_t len)
-{
-        return iic_tpm_write_generic(addr, buffer, len, SLEEP_DURATION_LOW,
-                                     SLEEP_DURATION_HI, MAX_COUNT);
-}
-/*
- * This function is needed especially for the cleanup situation after
- * sending TPM_READY
- * */
-static int iic_tpm_write_long(u8 addr, u8 *buffer, size_t len)
-{
-        return iic_tpm_write_generic(addr, buffer, len, SLEEP_DURATION_LONG_LOW,
-                                     SLEEP_DURATION_LONG_HI, MAX_COUNT_LONG);
-}
-enum tis_access {
-        TPM_ACCESS_VALID = 0x80,
-        TPM_ACCESS_ACTIVE_LOCALITY = 0x20,
-        TPM_ACCESS_REQUEST_PENDING = 0x04,
-        TPM_ACCESS_REQUEST_USE = 0x02,
-};
-enum tis_status {
-        TPM_STS_VALID = 0x80,
-        TPM_STS_COMMAND_READY = 0x40,
-        TPM_STS_GO = 0x20,
-        TPM_STS_DATA_AVAIL = 0x10,
-        TPM_STS_DATA_EXPECT = 0x08,
-};
-enum tis_defaults {
-        TIS_SHORT_TIMEOUT = 750,        /* ms */
-        TIS_LONG_TIMEOUT = 2000,        /* 2 sec */
-};
-#define TPM_ACCESS(l)                   (0x0000 | ((l) << 4))
-#define TPM_STS(l)                      (0x0001 | ((l) << 4))
-#define TPM_DATA_FIFO(l)                (0x0005 | ((l) << 4))
-#define TPM_DID_VID(l)                  (0x0006 | ((l) << 4))
-static int check_locality(struct tpm_chip *chip, int loc)
-{
-        u8 buf;
-        int rc;
-        rc = iic_tpm_read(TPM_ACCESS(loc), &buf, 1);
-        if (rc < 0)
-                return rc;
-        if ((buf & (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
-            (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) {
-                chip->vendor.locality = loc;
-                return loc;
-        }
-        return -EIO;
-}
-/* implementation similar to tpm_tis */
-static void release_locality(struct tpm_chip *chip, int loc, int force)
-{
-        u8 buf;
-        if (iic_tpm_read(TPM_ACCESS(loc), &buf, 1) < 0)
-                return;
-        if (force || (buf & (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) ==
-            (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) {
-                buf = TPM_ACCESS_ACTIVE_LOCALITY;
-                iic_tpm_write(TPM_ACCESS(loc), &buf, 1);
-        }
-}
-static int request_locality(struct tpm_chip *chip, int loc)
-{
-        unsigned long stop;
-        u8 buf = TPM_ACCESS_REQUEST_USE;
-        if (check_locality(chip, loc) >= 0)
-                return loc;
-        iic_tpm_write(TPM_ACCESS(loc), &buf, 1);
-        /* wait for burstcount */
-        stop = jiffies + chip->vendor.timeout_a;
-        do {
-                if (check_locality(chip, loc) >= 0)
-                        return loc;
-                usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI);
-        } while (time_before(jiffies, stop));
-        return -ETIME;
-}
-static u8 tpm_tis_i2c_status(struct tpm_chip *chip)
-{
-        /* NOTE: since I2C read may fail, return 0 in this case --> time-out */
-        u8 buf;
-        if (iic_tpm_read(TPM_STS(chip->vendor.locality), &buf, 1) < 0)
-                return 0;
-        else
-                return buf;
-}
-static void tpm_tis_i2c_ready(struct tpm_chip *chip)
-{
-        /* this causes the current command to be aborted */
-        u8 buf = TPM_STS_COMMAND_READY;
-        iic_tpm_write_long(TPM_STS(chip->vendor.locality), &buf, 1);
-}
-static ssize_t get_burstcount(struct tpm_chip *chip)
-{
-        unsigned long stop;
-        ssize_t burstcnt;
-        u8 buf[3];
-        /* wait for burstcount */
-        /* which timeout value, spec has 2 answers (c & d) */
-        stop = jiffies + chip->vendor.timeout_d;
-        do {
-                /* Note: STS is little endian */
-                if (iic_tpm_read(TPM_STS(chip->vendor.locality)+1, buf, 3) < 0)
-                        burstcnt = 0;
-                else
-                        burstcnt = (buf[2] << 16) + (buf[1] << 8) + buf[0];
-                if (burstcnt)
-                        return burstcnt;
-                usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI);
-        } while (time_before(jiffies, stop));
-        return -EBUSY;
-}
-static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
-                         int *status)
-{
-        unsigned long stop;
-        /* check current status */
-        *status = tpm_tis_i2c_status(chip);
-        if ((*status & mask) == mask)
-                return 0;
-        stop = jiffies + timeout;
-        do {
-                /* since we just checked the status, give the TPM some time */
-                usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI);
-                *status = tpm_tis_i2c_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)
-{
-        size_t size = 0;
-        ssize_t burstcnt;
-        u8 retries = 0;
-        int rc;
-        while (size < count) {
-                burstcnt = get_burstcount(chip);
-                /* burstcnt < 0 = TPM is busy */
-                if (burstcnt < 0)
-                        return burstcnt;
-                /* limit received data to max. left */
-                if (burstcnt > (count - size))
-                        burstcnt = count - size;
-                rc = iic_tpm_read(TPM_DATA_FIFO(chip->vendor.locality),
-                                  &(buf[size]), burstcnt);
-                if (rc == 0)
-                        size += burstcnt;
-                else if (rc < 0)
-                        retries++;
-                /* avoid endless loop in case of broken HW */
-                if (retries > MAX_COUNT_LONG)
-                        return -EIO;
-        }
-        return size;
-}
-static int tpm_tis_i2c_recv(struct tpm_chip *chip, u8 *buf, size_t count)
-{
-        int size = 0;
-        int expected, status;
-        if (count < TPM_HEADER_SIZE) {
-                size = -EIO;
-                goto out;
-        }
-        /* read first 10 bytes, including tag, paramsize, and result */
-        size = recv_data(chip, buf, TPM_HEADER_SIZE);
-        if (size < TPM_HEADER_SIZE) {
-                dev_err(chip->dev, "Unable to read header\n");
-                goto out;
-        }
-        expected = be32_to_cpu(*(__be32 *)(buf + 2));
-        if ((size_t) expected > count) {
-                size = -EIO;
-                goto out;
-        }
-        size += recv_data(chip, &buf[TPM_HEADER_SIZE],
-                          expected - TPM_HEADER_SIZE);
-        if (size < expected) {
-                dev_err(chip->dev, "Unable to read remainder of result\n");
-                size = -ETIME;
-                goto out;
-        }
-        wait_for_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c, &status);
-        if (status & TPM_STS_DATA_AVAIL) {      /* retry? */
-                dev_err(chip->dev, "Error left over data\n");
-                size = -EIO;
-                goto out;
-        }
-out:
-        tpm_tis_i2c_ready(chip);
-        /* The TPM needs some time to clean up here,
-         * so we sleep rather than keeping the bus busy
-         */
-        usleep_range(SLEEP_DURATION_RESET_LOW, SLEEP_DURATION_RESET_HI);
-        release_locality(chip, chip->vendor.locality, 0);
-        return size;
-}
-static int tpm_tis_i2c_send(struct tpm_chip *chip, u8 *buf, size_t len)
-{
-        int rc, status;
-        ssize_t burstcnt;
-        size_t count = 0;
-        u8 retries = 0;
-        u8 sts = TPM_STS_GO;
-        if (len > TPM_BUFSIZE)
-                return -E2BIG;  /* command is too long for our tpm, sorry */
-        if (request_locality(chip, 0) < 0)
-                return -EBUSY;
-        status = tpm_tis_i2c_status(chip);
-        if ((status & TPM_STS_COMMAND_READY) == 0) {
-                tpm_tis_i2c_ready(chip);
-                if (wait_for_stat
-                    (chip, TPM_STS_COMMAND_READY,
-                     chip->vendor.timeout_b, &status) < 0) {
-                        rc = -ETIME;
-                        goto out_err;
-                }
-        }
-        while (count < len - 1) {
-                burstcnt = get_burstcount(chip);
-                /* burstcnt < 0 = TPM is busy */
-                if (burstcnt < 0)
-                        return burstcnt;
-                if (burstcnt > (len - 1 - count))
-                        burstcnt = len - 1 - count;
-                rc = iic_tpm_write(TPM_DATA_FIFO(chip->vendor.locality),
-                                   &(buf[count]), burstcnt);
-                if (rc == 0)
-                        count += burstcnt;
-                else if (rc < 0)
-                        retries++;
-                /* avoid endless loop in case of broken HW */
-                if (retries > MAX_COUNT_LONG) {
-                        rc = -EIO;
-                        goto out_err;
-                }
-                wait_for_stat(chip, TPM_STS_VALID,
-                              chip->vendor.timeout_c, &status);
-                if ((status & TPM_STS_DATA_EXPECT) == 0) {
-                        rc = -EIO;
-                        goto out_err;
-                }
-        }
-        /* write last byte */
-        iic_tpm_write(TPM_DATA_FIFO(chip->vendor.locality), &(buf[count]), 1);
-        wait_for_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c, &status);
-        if ((status & TPM_STS_DATA_EXPECT) != 0) {
-                rc = -EIO;
-                goto out_err;
-        }
-        /* go and do it */
-        iic_tpm_write(TPM_STS(chip->vendor.locality), &sts, 1);
-        return len;
-out_err:
-        tpm_tis_i2c_ready(chip);
-        /* The TPM needs some time to clean up here,
-         * so we sleep rather than keeping the bus busy
-         */
-        usleep_range(SLEEP_DURATION_RESET_LOW, SLEEP_DURATION_RESET_HI);
-        release_locality(chip, chip->vendor.locality, 0);
-        return rc;
-}
-static const struct file_operations tis_ops = {
-        .owner = THIS_MODULE,
-        .llseek = no_llseek,
-        .open = tpm_open,
-        .read = tpm_read,
-        .write = tpm_write,
-        .release = tpm_release,
-};
-static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
-static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL);
-static DEVICE_ATTR(enabled, S_IRUGO, tpm_show_enabled, NULL);
-static DEVICE_ATTR(active, S_IRUGO, tpm_show_active, NULL);
-static DEVICE_ATTR(owned, S_IRUGO, tpm_show_owned, NULL);
-static DEVICE_ATTR(temp_deactivated, S_IRUGO, tpm_show_temp_deactivated, NULL);
-static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps_1_2, NULL);
-static DEVICE_ATTR(cancel, S_IWUSR | S_IWGRP, NULL, tpm_store_cancel);
-static DEVICE_ATTR(durations, S_IRUGO, tpm_show_durations, NULL);
-static DEVICE_ATTR(timeouts, S_IRUGO, tpm_show_timeouts, NULL);
-static struct attribute *tis_attrs[] = {
-        &dev_attr_pubek.attr,
-        &dev_attr_pcrs.attr,
-        &dev_attr_enabled.attr,
-        &dev_attr_active.attr,
-        &dev_attr_owned.attr,
-        &dev_attr_temp_deactivated.attr,
-        &dev_attr_caps.attr,
-        &dev_attr_cancel.attr,
-        &dev_attr_durations.attr,
-        &dev_attr_timeouts.attr,
-        NULL,
-};
-static struct attribute_group tis_attr_grp = {
-        .attrs = tis_attrs
-};
-static struct tpm_vendor_specific tpm_tis_i2c = {
-        .status = tpm_tis_i2c_status,
-        .recv = tpm_tis_i2c_recv,
-        .send = tpm_tis_i2c_send,
-        .cancel = tpm_tis_i2c_ready,
-        .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
-        .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
-        .req_canceled = TPM_STS_COMMAND_READY,
-        .attr_group = &tis_attr_grp,
-        .miscdev.fops = &tis_ops,
-};
-static int tpm_tis_i2c_init(struct device *dev)
-{
-        u32 vendor;
-        int rc = 0;
-        struct tpm_chip *chip;
-        chip = tpm_register_hardware(dev, &tpm_tis_i2c);
-        if (!chip) {
-                rc = -ENODEV;
-                goto out_err;
-        }
-        /* Disable interrupts */
-        chip->vendor.irq = 0;
-        /* Default timeouts */
-        chip->vendor.timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
-        chip->vendor.timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT);
-        chip->vendor.timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
-        chip->vendor.timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
-        if (request_locality(chip, 0) != 0) {
-                rc = -ENODEV;
-                goto out_vendor;
-        }
-        /* read four bytes from DID_VID register */
-        if (iic_tpm_read(TPM_DID_VID(0), (u8 *)&vendor, 4) < 0) {
-                rc = -EIO;
-                goto out_release;
-        }
-        /* create DID_VID register value, after swapping to little-endian */
-        vendor = be32_to_cpu((__be32) vendor);
-        if (vendor != TPM_TIS_I2C_DID_VID) {
-                rc = -ENODEV;
-                goto out_release;
-        }
-        dev_info(dev, "1.2 TPM (device-id 0x%X)\n", vendor >> 16);
-        INIT_LIST_HEAD(&chip->vendor.list);
-        tpm_dev.chip = chip;
-        tpm_get_timeouts(chip);
-        tpm_do_selftest(chip);
-        return 0;
-out_release:
-        release_locality(chip, chip->vendor.locality, 1);
-out_vendor:
-        /* close file handles */
-        tpm_dev_vendor_release(chip);
-        /* remove hardware */
-        tpm_remove_hardware(chip->dev);
-        /* reset these pointers, otherwise we oops */
-        chip->dev->release = NULL;
-        chip->release = NULL;
-        tpm_dev.client = NULL;
-        dev_set_drvdata(chip->dev, chip);
-out_err:
-        return rc;
-}
-static const struct i2c_device_id tpm_tis_i2c_table[] = {
-        {"tpm_i2c_infineon", 0},
-        {},
-};
-MODULE_DEVICE_TABLE(i2c, tpm_tis_i2c_table);
-static SIMPLE_DEV_PM_OPS(tpm_tis_i2c_ops, tpm_pm_suspend, tpm_pm_resume);
-static int tpm_tis_i2c_probe(struct i2c_client *client,
-                             const struct i2c_device_id *id)
-{
-        int rc;
-        if (tpm_dev.client != NULL)
-                return -EBUSY;  /* We only support one client */
-        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
-                dev_err(&client->dev,
-                        "no algorithms associated to the i2c bus\n");
-                return -ENODEV;
-        }
-        client->driver = &tpm_tis_i2c_driver;
-        tpm_dev.client = client;
-        rc = tpm_tis_i2c_init(&client->dev);
-        if (rc != 0) {
-                client->driver = NULL;
-                tpm_dev.client = NULL;
-                rc = -ENODEV;
-        }
-        return rc;
-}
-static int tpm_tis_i2c_remove(struct i2c_client *client)
-{
-        struct tpm_chip *chip = tpm_dev.chip;
-        release_locality(chip, chip->vendor.locality, 1);
-        /* close file handles */
-        tpm_dev_vendor_release(chip);
-        /* remove hardware */
-        tpm_remove_hardware(chip->dev);
-        /* reset these pointers, otherwise we oops */
-        chip->dev->release = NULL;
-        chip->release = NULL;
-        tpm_dev.client = NULL;
-        dev_set_drvdata(chip->dev, chip);
-        return 0;
-}
-static struct i2c_driver tpm_tis_i2c_driver = {
-        .id_table = tpm_tis_i2c_table,
-        .probe = tpm_tis_i2c_probe,
-        .remove = tpm_tis_i2c_remove,
-        .driver = {
-                   .name = "tpm_i2c_infineon",
-                   .owner = THIS_MODULE,
-                   .pm = &tpm_tis_i2c_ops,
-                   },
-};
-module_i2c_driver(tpm_tis_i2c_driver);
-MODULE_AUTHOR("Peter Huewe <peter.huewe@infineon.com>");
-MODULE_DESCRIPTION("TPM TIS I2C Infineon Driver");
-MODULE_VERSION("2.1.5");
-MODULE_LICENSE("GPL");
diff --git a/drivers/char/tpm/tpm_ibmvtpm.c b/drivers/char/tpm/tpm_ibmvtpm.c
deleted file mode 100644
index 9978609d93b..00000000000
--- a/drivers/char/tpm/tpm_ibmvtpm.c
+++ /dev/null
@@ -1,724 +0,0 @@
-/*
- * Copyright (C) 2012 IBM Corporation
- *
- * Author: Ashley Lai <adlai@us.ibm.com>
- *
- * Maintained by: <tpmdd-devel@lists.sourceforge.net>
- *
- * Device driver for TCG/TCPA TPM (trusted platform module).
- * Specifications at www.trustedcomputinggroup.org
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation, version 2 of the
- * License.
- *
- */
-#include <linux/dma-mapping.h>
-#include <linux/dmapool.h>
-#include <linux/slab.h>
-#include <asm/vio.h>
-#include <asm/irq.h>
-#include <linux/types.h>
-#include <linux/list.h>
-#include <linux/spinlock.h>
-#include <linux/interrupt.h>
-#include <linux/wait.h>
-#include <asm/prom.h>
-#include "tpm.h"
-#include "tpm_ibmvtpm.h"
-static const char tpm_ibmvtpm_driver_name[] = "tpm_ibmvtpm";
-static struct vio_device_id tpm_ibmvtpm_device_table[] = {
-        { "IBM,vtpm", "IBM,vtpm"},
-        { "", "" }
-};
-MODULE_DEVICE_TABLE(vio, tpm_ibmvtpm_device_table);
-/**
- * ibmvtpm_send_crq - Send a CRQ request
- * @vdev:       vio device struct
- * @w1:         first word
- * @w2:         second word
- *
- * Return value:
- *      0 -Sucess
- *      Non-zero - Failure
- */
-static int ibmvtpm_send_crq(struct vio_dev *vdev, u64 w1, u64 w2)
-{
-        return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, w1, w2);
-}
-/**
- * ibmvtpm_get_data - Retrieve ibm vtpm data
- * @dev:        device struct
- *
- * Return value:
- *      vtpm device struct
- */
-static struct ibmvtpm_dev *ibmvtpm_get_data(const struct device *dev)
-{
-        struct tpm_chip *chip = dev_get_drvdata(dev);
-        if (chip)
-                return (struct ibmvtpm_dev *)chip->vendor.data;
-        return NULL;
-}
-/**
- * tpm_ibmvtpm_recv - Receive data after send
- * @chip:       tpm chip struct
- * @buf:        buffer to read
- * count:       size of buffer
- *
- * Return value:
- *      Number of bytes read
- */
-static int tpm_ibmvtpm_recv(struct tpm_chip *chip, u8 *buf, size_t count)
-{
-        struct ibmvtpm_dev *ibmvtpm;
-        u16 len;
-        int sig;
-        ibmvtpm = (struct ibmvtpm_dev *)chip->vendor.data;
-        if (!ibmvtpm->rtce_buf) {
-                dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n");
-                return 0;
-        }
-        sig = wait_event_interruptible(ibmvtpm->wq, ibmvtpm->res_len != 0);
-        if (sig)
-                return -EINTR;
-        len = ibmvtpm->res_len;
-        if (count < len) {
-                dev_err(ibmvtpm->dev,
-                        "Invalid size in recv: count=%ld, crq_size=%d\n",
-                        count, len);
-                return -EIO;
-        }
-        spin_lock(&ibmvtpm->rtce_lock);
-        memcpy((void *)buf, (void *)ibmvtpm->rtce_buf, len);
-        memset(ibmvtpm->rtce_buf, 0, len);
-        ibmvtpm->res_len = 0;
-        spin_unlock(&ibmvtpm->rtce_lock);
-        return len;
-}
-/**
- * tpm_ibmvtpm_send - Send tpm request
- * @chip:       tpm chip struct
- * @buf:        buffer contains data to send
- * count:       size of buffer
- *
- * Return value:
- *      Number of bytes sent
- */
-static int tpm_ibmvtpm_send(struct tpm_chip *chip, u8 *buf, size_t count)
-{
-        struct ibmvtpm_dev *ibmvtpm;
-        struct ibmvtpm_crq crq;
-        u64 *word = (u64 *) &crq;
-        int rc;
-        ibmvtpm = (struct ibmvtpm_dev *)chip->vendor.data;
-        if (!ibmvtpm->rtce_buf) {
-                dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n");
-                return 0;
-        }
-        if (count > ibmvtpm->rtce_size) {
-                dev_err(ibmvtpm->dev,
-                        "Invalid size in send: count=%ld, rtce_size=%d\n",
-                        count, ibmvtpm->rtce_size);
-                return -EIO;
-        }
-        spin_lock(&ibmvtpm->rtce_lock);
-        memcpy((void *)ibmvtpm->rtce_buf, (void *)buf, count);
-        crq.valid = (u8)IBMVTPM_VALID_CMD;
-        crq.msg = (u8)VTPM_TPM_COMMAND;
-        crq.len = (u16)count;
-        crq.data = ibmvtpm->rtce_dma_handle;
-        rc = ibmvtpm_send_crq(ibmvtpm->vdev, word[0], word[1]);
-        if (rc != H_SUCCESS) {
-                dev_err(ibmvtpm->dev, "tpm_ibmvtpm_send failed rc=%d\n", rc);
-                rc = 0;
-        } else
-                rc = count;
-        spin_unlock(&ibmvtpm->rtce_lock);
-        return rc;
-}
-static void tpm_ibmvtpm_cancel(struct tpm_chip *chip)
-{
-        return;
-}
-static u8 tpm_ibmvtpm_status(struct tpm_chip *chip)
-{
-        return 0;
-}
-/**
- * ibmvtpm_crq_get_rtce_size - Send a CRQ request to get rtce size
- * @ibmvtpm:    vtpm device struct
- *
- * Return value:
- *      0 - Success
- *      Non-zero - Failure
- */
-static int ibmvtpm_crq_get_rtce_size(struct ibmvtpm_dev *ibmvtpm)
-{
-        struct ibmvtpm_crq crq;
-        u64 *buf = (u64 *) &crq;
-        int rc;
-        crq.valid = (u8)IBMVTPM_VALID_CMD;
-        crq.msg = (u8)VTPM_GET_RTCE_BUFFER_SIZE;
-        rc = ibmvtpm_send_crq(ibmvtpm->vdev, buf[0], buf[1]);
-        if (rc != H_SUCCESS)
-                dev_err(ibmvtpm->dev,
-                        "ibmvtpm_crq_get_rtce_size failed rc=%d\n", rc);
-        return rc;
-}
-/**
- * ibmvtpm_crq_get_version - Send a CRQ request to get vtpm version
- *                         - Note that this is vtpm version and not tpm version
- * @ibmvtpm:    vtpm device struct
- *
- * Return value:
- *      0 - Success
- *      Non-zero - Failure
- */
-static int ibmvtpm_crq_get_version(struct ibmvtpm_dev *ibmvtpm)
-{
-        struct ibmvtpm_crq crq;
-        u64 *buf = (u64 *) &crq;
-        int rc;
-        crq.valid = (u8)IBMVTPM_VALID_CMD;
-        crq.msg = (u8)VTPM_GET_VERSION;
-        rc = ibmvtpm_send_crq(ibmvtpm->vdev, buf[0], buf[1]);
-        if (rc != H_SUCCESS)
-                dev_err(ibmvtpm->dev,
-                        "ibmvtpm_crq_get_version failed rc=%d\n", rc);
-        return rc;
-}
-/**
- * ibmvtpm_crq_send_init_complete - Send a CRQ initialize complete message
- * @ibmvtpm:    vtpm device struct
- *
- * Return value:
- *      0 - Success
- *      Non-zero - Failure
- */
-static int ibmvtpm_crq_send_init_complete(struct ibmvtpm_dev *ibmvtpm)
-{
-        int rc;
-        rc = ibmvtpm_send_crq(ibmvtpm->vdev, INIT_CRQ_COMP_CMD, 0);
-        if (rc != H_SUCCESS)
-                dev_err(ibmvtpm->dev,
-                        "ibmvtpm_crq_send_init_complete failed rc=%d\n", rc);
-        return rc;
-}
-/**
- * ibmvtpm_crq_send_init - Send a CRQ initialize message
- * @ibmvtpm:    vtpm device struct
- *
- * Return value:
- *      0 - Success
- *      Non-zero - Failure
- */
-static int ibmvtpm_crq_send_init(struct ibmvtpm_dev *ibmvtpm)
-{
-        int rc;
-        rc = ibmvtpm_send_crq(ibmvtpm->vdev, INIT_CRQ_CMD, 0);
-        if (rc != H_SUCCESS)
-                dev_err(ibmvtpm->dev,
-                        "ibmvtpm_crq_send_init failed rc=%d\n", rc);
-        return rc;
-}
-/**
- * tpm_ibmvtpm_remove - ibm vtpm remove entry point
- * @vdev:       vio device struct
- *
- * Return value:
- *      0
- */
-static int tpm_ibmvtpm_remove(struct vio_dev *vdev)
-{
-        struct ibmvtpm_dev *ibmvtpm = ibmvtpm_get_data(&vdev->dev);
-        int rc = 0;
-        free_irq(vdev->irq, ibmvtpm);
-        do {
-                if (rc)
-                        msleep(100);
-                rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
-        } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
-        dma_unmap_single(ibmvtpm->dev, ibmvtpm->crq_dma_handle,
-                         CRQ_RES_BUF_SIZE, DMA_BIDIRECTIONAL);
-        free_page((unsigned long)ibmvtpm->crq_queue.crq_addr);
-        if (ibmvtpm->rtce_buf) {
-                dma_unmap_single(ibmvtpm->dev, ibmvtpm->rtce_dma_handle,
-                                 ibmvtpm->rtce_size, DMA_BIDIRECTIONAL);
-                kfree(ibmvtpm->rtce_buf);
-        }
-        tpm_remove_hardware(ibmvtpm->dev);
-        kfree(ibmvtpm);
-        return 0;
-}
-/**
- * tpm_ibmvtpm_get_desired_dma - Get DMA size needed by this driver
- * @vdev:       vio device struct
- *
- * Return value:
- *      Number of bytes the driver needs to DMA map
- */
-static unsigned long tpm_ibmvtpm_get_desired_dma(struct vio_dev *vdev)
-{
-        struct ibmvtpm_dev *ibmvtpm = ibmvtpm_get_data(&vdev->dev);
-        return CRQ_RES_BUF_SIZE + ibmvtpm->rtce_size;
-}
-/**
- * tpm_ibmvtpm_suspend - Suspend
- * @dev:        device struct
- *
- * Return value:
- *      0
- */
-static int tpm_ibmvtpm_suspend(struct device *dev)
-{
-        struct ibmvtpm_dev *ibmvtpm = ibmvtpm_get_data(dev);
-        struct ibmvtpm_crq crq;
-        u64 *buf = (u64 *) &crq;
-        int rc = 0;
-        crq.valid = (u8)IBMVTPM_VALID_CMD;
-        crq.msg = (u8)VTPM_PREPARE_TO_SUSPEND;
-        rc = ibmvtpm_send_crq(ibmvtpm->vdev, buf[0], buf[1]);
-        if (rc != H_SUCCESS)
-                dev_err(ibmvtpm->dev,
-                        "tpm_ibmvtpm_suspend failed rc=%d\n", rc);
-        return rc;
-}
-/**
- * ibmvtpm_reset_crq - Reset CRQ
- * @ibmvtpm:    ibm vtpm struct
- *
- * Return value:
- *      0 - Success
- *      Non-zero - Failure
- */
-static int ibmvtpm_reset_crq(struct ibmvtpm_dev *ibmvtpm)
-{
-        int rc = 0;
-        do {
-                if (rc)
-                        msleep(100);
-                rc = plpar_hcall_norets(H_FREE_CRQ,
-                                        ibmvtpm->vdev->unit_address);
-        } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
-        memset(ibmvtpm->crq_queue.crq_addr, 0, CRQ_RES_BUF_SIZE);
-        ibmvtpm->crq_queue.index = 0;
-        return plpar_hcall_norets(H_REG_CRQ, ibmvtpm->vdev->unit_address,
-                                  ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE);
-}
-/**
- * tpm_ibmvtpm_resume - Resume from suspend
- * @dev:        device struct
- *
- * Return value:
- *      0
- */
-static int tpm_ibmvtpm_resume(struct device *dev)
-{
-        struct ibmvtpm_dev *ibmvtpm = ibmvtpm_get_data(dev);
-        int rc = 0;
-        do {
-                if (rc)
-                        msleep(100);
-                rc = plpar_hcall_norets(H_ENABLE_CRQ,
-                                        ibmvtpm->vdev->unit_address);
-        } while (rc == H_IN_PROGRESS || rc == H_BUSY || H_IS_LONG_BUSY(rc));
-        if (rc) {
-                dev_err(dev, "Error enabling ibmvtpm rc=%d\n", rc);
-                return rc;
-        }
-        rc = vio_enable_interrupts(ibmvtpm->vdev);
-        if (rc) {
-                dev_err(dev, "Error vio_enable_interrupts rc=%d\n", rc);
-                return rc;
-        }
-        rc = ibmvtpm_crq_send_init(ibmvtpm);
-        if (rc)
-                dev_err(dev, "Error send_init rc=%d\n", rc);
-        return rc;
-}
-static const struct file_operations ibmvtpm_ops = {
-        .owner = THIS_MODULE,
-        .llseek = no_llseek,
-        .open = tpm_open,
-        .read = tpm_read,
-        .write = tpm_write,
-        .release = tpm_release,
-};
-static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
-static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL);
-static DEVICE_ATTR(enabled, S_IRUGO, tpm_show_enabled, NULL);
-static DEVICE_ATTR(active, S_IRUGO, tpm_show_active, NULL);
-static DEVICE_ATTR(owned, S_IRUGO, tpm_show_owned, NULL);
-static DEVICE_ATTR(temp_deactivated, S_IRUGO, tpm_show_temp_deactivated,
-                   NULL);
-static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps_1_2, NULL);
-static DEVICE_ATTR(cancel, S_IWUSR | S_IWGRP, NULL, tpm_store_cancel);
-static DEVICE_ATTR(durations, S_IRUGO, tpm_show_durations, NULL);
-static DEVICE_ATTR(timeouts, S_IRUGO, tpm_show_timeouts, NULL);
-static struct attribute *ibmvtpm_attrs[] = {
-        &dev_attr_pubek.attr,
-        &dev_attr_pcrs.attr,
-        &dev_attr_enabled.attr,
-        &dev_attr_active.attr,
-        &dev_attr_owned.attr,
-        &dev_attr_temp_deactivated.attr,
-        &dev_attr_caps.attr,
-        &dev_attr_cancel.attr,
-        &dev_attr_durations.attr,
-        &dev_attr_timeouts.attr, NULL,
-};
-static struct attribute_group ibmvtpm_attr_grp = { .attrs = ibmvtpm_attrs };
-static const struct tpm_vendor_specific tpm_ibmvtpm = {
-        .recv = tpm_ibmvtpm_recv,
-        .send = tpm_ibmvtpm_send,
-        .cancel = tpm_ibmvtpm_cancel,
-        .status = tpm_ibmvtpm_status,
-        .req_complete_mask = 0,
-        .req_complete_val = 0,
-        .req_canceled = 0,
-        .attr_group = &ibmvtpm_attr_grp,
-        .miscdev = { .fops = &ibmvtpm_ops, },
-};
-static const struct dev_pm_ops tpm_ibmvtpm_pm_ops = {
-        .suspend = tpm_ibmvtpm_suspend,
-        .resume = tpm_ibmvtpm_resume,
-};
-/**
- * ibmvtpm_crq_get_next - Get next responded crq
- * @ibmvtpm     vtpm device struct
- *
- * Return value:
- *      vtpm crq pointer
- */
-static struct ibmvtpm_crq *ibmvtpm_crq_get_next(struct ibmvtpm_dev *ibmvtpm)
-{
-        struct ibmvtpm_crq_queue *crq_q = &ibmvtpm->crq_queue;
-        struct ibmvtpm_crq *crq = &crq_q->crq_addr[crq_q->index];
-        if (crq->valid & VTPM_MSG_RES) {
-                if (++crq_q->index == crq_q->num_entry)
-                        crq_q->index = 0;
-                smp_rmb();
-        } else
-                crq = NULL;
-        return crq;
-}
-/**
- * ibmvtpm_crq_process - Process responded crq
- * @crq         crq to be processed
- * @ibmvtpm     vtpm device struct
- *
- * Return value:
- *      Nothing
- */
-static void ibmvtpm_crq_process(struct ibmvtpm_crq *crq,
-                                struct ibmvtpm_dev *ibmvtpm)
-{
-        int rc = 0;
-        switch (crq->valid) {
-        case VALID_INIT_CRQ:
-                switch (crq->msg) {
-                case INIT_CRQ_RES:
-                        dev_info(ibmvtpm->dev, "CRQ initialized\n");
-                        rc = ibmvtpm_crq_send_init_complete(ibmvtpm);
-                        if (rc)
-                                dev_err(ibmvtpm->dev, "Unable to send CRQ init complete rc=%d\n", rc);
-                        return;
-                case INIT_CRQ_COMP_RES:
-                        dev_info(ibmvtpm->dev,
-                                 "CRQ initialization completed\n");
-                        return;
-                default:
-                        dev_err(ibmvtpm->dev, "Unknown crq message type: %d\n", crq->msg);
-                        return;
-                }
-                return;
-        case IBMVTPM_VALID_CMD:
-                switch (crq->msg) {
-                case VTPM_GET_RTCE_BUFFER_SIZE_RES:
-                        if (crq->len <= 0) {
-                                dev_err(ibmvtpm->dev, "Invalid rtce size\n");
-                                return;
-                        }
-                        ibmvtpm->rtce_size = crq->len;
-                        ibmvtpm->rtce_buf = kmalloc(ibmvtpm->rtce_size,
-                                                    GFP_KERNEL);
-                        if (!ibmvtpm->rtce_buf) {
-                                dev_err(ibmvtpm->dev, "Failed to allocate memory for rtce buffer\n");
-                                return;
-                        }
-                        ibmvtpm->rtce_dma_handle = dma_map_single(ibmvtpm->dev,
-                                ibmvtpm->rtce_buf, ibmvtpm->rtce_size,
-                                DMA_BIDIRECTIONAL);
-                        if (dma_mapping_error(ibmvtpm->dev,
-                                              ibmvtpm->rtce_dma_handle)) {
-                                kfree(ibmvtpm->rtce_buf);
-                                ibmvtpm->rtce_buf = NULL;
-                                dev_err(ibmvtpm->dev, "Failed to dma map rtce buffer\n");
-                        }
-                        return;
-                case VTPM_GET_VERSION_RES:
-                        ibmvtpm->vtpm_version = crq->data;
-                        return;
-                case VTPM_TPM_COMMAND_RES:
-                        /* len of the data in rtce buffer */
-                        ibmvtpm->res_len = crq->len;
-                        wake_up_interruptible(&ibmvtpm->wq);
-                        return;
-                default:
-                        return;
-                }
-        }
-        return;
-}
-/**
- * ibmvtpm_interrupt -  Interrupt handler
- * @irq:                irq number to handle
- * @vtpm_instance:      vtpm that received interrupt
- *
- * Returns:
- *      IRQ_HANDLED
- **/
-static irqreturn_t ibmvtpm_interrupt(int irq, void *vtpm_instance)
-{
-        struct ibmvtpm_dev *ibmvtpm = (struct ibmvtpm_dev *) vtpm_instance;
-        struct ibmvtpm_crq *crq;
-        /* while loop is needed for initial setup (get version and
-         * get rtce_size). There should be only one tpm request at any
-         * given time.
-         */
-        while ((crq = ibmvtpm_crq_get_next(ibmvtpm)) != NULL) {
-                ibmvtpm_crq_process(crq, ibmvtpm);
-                crq->valid = 0;
-                smp_wmb();
-        }
-        return IRQ_HANDLED;
-}
-/**
- * tpm_ibmvtpm_probe - ibm vtpm initialize entry point
- * @vio_dev:    vio device struct
- * @id:         vio device id struct
- *
- * Return value:
- *      0 - Success
- *      Non-zero - Failure
- */
-static int tpm_ibmvtpm_probe(struct vio_dev *vio_dev,
-                                   const struct vio_device_id *id)
-{
-        struct ibmvtpm_dev *ibmvtpm;
-        struct device *dev = &vio_dev->dev;
-        struct ibmvtpm_crq_queue *crq_q;
-        struct tpm_chip *chip;
-        int rc = -ENOMEM, rc1;
-        chip = tpm_register_hardware(dev, &tpm_ibmvtpm);
-        if (!chip) {
-                dev_err(dev, "tpm_register_hardware failed\n");
-                return -ENODEV;
-        }
-        ibmvtpm = kzalloc(sizeof(struct ibmvtpm_dev), GFP_KERNEL);
-        if (!ibmvtpm) {
-                dev_err(dev, "kzalloc for ibmvtpm failed\n");
-                goto cleanup;
-        }
-        crq_q = &ibmvtpm->crq_queue;
-        crq_q->crq_addr = (struct ibmvtpm_crq *)get_zeroed_page(GFP_KERNEL);
-        if (!crq_q->crq_addr) {
-                dev_err(dev, "Unable to allocate memory for crq_addr\n");
-                goto cleanup;
-        }
-        crq_q->num_entry = CRQ_RES_BUF_SIZE / sizeof(*crq_q->crq_addr);
-        ibmvtpm->crq_dma_handle = dma_map_single(dev, crq_q->crq_addr,
-                                                 CRQ_RES_BUF_SIZE,
-                                                 DMA_BIDIRECTIONAL);
-        if (dma_mapping_error(dev, ibmvtpm->crq_dma_handle)) {
-                dev_err(dev, "dma mapping failed\n");
-                goto cleanup;
-        }
-        rc = plpar_hcall_norets(H_REG_CRQ, vio_dev->unit_address,
-                                ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE);
-        if (rc == H_RESOURCE)
-                rc = ibmvtpm_reset_crq(ibmvtpm);
-        if (rc) {
-                dev_err(dev, "Unable to register CRQ rc=%d\n", rc);
-                goto reg_crq_cleanup;
-        }
-        rc = request_irq(vio_dev->irq, ibmvtpm_interrupt, 0,
-                         tpm_ibmvtpm_driver_name, ibmvtpm);
-        if (rc) {
-                dev_err(dev, "Error %d register irq 0x%x\n", rc, vio_dev->irq);
-                goto init_irq_cleanup;
-        }
-        rc = vio_enable_interrupts(vio_dev);
-        if (rc) {
-                dev_err(dev, "Error %d enabling interrupts\n", rc);
-                goto init_irq_cleanup;
-        }
-        init_waitqueue_head(&ibmvtpm->wq);
-        crq_q->index = 0;
-        ibmvtpm->dev = dev;
-        ibmvtpm->vdev = vio_dev;
-        chip->vendor.data = (void *)ibmvtpm;
-        spin_lock_init(&ibmvtpm->rtce_lock);
-        rc = ibmvtpm_crq_send_init(ibmvtpm);
-        if (rc)
-                goto init_irq_cleanup;
-        rc = ibmvtpm_crq_get_version(ibmvtpm);
-        if (rc)
-                goto init_irq_cleanup;
-        rc = ibmvtpm_crq_get_rtce_size(ibmvtpm);
-        if (rc)
-                goto init_irq_cleanup;
-        return rc;
-init_irq_cleanup:
-        do {
-                rc1 = plpar_hcall_norets(H_FREE_CRQ, vio_dev->unit_address);
-        } while (rc1 == H_BUSY || H_IS_LONG_BUSY(rc1));
-reg_crq_cleanup:
-        dma_unmap_single(dev, ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE,
-                         DMA_BIDIRECTIONAL);
-cleanup:
-        if (ibmvtpm) {
-                if (crq_q->crq_addr)
-                        free_page((unsigned long)crq_q->crq_addr);
-                kfree(ibmvtpm);
-        }
-        tpm_remove_hardware(dev);
-        return rc;
-}
-static struct vio_driver ibmvtpm_driver = {
-        .id_table        = tpm_ibmvtpm_device_table,
-        .probe           = tpm_ibmvtpm_probe,
-        .remove          = tpm_ibmvtpm_remove,
-        .get_desired_dma = tpm_ibmvtpm_get_desired_dma,
-        .name            = tpm_ibmvtpm_driver_name,
-        .pm              = &tpm_ibmvtpm_pm_ops,
-};
-/**
- * ibmvtpm_module_init - Initialize ibm vtpm module
- *
- * Return value:
- *      0 -Success
- *      Non-zero - Failure
- */
-static int __init ibmvtpm_module_init(void)
-{
-        return vio_register_driver(&ibmvtpm_driver);
-}
-/**
- * ibmvtpm_module_exit - Teardown ibm vtpm module
- *
- * Return value:
- *      Nothing
- */
-static void __exit ibmvtpm_module_exit(void)
-{
-        vio_unregister_driver(&ibmvtpm_driver);
-}
-module_init(ibmvtpm_module_init);
-module_exit(ibmvtpm_module_exit);
-MODULE_AUTHOR("adlai@us.ibm.com");
-MODULE_DESCRIPTION("IBM vTPM Driver");
-MODULE_VERSION("1.0");
-MODULE_LICENSE("GPL");
diff --git a/drivers/char/tpm/tpm_ibmvtpm.h b/drivers/char/tpm/tpm_ibmvtpm.h
deleted file mode 100644
index bd82a791f99..00000000000
--- a/drivers/char/tpm/tpm_ibmvtpm.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (C) 2012 IBM Corporation
- *
- * Author: Ashley Lai <adlai@us.ibm.com>
- *
- * Maintained by: <tpmdd-devel@lists.sourceforge.net>
- *
- * Device driver for TCG/TCPA TPM (trusted platform module).
- * Specifications at www.trustedcomputinggroup.org
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation, version 2 of the
- * License.
- *
- */
-#ifndef __TPM_IBMVTPM_H__
-#define __TPM_IBMVTPM_H__
-/* vTPM Message Format 1 */
-struct ibmvtpm_crq {
-        u8 valid;
-        u8 msg;
-        u16 len;
-        u32 data;
-        u64 reserved;
-} __attribute__((packed, aligned(8)));
-struct ibmvtpm_crq_queue {
-        struct ibmvtpm_crq *crq_addr;
-        u32 index;
-        u32 num_entry;
-};
-struct ibmvtpm_dev {
-        struct device *dev;
-        struct vio_dev *vdev;
-        struct ibmvtpm_crq_queue crq_queue;
-        dma_addr_t crq_dma_handle;
-        u32 rtce_size;
-        void __iomem *rtce_buf;
-        dma_addr_t rtce_dma_handle;
-        spinlock_t rtce_lock;
-        wait_queue_head_t wq;
-        u16 res_len;
-        u32 vtpm_version;
-};
-#define CRQ_RES_BUF_SIZE        PAGE_SIZE
-/* Initialize CRQ */
-#define INIT_CRQ_CMD            0xC001000000000000LL /* Init cmd */
-#define INIT_CRQ_COMP_CMD       0xC002000000000000LL /* Init complete cmd */
-#define INIT_CRQ_RES            0x01    /* Init respond */
-#define INIT_CRQ_COMP_RES       0x02    /* Init complete respond */
-#define VALID_INIT_CRQ          0xC0    /* Valid command for init crq */
-/* vTPM CRQ response is the message type | 0x80 */
-#define VTPM_MSG_RES            0x80
-#define IBMVTPM_VALID_CMD       0x80
-/* vTPM CRQ message types */
-#define VTPM_GET_VERSION                        0x01
-#define VTPM_GET_VERSION_RES                    (0x01 | VTPM_MSG_RES)
-#define VTPM_TPM_COMMAND                        0x02
-#define VTPM_TPM_COMMAND_RES                    (0x02 | VTPM_MSG_RES)
-#define VTPM_GET_RTCE_BUFFER_SIZE               0x03
-#define VTPM_GET_RTCE_BUFFER_SIZE_RES           (0x03 | VTPM_MSG_RES)
-#define VTPM_PREPARE_TO_SUSPEND                 0x04
-#define VTPM_PREPARE_TO_SUSPEND_RES             (0x04 | VTPM_MSG_RES)
-#endif
diff --git a/drivers/char/tpm/tpm_infineon.c b/drivers/char/tpm/tpm_infineon.c
index 2b480c2960b..76da32e11f1 100644
--- a/drivers/char/tpm/tpm_infineon.c
+++ b/drivers/char/tpm/tpm_infineon.c
@@ -4,8 +4,8 @@
 * SLD 9630 TT 1.1 and SLB 9635 TT 1.2 Trusted Platform Module
 * Specifications at www.trustedcomputinggroup.org
 *
- * Copyright (C) 2005, Marcel Selhorst <tpmdd@selhorst.net>
+ * Copyright (C) 2005, Marcel Selhorst <m.selhorst@sirrix.com>
- * Sirrix AG - security technologies <tpmdd@sirrix.com> and
+ * Sirrix AG - security technologies, http://www.sirrix.com and
 * Applied Data Security Group, Ruhr-University Bochum, Germany
 * Project-Homepage: http://www.trust.rub.de/projects/linux-device-driver-infineon-tpm/ 
 *
@@ -415,7 +415,7 @@ static const struct pnp_device_id tpm_inf_pnp_tbl[] = {
 MODULE_DEVICE_TABLE(pnp, tpm_inf_pnp_tbl);
-static int tpm_inf_pnp_probe(struct pnp_dev *dev,
+static int __devinit tpm_inf_pnp_probe(struct pnp_dev *dev,
                                       const struct pnp_device_id *dev_id)
 {
        int rc = 0;
@@ -594,7 +594,7 @@ err_last:
        return rc;
 }
-static void tpm_inf_pnp_remove(struct pnp_dev *dev)
+static __devexit void tpm_inf_pnp_remove(struct pnp_dev *dev)
 {
        struct tpm_chip *chip = pnp_get_drvdata(dev);
@@ -655,7 +655,7 @@ static struct pnp_driver tpm_inf_pnp_driver = {
        .probe = tpm_inf_pnp_probe,
        .suspend = tpm_inf_pnp_suspend,
        .resume = tpm_inf_pnp_resume,
-        .remove = tpm_inf_pnp_remove
+        .remove = __devexit_p(tpm_inf_pnp_remove)
 };
 static int __init init_inf(void)
@@ -671,7 +671,7 @@ static void __exit cleanup_inf(void)
 module_init(init_inf);
 module_exit(cleanup_inf);
-MODULE_AUTHOR("Marcel Selhorst <tpmdd@sirrix.com>");
+MODULE_AUTHOR("Marcel Selhorst <m.selhorst@sirrix.com>");
 MODULE_DESCRIPTION("Driver for Infineon TPM SLD 9630 TT 1.1 / SLB 9635 TT 1.2");
 MODULE_VERSION("1.9.2");
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/tpm/tpm_nsc.c b/drivers/char/tpm/tpm_nsc.c
index 640c9a427b5..4d2464871ad 100644
--- a/drivers/char/tpm/tpm_nsc.c
+++ b/drivers/char/tpm/tpm_nsc.c
@@ -274,13 +274,22 @@ static void tpm_nsc_remove(struct device *dev)
        }
 }
-static SIMPLE_DEV_PM_OPS(tpm_nsc_pm, tpm_pm_suspend, tpm_pm_resume);
+static int tpm_nsc_suspend(struct platform_device *dev, pm_message_t msg)
+{
+        return tpm_pm_suspend(&dev->dev, msg);
+}
+static int tpm_nsc_resume(struct platform_device *dev)
+{
+        return tpm_pm_resume(&dev->dev);
+}
 static struct platform_driver nsc_drv = {
+        .suspend         = tpm_nsc_suspend,
+        .resume          = tpm_nsc_resume,
        .driver          = {
                .name    = "tpm_nsc",
                .owner   = THIS_MODULE,
-                .pm      = &tpm_nsc_pm,
        },
 };
diff --git a/drivers/char/tpm/tpm_of.c b/drivers/char/tpm/tpm_of.c
deleted file mode 100644
index 98ba2bd1a35..00000000000
--- a/drivers/char/tpm/tpm_of.c
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright 2012 IBM Corporation
- *
- * Author: Ashley Lai <adlai@us.ibm.com>
- *
- * Maintained by: <tpmdd-devel@lists.sourceforge.net>
- *
- * Read the event log created by the firmware on PPC64
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- *
- */
-#include <linux/slab.h>
-#include <linux/of.h>
-#include "tpm.h"
-#include "tpm_eventlog.h"
-int read_log(struct tpm_bios_log *log)
-{
-        struct device_node *np;
-        const u32 *sizep;
-        const __be64 *basep;
-        if (log->bios_event_log != NULL) {
-                pr_err("%s: ERROR - Eventlog already initialized\n", __func__);
-                return -EFAULT;
-        }
-        np = of_find_node_by_name(NULL, "ibm,vtpm");
-        if (!np) {
-                pr_err("%s: ERROR - IBMVTPM not supported\n", __func__);
-                return -ENODEV;
-        }
-        sizep = of_get_property(np, "linux,sml-size", NULL);
-        if (sizep == NULL) {
-                pr_err("%s: ERROR - SML size not found\n", __func__);
-                goto cleanup_eio;
-        }
-        if (*sizep == 0) {
-                pr_err("%s: ERROR - event log area empty\n", __func__);
-                goto cleanup_eio;
-        }
-        basep = of_get_property(np, "linux,sml-base", NULL);
-        if (basep == NULL) {
-                pr_err(KERN_ERR "%s: ERROR - SML not found\n", __func__);
-                goto cleanup_eio;
-        }
-        of_node_put(np);
-        log->bios_event_log = kmalloc(*sizep, GFP_KERNEL);
-        if (!log->bios_event_log) {
-                pr_err("%s: ERROR - Not enough memory for BIOS measurements\n",
-                       __func__);
-                return -ENOMEM;
-        }
-        log->bios_event_log_end = log->bios_event_log + *sizep;
-        memcpy(log->bios_event_log, __va(be64_to_cpup(basep)), *sizep);
-        return 0;
-cleanup_eio:
-        of_node_put(np);
-        return -EIO;
-}
diff --git a/drivers/char/tpm/tpm_ppi.c b/drivers/char/tpm/tpm_ppi.c
deleted file mode 100644
index 720ebcf29fd..00000000000
--- a/drivers/char/tpm/tpm_ppi.c
+++ /dev/null
@@ -1,463 +0,0 @@
-#include <linux/acpi.h>
-#include <acpi/acpi_drivers.h>
-#include "tpm.h"
-static const u8 tpm_ppi_uuid[] = {
-        0xA6, 0xFA, 0xDD, 0x3D,
-        0x1B, 0x36,
-        0xB4, 0x4E,
-        0xA4, 0x24,
-        0x8D, 0x10, 0x08, 0x9D, 0x16, 0x53
-};
-static char *tpm_device_name = "TPM";
-#define TPM_PPI_REVISION_ID     1
-#define TPM_PPI_FN_VERSION      1
-#define TPM_PPI_FN_SUBREQ       2
-#define TPM_PPI_FN_GETREQ       3
-#define TPM_PPI_FN_GETACT       4
-#define TPM_PPI_FN_GETRSP       5
-#define TPM_PPI_FN_SUBREQ2      7
-#define TPM_PPI_FN_GETOPR       8
-#define PPI_TPM_REQ_MAX         22
-#define PPI_VS_REQ_START        128
-#define PPI_VS_REQ_END          255
-#define PPI_VERSION_LEN         3
-static acpi_status ppi_callback(acpi_handle handle, u32 level, void *context,
-                                void **return_value)
-{
-        acpi_status status;
-        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
-        status = acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
-        if (strstr(buffer.pointer, context) != NULL) {
-                *return_value = handle;
-                kfree(buffer.pointer);
-                return AE_CTRL_TERMINATE;
-        }
-        return AE_OK;
-}
-static inline void ppi_assign_params(union acpi_object params[4],
-                                     u64 function_num)
-{
-        params[0].type = ACPI_TYPE_BUFFER;
-        params[0].buffer.length = sizeof(tpm_ppi_uuid);
-        params[0].buffer.pointer = (char *)tpm_ppi_uuid;
-        params[1].type = ACPI_TYPE_INTEGER;
-        params[1].integer.value = TPM_PPI_REVISION_ID;
-        params[2].type = ACPI_TYPE_INTEGER;
-        params[2].integer.value = function_num;
-        params[3].type = ACPI_TYPE_PACKAGE;
-        params[3].package.count = 0;
-        params[3].package.elements = NULL;
-}
-static ssize_t tpm_show_ppi_version(struct device *dev,
-                                    struct device_attribute *attr, char *buf)
-{
-        acpi_handle handle;
-        acpi_status status;
-        struct acpi_object_list input;
-        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object params[4];
-        union acpi_object *obj;
-        input.count = 4;
-        ppi_assign_params(params, TPM_PPI_FN_VERSION);
-        input.pointer = params;
-        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
-                                     ACPI_UINT32_MAX, ppi_callback, NULL,
-                                     tpm_device_name, &handle);
-        if (ACPI_FAILURE(status))
-                return -ENXIO;
-        status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
-                                         ACPI_TYPE_STRING);
-        if (ACPI_FAILURE(status))
-                return -ENOMEM;
-        obj = (union acpi_object *)output.pointer;
-        status = scnprintf(buf, PAGE_SIZE, "%s\n", obj->string.pointer);
-        kfree(output.pointer);
-        return status;
-}
-static ssize_t tpm_show_ppi_request(struct device *dev,
-                                    struct device_attribute *attr, char *buf)
-{
-        acpi_handle handle;
-        acpi_status status;
-        struct acpi_object_list input;
-        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object params[4];
-        union acpi_object *ret_obj;
-        input.count = 4;
-        ppi_assign_params(params, TPM_PPI_FN_GETREQ);
-        input.pointer = params;
-        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
-                                     ACPI_UINT32_MAX, ppi_callback, NULL,
-                                     tpm_device_name, &handle);
-        if (ACPI_FAILURE(status))
-                return -ENXIO;
-        status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
-                                            ACPI_TYPE_PACKAGE);
-        if (ACPI_FAILURE(status))
-                return -ENOMEM;
-        /*
-         * output.pointer should be of package type, including two integers.
-         * The first is function return code, 0 means success and 1 means
-         * error. The second is pending TPM operation requested by the OS, 0
-         * means none and >0 means operation value.
-         */
-        ret_obj = ((union acpi_object *)output.pointer)->package.elements;
-        if (ret_obj->type == ACPI_TYPE_INTEGER) {
-                if (ret_obj->integer.value) {
-                        status = -EFAULT;
-                        goto cleanup;
-                }
-                ret_obj++;
-                if (ret_obj->type == ACPI_TYPE_INTEGER)
-                        status = scnprintf(buf, PAGE_SIZE, "%llu\n",
-                                           ret_obj->integer.value);
-                else
-                        status = -EINVAL;
-        } else {
-                status = -EINVAL;
-        }
-cleanup:
-        kfree(output.pointer);
-        return status;
-}
-static ssize_t tpm_store_ppi_request(struct device *dev,
-                                     struct device_attribute *attr,
-                                     const char *buf, size_t count)
-{
-        char version[PPI_VERSION_LEN + 1];
-        acpi_handle handle;
-        acpi_status status;
-        struct acpi_object_list input;
-        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object params[4];
-        union acpi_object obj;
-        u32 req;
-        u64 ret;
-        input.count = 4;
-        ppi_assign_params(params, TPM_PPI_FN_VERSION);
-        input.pointer = params;
-        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
-                                     ACPI_UINT32_MAX, ppi_callback, NULL,
-                                     tpm_device_name, &handle);
-        if (ACPI_FAILURE(status))
-                return -ENXIO;
-        status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
-                                            ACPI_TYPE_STRING);
-        if (ACPI_FAILURE(status))
-                return -ENOMEM;
-        strncpy(version,
-                ((union acpi_object *)output.pointer)->string.pointer,
-                PPI_VERSION_LEN);
-        kfree(output.pointer);
-        output.length = ACPI_ALLOCATE_BUFFER;
-        output.pointer = NULL;
-        /*
-         * the function to submit TPM operation request to pre-os environment
-         * is updated with function index from SUBREQ to SUBREQ2 since PPI
-         * version 1.1
-         */
-        if (strcmp(version, "1.1") == -1)
-                params[2].integer.value = TPM_PPI_FN_SUBREQ;
-        else
-                params[2].integer.value = TPM_PPI_FN_SUBREQ2;
-        /*
-         * PPI spec defines params[3].type as ACPI_TYPE_PACKAGE. Some BIOS
-         * accept buffer/string/integer type, but some BIOS accept buffer/
-         * string/package type. For PPI version 1.0 and 1.1, use buffer type
-         * for compatibility, and use package type since 1.2 according to spec.
-         */
-        if (strcmp(version, "1.2") == -1) {
-                params[3].type = ACPI_TYPE_BUFFER;
-                params[3].buffer.length = sizeof(req);
-                sscanf(buf, "%d", &req);
-                params[3].buffer.pointer = (char *)&req;
-        } else {
-                params[3].package.count = 1;
-                obj.type = ACPI_TYPE_INTEGER;
-                sscanf(buf, "%llu", &obj.integer.value);
-                params[3].package.elements = &obj;
-        }
-        status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
-                                            ACPI_TYPE_INTEGER);
-        if (ACPI_FAILURE(status))
-                return -ENOMEM;
-        ret = ((union acpi_object *)output.pointer)->integer.value;
-        if (ret == 0)
-                status = (acpi_status)count;
-        else if (ret == 1)
-                status = -EPERM;
-        else
-                status = -EFAULT;
-        kfree(output.pointer);
-        return status;
-}
-static ssize_t tpm_show_ppi_transition_action(struct device *dev,
-                                              struct device_attribute *attr,
-                                              char *buf)
-{
-        char version[PPI_VERSION_LEN + 1];
-        acpi_handle handle;
-        acpi_status status;
-        struct acpi_object_list input;
-        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object params[4];
-        u32 ret;
-        char *info[] = {
-                "None",
-                "Shutdown",
-                "Reboot",
-                "OS Vendor-specific",
-                "Error",
-        };
-        input.count = 4;
-        ppi_assign_params(params, TPM_PPI_FN_VERSION);
-        input.pointer = params;
-        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
-                                     ACPI_UINT32_MAX, ppi_callback, NULL,
-                                     tpm_device_name, &handle);
-        if (ACPI_FAILURE(status))
-                return -ENXIO;
-        status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
-                                            ACPI_TYPE_STRING);
-        if (ACPI_FAILURE(status))
-                return -ENOMEM;
-        strncpy(version,
-                ((union acpi_object *)output.pointer)->string.pointer,
-                PPI_VERSION_LEN);
-        /*
-         * PPI spec defines params[3].type as empty package, but some platforms
-         * (e.g. Capella with PPI 1.0) need integer/string/buffer type, so for
-         * compatibility, define params[3].type as buffer, if PPI version < 1.2
-         */
-        if (strcmp(version, "1.2") == -1) {
-                params[3].type = ACPI_TYPE_BUFFER;
-                params[3].buffer.length =  0;
-                params[3].buffer.pointer = NULL;
-        }
-        params[2].integer.value = TPM_PPI_FN_GETACT;
-        kfree(output.pointer);
-        output.length = ACPI_ALLOCATE_BUFFER;
-        output.pointer = NULL;
-        status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
-                                            ACPI_TYPE_INTEGER);
-        if (ACPI_FAILURE(status))
-                return -ENOMEM;
-        ret = ((union acpi_object *)output.pointer)->integer.value;
-        if (ret < ARRAY_SIZE(info) - 1)
-                status = scnprintf(buf, PAGE_SIZE, "%d: %s\n", ret, info[ret]);
-        else
-                status = scnprintf(buf, PAGE_SIZE, "%d: %s\n", ret,
-                                   info[ARRAY_SIZE(info)-1]);
-        kfree(output.pointer);
-        return status;
-}
-static ssize_t tpm_show_ppi_response(struct device *dev,
-                                     struct device_attribute *attr,
-                                     char *buf)
-{
-        acpi_handle handle;
-        acpi_status status;
-        struct acpi_object_list input;
-        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object params[4];
-        union acpi_object *ret_obj;
-        u64 req;
-        input.count = 4;
-        ppi_assign_params(params, TPM_PPI_FN_GETRSP);
-        input.pointer = params;
-        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
-                                     ACPI_UINT32_MAX, ppi_callback, NULL,
-                                     tpm_device_name, &handle);
-        if (ACPI_FAILURE(status))
-                return -ENXIO;
-        status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
-                                            ACPI_TYPE_PACKAGE);
-        if (ACPI_FAILURE(status))
-                return -ENOMEM;
-        /*
-         * parameter output.pointer should be of package type, including
-         * 3 integers. The first means function return code, the second means
-         * most recent TPM operation request, and the last means response to
-         * the most recent TPM operation request. Only if the first is 0, and
-         * the second integer is not 0, the response makes sense.
-         */
-        ret_obj = ((union acpi_object *)output.pointer)->package.elements;
-        if (ret_obj->type != ACPI_TYPE_INTEGER) {
-                status = -EINVAL;
-                goto cleanup;
-        }
-        if (ret_obj->integer.value) {
-                status = -EFAULT;
-                goto cleanup;
-        }
-        ret_obj++;
-        if (ret_obj->type != ACPI_TYPE_INTEGER) {
-                status = -EINVAL;
-                goto cleanup;
-        }
-        if (ret_obj->integer.value) {
-                req = ret_obj->integer.value;
-                ret_obj++;
-                if (ret_obj->type != ACPI_TYPE_INTEGER) {
-                        status = -EINVAL;
-                        goto cleanup;
-                }
-                if (ret_obj->integer.value == 0)
-                        status = scnprintf(buf, PAGE_SIZE, "%llu %s\n", req,
-                                           "0: Success");
-                else if (ret_obj->integer.value == 0xFFFFFFF0)
-                        status = scnprintf(buf, PAGE_SIZE, "%llu %s\n", req,
-                                           "0xFFFFFFF0: User Abort");
-                else if (ret_obj->integer.value == 0xFFFFFFF1)
-                        status = scnprintf(buf, PAGE_SIZE, "%llu %s\n", req,
-                                           "0xFFFFFFF1: BIOS Failure");
-                else if (ret_obj->integer.value >= 1 &&
-                         ret_obj->integer.value <= 0x00000FFF)
-                        status = scnprintf(buf, PAGE_SIZE, "%llu %llu: %s\n",
-                                           req, ret_obj->integer.value,
-                                           "Corresponding TPM error");
-                else
-                        status = scnprintf(buf, PAGE_SIZE, "%llu %llu: %s\n",
-                                           req, ret_obj->integer.value,
-                                           "Error");
-        } else {
-                status = scnprintf(buf, PAGE_SIZE, "%llu: %s\n",
-                                   ret_obj->integer.value, "No Recent Request");
-        }
-cleanup:
-        kfree(output.pointer);
-        return status;
-}
-static ssize_t show_ppi_operations(char *buf, u32 start, u32 end)
-{
-        char *str = buf;
-        char version[PPI_VERSION_LEN];
-        acpi_handle handle;
-        acpi_status status;
-        struct acpi_object_list input;
-        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object params[4];
-        union acpi_object obj;
-        int i;
-        u32 ret;
-        char *info[] = {
-                "Not implemented",
-                "BIOS only",
-                "Blocked for OS by BIOS",
-                "User required",
-                "User not required",
-        };
-        input.count = 4;
-        ppi_assign_params(params, TPM_PPI_FN_VERSION);
-        input.pointer = params;
-        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
-                                     ACPI_UINT32_MAX, ppi_callback, NULL,
-                                     tpm_device_name, &handle);
-        if (ACPI_FAILURE(status))
-                return -ENXIO;
-        status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
-                                         ACPI_TYPE_STRING);
-        if (ACPI_FAILURE(status))
-                return -ENOMEM;
-        strncpy(version,
-                ((union acpi_object *)output.pointer)->string.pointer,
-                PPI_VERSION_LEN);
-        kfree(output.pointer);
-        output.length = ACPI_ALLOCATE_BUFFER;
-        output.pointer = NULL;
-        if (strcmp(version, "1.2") == -1)
-                return -EPERM;
-        params[2].integer.value = TPM_PPI_FN_GETOPR;
-        params[3].package.count = 1;
-        obj.type = ACPI_TYPE_INTEGER;
-        params[3].package.elements = &obj;
-        for (i = start; i <= end; i++) {
-                obj.integer.value = i;
-                status = acpi_evaluate_object_typed(handle, "_DSM",
-                         &input, &output, ACPI_TYPE_INTEGER);
-                if (ACPI_FAILURE(status))
-                        return -ENOMEM;
-                ret = ((union acpi_object *)output.pointer)->integer.value;
-                if (ret > 0 && ret < ARRAY_SIZE(info))
-                        str += scnprintf(str, PAGE_SIZE, "%d %d: %s\n",
-                                         i, ret, info[ret]);
-                kfree(output.pointer);
-                output.length = ACPI_ALLOCATE_BUFFER;
-                output.pointer = NULL;
-        }
-        return str - buf;
-}
-static ssize_t tpm_show_ppi_tcg_operations(struct device *dev,
-                                           struct device_attribute *attr,
-                                           char *buf)
-{
-        return show_ppi_operations(buf, 0, PPI_TPM_REQ_MAX);
-}
-static ssize_t tpm_show_ppi_vs_operations(struct device *dev,
-                                          struct device_attribute *attr,
-                                          char *buf)
-{
-        return show_ppi_operations(buf, PPI_VS_REQ_START, PPI_VS_REQ_END);
-}
-static DEVICE_ATTR(version, S_IRUGO, tpm_show_ppi_version, NULL);
-static DEVICE_ATTR(request, S_IRUGO | S_IWUSR | S_IWGRP,
-                   tpm_show_ppi_request, tpm_store_ppi_request);
-static DEVICE_ATTR(transition_action, S_IRUGO,
-                   tpm_show_ppi_transition_action, NULL);
-static DEVICE_ATTR(response, S_IRUGO, tpm_show_ppi_response, NULL);
-static DEVICE_ATTR(tcg_operations, S_IRUGO, tpm_show_ppi_tcg_operations, NULL);
-static DEVICE_ATTR(vs_operations, S_IRUGO, tpm_show_ppi_vs_operations, NULL);
-static struct attribute *ppi_attrs[] = {
-        &dev_attr_version.attr,
-        &dev_attr_request.attr,
-        &dev_attr_transition_action.attr,
-        &dev_attr_response.attr,
-        &dev_attr_tcg_operations.attr,
-        &dev_attr_vs_operations.attr, NULL,
-};
-static struct attribute_group ppi_attr_grp = {
-        .name = "ppi",
-        .attrs = ppi_attrs
-};
-int tpm_add_ppi(struct kobject *parent)
-{
-        return sysfs_create_group(parent, &ppi_attr_grp);
-}
-EXPORT_SYMBOL_GPL(tpm_add_ppi);
-void tpm_remove_ppi(struct kobject *parent)
-{
-        sysfs_remove_group(parent, &ppi_attr_grp);
-}
-EXPORT_SYMBOL_GPL(tpm_remove_ppi);
-MODULE_LICENSE("GPL");
diff --git a/drivers/char/tpm/tpm_tis.c b/drivers/char/tpm/tpm_tis.c
index ea31dafbcac..3f4051a7c5a 100644
--- a/drivers/char/tpm/tpm_tis.c
+++ b/drivers/char/tpm/tpm_tis.c
@@ -29,6 +29,8 @@
 #include <linux/freezer.h>
 #include "tpm.h"
+#define TPM_HEADER_SIZE 10
 enum tis_access {
        TPM_ACCESS_VALID = 0x80,
        TPM_ACCESS_ACTIVE_LOCALITY = 0x20,
@@ -76,7 +78,7 @@ enum tis_defaults {
 #define TPM_RID(l)                      (0x0F04 | ((l) << 12))
 static LIST_HEAD(tis_chips);
-static DEFINE_MUTEX(tis_lock);
+static DEFINE_SPINLOCK(tis_lock);
 #if defined(CONFIG_PNP) && defined(CONFIG_ACPI)
 static int is_itpm(struct pnp_dev *dev)
@@ -191,14 +193,54 @@ 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_tpm_stat(chip,
+               wait_for_stat(chip,
-                                 TPM_STS_DATA_AVAIL | TPM_STS_VALID,
+                             TPM_STS_DATA_AVAIL | TPM_STS_VALID,
-                                 chip->vendor.timeout_c,
+                             chip->vendor.timeout_c,
-                                 &chip->vendor.read_queue)
+                             &chip->vendor.read_queue)
               == 0) {
                burstcnt = get_burstcount(chip);
                for (; burstcnt > 0 && size < count; burstcnt--)
@@ -240,8 +282,8 @@ static int tpm_tis_recv(struct tpm_chip *chip, u8 *buf, size_t count)
                goto out;
        }
-        wait_for_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
+        wait_for_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
-                          &chip->vendor.int_queue);
+                      &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");
@@ -255,7 +297,7 @@ out:
        return size;
 }
-static bool itpm;
+static int itpm;
 module_param(itpm, bool, 0444);
 MODULE_PARM_DESC(itpm, "Force iTPM workarounds (found on some Lenovo laptops)");
@@ -275,7 +317,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_tpm_stat
+                if (wait_for_stat
                    (chip, TPM_STS_COMMAND_READY, chip->vendor.timeout_b,
                     &chip->vendor.int_queue) < 0) {
                        rc = -ETIME;
@@ -291,8 +333,8 @@ static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len)
                        count++;
                }
-                wait_for_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
+                wait_for_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
-                                  &chip->vendor.int_queue);
+                              &chip->vendor.int_queue);
                status = tpm_tis_status(chip);
                if (!itpm && (status & TPM_STS_DATA_EXPECT) == 0) {
                        rc = -EIO;
@@ -303,8 +345,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_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
+        wait_for_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
-                          &chip->vendor.int_queue);
+                      &chip->vendor.int_queue);
        status = tpm_tis_status(chip);
        if ((status & TPM_STS_DATA_EXPECT) != 0) {
                rc = -EIO;
@@ -339,7 +381,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_tpm_stat
+                if (wait_for_stat
                    (chip, TPM_STS_DATA_AVAIL | TPM_STS_VALID,
                     tpm_calc_ordinal_duration(chip, ordinal),
                     &chip->vendor.read_queue) < 0) {
@@ -367,12 +409,7 @@ static int probe_itpm(struct tpm_chip *chip)
                0x00, 0x00, 0x00, 0xf1
        };
        size_t len = sizeof(cmd_getticks);
-        bool rem_itpm = itpm;
+        int rem_itpm = itpm;
-        u16 vendor = ioread16(chip->vendor.iobase + TPM_DID_VID(0));
-        /* probe only iTPMS */
-        if (vendor != TPM_VID_INTEL)
-                return 0;
        itpm = 0;
@@ -502,7 +539,7 @@ static irqreturn_t tis_int_handler(int dummy, void *dev_id)
        return IRQ_HANDLED;
 }
-static bool interrupts = 1;
+static int interrupts = 1;
 module_param(interrupts, bool, 0444);
 MODULE_PARM_DESC(interrupts, "Enable interrupts");
@@ -510,7 +547,7 @@ static int tpm_tis_init(struct device *dev, resource_size_t start,
                        resource_size_t len, unsigned int irq)
 {
        u32 vendor, intfcaps, intmask;
-        int rc, i, irq_s, irq_e, probe;
+        int rc, i, irq_s, irq_e;
        struct tpm_chip *chip;
        if (!(chip = tpm_register_hardware(dev, &tpm_tis)))
@@ -540,12 +577,11 @@ static int tpm_tis_init(struct device *dev, resource_size_t start,
                 vendor >> 16, ioread8(chip->vendor.iobase + TPM_RID(0)));
        if (!itpm) {
-                probe = probe_itpm(chip);
+                itpm = probe_itpm(chip);
-                if (probe < 0) {
+                if (itpm < 0) {
                        rc = -ENODEV;
                        goto out_err;
                }
-                itpm = (probe == 0) ? 0 : 1;
        }
        if (itpm)
@@ -578,17 +614,7 @@ 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 */
-        if (tpm_get_timeouts(chip)) {
+        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);
@@ -692,10 +718,11 @@ static int tpm_tis_init(struct device *dev, resource_size_t start,
        }
        INIT_LIST_HEAD(&chip->vendor.list);
-        mutex_lock(&tis_lock);
+        spin_lock(&tis_lock);
        list_add(&chip->vendor.list, &tis_chips);
-        mutex_unlock(&tis_lock);
+        spin_unlock(&tis_lock);
+        tpm_continue_selftest(chip);
        return 0;
 out_err:
@@ -705,7 +732,6 @@ out_err:
        return rc;
 }
-#if defined(CONFIG_PNP) || defined(CONFIG_PM_SLEEP)
 static void tpm_tis_reenable_interrupts(struct tpm_chip *chip)
 {
        u32 intmask;
@@ -726,10 +752,10 @@ static void tpm_tis_reenable_interrupts(struct tpm_chip *chip)
        iowrite32(intmask,
                  chip->vendor.iobase + TPM_INT_ENABLE(chip->vendor.locality));
 }
-#endif
 #ifdef CONFIG_PNP
-static int tpm_tis_pnp_init(struct pnp_dev *pnp_dev,
+static int __devinit tpm_tis_pnp_init(struct pnp_dev *pnp_dev,
                                      const struct pnp_device_id *pnp_id)
 {
        resource_size_t start, len;
@@ -751,7 +777,7 @@ static int tpm_tis_pnp_init(struct pnp_dev *pnp_dev,
 static int tpm_tis_pnp_suspend(struct pnp_dev *dev, pm_message_t msg)
 {
-        return tpm_pm_suspend(&dev->dev);
+        return tpm_pm_suspend(&dev->dev, msg);
 }
 static int tpm_tis_pnp_resume(struct pnp_dev *dev)
@@ -764,12 +790,12 @@ static int tpm_tis_pnp_resume(struct pnp_dev *dev)
        ret = tpm_pm_resume(&dev->dev);
        if (!ret)
-                tpm_do_selftest(chip);
+                tpm_continue_selftest(chip);
        return ret;
 }
-static struct pnp_device_id tpm_pnp_tbl[] = {
+static struct pnp_device_id tpm_pnp_tbl[] __devinitdata = {
        {"PNP0C31", 0},         /* TPM */
        {"ATM1200", 0},         /* Atmel */
        {"IFX0102", 0},         /* Infineon */
@@ -783,7 +809,7 @@ static struct pnp_device_id tpm_pnp_tbl[] = {
 };
 MODULE_DEVICE_TABLE(pnp, tpm_pnp_tbl);
-static void tpm_tis_pnp_remove(struct pnp_dev *dev)
+static __devexit void tpm_tis_pnp_remove(struct pnp_dev *dev)
 {
        struct tpm_chip *chip = pnp_get_drvdata(dev);
@@ -807,32 +833,32 @@ module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id,
                    sizeof(tpm_pnp_tbl[TIS_HID_USR_IDX].id), 0444);
 MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe");
 #endif
+static int tpm_tis_suspend(struct platform_device *dev, pm_message_t msg)
+{
+        return tpm_pm_suspend(&dev->dev, msg);
+}
-#ifdef CONFIG_PM_SLEEP
+static int tpm_tis_resume(struct platform_device *dev)
-static int tpm_tis_resume(struct device *dev)
 {
-        struct tpm_chip *chip = dev_get_drvdata(dev);
+        struct tpm_chip *chip = dev_get_drvdata(&dev->dev);
        if (chip->vendor.irq)
                tpm_tis_reenable_interrupts(chip);
-        return tpm_pm_resume(dev);
+        return tpm_pm_resume(&dev->dev);
 }
-#endif
-static SIMPLE_DEV_PM_OPS(tpm_tis_pm, tpm_pm_suspend, tpm_tis_resume);
 static struct platform_driver tis_drv = {
        .driver = {
                .name = "tpm_tis",
                .owner          = THIS_MODULE,
-                .pm             = &tpm_tis_pm,
        },
+        .suspend = tpm_tis_suspend,
+        .resume = tpm_tis_resume,
 };
 static struct platform_device *pdev;
-static bool force;
+static int force;
 module_param(force, bool, 0444);
 MODULE_PARM_DESC(force, "Force device probe rather than using ACPI entry");
 static int __init init_tis(void)
@@ -859,7 +885,7 @@ static void __exit cleanup_tis(void)
 {
        struct tpm_vendor_specific *i, *j;
        struct tpm_chip *chip;
-        mutex_lock(&tis_lock);
+        spin_lock(&tis_lock);
        list_for_each_entry_safe(i, j, &tis_chips, list) {
                chip = to_tpm_chip(i);
                tpm_remove_hardware(chip->dev);
@@ -875,7 +901,7 @@ static void __exit cleanup_tis(void)
                iounmap(i->iobase);
                list_del(&i->list);
        }
-        mutex_unlock(&tis_lock);
+        spin_unlock(&tis_lock);
 #ifdef CONFIG_PNP
        if (!force) {
                pnp_unregister_driver(&tis_pnp_driver);
diff --git a/drivers/char/ttyprintk.c b/drivers/char/ttyprintk.c
index 4945bd3d18d..a1f68af4ccf 100644
--- a/drivers/char/ttyprintk.c
+++ b/drivers/char/ttyprintk.c
@@ -17,7 +17,6 @@
 #include <linux/device.h>
 #include <linux/serial.h>
 #include <linux/tty.h>
-#include <linux/export.h>
 struct ttyprintk_port {
        struct tty_port port;
@@ -67,7 +66,7 @@ static int tpk_printk(const unsigned char *buf, int count)
                                tmp[tpk_curr + 1] = '\0';
                                printk(KERN_INFO "%s%s", tpk_tag, tmp);
                                tpk_curr = 0;
-                                if ((i + 1) < count && buf[i + 1] == '\n')
+                                if (buf[i + 1] == '\n')
                                        i++;
                                break;
                        case '\n':
@@ -171,35 +170,31 @@ static const struct tty_operations ttyprintk_ops = {
        .ioctl = tpk_ioctl,
 };
-static struct tty_port_operations null_ops = { };
+struct tty_port_operations null_ops = { };
 static struct tty_driver *ttyprintk_driver;
 static int __init ttyprintk_init(void)
 {
        int ret = -ENOMEM;
+        void *rp;
-        tpk_port.port.ops = &null_ops;
+        ttyprintk_driver = alloc_tty_driver(1);
-        mutex_init(&tpk_port.port_write_mutex);
+        if (!ttyprintk_driver)
+                return ret;
-        ttyprintk_driver = tty_alloc_driver(1,
-                        TTY_DRIVER_RESET_TERMIOS |
-                        TTY_DRIVER_REAL_RAW |
-                        TTY_DRIVER_UNNUMBERED_NODE);
-        if (IS_ERR(ttyprintk_driver))
-                return PTR_ERR(ttyprintk_driver);
-        tty_port_init(&tpk_port.port);
+        ttyprintk_driver->owner = THIS_MODULE;
        ttyprintk_driver->driver_name = "ttyprintk";
        ttyprintk_driver->name = "ttyprintk";
        ttyprintk_driver->major = TTYAUX_MAJOR;
        ttyprintk_driver->minor_start = 3;
+        ttyprintk_driver->num = 1;
        ttyprintk_driver->type = TTY_DRIVER_TYPE_CONSOLE;
        ttyprintk_driver->init_termios = tty_std_termios;
        ttyprintk_driver->init_termios.c_oflag = OPOST | OCRNL | ONOCR | ONLRET;
+        ttyprintk_driver->flags = TTY_DRIVER_RESET_TERMIOS |
+                TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
        tty_set_operations(ttyprintk_driver, &ttyprintk_ops);
-        tty_port_link_device(&tpk_port.port, ttyprintk_driver, 0);
        ret = tty_register_driver(ttyprintk_driver);
        if (ret < 0) {
@@ -207,12 +202,23 @@ static int __init ttyprintk_init(void)
                goto error;
        }
+        /* create our unnumbered device */
+        rp = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 3), NULL,
+                                ttyprintk_driver->name);
+        if (IS_ERR(rp)) {
+                printk(KERN_ERR "Couldn't create ttyprintk device\n");
+                ret = PTR_ERR(rp);
+                goto error;
+        }
+        tty_port_init(&tpk_port.port);
+        tpk_port.port.ops = &null_ops;
+        mutex_init(&tpk_port.port_write_mutex);
        return 0;
 error:
-        tty_unregister_driver(ttyprintk_driver);
        put_tty_driver(ttyprintk_driver);
-        tty_port_destroy(&tpk_port.port);
        ttyprintk_driver = NULL;
        return ret;
 }
diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index 684b0d53764..fb68b129537 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
@@ -19,13 +19,9 @@
 */
 #include <linux/cdev.h>
 #include <linux/debugfs.h>
-#include <linux/completion.h>
 #include <linux/device.h>
 #include <linux/err.h>
-#include <linux/freezer.h>
 #include <linux/fs.h>
-#include <linux/splice.h>
-#include <linux/pagemap.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/poll.h>
@@ -36,13 +32,8 @@
 #include <linux/virtio_console.h>
 #include <linux/wait.h>
 #include <linux/workqueue.h>
-#include <linux/module.h>
-#include <linux/dma-mapping.h>
-#include <linux/kconfig.h>
 #include "../tty/hvc/hvc_console.h"
-#define is_rproc_enabled IS_ENABLED(CONFIG_REMOTEPROC)
 /*
 * This is a global struct for storing common data for all the devices
 * this driver handles.
@@ -82,7 +73,6 @@ struct ports_driver_data {
 static struct ports_driver_data pdrvdata;
 DEFINE_SPINLOCK(pdrvdata_lock);
-DECLARE_COMPLETION(early_console_added);
 /* This struct holds information that's relevant only for console ports */
 struct console {
@@ -115,21 +105,6 @@ struct port_buffer {
        size_t len;
        /* offset in the buf from which to consume data */
        size_t offset;
-        /* DMA address of buffer */
-        dma_addr_t dma;
-        /* Device we got DMA memory from */
-        struct device *dev;
-        /* List of pending dma buffers to free */
-        struct list_head list;
-        /* If sgpages == 0 then buf is used */
-        unsigned int sgpages;
-        /* sg is used if spages > 0. sg must be the last in is struct */
-        struct scatterlist sg[0];
 };
 /*
@@ -176,10 +151,6 @@ struct ports_device {
        int chr_major;
 };
-struct port_stats {
-        unsigned long bytes_sent, bytes_received, bytes_discarded;
-};
 /* This struct holds the per-port data */
 struct port {
        /* Next port in the list, head is in the ports_device */
@@ -208,13 +179,6 @@ struct port {
        struct dentry *debugfs_file;
        /*
-         * Keep count of the bytes sent, received and discarded for
-         * this port for accounting and debugging purposes.  These
-         * counts are not reset across port open / close events.
-         */
-        struct port_stats stats;
-        /*
         * The entries in this struct will be valid if this port is
         * hooked up to an hvc console
         */
@@ -344,11 +308,6 @@ static bool is_console_port(struct port *port)
        return false;
 }
-static bool is_rproc_serial(const struct virtio_device *vdev)
-{
-        return is_rproc_enabled && vdev->id.device == VIRTIO_ID_RPROC_SERIAL;
-}
 static inline bool use_multiport(struct ports_device *portdev)
 {
        /*
@@ -360,110 +319,20 @@ static inline bool use_multiport(struct ports_device *portdev)
        return portdev->vdev->features[0] & (1 << VIRTIO_CONSOLE_F_MULTIPORT);
 }
-static DEFINE_SPINLOCK(dma_bufs_lock);
+static void free_buf(struct port_buffer *buf)
-static LIST_HEAD(pending_free_dma_bufs);
-static void free_buf(struct port_buffer *buf, bool can_sleep)
 {
-        unsigned int i;
+        kfree(buf->buf);
-        for (i = 0; i < buf->sgpages; i++) {
-                struct page *page = sg_page(&buf->sg[i]);
-                if (!page)
-                        break;
-                put_page(page);
-        }
-        if (!buf->dev) {
-                kfree(buf->buf);
-        } else if (is_rproc_enabled) {
-                unsigned long flags;
-                /* dma_free_coherent requires interrupts to be enabled. */
-                if (!can_sleep) {
-                        /* queue up dma-buffers to be freed later */
-                        spin_lock_irqsave(&dma_bufs_lock, flags);
-                        list_add_tail(&buf->list, &pending_free_dma_bufs);
-                        spin_unlock_irqrestore(&dma_bufs_lock, flags);
-                        return;
-                }
-                dma_free_coherent(buf->dev, buf->size, buf->buf, buf->dma);
-                /* Release device refcnt and allow it to be freed */
-                put_device(buf->dev);
-        }
        kfree(buf);
 }
-static void reclaim_dma_bufs(void)
+static struct port_buffer *alloc_buf(size_t buf_size)
-{
-        unsigned long flags;
-        struct port_buffer *buf, *tmp;
-        LIST_HEAD(tmp_list);
-        if (list_empty(&pending_free_dma_bufs))
-                return;
-        /* Create a copy of the pending_free_dma_bufs while holding the lock */
-        spin_lock_irqsave(&dma_bufs_lock, flags);
-        list_cut_position(&tmp_list, &pending_free_dma_bufs,
-                          pending_free_dma_bufs.prev);
-        spin_unlock_irqrestore(&dma_bufs_lock, flags);
-        /* Release the dma buffers, without irqs enabled */
-        list_for_each_entry_safe(buf, tmp, &tmp_list, list) {
-                list_del(&buf->list);
-                free_buf(buf, true);
-        }
-}
-static struct port_buffer *alloc_buf(struct virtqueue *vq, size_t buf_size,
-                                     int pages)
 {
        struct port_buffer *buf;
-        reclaim_dma_bufs();
+        buf = kmalloc(sizeof(*buf), GFP_KERNEL);
-        /*
-         * Allocate buffer and the sg list. The sg list array is allocated
-         * directly after the port_buffer struct.
-         */
-        buf = kmalloc(sizeof(*buf) + sizeof(struct scatterlist) * pages,
-                      GFP_KERNEL);
        if (!buf)
                goto fail;
+        buf->buf = kzalloc(buf_size, GFP_KERNEL);
-        buf->sgpages = pages;
-        if (pages > 0) {
-                buf->dev = NULL;
-                buf->buf = NULL;
-                return buf;
-        }
-        if (is_rproc_serial(vq->vdev)) {
-                /*
-                 * Allocate DMA memory from ancestor. When a virtio
-                 * device is created by remoteproc, the DMA memory is
-                 * associated with the grandparent device:
-                 * vdev => rproc => platform-dev.
-                 * The code here would have been less quirky if
-                 * DMA_MEMORY_INCLUDES_CHILDREN had been supported
-                 * in dma-coherent.c
-                 */
-                if (!vq->vdev->dev.parent || !vq->vdev->dev.parent->parent)
-                        goto free_buf;
-                buf->dev = vq->vdev->dev.parent->parent;
-                /* Increase device refcnt to avoid freeing it */
-                get_device(buf->dev);
-                buf->buf = dma_alloc_coherent(buf->dev, buf_size, &buf->dma,
-                                              GFP_KERNEL);
-        } else {
-                buf->dev = NULL;
-                buf->buf = kmalloc(buf_size, GFP_KERNEL);
-        }
        if (!buf->buf)
                goto free_buf;
        buf->len = 0;
@@ -478,19 +347,17 @@ fail:
 }
 /* Callers should take appropriate locks */
-static struct port_buffer *get_inbuf(struct port *port)
+static void *get_inbuf(struct port *port)
 {
        struct port_buffer *buf;
+        struct virtqueue *vq;
        unsigned int len;
-        if (port->inbuf)
+        vq = port->in_vq;
-                return port->inbuf;
+        buf = virtqueue_get_buf(vq, &len);
-        buf = virtqueue_get_buf(port->in_vq, &len);
        if (buf) {
                buf->len = len;
                buf->offset = 0;
-                port->stats.bytes_received += len;
        }
        return buf;
 }
@@ -508,10 +375,8 @@ 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, GFP_ATOMIC);
+        ret = virtqueue_add_buf(vq, sg, 0, 1, buf);
        virtqueue_kick(vq);
-        if (!ret)
-                ret = vq->num_free;
        return ret;
 }
@@ -519,27 +384,32 @@ static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
 static void discard_port_data(struct port *port)
 {
        struct port_buffer *buf;
-        unsigned int err;
+        struct virtqueue *vq;
+        unsigned int len;
+        int ret;
        if (!port->portdev) {
                /* Device has been unplugged.  vqs are already gone. */
                return;
        }
-        buf = get_inbuf(port);
+        vq = port->in_vq;
+        if (port->inbuf)
+                buf = port->inbuf;
+        else
+                buf = virtqueue_get_buf(vq, &len);
-        err = 0;
+        ret = 0;
        while (buf) {
-                port->stats.bytes_discarded += buf->len - buf->offset;
+                if (add_inbuf(vq, buf) < 0) {
-                if (add_inbuf(port->in_vq, buf) < 0) {
+                        ret++;
-                        err++;
+                        free_buf(buf);
-                        free_buf(buf, false);
                }
-                port->inbuf = NULL;
+                buf = virtqueue_get_buf(vq, &len);
-                buf = get_inbuf(port);
        }
-        if (err)
+        port->inbuf = NULL;
+        if (ret)
                dev_warn(port->dev, "Errors adding %d buffers back to vq\n",
-                         err);
+                         ret);
 }
 static bool port_has_data(struct port *port)
@@ -547,12 +417,18 @@ static bool port_has_data(struct port *port)
        unsigned long flags;
        bool ret;
-        ret = false;
        spin_lock_irqsave(&port->inbuf_lock, flags);
+        if (port->inbuf) {
+                ret = true;
+                goto out;
+        }
        port->inbuf = get_inbuf(port);
-        if (port->inbuf)
+        if (port->inbuf) {
                ret = true;
+                goto out;
+        }
+        ret = false;
+out:
        spin_unlock_irqrestore(&port->inbuf_lock, flags);
        return ret;
 }
@@ -575,7 +451,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, GFP_ATOMIC) == 0) {
+        if (virtqueue_add_buf(vq, sg, 1, 0, &cpkt) >= 0) {
                virtqueue_kick(vq);
                while (!virtqueue_get_buf(vq, &len))
                        cpu_relax();
@@ -592,11 +468,10 @@ static ssize_t send_control_msg(struct port *port, unsigned int event,
        return 0;
 }
 /* Callers must take the port->outvq_lock */
 static void reclaim_consumed_buffers(struct port *port)
 {
-        struct port_buffer *buf;
+        void *buf;
        unsigned int len;
        if (!port->portdev) {
@@ -604,17 +479,17 @@ static void reclaim_consumed_buffers(struct port *port)
                return;
        }
        while ((buf = virtqueue_get_buf(port->out_vq, &len))) {
-                free_buf(buf, false);
+                kfree(buf);
                port->outvq_full = false;
        }
 }
-static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,
+static ssize_t send_buf(struct port *port, void *in_buf, size_t in_count,
-                              int nents, size_t in_count,
+                        bool nonblock)
-                              void *data, bool nonblock)
 {
+        struct scatterlist sg[1];
        struct virtqueue *out_vq;
-        int err;
+        ssize_t ret;
        unsigned long flags;
        unsigned int len;
@@ -624,17 +499,18 @@ static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,
        reclaim_consumed_buffers(port);
-        err = virtqueue_add_buf(out_vq, sg, nents, 0, data, GFP_ATOMIC);
+        sg_init_one(sg, in_buf, in_count);
+        ret = virtqueue_add_buf(out_vq, sg, 1, 0, in_buf);
        /* Tell Host to go! */
        virtqueue_kick(out_vq);
-        if (err) {
+        if (ret < 0) {
                in_count = 0;
                goto done;
        }
-        if (out_vq->num_free == 0)
+        if (ret == 0)
                port->outvq_full = true;
        if (nonblock)
@@ -653,8 +529,6 @@ static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,
                cpu_relax();
 done:
        spin_unlock_irqrestore(&port->outvq_lock, flags);
-        port->stats.bytes_sent += in_count;
        /*
         * We're expected to return the amount of data we wrote -- all
         * of it
@@ -759,8 +633,8 @@ static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
                if (filp->f_flags & O_NONBLOCK)
                        return -EAGAIN;
-                ret = wait_event_freezable(port->waitqueue,
+                ret = wait_event_interruptible(port->waitqueue,
-                                           !will_read_block(port));
+                                               !will_read_block(port));
                if (ret < 0)
                        return ret;
        }
@@ -783,34 +657,13 @@ static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
        return fill_readbuf(port, ubuf, count, true);
 }
-static int wait_port_writable(struct port *port, bool nonblock)
-{
-        int ret;
-        if (will_write_block(port)) {
-                if (nonblock)
-                        return -EAGAIN;
-                ret = wait_event_freezable(port->waitqueue,
-                                           !will_write_block(port));
-                if (ret < 0)
-                        return ret;
-        }
-        /* Port got hot-unplugged. */
-        if (!port->guest_connected)
-                return -ENODEV;
-        return 0;
-}
 static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
                               size_t count, loff_t *offp)
 {
        struct port *port;
-        struct port_buffer *buf;
+        char *buf;
        ssize_t ret;
        bool nonblock;
-        struct scatterlist sg[1];
        /* Userspace could be out to fool us */
        if (!count)
@@ -820,17 +673,26 @@ static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
        nonblock = filp->f_flags & O_NONBLOCK;
-        ret = wait_port_writable(port, nonblock);
+        if (will_write_block(port)) {
-        if (ret < 0)
+                if (nonblock)
-                return ret;
+                        return -EAGAIN;
+                ret = wait_event_interruptible(port->waitqueue,
+                                               !will_write_block(port));
+                if (ret < 0)
+                        return ret;
+        }
+        /* Port got hot-unplugged. */
+        if (!port->guest_connected)
+                return -ENODEV;
        count = min((size_t)(32 * 1024), count);
-        buf = alloc_buf(port->out_vq, count, 0);
+        buf = kmalloc(count, GFP_KERNEL);
        if (!buf)
                return -ENOMEM;
-        ret = copy_from_user(buf->buf, ubuf, count);
+        ret = copy_from_user(buf, ubuf, count);
        if (ret) {
                ret = -EFAULT;
                goto free_buf;
@@ -844,118 +706,17 @@ static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
         * through to the host.
         */
        nonblock = true;
-        sg_init_one(sg, buf->buf, count);
+        ret = send_buf(port, buf, count, nonblock);
-        ret = __send_to_port(port, sg, 1, count, buf, nonblock);
        if (nonblock && ret > 0)
                goto out;
 free_buf:
-        free_buf(buf, true);
+        kfree(buf);
 out:
        return ret;
 }
-struct sg_list {
-        unsigned int n;
-        unsigned int size;
-        size_t len;
-        struct scatterlist *sg;
-};
-static int pipe_to_sg(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
-                        struct splice_desc *sd)
-{
-        struct sg_list *sgl = sd->u.data;
-        unsigned int offset, len;
-        if (sgl->n == sgl->size)
-                return 0;
-        /* Try lock this page */
-        if (buf->ops->steal(pipe, buf) == 0) {
-                /* Get reference and unlock page for moving */
-                get_page(buf->page);
-                unlock_page(buf->page);
-                len = min(buf->len, sd->len);
-                sg_set_page(&(sgl->sg[sgl->n]), buf->page, len, buf->offset);
-        } else {
-                /* Failback to copying a page */
-                struct page *page = alloc_page(GFP_KERNEL);
-                char *src = buf->ops->map(pipe, buf, 1);
-                char *dst;
-                if (!page)
-                        return -ENOMEM;
-                dst = kmap(page);
-                offset = sd->pos & ~PAGE_MASK;
-                len = sd->len;
-                if (len + offset > PAGE_SIZE)
-                        len = PAGE_SIZE - offset;
-                memcpy(dst + offset, src + buf->offset, len);
-                kunmap(page);
-                buf->ops->unmap(pipe, buf, src);
-                sg_set_page(&(sgl->sg[sgl->n]), page, len, offset);
-        }
-        sgl->n++;
-        sgl->len += len;
-        return len;
-}
-/* Faster zero-copy write by splicing */
-static ssize_t port_fops_splice_write(struct pipe_inode_info *pipe,
-                                      struct file *filp, loff_t *ppos,
-                                      size_t len, unsigned int flags)
-{
-        struct port *port = filp->private_data;
-        struct sg_list sgl;
-        ssize_t ret;
-        struct port_buffer *buf;
-        struct splice_desc sd = {
-                .total_len = len,
-                .flags = flags,
-                .pos = *ppos,
-                .u.data = &sgl,
-        };
-        /*
-         * Rproc_serial does not yet support splice. To support splice
-         * pipe_to_sg() must allocate dma-buffers and copy content from
-         * regular pages to dma pages. And alloc_buf and free_buf must
-         * support allocating and freeing such a list of dma-buffers.
-         */
-        if (is_rproc_serial(port->out_vq->vdev))
-                return -EINVAL;
-        ret = wait_port_writable(port, filp->f_flags & O_NONBLOCK);
-        if (ret < 0)
-                return ret;
-        buf = alloc_buf(port->out_vq, 0, pipe->nrbufs);
-        if (!buf)
-                return -ENOMEM;
-        sgl.n = 0;
-        sgl.len = 0;
-        sgl.size = pipe->nrbufs;
-        sgl.sg = buf->sg;
-        sg_init_table(sgl.sg, sgl.size);
-        ret = __splice_from_pipe(pipe, &sd, pipe_to_sg);
-        if (likely(ret > 0))
-                ret = __send_to_port(port, buf->sg, sgl.n, sgl.len, buf, true);
-        if (unlikely(ret <= 0))
-                free_buf(buf, true);
-        return ret;
-}
 static unsigned int port_fops_poll(struct file *filp, poll_table *wait)
 {
        struct port *port;
@@ -1001,7 +762,6 @@ static int port_fops_release(struct inode *inode, struct file *filp)
        reclaim_consumed_buffers(port);
        spin_unlock_irq(&port->outvq_lock);
-        reclaim_dma_bufs();
        /*
         * Locks aren't necessary here as a port can't be opened after
         * unplug, and if a port isn't unplugged, a kref would already
@@ -1088,7 +848,6 @@ static const struct file_operations port_fops = {
        .open  = port_fops_open,
        .read  = port_fops_read,
        .write = port_fops_write,
-        .splice_write = port_fops_splice_write,
        .poll  = port_fops_poll,
        .release = port_fops_release,
        .fasync = port_fops_fasync,
@@ -1106,7 +865,6 @@ static const struct file_operations port_fops = {
 static int put_chars(u32 vtermno, const char *buf, int count)
 {
        struct port *port;
-        struct scatterlist sg[1];
        if (unlikely(early_put_chars))
                return early_put_chars(vtermno, buf, count);
@@ -1115,8 +873,7 @@ static int put_chars(u32 vtermno, const char *buf, int count)
        if (!port)
                return -EPIPE;
-        sg_init_one(sg, buf, count);
+        return send_buf(port, (void *)buf, count, false);
-        return __send_to_port(port, sg, 1, count, (void *)buf, false);
 }
 /*
@@ -1153,10 +910,7 @@ static void resize_console(struct port *port)
                return;
        vdev = port->portdev->vdev;
+        if (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE))
-        /* Don't test F_SIZE at all if we're rproc: not a valid feature! */
-        if (!is_rproc_serial(vdev) &&
-            virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE))
                hvc_resize(port->cons.hvc, port->cons.ws);
 }
@@ -1276,6 +1030,12 @@ static struct attribute_group port_attribute_group = {
        .attrs = port_sysfs_entries,
 };
+static int debugfs_open(struct inode *inode, struct file *filp)
+{
+        filp->private_data = inode->i_private;
+        return 0;
+}
 static ssize_t debugfs_read(struct file *filp, char __user *ubuf,
                            size_t count, loff_t *offp)
 {
@@ -1299,14 +1059,6 @@ static ssize_t debugfs_read(struct file *filp, char __user *ubuf,
        out_offset += snprintf(buf + out_offset, out_count - out_offset,
                               "outvq_full: %d\n", port->outvq_full);
        out_offset += snprintf(buf + out_offset, out_count - out_offset,
-                               "bytes_sent: %lu\n", port->stats.bytes_sent);
-        out_offset += snprintf(buf + out_offset, out_count - out_offset,
-                               "bytes_received: %lu\n",
-                               port->stats.bytes_received);
-        out_offset += snprintf(buf + out_offset, out_count - out_offset,
-                               "bytes_discarded: %lu\n",
-                               port->stats.bytes_discarded);
-        out_offset += snprintf(buf + out_offset, out_count - out_offset,
                               "is_console: %s\n",
                               is_console_port(port) ? "yes" : "no");
        out_offset += snprintf(buf + out_offset, out_count - out_offset,
@@ -1319,7 +1071,7 @@ static ssize_t debugfs_read(struct file *filp, char __user *ubuf,
 static const struct file_operations port_debugfs_ops = {
        .owner = THIS_MODULE,
-        .open  = simple_open,
+        .open  = debugfs_open,
        .read  = debugfs_read,
 };
@@ -1340,7 +1092,7 @@ static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock)
        nr_added_bufs = 0;
        do {
-                buf = alloc_buf(vq, PAGE_SIZE, 0);
+                buf = alloc_buf(PAGE_SIZE);
                if (!buf)
                        break;
@@ -1348,7 +1100,7 @@ static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock)
                ret = add_inbuf(vq, buf);
                if (ret < 0) {
                        spin_unlock_irq(lock);
-                        free_buf(buf, true);
+                        free_buf(buf);
                        break;
                }
                nr_added_bufs++;
@@ -1391,7 +1143,6 @@ static int add_port(struct ports_device *portdev, u32 id)
        port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
        port->host_connected = port->guest_connected = false;
-        port->stats = (struct port_stats) { 0 };
        port->outvq_full = false;
@@ -1436,18 +1187,10 @@ static int add_port(struct ports_device *portdev, u32 id)
                goto free_device;
        }
-        if (is_rproc_serial(port->portdev->vdev))
+        /*
-                /*
+         * If we're not using multiport support, this has to be a console port
-                 * For rproc_serial assume remote processor is connected.
+         */
-                 * rproc_serial does not want the console port, only
+        if (!use_multiport(port->portdev)) {
-                 * the generic port implementation.
-                 */
-                port->host_connected = true;
-        else if (!use_multiport(port->portdev)) {
-                /*
-                 * If we're not using multiport support,
-                 * this has to be a console port.
-                 */
                err = init_port_console(port);
                if (err)
                        goto free_inbufs;
@@ -1480,7 +1223,7 @@ static int add_port(struct ports_device *portdev, u32 id)
 free_inbufs:
        while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
-                free_buf(buf, true);
+                free_buf(buf);
 free_device:
        device_destroy(pdrvdata.class, port->dev->devt);
 free_cdev:
@@ -1511,24 +1254,6 @@ 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, true);
-        /* Free pending buffers from the out-queue. */
-        while ((buf = virtqueue_detach_unused_buf(port->out_vq)))
-                free_buf(buf, true);
-}
 /*
 * Port got unplugged.  Remove port from portdev's list and drop the
 * kref reference.  If no userspace has this port opened, it will
@@ -1536,6 +1261,8 @@ static void remove_port_data(struct port *port)
 */
 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);
@@ -1556,7 +1283,14 @@ static void unplug_port(struct port *port)
                hvc_remove(port->cons.hvc);
        }
-        remove_port_data(port);
+        /* 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);
        /*
         * We should just assume the device itself has gone off --
@@ -1618,7 +1352,6 @@ static void handle_control_message(struct ports_device *portdev,
                        break;
                init_port_console(port);
-                complete(&early_console_added);
                /*
                 * Could remove the port here in case init fails - but
                 * have to notify the host first.
@@ -1661,13 +1394,6 @@ static void handle_control_message(struct ports_device *portdev,
                break;
        case VIRTIO_CONSOLE_PORT_NAME:
                /*
-                 * If we woke up after hibernation, we can get this
-                 * again.  Skip it in that case.
-                 */
-                if (port->name)
-                        break;
-                /*
                 * Skip the size of the header and the cpkt to get the size
                 * of the name that was sent
                 */
@@ -1728,7 +1454,7 @@ static void control_work_handler(struct work_struct *work)
                if (add_inbuf(portdev->c_ivq, buf) < 0) {
                        dev_warn(&portdev->vdev->dev,
                                 "Error adding buffer to queue\n");
-                        free_buf(buf, false);
+                        free_buf(buf);
                }
        }
        spin_unlock(&portdev->cvq_lock);
@@ -1755,7 +1481,8 @@ static void in_intr(struct virtqueue *vq)
                return;
        spin_lock_irqsave(&port->inbuf_lock, flags);
-        port->inbuf = get_inbuf(port);
+        if (!port->inbuf)
+                port->inbuf = get_inbuf(port);
        /*
         * Don't queue up data when port is closed.  This condition
@@ -1836,7 +1563,7 @@ static int init_vqs(struct ports_device *portdev)
        portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
                                   GFP_KERNEL);
        if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs ||
-            !portdev->out_vqs) {
+                        !portdev->out_vqs) {
                err = -ENOMEM;
                goto free;
        }
@@ -1908,28 +1635,6 @@ 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, true);
-        while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq)))
-                free_buf(buf, true);
-}
 /*
 * Once we're further in boot, we get probed like any other virtio
 * device.
@@ -1938,15 +1643,11 @@ static void remove_controlq_data(struct ports_device *portdev)
 * config space to see how many ports the host has spawned.  We
 * initialize each port found.
 */
-static int virtcons_probe(struct virtio_device *vdev)
+static int __devinit virtcons_probe(struct virtio_device *vdev)
 {
        struct ports_device *portdev;
        int err;
        bool multiport;
-        bool early = early_put_chars != NULL;
-        /* Ensure to read early_put_chars now */
-        barrier();
        portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
        if (!portdev) {
@@ -1974,14 +1675,12 @@ static int virtcons_probe(struct virtio_device *vdev)
        multiport = false;
        portdev->config.max_nr_ports = 1;
+        if (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT)) {
-        /* Don't test MULTIPORT at all if we're rproc: not a valid feature! */
-        if (!is_rproc_serial(vdev) &&
-            virtio_config_val(vdev, VIRTIO_CONSOLE_F_MULTIPORT,
-                                  offsetof(struct virtio_console_config,
-                                           max_nr_ports),
-                                  &portdev->config.max_nr_ports) == 0) {
                multiport = true;
+                vdev->config->get(vdev, offsetof(struct virtio_console_config,
+                                                 max_nr_ports),
+                                  &portdev->config.max_nr_ports,
+                                  sizeof(portdev->config.max_nr_ports));
        }
        err = init_vqs(portdev);
@@ -2020,26 +1719,15 @@ static int virtcons_probe(struct virtio_device *vdev)
        __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
                           VIRTIO_CONSOLE_DEVICE_READY, 1);
-        /*
-         * If there was an early virtio console, assume that there are no
-         * other consoles. We need to wait until the hvc_alloc matches the
-         * hvc_instantiate, otherwise tty_open will complain, resulting in
-         * a "Warning: unable to open an initial console" boot failure.
-         * Without multiport this is done in add_port above. With multiport
-         * this might take some host<->guest communication - thus we have to
-         * wait.
-         */
-        if (multiport && early)
-                wait_for_completion(&early_console_added);
        return 0;
 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);
-        remove_vqs(portdev);
+        vdev->config->del_vqs(vdev);
+        kfree(portdev->in_vqs);
+        kfree(portdev->out_vqs);
 free_chrdev:
        unregister_chrdev(portdev->chr_major, "virtio-portsdev");
 free:
@@ -2077,8 +1765,21 @@ static void virtcons_remove(struct virtio_device *vdev)
         * have to just stop using the port, as the vqs are going
         * away.
         */
-        remove_controlq_data(portdev);
+        if (use_multiport(portdev)) {
-        remove_vqs(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);
        kfree(portdev);
 }
@@ -2092,85 +1793,6 @@ static unsigned int features[] = {
        VIRTIO_CONSOLE_F_MULTIPORT,
 };
-static struct virtio_device_id rproc_serial_id_table[] = {
-#if IS_ENABLED(CONFIG_REMOTEPROC)
-        { VIRTIO_ID_RPROC_SERIAL, VIRTIO_DEV_ANY_ID },
-#endif
-        { 0 },
-};
-static unsigned int rproc_serial_features[] = {
-};
-#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);
-                /*
-                 * If a port was open at the time of suspending, we
-                 * have to let the host know that it's still open.
-                 */
-                if (port->guest_connected)
-                        send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
-        }
-        return 0;
-}
-#endif
 static struct virtio_driver virtio_console = {
        .feature_table = features,
        .feature_table_size = ARRAY_SIZE(features),
@@ -2180,20 +1802,6 @@ 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 struct virtio_driver virtio_rproc_serial = {
-        .feature_table = rproc_serial_features,
-        .feature_table_size = ARRAY_SIZE(rproc_serial_features),
-        .driver.name =  "virtio_rproc_serial",
-        .driver.owner = THIS_MODULE,
-        .id_table =     rproc_serial_id_table,
-        .probe =        virtcons_probe,
-        .remove =       virtcons_remove,
 };
 static int __init init(void)
@@ -2215,33 +1823,12 @@ static int __init init(void)
        INIT_LIST_HEAD(&pdrvdata.consoles);
        INIT_LIST_HEAD(&pdrvdata.portdevs);
-        err = register_virtio_driver(&virtio_console);
+        return register_virtio_driver(&virtio_console);
-        if (err < 0) {
-                pr_err("Error %d registering virtio driver\n", err);
-                goto free;
-        }
-        err = register_virtio_driver(&virtio_rproc_serial);
-        if (err < 0) {
-                pr_err("Error %d registering virtio rproc serial driver\n",
-                       err);
-                goto unregister;
-        }
-        return 0;
-unregister:
-        unregister_virtio_driver(&virtio_console);
-free:
-        if (pdrvdata.debugfs_dir)
-                debugfs_remove_recursive(pdrvdata.debugfs_dir);
-        class_destroy(pdrvdata.class);
-        return err;
 }
 static void __exit fini(void)
 {
-        reclaim_dma_bufs();
        unregister_virtio_driver(&virtio_console);
-        unregister_virtio_driver(&virtio_rproc_serial);
        class_destroy(pdrvdata.class);
        if (pdrvdata.debugfs_dir)
diff --git a/drivers/char/xilinx_hwicap/xilinx_hwicap.c b/drivers/char/xilinx_hwicap/xilinx_hwicap.c
index 5224da5202d..e90e1c74fd4 100644
--- a/drivers/char/xilinx_hwicap/xilinx_hwicap.c
+++ b/drivers/char/xilinx_hwicap/xilinx_hwicap.c
@@ -89,6 +89,7 @@
 #include <asm/io.h>
 #include <asm/uaccess.h>
+#include <asm/system.h>
 #ifdef CONFIG_OF
 /* For open firmware. */
@@ -167,7 +168,6 @@ static const struct config_registers v4_config_registers = {
        .BOOTSTS = UNIMPLEMENTED,
        .CTL_1 = UNIMPLEMENTED,
 };
 static const struct config_registers v5_config_registers = {
        .CRC = 0,
        .FAR = 1,
@@ -193,31 +193,6 @@ static const struct config_registers v5_config_registers = {
        .CTL_1 = 19,
 };
-static const struct config_registers v6_config_registers = {
-        .CRC = 0,
-        .FAR = 1,
-        .FDRI = 2,
-        .FDRO = 3,
-        .CMD = 4,
-        .CTL = 5,
-        .MASK = 6,
-        .STAT = 7,
-        .LOUT = 8,
-        .COR = 9,
-        .MFWR = 10,
-        .FLR = UNIMPLEMENTED,
-        .KEY = UNIMPLEMENTED,
-        .CBC = 11,
-        .IDCODE = 12,
-        .AXSS = 13,
-        .C0R_1 = 14,
-        .CSOB = 15,
-        .WBSTAR = 16,
-        .TIMER = 17,
-        .BOOTSTS = 22,
-        .CTL_1 = 24,
-};
 /**
 * hwicap_command_desync - Send a DESYNC command to the ICAP port.
 * @drvdata: a pointer to the drvdata.
@@ -595,7 +570,7 @@ static const struct file_operations hwicap_fops = {
        .llseek = noop_llseek,
 };
-static int hwicap_setup(struct device *dev, int id,
+static int __devinit hwicap_setup(struct device *dev, int id,
                const struct resource *regs_res,
                const struct hwicap_driver_config *config,
                const struct config_registers *config_regs)
@@ -717,7 +692,7 @@ static struct hwicap_driver_config fifo_icap_config = {
        .reset = fifo_icap_reset,
 };
-static int hwicap_remove(struct device *dev)
+static int __devexit hwicap_remove(struct device *dev)
 {
        struct hwicap_drvdata *drvdata;
@@ -740,7 +715,7 @@ static int hwicap_remove(struct device *dev)
 }
 #ifdef CONFIG_OF
-static int hwicap_of_probe(struct platform_device *op,
+static int __devinit hwicap_of_probe(struct platform_device *op,
                                     const struct hwicap_driver_config *config)
 {
        struct resource res;
@@ -770,8 +745,6 @@ static int hwicap_of_probe(struct platform_device *op,
                        regs = &v4_config_registers;
                } else if (!strcmp(family, "virtex5")) {
                        regs = &v5_config_registers;
-                } else if (!strcmp(family, "virtex6")) {
-                        regs = &v6_config_registers;
                }
        }
        return hwicap_setup(&op->dev, id ? *id : -1, &res, config,
@@ -785,8 +758,8 @@ static inline int hwicap_of_probe(struct platform_device *op,
 }
 #endif /* CONFIG_OF */
-static const struct of_device_id hwicap_of_match[];
+static const struct of_device_id __devinitconst hwicap_of_match[];
-static int hwicap_drv_probe(struct platform_device *pdev)
+static int __devinit hwicap_drv_probe(struct platform_device *pdev)
 {
        const struct of_device_id *match;
        struct resource *res;
@@ -813,8 +786,6 @@ static int hwicap_drv_probe(struct platform_device *pdev)
                        regs = &v4_config_registers;
                } else if (!strcmp(family, "virtex5")) {
                        regs = &v5_config_registers;
-                } else if (!strcmp(family, "virtex6")) {
-                        regs = &v6_config_registers;
                }
        }
@@ -822,14 +793,14 @@ static int hwicap_drv_probe(struct platform_device *pdev)
                        &buffer_icap_config, regs);
 }
-static int hwicap_drv_remove(struct platform_device *pdev)
+static int __devexit hwicap_drv_remove(struct platform_device *pdev)
 {
        return hwicap_remove(&pdev->dev);
 }
 #ifdef CONFIG_OF
 /* Match table for device tree binding */
-static const struct of_device_id hwicap_of_match[] = {
+static const struct of_device_id __devinitconst hwicap_of_match[] = {
        { .compatible = "xlnx,opb-hwicap-1.00.b", .data = &buffer_icap_config},
        { .compatible = "xlnx,xps-hwicap-1.00.a", .data = &fifo_icap_config},
        {},
diff --git a/drivers/char/xilinx_hwicap/xilinx_hwicap.h b/drivers/char/xilinx_hwicap/xilinx_hwicap.h
index d31ee23c9f1..8cca11981c5 100644
--- a/drivers/char/xilinx_hwicap/xilinx_hwicap.h
+++ b/drivers/char/xilinx_hwicap/xilinx_hwicap.h
@@ -86,7 +86,7 @@ struct hwicap_driver_config {
 };
 /* Number of times to poll the done regsiter */
-#define XHI_MAX_RETRIES     5000
+#define XHI_MAX_RETRIES     10
 /************ Constant Definitions *************/
author	Jonathan Herman <hermanjl@cs.unc.edu>	2013-01-17 16:15:55 -0500
committer	Jonathan Herman <hermanjl@cs.unc.edu>	2013-01-17 16:15:55 -0500
commit	8dea78da5cee153b8af9c07a2745f6c55057fe12 (patch)
tree	a8f4d49d63b1ecc92f2fddceba0655b2472c5bd9 /drivers/char
parent	406089d01562f1e2bf9f089fd7637009ebaad589 (diff)