69 files changed, 1821 insertions, 693 deletions

diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index c29365d5b524..fdf4370db994 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -661,7 +661,7 @@ config HW_RANDOM
 
 config NVRAM
         tristate "/dev/nvram support"
-        depends on ATARI || X86 || X86_64 || ARM || GENERIC_NVRAM
+        depends on ATARI || X86 || ARM || GENERIC_NVRAM
         ---help---
           If you say Y here and create a character special file /dev/nvram
           with major number 10 and minor number 144 using mknod ("man mknod"),
@@ -985,7 +985,7 @@ config MAX_RAW_DEVS
 
 config HANGCHECK_TIMER
         tristate "Hangcheck timer"
-        depends on X86_64 || X86 || IA64 || PPC64 || ARCH_S390
+        depends on X86 || IA64 || PPC64 || ARCH_S390
         help
           The hangcheck-timer module detects when the system has gone
           out to lunch past a certain margin.  It can reboot the system
@@ -1001,5 +1001,17 @@ config MMTIMER
 
 source "drivers/char/tpm/Kconfig"
 
+config TELCLOCK
+        tristate "Telecom clock driver for MPBL0010 ATCA SBC"
+        depends on EXPERIMENTAL
+        default n
+        help
+          The telecom clock device is specific to the MPBL0010 ATCA computer and
+          allows direct userspace access to the configuration of the telecom clock
+          configuration settings.  This device is used for hardware synchronization
+          across the ATCA backplane fabric.  Upon loading, the driver exports a
+          sysfs directory, /sys/devices/platform/telco_clock, with a number of
+          files for controlling the behavior of this hardware.
+
 endmenu
 
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 08f69287ea36..4aeae687e88a 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -82,6 +82,7 @@ obj-$(CONFIG_NWFLASH) += nwflash.o
 obj-$(CONFIG_SCx200_GPIO) += scx200_gpio.o
 obj-$(CONFIG_GPIO_VR41XX) += vr41xx_giu.o
 obj-$(CONFIG_TANBAC_TB0219) += tb0219.o
+obj-$(CONFIG_TELCLOCK) += tlclk.o
 
 obj-$(CONFIG_WATCHDOG)  += watchdog/
 obj-$(CONFIG_MWAVE) += mwave/
diff --git a/drivers/char/agp/Kconfig b/drivers/char/agp/Kconfig
index 7f8c1b53b754..486ed8a11b59 100644
--- a/drivers/char/agp/Kconfig
+++ b/drivers/char/agp/Kconfig
@@ -27,7 +27,7 @@ config AGP
 
 config AGP_ALI
         tristate "ALI chipset support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         ---help---
           This option gives you AGP support for the GLX component of
           XFree86 4.x on the following ALi chipsets.  The supported chipsets
@@ -45,7 +45,7 @@ config AGP_ALI
 
 config AGP_ATI
         tristate "ATI chipset support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         ---help---
       This option gives you AGP support for the GLX component of
       XFree86 4.x on the ATI RadeonIGP family of chipsets.
@@ -55,7 +55,7 @@ config AGP_ATI
 
 config AGP_AMD
         tristate "AMD Irongate, 761, and 762 chipset support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         help
           This option gives you AGP support for the GLX component of
           XFree86 4.x on AMD Irongate, 761, and 762 chipsets.
@@ -91,7 +91,7 @@ config AGP_INTEL
 
 config AGP_NVIDIA
         tristate "NVIDIA nForce/nForce2 chipset support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         help
           This option gives you AGP support for the GLX component of
           XFree86 4.x on the following NVIDIA chipsets.  The supported chipsets
@@ -99,7 +99,7 @@ config AGP_NVIDIA
 
 config AGP_SIS
         tristate "SiS chipset support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         help
           This option gives you AGP support for the GLX component of
           XFree86 4.x on Silicon Integrated Systems [SiS] chipsets.
@@ -111,14 +111,14 @@ config AGP_SIS
 
 config AGP_SWORKS
         tristate "Serverworks LE/HE chipset support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         help
           Say Y here to support the Serverworks AGP card.  See 
           <http://www.serverworks.com/> for product descriptions and images.
 
 config AGP_VIA
         tristate "VIA chipset support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         help
           This option gives you AGP support for the GLX component of
           XFree86 4.x on VIA MVP3/Apollo Pro chipsets.
@@ -154,7 +154,7 @@ config AGP_UNINORTH
 
 config AGP_EFFICEON
         tristate "Transmeta Efficeon support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         help
           This option gives you AGP support for the Transmeta Efficeon
           series processors with integrated northbridges.
diff --git a/drivers/char/agp/ali-agp.c b/drivers/char/agp/ali-agp.c
index 9c9c9c2247ce..b02fc2267159 100644
--- a/drivers/char/agp/ali-agp.c
+++ b/drivers/char/agp/ali-agp.c
@@ -7,6 +7,7 @@
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/agp_backend.h>
+#include <asm/page.h>           /* PAGE_SIZE */
 #include "agp.h"
 
 #define ALI_AGPCTRL     0xb8
diff --git a/drivers/char/agp/amd64-agp.c b/drivers/char/agp/amd64-agp.c
index 0a7624a9b1c1..0e6c3a31d344 100644
--- a/drivers/char/agp/amd64-agp.c
+++ b/drivers/char/agp/amd64-agp.c
@@ -13,6 +13,7 @@
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/agp_backend.h>
+#include <asm/page.h>           /* PAGE_SIZE */
 #include "agp.h"
 
 /* Will need to be increased if AMD64 ever goes >8-way. */
diff --git a/drivers/char/agp/ati-agp.c b/drivers/char/agp/ati-agp.c
index e572ced9100a..0b6e72642d6e 100644
--- a/drivers/char/agp/ati-agp.c
+++ b/drivers/char/agp/ati-agp.c
@@ -6,6 +6,8 @@
 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/init.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/agp_backend.h>
 #include <asm/agp.h>
 #include "agp.h"
diff --git a/drivers/char/agp/i460-agp.c b/drivers/char/agp/i460-agp.c
index 94943298c03e..a2d9e5e48bbe 100644
--- a/drivers/char/agp/i460-agp.c
+++ b/drivers/char/agp/i460-agp.c
@@ -10,6 +10,8 @@
 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/init.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/agp_backend.h>
 
 #include "agp.h"
diff --git a/drivers/char/agp/isoch.c b/drivers/char/agp/isoch.c
index c9ac731504f2..40083241804e 100644
--- a/drivers/char/agp/isoch.c
+++ b/drivers/char/agp/isoch.c
@@ -6,6 +6,7 @@
 #include <linux/pci.h>
 #include <linux/agp_backend.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 
 #include "agp.h"
 
diff --git a/drivers/char/agp/sgi-agp.c b/drivers/char/agp/sgi-agp.c
index d3aa159c9dec..7957fc91f6ad 100644
--- a/drivers/char/agp/sgi-agp.c
+++ b/drivers/char/agp/sgi-agp.c
@@ -17,6 +17,7 @@
 #include <linux/init.h>
 #include <linux/agp_backend.h>
 #include <asm/sn/addrs.h>
+#include <asm/sn/io.h>
 #include <asm/sn/pcidev.h>
 #include <asm/sn/pcibus_provider_defs.h>
 #include <asm/sn/tioca_provider.h>
diff --git a/drivers/char/agp/sworks-agp.c b/drivers/char/agp/sworks-agp.c
index a9fb12c20eb7..71ea59a1dbeb 100644
--- a/drivers/char/agp/sworks-agp.c
+++ b/drivers/char/agp/sworks-agp.c
@@ -5,6 +5,8 @@
 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/init.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/agp_backend.h>
 #include "agp.h"
 
diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
index cf4c3648463d..c7f818cd7b02 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -281,7 +281,7 @@ static char rcsid[] =
  * make sure "cyc" appears in all kernel messages; all soft interrupts
  * handled by same routine; recognize out-of-band reception; comment
  * out some diagnostic messages; leave RTS/CTS flow control to hardware;
- * fix race condition in -Z buffer management; only -Y needs to explictly
+ * fix race condition in -Z buffer management; only -Y needs to explicitly
  * flush chars; tidy up some startup messages;
  *
  * Revision 1.36.4.18  1996/07/25 18:57:31  bentson
diff --git a/drivers/char/drm/drm_sysfs.c b/drivers/char/drm/drm_sysfs.c
index 475cc5e555e1..6d3449761914 100644
--- a/drivers/char/drm/drm_sysfs.c
+++ b/drivers/char/drm/drm_sysfs.c
@@ -15,6 +15,8 @@
 #include <linux/device.h>
 #include <linux/kdev_t.h>
 #include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/string.h>
 
 #include "drm_core.h"
 #include "drmP.h"
diff --git a/drivers/char/drm/radeon_cp.c b/drivers/char/drm/radeon_cp.c
index e64d680899f5..03839ea31092 100644
--- a/drivers/char/drm/radeon_cp.c
+++ b/drivers/char/drm/radeon_cp.c
@@ -1132,11 +1132,13 @@ static void radeon_cp_init_ring_buffer(drm_device_t * dev,
                               (dev_priv->gart_vm_start >> 16)));
 
                 ring_start = (dev_priv->cp_ring->offset
-                              - dev->agp->base + dev_priv->gart_vm_start);
+                              - dev->agp->base
+                              + dev_priv->gart_vm_start);
         } else
 #endif
                 ring_start = (dev_priv->cp_ring->offset
-                              - dev->sg->handle + dev_priv->gart_vm_start);
+                              - (unsigned long)dev->sg->virtual
+                              + dev_priv->gart_vm_start);
 
         RADEON_WRITE(RADEON_CP_RB_BASE, ring_start);
 
@@ -1162,7 +1164,8 @@ static void radeon_cp_init_ring_buffer(drm_device_t * dev,
                 drm_sg_mem_t *entry = dev->sg;
                 unsigned long tmp_ofs, page_ofs;
 
-                tmp_ofs = dev_priv->ring_rptr->offset - dev->sg->handle;
+                tmp_ofs = dev_priv->ring_rptr->offset -
+                                (unsigned long)dev->sg->virtual;
                 page_ofs = tmp_ofs >> PAGE_SHIFT;
 
                 RADEON_WRITE(RADEON_CP_RB_RPTR_ADDR, entry->busaddr[page_ofs]);
@@ -1529,8 +1532,8 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
         else
 #endif
                 dev_priv->gart_buffers_offset = (dev->agp_buffer_map->offset
-                                                 - dev->sg->handle
-                                                 + dev_priv->gart_vm_start);
+                                        - (unsigned long)dev->sg->virtual
+                                        + dev_priv->gart_vm_start);
 
         DRM_DEBUG("dev_priv->gart_size %d\n", dev_priv->gart_size);
         DRM_DEBUG("dev_priv->gart_vm_start 0x%x\n", dev_priv->gart_vm_start);
diff --git a/drivers/char/dsp56k.c b/drivers/char/dsp56k.c
index 26271e3ca823..8693835cb2d5 100644
--- a/drivers/char/dsp56k.c
+++ b/drivers/char/dsp56k.c
@@ -515,7 +515,7 @@ static int __init dsp56k_init_driver(void)
                 err = PTR_ERR(dsp56k_class);
                 goto out_chrdev;
         }
-        class_device_create(dsp56k_class, MKDEV(DSP56K_MAJOR, 0), NULL, "dsp56k");
+        class_device_create(dsp56k_class, NULL, MKDEV(DSP56K_MAJOR, 0), NULL, "dsp56k");
 
         err = devfs_mk_cdev(MKDEV(DSP56K_MAJOR, 0),
                       S_IFCHR | S_IRUSR | S_IWUSR, "dsp56k");
diff --git a/drivers/char/epca.c b/drivers/char/epca.c
index 407708a001e4..b7a0e4d6b934 100644
--- a/drivers/char/epca.c
+++ b/drivers/char/epca.c
@@ -3113,6 +3113,7 @@ MODULE_DEVICE_TABLE(pci, epca_pci_tbl);
 int __init init_PCI (void)
 {       /* Begin init_PCI */
         memset (&epca_driver, 0, sizeof (epca_driver));
+        epca_driver.owner = THIS_MODULE;
         epca_driver.name = "epca";
         epca_driver.id_table = epca_pci_tbl;
         epca_driver.probe = epca_init_one;
diff --git a/drivers/char/ftape/zftape/zftape-init.c b/drivers/char/ftape/zftape/zftape-init.c
index 5745b74044ec..821357ce7e0e 100644
--- a/drivers/char/ftape/zftape/zftape-init.c
+++ b/drivers/char/ftape/zftape/zftape-init.c
@@ -331,27 +331,27 @@ KERN_INFO
 
         zft_class = class_create(THIS_MODULE, "zft");
         for (i = 0; i < 4; i++) {
-                class_device_create(zft_class, MKDEV(QIC117_TAPE_MAJOR, i), NULL, "qft%i", i);
+                class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i), NULL, "qft%i", i);
                 devfs_mk_cdev(MKDEV(QIC117_TAPE_MAJOR, i),
                                 S_IFCHR | S_IRUSR | S_IWUSR,
                                 "qft%i", i);
-                class_device_create(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 4), NULL, "nqft%i", i);
+                class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 4), NULL, "nqft%i", i);
                 devfs_mk_cdev(MKDEV(QIC117_TAPE_MAJOR, i + 4),
                                 S_IFCHR | S_IRUSR | S_IWUSR,
                                 "nqft%i", i);
-                class_device_create(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 16), NULL, "zqft%i", i);
+                class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 16), NULL, "zqft%i", i);
                 devfs_mk_cdev(MKDEV(QIC117_TAPE_MAJOR, i + 16),
                                 S_IFCHR | S_IRUSR | S_IWUSR,
                                 "zqft%i", i);
-                class_device_create(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 20), NULL, "nzqft%i", i);
+                class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 20), NULL, "nzqft%i", i);
                 devfs_mk_cdev(MKDEV(QIC117_TAPE_MAJOR, i + 20),
                                 S_IFCHR | S_IRUSR | S_IWUSR,
                                 "nzqft%i", i);
-                class_device_create(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 32), NULL, "rawqft%i", i);
+                class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 32), NULL, "rawqft%i", i);
                 devfs_mk_cdev(MKDEV(QIC117_TAPE_MAJOR, i + 32),
                                 S_IFCHR | S_IRUSR | S_IWUSR,
                                 "rawqft%i", i);
-                class_device_create(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 36), NULL, "nrawrawqft%i", i);
+                class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 36), NULL, "nrawrawqft%i", i);
                 devfs_mk_cdev(MKDEV(QIC117_TAPE_MAJOR, i + 36),
                                 S_IFCHR | S_IRUSR | S_IWUSR,
                                 "nrawqft%i", i);
diff --git a/drivers/char/hangcheck-timer.c b/drivers/char/hangcheck-timer.c
index a54bc93353af..66e53dd450ff 100644
--- a/drivers/char/hangcheck-timer.c
+++ b/drivers/char/hangcheck-timer.c
@@ -117,7 +117,7 @@ __setup("hcheck_reboot", hangcheck_parse_reboot);
 __setup("hcheck_dump_tasks", hangcheck_parse_dump_tasks);
 #endif /* not MODULE */
 
-#if defined(CONFIG_X86) || defined(CONFIG_X86_64)
+#if defined(CONFIG_X86)
 # define HAVE_MONOTONIC
 # define TIMER_FREQ 1000000000ULL
 #elif defined(CONFIG_ARCH_S390)
diff --git a/drivers/char/hpet.c b/drivers/char/hpet.c
index c055bb630ffc..3808d9572619 100644
--- a/drivers/char/hpet.c
+++ b/drivers/char/hpet.c
@@ -49,7 +49,9 @@
 #define HPET_USER_FREQ  (64)
 #define HPET_DRIFT      (500)
 
-static u32 hpet_ntimer, hpet_nhpet, hpet_max_freq = HPET_USER_FREQ;
+#define HPET_RANGE_SIZE         1024    /* from HPET spec */
+
+static u32 hpet_nhpet, hpet_max_freq = HPET_USER_FREQ;
 
 /* A lock for concurrent access by app and isr hpet activity. */
 static DEFINE_SPINLOCK(hpet_lock);
@@ -78,7 +80,7 @@ struct hpets {
         struct hpet __iomem *hp_hpet;
         unsigned long hp_hpet_phys;
         struct time_interpolator *hp_interpolator;
-        unsigned long hp_period;
+        unsigned long long hp_tick_freq;
         unsigned long hp_delta;
         unsigned int hp_ntimer;
         unsigned int hp_which;
@@ -90,6 +92,7 @@ static struct hpets *hpets;
 #define HPET_OPEN               0x0001
 #define HPET_IE                 0x0002  /* interrupt enabled */
 #define HPET_PERIODIC           0x0004
+#define HPET_SHARED_IRQ         0x0008
 
 #if BITS_PER_LONG == 64
 #define write_counter(V, MC)    writeq(V, MC)
@@ -120,6 +123,11 @@ static irqreturn_t hpet_interrupt(int irq, void *data, struct pt_regs *regs)
         unsigned long isr;
 
         devp = data;
+        isr = 1 << (devp - devp->hd_hpets->hp_dev);
+
+        if ((devp->hd_flags & HPET_SHARED_IRQ) &&
+            !(isr & readl(&devp->hd_hpet->hpet_isr)))
+                return IRQ_NONE;
 
         spin_lock(&hpet_lock);
         devp->hd_irqdata++;
@@ -137,8 +145,8 @@ static irqreturn_t hpet_interrupt(int irq, void *data, struct pt_regs *regs)
                               &devp->hd_timer->hpet_compare);
         }
 
-        isr = (1 << (devp - devp->hd_hpets->hp_dev));
-        writeq(isr, &devp->hd_hpet->hpet_isr);
+        if (devp->hd_flags & HPET_SHARED_IRQ)
+                writel(isr, &devp->hd_hpet->hpet_isr);
         spin_unlock(&hpet_lock);
 
         spin_lock(&hpet_task_lock);
@@ -276,7 +284,8 @@ static int hpet_mmap(struct file *file, struct vm_area_struct *vma)
 
         if (io_remap_pfn_range(vma, vma->vm_start, addr >> PAGE_SHIFT,
                                         PAGE_SIZE, vma->vm_page_prot)) {
-                printk(KERN_ERR "remap_pfn_range failed in hpet.c\n");
+                printk(KERN_ERR "%s: io_remap_pfn_range failed\n",
+                        __FUNCTION__);
                 return -EAGAIN;
         }
 
@@ -364,7 +373,9 @@ static int hpet_ioctl_ieon(struct hpet_dev *devp)
         hpet = devp->hd_hpet;
         hpetp = devp->hd_hpets;
 
-        v = readq(&timer->hpet_config);
+        if (!devp->hd_ireqfreq)
+                return -EIO;
+
         spin_lock_irq(&hpet_lock);
 
         if (devp->hd_flags & HPET_IE) {
@@ -373,16 +384,21 @@ static int hpet_ioctl_ieon(struct hpet_dev *devp)
         }
 
         devp->hd_flags |= HPET_IE;
+
+        if (readl(&timer->hpet_config) & Tn_INT_TYPE_CNF_MASK)
+                devp->hd_flags |= HPET_SHARED_IRQ;
         spin_unlock_irq(&hpet_lock);
 
-        t = readq(&timer->hpet_config);
         irq = devp->hd_hdwirq;
 
         if (irq) {
-                sprintf(devp->hd_name, "hpet%d", (int)(devp - hpetp->hp_dev));
+                unsigned long irq_flags;
 
-                if (request_irq
-                    (irq, hpet_interrupt, SA_INTERRUPT, devp->hd_name, (void *)devp)) {
+                sprintf(devp->hd_name, "hpet%d", (int)(devp - hpetp->hp_dev));
+                irq_flags = devp->hd_flags & HPET_SHARED_IRQ
+                                                ? SA_SHIRQ : SA_INTERRUPT;
+                if (request_irq(irq, hpet_interrupt, irq_flags,
+                                devp->hd_name, (void *)devp)) {
                         printk(KERN_ERR "hpet: IRQ %d is not free\n", irq);
                         irq = 0;
                 }
@@ -416,20 +432,24 @@ static int hpet_ioctl_ieon(struct hpet_dev *devp)
                 write_counter(t + m + hpetp->hp_delta, &timer->hpet_compare);
         }
 
-        isr = (1 << (devp - hpets->hp_dev));
-        writeq(isr, &hpet->hpet_isr);
+        if (devp->hd_flags & HPET_SHARED_IRQ) {
+                isr = 1 << (devp - devp->hd_hpets->hp_dev);
+                writel(isr, &hpet->hpet_isr);
+        }
         writeq(g, &timer->hpet_config);
         local_irq_restore(flags);
 
         return 0;
 }
 
-static inline unsigned long hpet_time_div(unsigned long dis)
+/* converts Hz to number of timer ticks */
+static inline unsigned long hpet_time_div(struct hpets *hpets,
+                                          unsigned long dis)
 {
-        unsigned long long m = 1000000000000000ULL;
+        unsigned long long m;
 
+        m = hpets->hp_tick_freq + (dis >> 1);
         do_div(m, dis);
-
         return (unsigned long)m;
 }
 
@@ -477,14 +497,21 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
                 {
                         struct hpet_info info;
 
-                        info.hi_ireqfreq = hpet_time_div(hpetp->hp_period *
-                                                         devp->hd_ireqfreq);
+                        if (devp->hd_ireqfreq)
+                                info.hi_ireqfreq =
+                                        hpet_time_div(hpetp, devp->hd_ireqfreq);
+                        else
+                                info.hi_ireqfreq = 0;
                         info.hi_flags =
                             readq(&timer->hpet_config) & Tn_PER_INT_CAP_MASK;
-                        info.hi_hpet = devp->hd_hpets->hp_which;
-                        info.hi_timer = devp - devp->hd_hpets->hp_dev;
-                        if (copy_to_user((void __user *)arg, &info, sizeof(info)))
-                                err = -EFAULT;
+                        info.hi_hpet = hpetp->hp_which;
+                        info.hi_timer = devp - hpetp->hp_dev;
+                        if (kernel)
+                                memcpy((void *)arg, &info, sizeof(info));
+                        else
+                                if (copy_to_user((void __user *)arg, &info,
+                                                 sizeof(info)))
+                                        err = -EFAULT;
                         break;
                 }
         case HPET_EPI:
@@ -516,12 +543,12 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
                         break;
                 }
 
-                if (arg & (arg - 1)) {
+                if (!arg) {
                         err = -EINVAL;
                         break;
                 }
 
-                devp->hd_ireqfreq = hpet_time_div(hpetp->hp_period * arg);
+                devp->hd_ireqfreq = hpet_time_div(hpetp, arg);
         }
 
         return err;
@@ -539,6 +566,17 @@ static struct file_operations hpet_fops = {
         .mmap = hpet_mmap,
 };
 
+static int hpet_is_known(struct hpet_data *hdp)
+{
+        struct hpets *hpetp;
+
+        for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next)
+                if (hpetp->hp_hpet_phys == hdp->hd_phys_address)
+                        return 1;
+
+        return 0;
+}
+
 EXPORT_SYMBOL(hpet_alloc);
 EXPORT_SYMBOL(hpet_register);
 EXPORT_SYMBOL(hpet_unregister);
@@ -563,6 +601,8 @@ int hpet_register(struct hpet_task *tp, int periodic)
                 return -EINVAL;
         }
 
+        tp->ht_opaque = NULL;
+
         spin_lock_irq(&hpet_task_lock);
         spin_lock(&hpet_lock);
 
@@ -702,15 +742,14 @@ static void hpet_register_interpolator(struct hpets *hpetp)
 #ifdef  CONFIG_TIME_INTERPOLATION
         struct time_interpolator *ti;
 
-        ti = kmalloc(sizeof(*ti), GFP_KERNEL);
+        ti = kzalloc(sizeof(*ti), GFP_KERNEL);
         if (!ti)
                 return;
 
-        memset(ti, 0, sizeof(*ti));
         ti->source = TIME_SOURCE_MMIO64;
         ti->shift = 10;
         ti->addr = &hpetp->hp_hpet->hpet_mc;
-        ti->frequency = hpet_time_div(hpets->hp_period);
+        ti->frequency = hpetp->hp_tick_freq;
         ti->drift = HPET_DRIFT;
         ti->mask = -1;
 
@@ -743,11 +782,11 @@ static unsigned long hpet_calibrate(struct hpets *hpetp)
         if (!timer)
                 return 0;
 
-        hpet = hpets->hp_hpet;
+        hpet = hpetp->hp_hpet;
         t = read_counter(&timer->hpet_compare);
 
         i = 0;
-        count = hpet_time_div(hpetp->hp_period * TICK_CALIBRATE);
+        count = hpet_time_div(hpetp, TICK_CALIBRATE);
 
         local_irq_save(flags);
 
@@ -771,28 +810,29 @@ int hpet_alloc(struct hpet_data *hdp)
         struct hpets *hpetp;
         size_t siz;
         struct hpet __iomem *hpet;
-        static struct hpets *last = (struct hpets *)0;
-        unsigned long ns;
+        static struct hpets *last = NULL;
+        unsigned long period;
+        unsigned long long temp;
 
         /*
          * hpet_alloc can be called by platform dependent code.
-         * if platform dependent code has allocated the hpet
-         * ACPI also reports hpet, then we catch it here.
+         * If platform dependent code has allocated the hpet that
+         * ACPI has also reported, then we catch it here.
          */
-        for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next)
-                if (hpetp->hp_hpet == hdp->hd_address)
-                        return 0;
+        if (hpet_is_known(hdp)) {
+                printk(KERN_DEBUG "%s: duplicate HPET ignored\n",
+                        __FUNCTION__);
+                return 0;
+        }
 
         siz = sizeof(struct hpets) + ((hdp->hd_nirqs - 1) *
                                       sizeof(struct hpet_dev));
 
-        hpetp = kmalloc(siz, GFP_KERNEL);
+        hpetp = kzalloc(siz, GFP_KERNEL);
 
         if (!hpetp)
                 return -ENOMEM;
 
-        memset(hpetp, 0, siz);
-
         hpetp->hp_which = hpet_nhpet++;
         hpetp->hp_hpet = hdp->hd_address;
         hpetp->hp_hpet_phys = hdp->hd_phys_address;
@@ -822,21 +862,23 @@ int hpet_alloc(struct hpet_data *hdp)
 
         last = hpetp;
 
-        hpetp->hp_period = (cap & HPET_COUNTER_CLK_PERIOD_MASK) >>
-            HPET_COUNTER_CLK_PERIOD_SHIFT;
+        period = (cap & HPET_COUNTER_CLK_PERIOD_MASK) >>
+                HPET_COUNTER_CLK_PERIOD_SHIFT; /* fs, 10^-15 */
+        temp = 1000000000000000uLL; /* 10^15 femtoseconds per second */
+        temp += period >> 1; /* round */
+        do_div(temp, period);
+        hpetp->hp_tick_freq = temp; /* ticks per second */
 
-        printk(KERN_INFO "hpet%d: at MMIO 0x%lx, IRQ%s",
-                hpetp->hp_which, hdp->hd_phys_address,
+        printk(KERN_INFO "hpet%d: at MMIO 0x%lx (virtual 0x%p), IRQ%s",
+                hpetp->hp_which, hdp->hd_phys_address, hdp->hd_address,
                 hpetp->hp_ntimer > 1 ? "s" : "");
         for (i = 0; i < hpetp->hp_ntimer; i++)
                 printk("%s %d", i > 0 ? "," : "", hdp->hd_irq[i]);
         printk("\n");
 
-        ns = hpetp->hp_period;  /* femptoseconds, 10^-15 */
-        ns /= 1000000;          /* convert to nanoseconds, 10^-9 */
-        printk(KERN_INFO "hpet%d: %ldns tick, %d %d-bit timers\n",
-                hpetp->hp_which, ns, hpetp->hp_ntimer,
-                cap & HPET_COUNTER_SIZE_MASK ? 64 : 32);
+        printk(KERN_INFO "hpet%u: %u %d-bit timers, %Lu Hz\n",
+               hpetp->hp_which, hpetp->hp_ntimer,
+               cap & HPET_COUNTER_SIZE_MASK ? 64 : 32, hpetp->hp_tick_freq);
 
         mcfg = readq(&hpet->hpet_config);
         if ((mcfg & HPET_ENABLE_CNF_MASK) == 0) {
@@ -845,13 +887,10 @@ int hpet_alloc(struct hpet_data *hdp)
                 writeq(mcfg, &hpet->hpet_config);
         }
 
-        for (i = 0, devp = hpetp->hp_dev; i < hpetp->hp_ntimer;
-             i++, hpet_ntimer++, devp++) {
-                unsigned long v;
+        for (i = 0, devp = hpetp->hp_dev; i < hpetp->hp_ntimer; i++, devp++) {
                 struct hpet_timer __iomem *timer;
 
                 timer = &hpet->hpet_timers[devp - hpetp->hp_dev];
-                v = readq(&timer->hpet_config);
 
                 devp->hd_hpets = hpetp;
                 devp->hd_hpet = hpet;
@@ -880,7 +919,6 @@ static acpi_status hpet_resources(struct acpi_resource *res, void *data)
         struct hpet_data *hdp;
         acpi_status status;
         struct acpi_resource_address64 addr;
-        struct hpets *hpetp;
 
         hdp = data;
 
@@ -893,9 +931,29 @@ static acpi_status hpet_resources(struct acpi_resource *res, void *data)
                 hdp->hd_phys_address = addr.min_address_range;
                 hdp->hd_address = ioremap(addr.min_address_range, size);
 
-                for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next)
-                        if (hpetp->hp_hpet == hdp->hd_address)
-                                return -EBUSY;
+                if (hpet_is_known(hdp)) {
+                        printk(KERN_DEBUG "%s: 0x%lx is busy\n",
+                                __FUNCTION__, hdp->hd_phys_address);
+                        iounmap(hdp->hd_address);
+                        return -EBUSY;
+                }
+        } else if (res->id == ACPI_RSTYPE_FIXED_MEM32) {
+                struct acpi_resource_fixed_mem32 *fixmem32;
+
+                fixmem32 = &res->data.fixed_memory32;
+                if (!fixmem32)
+                        return -EINVAL;
+
+                hdp->hd_phys_address = fixmem32->range_base_address;
+                hdp->hd_address = ioremap(fixmem32->range_base_address,
+                                                HPET_RANGE_SIZE);
+
+                if (hpet_is_known(hdp)) {
+                        printk(KERN_DEBUG "%s: 0x%lx is busy\n",
+                                __FUNCTION__, hdp->hd_phys_address);
+                        iounmap(hdp->hd_address);
+                        return -EBUSY;
+                }
         } else if (res->id == ACPI_RSTYPE_EXT_IRQ) {
                 struct acpi_resource_ext_irq *irqp;
                 int i;
diff --git a/drivers/char/hvc_vio.c b/drivers/char/hvc_vio.c
index 78d681dc35a8..f5212eb2b41d 100644
--- a/drivers/char/hvc_vio.c
+++ b/drivers/char/hvc_vio.c
@@ -95,11 +95,11 @@ static int __devexit hvc_vio_remove(struct vio_dev *vdev)
 }
 
 static struct vio_driver hvc_vio_driver = {
-        .name           = hvc_driver_name,
         .id_table       = hvc_driver_table,
         .probe          = hvc_vio_probe,
         .remove         = hvc_vio_remove,
         .driver         = {
+                .name   = hvc_driver_name,
                 .owner  = THIS_MODULE,
         }
 };
diff --git a/drivers/char/hvcs.c b/drivers/char/hvcs.c
index f47f009f9259..53dc77c760fc 100644
--- a/drivers/char/hvcs.c
+++ b/drivers/char/hvcs.c
@@ -720,10 +720,13 @@ static int __devexit hvcs_remove(struct vio_dev *dev)
 };
 
 static struct vio_driver hvcs_vio_driver = {
-        .name           = hvcs_driver_name,
         .id_table       = hvcs_driver_table,
         .probe          = hvcs_probe,
         .remove         = hvcs_remove,
+        .driver         = {
+                .name   = hvcs_driver_name,
+                .owner  = THIS_MODULE,
+        }
 };
 
 /* Only called from hvcs_get_pi please */
diff --git a/drivers/char/ip2main.c b/drivers/char/ip2main.c
index 9e4e26aef94e..d815d197dc3e 100644
--- a/drivers/char/ip2main.c
+++ b/drivers/char/ip2main.c
@@ -721,8 +721,9 @@ ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
                         }
 
                         if ( NULL != ( pB = i2BoardPtrTable[i] ) ) {
-                                class_device_create(ip2_class, MKDEV(IP2_IPL_MAJOR,
-                                                4 * i), NULL, "ipl%d", i);
+                                class_device_create(ip2_class, NULL,
+                                                MKDEV(IP2_IPL_MAJOR, 4 * i),
+                                                NULL, "ipl%d", i);
                                 err = devfs_mk_cdev(MKDEV(IP2_IPL_MAJOR, 4 * i),
                                                 S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR,
                                                 "ip2/ipl%d", i);
@@ -732,8 +733,9 @@ ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
                                         goto out_class;
                                 }
 
-                                class_device_create(ip2_class, MKDEV(IP2_IPL_MAJOR,
-                                                4 * i + 1), NULL, "stat%d", i);
+                                class_device_create(ip2_class, NULL,
+                                                MKDEV(IP2_IPL_MAJOR, 4 * i + 1),
+                                                NULL, "stat%d", i);
                                 err = devfs_mk_cdev(MKDEV(IP2_IPL_MAJOR, 4 * i + 1),
                                                 S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR,
                                                 "ip2/stat%d", i);
diff --git a/drivers/char/ipmi/ipmi_devintf.c b/drivers/char/ipmi/ipmi_devintf.c
index a09ff1080687..7c0684deea06 100644
--- a/drivers/char/ipmi/ipmi_devintf.c
+++ b/drivers/char/ipmi/ipmi_devintf.c
@@ -798,7 +798,7 @@ static void ipmi_new_smi(int if_num)
         devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
                       "ipmidev/%d", if_num);
 
-        class_device_create(ipmi_class, dev, NULL, "ipmi%d", if_num);
+        class_device_create(ipmi_class, NULL, dev, NULL, "ipmi%d", if_num);
 }
 
 static void ipmi_smi_gone(int if_num)
diff --git a/drivers/char/istallion.c b/drivers/char/istallion.c
index 9c19e5435a11..e3ddbdb85a2f 100644
--- a/drivers/char/istallion.c
+++ b/drivers/char/istallion.c
@@ -5246,7 +5246,8 @@ int __init stli_init(void)
                 devfs_mk_cdev(MKDEV(STL_SIOMEMMAJOR, i),
                                S_IFCHR | S_IRUSR | S_IWUSR,
                                "staliomem/%d", i);
-                class_device_create(istallion_class, MKDEV(STL_SIOMEMMAJOR, i),
+                class_device_create(istallion_class, NULL,
+                                MKDEV(STL_SIOMEMMAJOR, i),
                                 NULL, "staliomem%d", i);
         }
 
diff --git a/drivers/char/lcd.c b/drivers/char/lcd.c
index b77161146144..29963d8be667 100644
--- a/drivers/char/lcd.c
+++ b/drivers/char/lcd.c
@@ -575,8 +575,8 @@ static inline int button_pressed(void)
 
 static int lcd_waiters = 0;
 
-static long lcd_read(struct inode *inode, struct file *file, char *buf,
-                     unsigned long count)
+static ssize_t lcd_read(struct file *file, char *buf,
+                     size_t count, loff_t *ofs)
 {
         long buttons_now;
 
diff --git a/drivers/char/lcd.h b/drivers/char/lcd.h
index 878a95280e87..a8d4ae737158 100644
--- a/drivers/char/lcd.h
+++ b/drivers/char/lcd.h
@@ -22,7 +22,7 @@ static int timeout(volatile unsigned long);
 #define MAX_IDLE_TIME 120
 
 struct lcd_display {
-        unsigned long buttons;
+        unsigned buttons;
         int size1;
         int size2;
         unsigned char line1[LCD_CHARS_PER_LINE];
diff --git a/drivers/char/lp.c b/drivers/char/lp.c
index 2afb9038dbc5..e57260525293 100644
--- a/drivers/char/lp.c
+++ b/drivers/char/lp.c
@@ -805,7 +805,7 @@ static int lp_register(int nr, struct parport *port)
         if (reset)
                 lp_reset(nr);
 
-        class_device_create(lp_class, MKDEV(LP_MAJOR, nr), NULL,
+        class_device_create(lp_class, NULL, MKDEV(LP_MAJOR, nr), NULL,
                                 "lp%d", nr);
         devfs_mk_cdev(MKDEV(LP_MAJOR, nr), S_IFCHR | S_IRUGO | S_IWUGO,
                         "printers/%d", nr);
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index f182752fe918..91dd669273e0 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -231,9 +231,7 @@ static ssize_t write_mem(struct file * file, const char __user * buf,
 static int mmap_mem(struct file * file, struct vm_area_struct * vma)
 {
 #if defined(__HAVE_PHYS_MEM_ACCESS_PROT)
-        unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
-
-        vma->vm_page_prot = phys_mem_access_prot(file, offset,
+        vma->vm_page_prot = phys_mem_access_prot(file, vma->vm_pgoff,
                                                  vma->vm_end - vma->vm_start,
                                                  vma->vm_page_prot);
 #elif defined(pgprot_noncached)
@@ -920,7 +918,8 @@ static int __init chr_dev_init(void)
 
         mem_class = class_create(THIS_MODULE, "mem");
         for (i = 0; i < ARRAY_SIZE(devlist); i++) {
-                class_device_create(mem_class, MKDEV(MEM_MAJOR, devlist[i].minor),
+                class_device_create(mem_class, NULL,
+                                        MKDEV(MEM_MAJOR, devlist[i].minor),
                                         NULL, devlist[i].name);
                 devfs_mk_cdev(MKDEV(MEM_MAJOR, devlist[i].minor),
                                 S_IFCHR | devlist[i].mode, devlist[i].name);
diff --git a/drivers/char/misc.c b/drivers/char/misc.c
index 0c8375165e29..3e4c0414a01a 100644
--- a/drivers/char/misc.c
+++ b/drivers/char/misc.c
@@ -234,7 +234,7 @@ int misc_register(struct miscdevice * misc)
         }
         dev = MKDEV(MISC_MAJOR, misc->minor);
 
-        misc->class = class_device_create(misc_class, dev, misc->dev,
+        misc->class = class_device_create(misc_class, NULL, dev, misc->dev,
                                           "%s", misc->name);
         if (IS_ERR(misc->class)) {
                 err = PTR_ERR(misc->class);
diff --git a/drivers/char/mmtimer.c b/drivers/char/mmtimer.c
index 12006182f575..78c89a3e7825 100644
--- a/drivers/char/mmtimer.c
+++ b/drivers/char/mmtimer.c
@@ -441,7 +441,7 @@ static irqreturn_t
 mmtimer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
         int i;
-        mmtimer_t *base = timers + cpuid_to_cnodeid(smp_processor_id()) *
+        mmtimer_t *base = timers + cpu_to_node(smp_processor_id()) *
                                                 NUM_COMPARATORS;
         unsigned long expires = 0;
         int result = IRQ_NONE;
@@ -608,7 +608,7 @@ static int sgi_timer_set(struct k_itimer *timr, int flags,
          */
         preempt_disable();
 
-        nodeid =  cpuid_to_cnodeid(smp_processor_id());
+        nodeid =  cpu_to_node(smp_processor_id());
         base = timers + nodeid * NUM_COMPARATORS;
 retry:
         /* Don't use an allocated timer, or a deleted one that's pending */
diff --git a/drivers/char/mwave/3780i.c b/drivers/char/mwave/3780i.c
index 613aed9e1840..d1fe05e83882 100644
--- a/drivers/char/mwave/3780i.c
+++ b/drivers/char/mwave/3780i.c
@@ -53,6 +53,8 @@
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/bitops.h>
+#include <linux/sched.h>        /* cond_resched() */
+
 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
diff --git a/drivers/char/n_tty.c b/drivers/char/n_tty.c
index c9bdf544ed2c..c556f4d3ccd7 100644
--- a/drivers/char/n_tty.c
+++ b/drivers/char/n_tty.c
@@ -62,7 +62,7 @@
 
 static inline unsigned char *alloc_buf(void)
 {
-        unsigned int prio = in_interrupt() ? GFP_ATOMIC : GFP_KERNEL;
+        gfp_t prio = in_interrupt() ? GFP_ATOMIC : GFP_KERNEL;
 
         if (PAGE_SIZE != N_TTY_BUF_SIZE)
                 return kmalloc(N_TTY_BUF_SIZE, prio);
diff --git a/drivers/char/nvram.c b/drivers/char/nvram.c
index 1af733d07321..9e24bbd4090c 100644
--- a/drivers/char/nvram.c
+++ b/drivers/char/nvram.c
@@ -32,9 +32,11 @@
  *              added changelog
  *      1.2     Erik Gilling: Cobalt Networks support
  *              Tim Hockin: general cleanup, Cobalt support
+ *      1.3     Jon Ringle: Comdial MP1000 support
+ *
  */
 
-#define NVRAM_VERSION   "1.2"
+#define NVRAM_VERSION   "1.3"
 
 #include <linux/module.h>
 #include <linux/config.h>
@@ -45,6 +47,7 @@
 #define PC              1
 #define ATARI           2
 #define COBALT          3
+#define MP1000          4
 
 /* select machine configuration */
 #if defined(CONFIG_ATARI)
@@ -54,6 +57,9 @@
 #  if defined(CONFIG_COBALT)
 #    include <linux/cobalt-nvram.h>
 #    define MACH COBALT
+#  elif defined(CONFIG_MACH_MP1000)
+#    undef MACH
+#    define MACH MP1000
 #  else
 #    define MACH PC
 #  endif
@@ -112,6 +118,23 @@
 
 #endif
 
+#if MACH == MP1000
+
+/* RTC in a MP1000 */
+#define CHECK_DRIVER_INIT()     1
+
+#define MP1000_CKS_RANGE_START  0
+#define MP1000_CKS_RANGE_END    111
+#define MP1000_CKS_LOC          112
+
+#define NVRAM_BYTES             (128-NVRAM_FIRST_BYTE)
+
+#define mach_check_checksum     mp1000_check_checksum
+#define mach_set_checksum       mp1000_set_checksum
+#define mach_proc_infos         mp1000_proc_infos
+
+#endif
+
 /* 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
@@ -915,6 +938,91 @@ atari_proc_infos(unsigned char *nvram, char *buffer, int *len,
 
 #endif /* MACH == ATARI */
 
+#if MACH == MP1000
+
+static int
+mp1000_check_checksum(void)
+{
+        int i;
+        unsigned short sum = 0;
+        unsigned short expect;
+
+        for (i = MP1000_CKS_RANGE_START; i <= MP1000_CKS_RANGE_END; ++i)
+                sum += __nvram_read_byte(i);
+
+        expect = __nvram_read_byte(MP1000_CKS_LOC+1)<<8 |
+            __nvram_read_byte(MP1000_CKS_LOC);
+        return ((sum & 0xffff) == expect);
+}
+
+static void
+mp1000_set_checksum(void)
+{
+        int i;
+        unsigned short sum = 0;
+
+        for (i = MP1000_CKS_RANGE_START; i <= MP1000_CKS_RANGE_END; ++i)
+                sum += __nvram_read_byte(i);
+        __nvram_write_byte(sum >> 8, MP1000_CKS_LOC + 1);
+        __nvram_write_byte(sum & 0xff, MP1000_CKS_LOC);
+}
+
+#ifdef CONFIG_PROC_FS
+
+#define         SERVER_N_LEN         32
+#define         PATH_N_LEN           32
+#define         FILE_N_LEN           32
+#define         NVRAM_MAGIC_SIG      0xdead
+
+typedef struct NvRamImage
+{
+        unsigned short int    magic;
+        unsigned short int    mode;
+        char                  fname[FILE_N_LEN];
+        char                  path[PATH_N_LEN];
+        char                  server[SERVER_N_LEN];
+        char                  pad[12];
+} NvRam;
+
+static int
+mp1000_proc_infos(unsigned char *nvram, char *buffer, int *len,
+    off_t *begin, off_t offset, int size)
+{
+        int checksum;
+        NvRam* nv = (NvRam*)nvram;
+
+        spin_lock_irq(&rtc_lock);
+        checksum = __nvram_check_checksum();
+        spin_unlock_irq(&rtc_lock);
+
+        PRINT_PROC("Checksum status: %svalid\n", checksum ? "" : "not ");
+
+        switch( nv->mode )
+        {
+           case 0 :
+                    PRINT_PROC( "\tMode 0, tftp prompt\n" );
+                    break;
+           case 1 :
+                    PRINT_PROC( "\tMode 1, booting from disk\n" );
+                    break;
+           case 2 :
+                    PRINT_PROC( "\tMode 2, Alternate boot from disk /boot/%s\n", nv->fname );
+                    break;
+           case 3 :
+                    PRINT_PROC( "\tMode 3, Booting from net:\n" );
+                    PRINT_PROC( "\t\t%s:%s%s\n",nv->server, nv->path, nv->fname );
+                    break;
+           default:
+                    PRINT_PROC( "\tInconsistant nvram?\n" );
+                    break;
+        }
+
+        return 1;
+}
+#endif
+
+#endif /* MACH == MP1000 */
+
 MODULE_LICENSE("GPL");
 
 EXPORT_SYMBOL(__nvram_read_byte);
diff --git a/drivers/char/ppdev.c b/drivers/char/ppdev.c
index 0e22880432bc..306ee0f091a4 100644
--- a/drivers/char/ppdev.c
+++ b/drivers/char/ppdev.c
@@ -752,7 +752,7 @@ static struct file_operations pp_fops = {
 
 static void pp_attach(struct parport *port)
 {
-        class_device_create(ppdev_class, MKDEV(PP_MAJOR, port->number),
+        class_device_create(ppdev_class, NULL, MKDEV(PP_MAJOR, port->number),
                         NULL, "parport%d", port->number);
 }
 
diff --git a/drivers/char/qtronix.c b/drivers/char/qtronix.c
index 40a3cf62e1a8..601d09baf9d7 100644
--- a/drivers/char/qtronix.c
+++ b/drivers/char/qtronix.c
@@ -591,6 +591,11 @@ static int __init psaux_init(void)
                 return retval;
 
         queue = (struct aux_queue *) kmalloc(sizeof(*queue), GFP_KERNEL);
+        if (!queue) {
+                misc_deregister(&psaux_mouse);
+                return -ENOMEM;
+        }
+                
         memset(queue, 0, sizeof(*queue));
         queue->head = queue->tail = 0;
         init_waitqueue_head(&queue->proc_list);
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index f13e5de02207..30e4cbe16bb0 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -128,7 +128,7 @@ raw_ioctl(struct inode *inode, struct file *filp,
 static void bind_device(struct raw_config_request *rq)
 {
         class_device_destroy(raw_class, MKDEV(RAW_MAJOR, rq->raw_minor));
-        class_device_create(raw_class, MKDEV(RAW_MAJOR, rq->raw_minor),
+        class_device_create(raw_class, NULL, MKDEV(RAW_MAJOR, rq->raw_minor),
                                       NULL, "raw%d", rq->raw_minor);
 }
 
@@ -307,7 +307,7 @@ static int __init raw_init(void)
                 unregister_chrdev_region(dev, MAX_RAW_MINORS);
                 goto error;
         }
-        class_device_create(raw_class, MKDEV(RAW_MAJOR, 0), NULL, "rawctl");
+        class_device_create(raw_class, NULL, MKDEV(RAW_MAJOR, 0), NULL, "rawctl");
 
         devfs_mk_cdev(MKDEV(RAW_MAJOR, 0),
                       S_IFCHR | S_IRUGO | S_IWUGO,
diff --git a/drivers/char/rocket.c b/drivers/char/rocket.c
index 5b1d3680c8ab..928b850cc679 100644
--- a/drivers/char/rocket.c
+++ b/drivers/char/rocket.c
@@ -256,7 +256,6 @@ static int sInitController(CONTROLLER_T * CtlP, int CtlNum, ByteIO_t MudbacIO,
 static int sReadAiopID(ByteIO_t io);
 static int sReadAiopNumChan(WordIO_t io);
 
-#ifdef MODULE
 MODULE_AUTHOR("Theodore Ts'o");
 MODULE_DESCRIPTION("Comtrol RocketPort driver");
 module_param(board1, ulong, 0);
@@ -288,17 +287,14 @@ MODULE_PARM_DESC(pc104_3, "set interface types for ISA(PC104) board #3 (e.g. pc1
 module_param_array(pc104_4, ulong, NULL, 0);
 MODULE_PARM_DESC(pc104_4, "set interface types for ISA(PC104) board #4 (e.g. pc104_4=232,232,485,485,...");
 
-int rp_init(void);
+static int rp_init(void);
 static void rp_cleanup_module(void);
 
 module_init(rp_init);
 module_exit(rp_cleanup_module);
 
-#endif
 
-#ifdef MODULE_LICENSE
 MODULE_LICENSE("Dual BSD/GPL");
-#endif
 
 /*************************************************************************/
 /*                     Module code starts here                           */
@@ -2378,7 +2374,7 @@ static struct tty_operations rocket_ops = {
 /*
  * The module "startup" routine; it's run when the module is loaded.
  */
-int __init rp_init(void)
+static int __init rp_init(void)
 {
         int retval, pci_boards_found, isa_boards_found, i;
 
@@ -2502,7 +2498,6 @@ int __init rp_init(void)
         return 0;
 }
 
-#ifdef MODULE
 
 static void rp_cleanup_module(void)
 {
@@ -2530,7 +2525,6 @@ static void rp_cleanup_module(void)
         if (controller)
                 release_region(controller, 4);
 }
-#endif
 
 /***************************************************************************
 Function: sInitController
diff --git a/drivers/char/s3c2410-rtc.c b/drivers/char/s3c2410-rtc.c
index e1a90d9a8756..d724c0de4f28 100644
--- a/drivers/char/s3c2410-rtc.c
+++ b/drivers/char/s3c2410-rtc.c
@@ -20,7 +20,7 @@
 #include <linux/fs.h>
 #include <linux/string.h>
 #include <linux/init.h>
-#include <linux/device.h>
+#include <linux/platform_device.h>
 #include <linux/interrupt.h>
 #include <linux/rtc.h>
 #include <linux/bcd.h>
@@ -519,30 +519,28 @@ static struct timespec s3c2410_rtc_delta;
 
 static int ticnt_save;
 
-static int s3c2410_rtc_suspend(struct device *dev, pm_message_t state, u32 level)
+static int s3c2410_rtc_suspend(struct device *dev, pm_message_t state)
 {
         struct rtc_time tm;
         struct timespec time;
 
         time.tv_nsec = 0;
 
-        if (level == SUSPEND_POWER_DOWN) {
-                /* save TICNT for anyone using periodic interrupts */
+        /* save TICNT for anyone using periodic interrupts */
 
-                ticnt_save = readb(S3C2410_TICNT);
+        ticnt_save = readb(S3C2410_TICNT);
 
-                /* calculate time delta for suspend */
+        /* calculate time delta for suspend */
 
-                s3c2410_rtc_gettime(&tm);
-                rtc_tm_to_time(&tm, &time.tv_sec);
-                save_time_delta(&s3c2410_rtc_delta, &time);
-                s3c2410_rtc_enable(dev, 0);
-        }
+        s3c2410_rtc_gettime(&tm);
+        rtc_tm_to_time(&tm, &time.tv_sec);
+        save_time_delta(&s3c2410_rtc_delta, &time);
+        s3c2410_rtc_enable(dev, 0);
 
         return 0;
 }
 
-static int s3c2410_rtc_resume(struct device *dev, u32 level)
+static int s3c2410_rtc_resume(struct device *dev)
 {
         struct rtc_time tm;
         struct timespec time;
diff --git a/drivers/char/ser_a2232.c b/drivers/char/ser_a2232.c
index 6b4e9d155f50..dda30e42ec79 100644
--- a/drivers/char/ser_a2232.c
+++ b/drivers/char/ser_a2232.c
@@ -790,7 +790,7 @@ static int __init a2232board_init(void)
 
         }       
 
-        printk("Total: %d A2232 boards initialized.\n.", nr_a2232); /* Some status report if no card was found */
+        printk("Total: %d A2232 boards initialized.\n", nr_a2232); /* Some status report if no card was found */
 
         a2232_init_portstructs();
 
diff --git a/drivers/char/snsc.c b/drivers/char/snsc.c
index 261a41bf6d02..0e7d216e7eb0 100644
--- a/drivers/char/snsc.c
+++ b/drivers/char/snsc.c
@@ -377,7 +377,7 @@ scdrv_init(void)
         dev_t first_dev, dev;
         nasid_t event_nasid = ia64_sn_get_console_nasid();
 
-        if (alloc_chrdev_region(&first_dev, 0, numionodes,
+        if (alloc_chrdev_region(&first_dev, 0, num_cnodes,
                                 SYSCTL_BASENAME) < 0) {
                 printk("%s: failed to register SN system controller device\n",
                        __FUNCTION__);
@@ -385,7 +385,7 @@ scdrv_init(void)
         }
         snsc_class = class_create(THIS_MODULE, SYSCTL_BASENAME);
 
-        for (cnode = 0; cnode < numionodes; cnode++) {
+        for (cnode = 0; cnode < num_cnodes; cnode++) {
                         geoid = cnodeid_get_geoid(cnode);
                         devnamep = devname;
                         format_module_id(devnamep, geo_module(geoid),
@@ -437,7 +437,7 @@ scdrv_init(void)
                                 continue;
                         }
 
-                        class_device_create(snsc_class, dev, NULL,
+                        class_device_create(snsc_class, NULL, dev, NULL,
                                                 "%s", devname);
 
                         ia64_sn_irtr_intr_enable(scd->scd_nasid,
diff --git a/drivers/char/sonypi.c b/drivers/char/sonypi.c
index 36ae9ad2598c..d05067dcea01 100644
--- a/drivers/char/sonypi.c
+++ b/drivers/char/sonypi.c
@@ -48,6 +48,7 @@
 #include <linux/dmi.h>
 #include <linux/err.h>
 #include <linux/kfifo.h>
+#include <linux/platform_device.h>
 
 #include <asm/uaccess.h>
 #include <asm/io.h>
@@ -424,10 +425,6 @@ static struct sonypi_eventtypes {
 
 #define SONYPI_BUF_SIZE 128
 
-/* The name of the devices for the input device drivers */
-#define SONYPI_JOG_INPUTNAME    "Sony Vaio Jogdial"
-#define SONYPI_KEY_INPUTNAME    "Sony Vaio Keys"
-
 /* Correspondance table between sonypi events and input layer events */
 static struct {
         int sonypiev;
@@ -490,8 +487,8 @@ static struct sonypi_device {
         struct fasync_struct *fifo_async;
         int open_count;
         int model;
-        struct input_dev input_jog_dev;
-        struct input_dev input_key_dev;
+        struct input_dev *input_jog_dev;
+        struct input_dev *input_key_dev;
         struct work_struct input_work;
         struct kfifo *input_fifo;
         spinlock_t input_fifo_lock;
@@ -779,8 +776,8 @@ static void input_keyrelease(void *data)
 
 static void sonypi_report_input_event(u8 event)
 {
-        struct input_dev *jog_dev = &sonypi_device.input_jog_dev;
-        struct input_dev *key_dev = &sonypi_device.input_key_dev;
+        struct input_dev *jog_dev = sonypi_device.input_jog_dev;
+        struct input_dev *key_dev = sonypi_device.input_key_dev;
         struct sonypi_keypress kp = { NULL };
         int i;
 
@@ -1171,19 +1168,17 @@ static int sonypi_disable(void)
 #ifdef CONFIG_PM
 static int old_camera_power;
 
-static int sonypi_suspend(struct device *dev, pm_message_t state, u32 level)
+static int sonypi_suspend(struct device *dev, pm_message_t state)
 {
-        if (level == SUSPEND_DISABLE) {
-                old_camera_power = sonypi_device.camera_power;
-                sonypi_disable();
-        }
+        old_camera_power = sonypi_device.camera_power;
+        sonypi_disable();
+
         return 0;
 }
 
-static int sonypi_resume(struct device *dev, u32 level)
+static int sonypi_resume(struct device *dev)
 {
-        if (level == RESUME_ENABLE)
-                sonypi_enable(old_camera_power);
+        sonypi_enable(old_camera_power);
         return 0;
 }
 #endif
@@ -1203,6 +1198,47 @@ static struct device_driver sonypi_driver = {
         .shutdown       = sonypi_shutdown,
 };
 
+static int __devinit sonypi_create_input_devices(void)
+{
+        struct input_dev *jog_dev;
+        struct input_dev *key_dev;
+        int i;
+
+        sonypi_device.input_jog_dev = jog_dev = input_allocate_device();
+        if (!jog_dev)
+                return -ENOMEM;
+
+        jog_dev->name = "Sony Vaio Jogdial";
+        jog_dev->id.bustype = BUS_ISA;
+        jog_dev->id.vendor = PCI_VENDOR_ID_SONY;
+
+        jog_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
+        jog_dev->keybit[LONG(BTN_MOUSE)] = BIT(BTN_MIDDLE);
+        jog_dev->relbit[0] = BIT(REL_WHEEL);
+
+        sonypi_device.input_key_dev = key_dev = input_allocate_device();
+        if (!key_dev) {
+                input_free_device(jog_dev);
+                sonypi_device.input_jog_dev = NULL;
+                return -ENOMEM;
+        }
+
+        key_dev->name = "Sony Vaio Keys";
+        key_dev->id.bustype = BUS_ISA;
+        key_dev->id.vendor = PCI_VENDOR_ID_SONY;
+
+        /* Initialize the Input Drivers: special keys */
+        key_dev->evbit[0] = BIT(EV_KEY);
+        for (i = 0; sonypi_inputkeys[i].sonypiev; i++)
+                if (sonypi_inputkeys[i].inputev)
+                        set_bit(sonypi_inputkeys[i].inputev, key_dev->keybit);
+
+        input_register_device(jog_dev);
+        input_register_device(key_dev);
+
+        return 0;
+}
+
 static int __devinit sonypi_probe(void)
 {
         int i, ret;
@@ -1298,34 +1334,10 @@ static int __devinit sonypi_probe(void)
         }
 
         if (useinput) {
-                /* Initialize the Input Drivers: jogdial */
-                int i;
-                sonypi_device.input_jog_dev.evbit[0] =
-                        BIT(EV_KEY) | BIT(EV_REL);
-                sonypi_device.input_jog_dev.keybit[LONG(BTN_MOUSE)] =
-                        BIT(BTN_MIDDLE);
-                sonypi_device.input_jog_dev.relbit[0] = BIT(REL_WHEEL);
-                sonypi_device.input_jog_dev.name = SONYPI_JOG_INPUTNAME;
-                sonypi_device.input_jog_dev.id.bustype = BUS_ISA;
-                sonypi_device.input_jog_dev.id.vendor = PCI_VENDOR_ID_SONY;
-
-                input_register_device(&sonypi_device.input_jog_dev);
-                printk(KERN_INFO "%s input method installed.\n",
-                       sonypi_device.input_jog_dev.name);
-
-                /* Initialize the Input Drivers: special keys */
-                sonypi_device.input_key_dev.evbit[0] = BIT(EV_KEY);
-                for (i = 0; sonypi_inputkeys[i].sonypiev; i++)
-                        if (sonypi_inputkeys[i].inputev)
-                                set_bit(sonypi_inputkeys[i].inputev,
-                                        sonypi_device.input_key_dev.keybit);
-                sonypi_device.input_key_dev.name = SONYPI_KEY_INPUTNAME;
-                sonypi_device.input_key_dev.id.bustype = BUS_ISA;
-                sonypi_device.input_key_dev.id.vendor = PCI_VENDOR_ID_SONY;
 
-                input_register_device(&sonypi_device.input_key_dev);
-                printk(KERN_INFO "%s input method installed.\n",
-                       sonypi_device.input_key_dev.name);
+                ret = sonypi_create_input_devices();
+                if (ret)
+                        goto out_inputdevices;
 
                 spin_lock_init(&sonypi_device.input_fifo_lock);
                 sonypi_device.input_fifo =
@@ -1375,8 +1387,9 @@ static int __devinit sonypi_probe(void)
 out_platformdev:
         kfifo_free(sonypi_device.input_fifo);
 out_infifo:
-        input_unregister_device(&sonypi_device.input_key_dev);
-        input_unregister_device(&sonypi_device.input_jog_dev);
+        input_unregister_device(sonypi_device.input_key_dev);
+        input_unregister_device(sonypi_device.input_jog_dev);
+out_inputdevices:
         free_irq(sonypi_device.irq, sonypi_irq);
 out_reqirq:
         release_region(sonypi_device.ioport1, sonypi_device.region_size);
@@ -1402,8 +1415,8 @@ static void __devexit sonypi_remove(void)
         platform_device_unregister(sonypi_device.pdev);
 
         if (useinput) {
-                input_unregister_device(&sonypi_device.input_key_dev);
-                input_unregister_device(&sonypi_device.input_jog_dev);
+                input_unregister_device(sonypi_device.input_key_dev);
+                input_unregister_device(sonypi_device.input_jog_dev);
                 kfifo_free(sonypi_device.input_fifo);
         }
 
diff --git a/drivers/char/specialix.c b/drivers/char/specialix.c
index 50e0b612a8a2..352547eabf7b 100644
--- a/drivers/char/specialix.c
+++ b/drivers/char/specialix.c
@@ -38,19 +38,19 @@
  *
  * Revision 1.0:  April 1st 1997.
  *                Initial release for alpha testing.
- * Revision 1.1:  April 14th 1997. 
- *                Incorporated Richard Hudsons suggestions, 
+ * Revision 1.1:  April 14th 1997.
+ *                Incorporated Richard Hudsons suggestions,
  *                removed some debugging printk's.
  * Revision 1.2:  April 15th 1997.
  *                Ported to 2.1.x kernels.
- * Revision 1.3:  April 17th 1997 
- *                Backported to 2.0. (Compatibility macros). 
+ * Revision 1.3:  April 17th 1997
+ *                Backported to 2.0. (Compatibility macros).
  * Revision 1.4:  April 18th 1997
- *                Fixed DTR/RTS bug that caused the card to indicate 
- *                "don't send data" to a modem after the password prompt.  
+ *                Fixed DTR/RTS bug that caused the card to indicate
+ *                "don't send data" to a modem after the password prompt.
  *                Fixed bug for premature (fake) interrupts.
  * Revision 1.5:  April 19th 1997
- *                fixed a minor typo in the header file, cleanup a little. 
+ *                fixed a minor typo in the header file, cleanup a little.
  *                performance warnings are now MAXed at once per minute.
  * Revision 1.6:  May 23 1997
  *                Changed the specialix=... format to include interrupt.
@@ -60,10 +60,10 @@
  *                port to linux-2.1.43 kernel.
  * Revision 1.9:  Oct 9  1998
  *                Added stuff for the IO8+/PCI version.
- * Revision 1.10: Oct 22  1999 / Jan 21 2000. 
- *                Added stuff for setserial. 
+ * Revision 1.10: Oct 22  1999 / Jan 21 2000.
+ *                Added stuff for setserial.
  *                Nicolas Mailhot (Nicolas.Mailhot@email.enst.fr)
- * 
+ *
  */
 
 #define VERSION "1.11"
@@ -154,7 +154,7 @@ static int sx_poll = HZ;
 
 
 
-/* 
+/*
  * The following defines are mostly for testing purposes. But if you need
  * some nice reporting in your syslog, you can define them also.
  */
@@ -188,7 +188,7 @@ static DECLARE_MUTEX(tmp_buf_sem);
 
 static unsigned long baud_table[] =  {
         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
-        9600, 19200, 38400, 57600, 115200, 0, 
+        9600, 19200, 38400, 57600, 115200, 0,
 };
 
 static struct specialix_board sx_board[SX_NBOARD] =  {
@@ -216,7 +216,7 @@ static inline int sx_paranoia_check(struct specialix_port const * port,
                 KERN_ERR "sx: Warning: bad specialix port magic number for device %s in %s\n";
         static const char *badinfo =
                 KERN_ERR "sx: Warning: null specialix port for device %s in %s\n";
- 
+
         if (!port) {
                 printk(badinfo, name, routine);
                 return 1;
@@ -231,9 +231,9 @@ static inline int sx_paranoia_check(struct specialix_port const * port,
 
 
 /*
- * 
+ *
  *  Service functions for specialix IO8+ driver.
- * 
+ *
  */
 
 /* Get board number from pointer */
@@ -246,7 +246,7 @@ static inline int board_No (struct specialix_board * bp)
 /* Get port number from pointer */
 static inline int port_No (struct specialix_port const * port)
 {
-        return SX_PORT(port - sx_port); 
+        return SX_PORT(port - sx_port);
 }
 
 
@@ -309,7 +309,7 @@ static inline void sx_wait_CCR(struct specialix_board  * bp)
                         return;
                 udelay (1);
         }
-        
+
         printk(KERN_ERR "sx%d: Timeout waiting for CCR.\n", board_No(bp));
 }
 
@@ -329,7 +329,7 @@ static inline void sx_wait_CCR_off(struct specialix_board  * bp)
                         return;
                 udelay (1);
         }
-        
+
         printk(KERN_ERR "sx%d: Timeout waiting for CCR.\n", board_No(bp));
 }
 
@@ -338,34 +338,28 @@ static inline void sx_wait_CCR_off(struct specialix_board  * bp)
  *  specialix IO8+ IO range functions.
  */
 
-static inline int sx_check_io_range(struct specialix_board * bp)
+static inline int sx_request_io_range(struct specialix_board * bp)
 {
-        return check_region (bp->base, SX_IO_SPACE);
-}
-
-
-static inline void sx_request_io_range(struct specialix_board * bp)
-{
-        request_region(bp->base, 
-                       bp->flags&SX_BOARD_IS_PCI?SX_PCI_IO_SPACE:SX_IO_SPACE,
-                       "specialix IO8+" );
+        return request_region(bp->base,
+                bp->flags & SX_BOARD_IS_PCI ? SX_PCI_IO_SPACE : SX_IO_SPACE,
+                "specialix IO8+") == NULL;
 }
 
 
 static inline void sx_release_io_range(struct specialix_board * bp)
 {
-        release_region(bp->base, 
+        release_region(bp->base,
                        bp->flags&SX_BOARD_IS_PCI?SX_PCI_IO_SPACE:SX_IO_SPACE);
 }
 
-        
+
 /* Must be called with enabled interrupts */
-/* Ugly. Very ugly. Don't use this for anything else than initialization 
+/* Ugly. Very ugly. Don't use this for anything else than initialization
    code */
 static inline void sx_long_delay(unsigned long delay)
 {
         unsigned long i;
-        
+
         for (i = jiffies + delay; time_after(i, jiffies); ) ;
 }
 
@@ -378,7 +372,7 @@ static int sx_set_irq ( struct specialix_board *bp)
         int i;
         unsigned long flags;
 
-        if (bp->flags & SX_BOARD_IS_PCI) 
+        if (bp->flags & SX_BOARD_IS_PCI)
                 return 1;
         switch (bp->irq) {
         /* In the same order as in the docs... */
@@ -420,7 +414,7 @@ static int sx_init_CD186x(struct specialix_board  * bp)
         sx_out_off(bp, CD186x_PILR3, SX_ACK_RINT);      /* Prio for receiver intr    */
         /* Set RegAckEn */
         sx_out_off(bp, CD186x_SRCR, sx_in (bp, CD186x_SRCR) | SRCR_REGACKEN);
-        
+
         /* Setting up prescaler. We need 4 ticks per 1 ms */
         scaler =  SX_OSCFREQ/SPECIALIX_TPS;
 
@@ -448,7 +442,7 @@ static int read_cross_byte (struct specialix_board *bp, int reg, int bit)
         spin_lock_irqsave(&bp->lock, flags);
         for (i=0, t=0;i<8;i++) {
                 sx_out_off (bp, CD186x_CAR, i);
-                if (sx_in_off (bp, reg) & bit) 
+                if (sx_in_off (bp, reg) & bit)
                         t |= 1 << i;
         }
         spin_unlock_irqrestore(&bp->lock, flags);
@@ -472,7 +466,7 @@ void missed_irq (unsigned long data)
         spin_unlock_irqrestore(&bp->lock, flags);
         if (irq) {
                 printk (KERN_INFO "Missed interrupt... Calling int from timer. \n");
-                sx_interrupt (((struct specialix_board *)data)->irq, 
+                sx_interrupt (((struct specialix_board *)data)->irq,
                               (void*)data, NULL);
         }
         missed_irq_timer.expires = jiffies + sx_poll;
@@ -495,7 +489,7 @@ static int sx_probe(struct specialix_board *bp)
 
         func_enter();
 
-        if (sx_check_io_range(bp)) {
+        if (sx_request_io_range(bp)) {
                 func_exit();
                 return 1;
         }
@@ -509,15 +503,16 @@ static int sx_probe(struct specialix_board *bp)
         short_pause ();
         val2 = sx_in_off(bp, CD186x_PPRL);
 
-        
+
         if ((val1 != 0x5a) || (val2 != 0xa5)) {
                 printk(KERN_INFO "sx%d: specialix IO8+ Board at 0x%03x not found.\n",
                        board_No(bp), bp->base);
+                sx_release_io_range(bp);
                 func_exit();
                 return 1;
         }
 
-        /* Check the DSR lines that Specialix uses as board 
+        /* Check the DSR lines that Specialix uses as board
            identification */
         val1 = read_cross_byte (bp, CD186x_MSVR, MSVR_DSR);
         val2 = read_cross_byte (bp, CD186x_MSVR, MSVR_RTS);
@@ -532,6 +527,7 @@ static int sx_probe(struct specialix_board *bp)
         if (val1 != val2) {
                 printk(KERN_INFO "sx%d: specialix IO8+ ID %02x at 0x%03x not found (%02x).\n",
                        board_No(bp), val2, bp->base, val1);
+                sx_release_io_range(bp);
                 func_exit();
                 return 1;
         }
@@ -546,7 +542,7 @@ static int sx_probe(struct specialix_board *bp)
                 sx_wait_CCR(bp);
                 sx_out(bp, CD186x_CCR, CCR_TXEN);        /* Enable transmitter     */
                 sx_out(bp, CD186x_IER, IER_TXRDY);       /* Enable tx empty intr   */
-                sx_long_delay(HZ/20);                   
+                sx_long_delay(HZ/20);
                 irqs = probe_irq_off(irqs);
 
                 dprintk (SX_DEBUG_INIT, "SRSR = %02x, ", sx_in(bp, CD186x_SRSR));
@@ -561,14 +557,15 @@ static int sx_probe(struct specialix_board *bp)
                 }
 
                 dprintk (SX_DEBUG_INIT "val1 = %02x, val2 = %02x, val3 = %02x.\n",
-                        val1, val2, val3); 
-        
+                        val1, val2, val3);
+
         }
-        
+
 #if 0
         if (irqs <= 0) {
                 printk(KERN_ERR "sx%d: Can't find IRQ for specialix IO8+ board at 0x%03x.\n",
                        board_No(bp), bp->base);
+                sx_release_io_range(bp);
                 func_exit();
                 return 1;
         }
@@ -579,19 +576,20 @@ static int sx_probe(struct specialix_board *bp)
 #endif
         /* Reset CD186x again  */
         if (!sx_init_CD186x(bp)) {
+                sx_release_io_range(bp);
                 func_exit();
-                return -EIO;
+                return 1;
         }
 
         sx_request_io_range(bp);
         bp->flags |= SX_BOARD_PRESENT;
-        
+
         /* Chip           revcode   pkgtype
                           GFRCR     SRCR bit 7
            CD180 rev B    0x81      0
            CD180 rev C    0x82      0
            CD1864 rev A   0x82      1
-           CD1865 rev A   0x83      1  -- Do not use!!! Does not work. 
+           CD1865 rev A   0x83      1  -- Do not use!!! Does not work.
            CD1865 rev B   0x84      1
          -- Thanks to Gwen Wang, Cirrus Logic.
          */
@@ -623,8 +621,8 @@ static int sx_probe(struct specialix_board *bp)
         return 0;
 }
 
-/* 
- * 
+/*
+ *
  *  Interrupt processing routines.
  * */
 
@@ -657,7 +655,7 @@ static inline struct specialix_port * sx_get_port(struct specialix_board * bp,
                         return port;
                 }
         }
-        printk(KERN_INFO "sx%d: %s interrupt from invalid port %d\n", 
+        printk(KERN_INFO "sx%d: %s interrupt from invalid port %d\n",
                board_No(bp), what, channel);
         return NULL;
 }
@@ -681,7 +679,7 @@ static inline void sx_receive_exc(struct specialix_board * bp)
         tty = port->tty;
         dprintk (SX_DEBUG_RX, "port: %p count: %d BUFF_SIZE: %d\n",
                  port,  tty->flip.count, TTY_FLIPBUF_SIZE);
-        
+
         status = sx_in(bp, CD186x_RCSR);
 
         dprintk (SX_DEBUG_RX, "status: 0x%x\n", status);
@@ -707,30 +705,30 @@ static inline void sx_receive_exc(struct specialix_board * bp)
                 return;
         }
         if (status & RCSR_TOUT) {
-                printk(KERN_INFO "sx%d: port %d: Receiver timeout. Hardware problems ?\n", 
+                printk(KERN_INFO "sx%d: port %d: Receiver timeout. Hardware problems ?\n",
                        board_No(bp), port_No(port));
                 func_exit();
                 return;
-                
+
         } else if (status & RCSR_BREAK) {
                 dprintk(SX_DEBUG_RX, "sx%d: port %d: Handling break...\n",
                        board_No(bp), port_No(port));
                 *tty->flip.flag_buf_ptr++ = TTY_BREAK;
                 if (port->flags & ASYNC_SAK)
                         do_SAK(tty);
-                
-        } else if (status & RCSR_PE) 
+
+        } else if (status & RCSR_PE)
                 *tty->flip.flag_buf_ptr++ = TTY_PARITY;
-        
-        else if (status & RCSR_FE) 
+
+        else if (status & RCSR_FE)
                 *tty->flip.flag_buf_ptr++ = TTY_FRAME;
-        
+
         else if (status & RCSR_OE)
                 *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
-        
+
         else
                 *tty->flip.flag_buf_ptr++ = 0;
-        
+
         *tty->flip.char_buf_ptr++ = ch;
         tty->flip.count++;
         schedule_delayed_work(&tty->flip.work, 1);
@@ -746,18 +744,18 @@ static inline void sx_receive(struct specialix_board * bp)
         unsigned char count;
 
         func_enter();
-        
+
         if (!(port = sx_get_port(bp, "Receive"))) {
                 dprintk (SX_DEBUG_RX, "Hmm, couldn't find port.\n");
                 func_exit();
                 return;
         }
         tty = port->tty;
-        
+
         count = sx_in(bp, CD186x_RDCR);
         dprintk (SX_DEBUG_RX, "port: %p: count: %d\n", port, count);
         port->hits[count > 8 ? 9 : count]++;
-        
+
         while (count--) {
                 if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
                         printk(KERN_INFO "sx%d: port %d: Working around flip buffer overflow.\n",
@@ -787,7 +785,7 @@ static inline void sx_transmit(struct specialix_board * bp)
         }
         dprintk (SX_DEBUG_TX, "port: %p\n", port);
         tty = port->tty;
-        
+
         if (port->IER & IER_TXEMPTY) {
                 /* FIFO drained */
                 sx_out(bp, CD186x_CAR, port_No(port));
@@ -796,7 +794,7 @@ static inline void sx_transmit(struct specialix_board * bp)
                 func_exit();
                 return;
         }
-        
+
         if ((port->xmit_cnt <= 0 && !port->break_length)
             || tty->stopped || tty->hw_stopped) {
                 sx_out(bp, CD186x_CAR, port_No(port));
@@ -805,7 +803,7 @@ static inline void sx_transmit(struct specialix_board * bp)
                 func_exit();
                 return;
         }
-        
+
         if (port->break_length) {
                 if (port->break_length > 0) {
                         if (port->COR2 & COR2_ETC) {
@@ -831,7 +829,7 @@ static inline void sx_transmit(struct specialix_board * bp)
                 func_exit();
                 return;
         }
-        
+
         count = CD186x_NFIFO;
         do {
                 sx_out(bp, CD186x_TDR, port->xmit_buf[port->xmit_tail++]);
@@ -839,7 +837,7 @@ static inline void sx_transmit(struct specialix_board * bp)
                 if (--port->xmit_cnt <= 0)
                         break;
         } while (--count > 0);
-        
+
         if (port->xmit_cnt <= 0) {
                 sx_out(bp, CD186x_CAR, port_No(port));
                 port->IER &= ~IER_TXRDY;
@@ -862,9 +860,9 @@ static inline void sx_check_modem(struct specialix_board * bp)
         dprintk (SX_DEBUG_SIGNALS, "Modem intr. ");
         if (!(port = sx_get_port(bp, "Modem")))
                 return;
-        
+
         tty = port->tty;
-        
+
         mcr = sx_in(bp, CD186x_MCR);
         printk ("mcr = %02x.\n", mcr);
 
@@ -879,7 +877,7 @@ static inline void sx_check_modem(struct specialix_board * bp)
                         schedule_work(&port->tqueue_hangup);
                 }
         }
-        
+
 #ifdef SPECIALIX_BRAIN_DAMAGED_CTS
         if (mcr & MCR_CTSCHG) {
                 if (sx_in(bp, CD186x_MSVR) & MSVR_CTS) {
@@ -906,7 +904,7 @@ static inline void sx_check_modem(struct specialix_board * bp)
                 sx_out(bp, CD186x_IER, port->IER);
         }
 #endif /* SPECIALIX_BRAIN_DAMAGED_CTS */
-        
+
         /* Clear change bits */
         sx_out(bp, CD186x_MCR, 0);
 }
@@ -940,7 +938,7 @@ static irqreturn_t sx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         while ((++loop < 16) && (status = (sx_in(bp, CD186x_SRSR) &
                                            (SRSR_RREQint |
                                             SRSR_TREQint |
-                                            SRSR_MREQint)))) {  
+                                            SRSR_MREQint)))) {
                 if (status & SRSR_RREQint) {
                         ack = sx_in(bp, CD186x_RRAR);
 
@@ -951,7 +949,7 @@ static irqreturn_t sx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                         else
                                 printk(KERN_ERR "sx%d: status: 0x%x Bad receive ack 0x%02x.\n",
                                        board_No(bp), status, ack);
-                
+
                 } else if (status & SRSR_TREQint) {
                         ack = sx_in(bp, CD186x_TRAR);
 
@@ -963,13 +961,13 @@ static irqreturn_t sx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                 } else if (status & SRSR_MREQint) {
                         ack = sx_in(bp, CD186x_MRAR);
 
-                        if (ack == (SX_ID | GIVR_IT_MODEM)) 
+                        if (ack == (SX_ID | GIVR_IT_MODEM))
                                 sx_check_modem(bp);
                         else
                                 printk(KERN_ERR "sx%d: status: 0x%x Bad modem ack 0x%02x.\n",
                                        board_No(bp), status, ack);
-                
-                } 
+
+                }
 
                 sx_out(bp, CD186x_EOIR, 0);   /* Mark end of interrupt */
         }
@@ -1026,7 +1024,7 @@ static inline int sx_setup_board(struct specialix_board * bp)
 {
         int error;
 
-        if (bp->flags & SX_BOARD_ACTIVE) 
+        if (bp->flags & SX_BOARD_ACTIVE)
                 return 0;
 
         if (bp->flags & SX_BOARD_IS_PCI)
@@ -1034,7 +1032,7 @@ static inline int sx_setup_board(struct specialix_board * bp)
         else
                 error = request_irq(bp->irq, sx_interrupt, SA_INTERRUPT, "specialix IO8+", bp);
 
-        if (error) 
+        if (error)
                 return error;
 
         turn_ints_on (bp);
@@ -1055,7 +1053,7 @@ static inline void sx_shutdown_board(struct specialix_board *bp)
         }
 
         bp->flags &= ~SX_BOARD_ACTIVE;
-        
+
         dprintk (SX_DEBUG_IRQ, "Freeing IRQ%d for board %d.\n",
                  bp->irq, board_No (bp));
         free_irq(bp->irq, bp);
@@ -1068,7 +1066,7 @@ static inline void sx_shutdown_board(struct specialix_board *bp)
 
 
 /*
- * Setting up port characteristics. 
+ * Setting up port characteristics.
  * Must be called with disabled interrupts
  */
 static void sx_change_speed(struct specialix_board *bp, struct specialix_port *port)
@@ -1103,10 +1101,10 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
         spin_unlock_irqrestore(&bp->lock, flags);
         dprintk (SX_DEBUG_TERMIOS, "sx: got MSVR=%02x.\n", port->MSVR);
         baud = C_BAUD(tty);
-        
+
         if (baud & CBAUDEX) {
                 baud &= ~CBAUDEX;
-                if (baud < 1 || baud > 2) 
+                if (baud < 1 || baud > 2)
                         port->tty->termios->c_cflag &= ~CBAUDEX;
                 else
                         baud += 15;
@@ -1117,8 +1115,8 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
                         baud += 2;
         }
-        
-        
+
+
         if (!baud_table[baud]) {
                 /* Drop DTR & exit */
                 dprintk (SX_DEBUG_TERMIOS, "Dropping DTR...  Hmm....\n");
@@ -1127,7 +1125,7 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                         spin_lock_irqsave(&bp->lock, flags);
                         sx_out(bp, CD186x_MSVR, port->MSVR );
                         spin_unlock_irqrestore(&bp->lock, flags);
-                } 
+                }
                 else
                         dprintk (SX_DEBUG_TERMIOS, "Can't drop DTR: no DTR.\n");
                 return;
@@ -1137,9 +1135,9 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                         port ->MSVR |= MSVR_DTR;
                 }
         }
-        
+
         /*
-         * Now we must calculate some speed depended things 
+         * Now we must calculate some speed depended things
          */
 
         /* Set baud rate for port */
@@ -1152,7 +1150,7 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                 tmp = (((SX_OSCFREQ + baud_table[baud]/2) / baud_table[baud] +
                          CD186x_TPC/2) / CD186x_TPC);
 
-        if ((tmp < 0x10) && time_before(again, jiffies)) { 
+        if ((tmp < 0x10) && time_before(again, jiffies)) {
                 again = jiffies + HZ * 60;
                 /* Page 48 of version 2.0 of the CL-CD1865 databook */
                 if (tmp >= 12) {
@@ -1164,27 +1162,27 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                         printk (KERN_INFO "sx%d: Baud rate divisor is %ld. \n"
                                 "Warning: overstressing Cirrus chip. "
                                 "This might not work.\n"
-                                "Read specialix.txt for more info.\n", 
+                                "Read specialix.txt for more info.\n",
                                 port_No (port), tmp);
                 }
         }
         spin_lock_irqsave(&bp->lock, flags);
-        sx_out(bp, CD186x_RBPRH, (tmp >> 8) & 0xff); 
-        sx_out(bp, CD186x_TBPRH, (tmp >> 8) & 0xff); 
-        sx_out(bp, CD186x_RBPRL, tmp & 0xff); 
+        sx_out(bp, CD186x_RBPRH, (tmp >> 8) & 0xff);
+        sx_out(bp, CD186x_TBPRH, (tmp >> 8) & 0xff);
+        sx_out(bp, CD186x_RBPRL, tmp & 0xff);
         sx_out(bp, CD186x_TBPRL, tmp & 0xff);
         spin_unlock_irqrestore(&bp->lock, flags);
         if (port->custom_divisor) {
                 baud = (SX_OSCFREQ + port->custom_divisor/2) / port->custom_divisor;
                 baud = ( baud + 5 ) / 10;
-        } else 
+        } else
                 baud = (baud_table[baud] + 5) / 10;   /* Estimated CPS */
 
         /* Two timer ticks seems enough to wakeup something like SLIP driver */
-        tmp = ((baud + HZ/2) / HZ) * 2 - CD186x_NFIFO;          
+        tmp = ((baud + HZ/2) / HZ) * 2 - CD186x_NFIFO;
         port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
                                               SERIAL_XMIT_SIZE - 1 : tmp);
-        
+
         /* Receiver timeout will be transmission time for 1.5 chars */
         tmp = (SPECIALIX_TPS + SPECIALIX_TPS/2 + baud/2) / baud;
         tmp = (tmp > 0xff) ? 0xff : tmp;
@@ -1205,29 +1203,29 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                 cor1 |= COR1_8BITS;
                 break;
         }
-        
-        if (C_CSTOPB(tty)) 
+
+        if (C_CSTOPB(tty))
                 cor1 |= COR1_2SB;
-        
+
         cor1 |= COR1_IGNORE;
         if (C_PARENB(tty)) {
                 cor1 |= COR1_NORMPAR;
-                if (C_PARODD(tty)) 
+                if (C_PARODD(tty))
                         cor1 |= COR1_ODDP;
-                if (I_INPCK(tty)) 
+                if (I_INPCK(tty))
                         cor1 &= ~COR1_IGNORE;
         }
         /* Set marking of some errors */
         port->mark_mask = RCSR_OE | RCSR_TOUT;
-        if (I_INPCK(tty)) 
+        if (I_INPCK(tty))
                 port->mark_mask |= RCSR_FE | RCSR_PE;
-        if (I_BRKINT(tty) || I_PARMRK(tty)) 
+        if (I_BRKINT(tty) || I_PARMRK(tty))
                 port->mark_mask |= RCSR_BREAK;
-        if (I_IGNPAR(tty)) 
+        if (I_IGNPAR(tty))
                 port->mark_mask &= ~(RCSR_FE | RCSR_PE);
         if (I_IGNBRK(tty)) {
                 port->mark_mask &= ~RCSR_BREAK;
-                if (I_IGNPAR(tty)) 
+                if (I_IGNPAR(tty))
                         /* Real raw mode. Ignore all */
                         port->mark_mask &= ~RCSR_OE;
         }
@@ -1241,7 +1239,7 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                 tty->hw_stopped = !(sx_in(bp, CD186x_MSVR) & (MSVR_CTS|MSVR_DSR));
                 spin_unlock_irqrestore(&bp->lock, flags);
 #else
-                port->COR2 |= COR2_CTSAE; 
+                port->COR2 |= COR2_CTSAE;
 #endif
         }
         /* Enable Software Flow Control. FIXME: I'm not sure about this */
@@ -1264,11 +1262,11 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                 mcor1 |= MCOR1_CDZD;
                 mcor2 |= MCOR2_CDOD;
         }
-        
-        if (C_CREAD(tty)) 
+
+        if (C_CREAD(tty))
                 /* Enable receiver */
                 port->IER |= IER_RXD;
-        
+
         /* Set input FIFO size (1-8 bytes) */
         cor3 |= sx_rxfifo;
         /* Setting up CD186x channel registers */
@@ -1311,11 +1309,11 @@ static int sx_setup_port(struct specialix_board *bp, struct specialix_port *port
                 func_exit();
                 return 0;
         }
-        
+
         if (!port->xmit_buf) {
                 /* We may sleep in get_zeroed_page() */
                 unsigned long tmp;
-                
+
                 if (!(tmp = get_zeroed_page(GFP_KERNEL))) {
                         func_exit();
                         return -ENOMEM;
@@ -1328,10 +1326,10 @@ static int sx_setup_port(struct specialix_board *bp, struct specialix_port *port
                 }
                 port->xmit_buf = (unsigned char *) tmp;
         }
-                
+
         spin_lock_irqsave(&port->lock, flags);
 
-        if (port->tty) 
+        if (port->tty)
                 clear_bit(TTY_IO_ERROR, &port->tty->flags);
 
         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
@@ -1340,7 +1338,7 @@ static int sx_setup_port(struct specialix_board *bp, struct specialix_port *port
 
         spin_unlock_irqrestore(&port->lock, flags);
 
-                
+
         func_exit();
         return 0;
 }
@@ -1352,14 +1350,14 @@ static void sx_shutdown_port(struct specialix_board *bp, struct specialix_port *
         struct tty_struct *tty;
         int i;
         unsigned long flags;
-        
+
         func_enter();
 
         if (!(port->flags & ASYNC_INITIALIZED)) {
                 func_exit();
                 return;
         }
-        
+
         if (sx_debug & SX_DEBUG_FIFO) {
                 dprintk(SX_DEBUG_FIFO, "sx%d: port %d: %ld overruns, FIFO hits [ ",
                         board_No(bp), port_No(port), port->overrun);
@@ -1394,13 +1392,13 @@ static void sx_shutdown_port(struct specialix_board *bp, struct specialix_port *
         if (tty)
                 set_bit(TTY_IO_ERROR, &tty->flags);
         port->flags &= ~ASYNC_INITIALIZED;
-        
-        if (!bp->count) 
+
+        if (!bp->count)
                 sx_shutdown_board(bp);
         func_exit();
 }
 
-        
+
 static int block_til_ready(struct tty_struct *tty, struct file * filp,
                            struct specialix_port *port)
 {
@@ -1427,7 +1425,7 @@ static int block_til_ready(struct tty_struct *tty, struct file * filp,
                         return -ERESTARTSYS;
                 }
         }
-        
+
         /*
          * If non-blocking mode is set, or the port is not enabled,
          * then make the check up front and then exit.
@@ -1477,7 +1475,7 @@ static int block_til_ready(struct tty_struct *tty, struct file * filp,
                         if (port->flags & ASYNC_HUP_NOTIFY)
                                 retval = -EAGAIN;
                         else
-                                retval = -ERESTARTSYS;  
+                                retval = -ERESTARTSYS;
                         break;
                 }
                 if (!(port->flags & ASYNC_CLOSING) &&
@@ -1506,7 +1504,7 @@ static int block_til_ready(struct tty_struct *tty, struct file * filp,
         port->flags |= ASYNC_NORMAL_ACTIVE;
         func_exit();
         return 0;
-}       
+}
 
 
 static int sx_open(struct tty_struct * tty, struct file * filp)
@@ -1526,7 +1524,7 @@ static int sx_open(struct tty_struct * tty, struct file * filp)
                 func_exit();
                 return -ENODEV;
         }
-        
+
         bp = &sx_board[board];
         port = sx_port + board * SX_NPORT + SX_PORT(tty->index);
         port->overrun = 0;
@@ -1557,7 +1555,7 @@ static int sx_open(struct tty_struct * tty, struct file * filp)
                 func_enter();
                 return error;
         }
-        
+
         if ((error = block_til_ready(tty, filp, port))) {
                 func_enter();
                 return error;
@@ -1574,7 +1572,7 @@ static void sx_close(struct tty_struct * tty, struct file * filp)
         struct specialix_board *bp;
         unsigned long flags;
         unsigned long timeout;
-        
+
         func_enter();
         if (!port || sx_paranoia_check(port, tty->name, "close")) {
                 func_exit();
@@ -1587,7 +1585,7 @@ static void sx_close(struct tty_struct * tty, struct file * filp)
                 func_exit();
                 return;
         }
-        
+
         bp = port_Board(port);
         if ((tty->count == 1) && (port->count != 1)) {
                 printk(KERN_ERR "sx%d: sx_close: bad port count;"
@@ -1607,7 +1605,7 @@ static void sx_close(struct tty_struct * tty, struct file * filp)
         }
         port->flags |= ASYNC_CLOSING;
         /*
-         * Now we wait for the transmit buffer to clear; and we notify 
+         * Now we wait for the transmit buffer to clear; and we notify
          * the line discipline to only process XON/XOFF characters.
          */
         tty->closing = 1;
@@ -1681,7 +1679,7 @@ static void sx_close(struct tty_struct * tty, struct file * filp)
 }
 
 
-static int sx_write(struct tty_struct * tty, 
+static int sx_write(struct tty_struct * tty,
                     const unsigned char *buf, int count)
 {
         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
@@ -1694,7 +1692,7 @@ static int sx_write(struct tty_struct * tty,
                 func_exit();
                 return 0;
         }
-        
+
         bp = port_Board(port);
 
         if (!tty || !port->xmit_buf || !tmp_buf) {
@@ -1824,7 +1822,7 @@ static int sx_chars_in_buffer(struct tty_struct *tty)
         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
 
         func_enter();
-        
+
         if (sx_paranoia_check(port, tty->name, "sx_chars_in_buffer")) {
                 func_exit();
                 return 0;
@@ -1881,13 +1879,13 @@ static int sx_tiocmget(struct tty_struct *tty, struct file *file)
                 port_No(port), status, sx_in (bp, CD186x_CAR));
         dprintk (SX_DEBUG_INIT, "sx_port = %p, port = %p\n", sx_port, port);
         if (SX_CRTSCTS(port->tty)) {
-                result  = /*   (status & MSVR_RTS) ? */ TIOCM_DTR /* : 0) */ 
+                result  = /*   (status & MSVR_RTS) ? */ TIOCM_DTR /* : 0) */
                           |   ((status & MSVR_DTR) ? TIOCM_RTS : 0)
                           |   ((status & MSVR_CD)  ? TIOCM_CAR : 0)
                           |/* ((status & MSVR_DSR) ? */ TIOCM_DSR /* : 0) */
                           |   ((status & MSVR_CTS) ? TIOCM_CTS : 0);
         } else {
-                result  = /*   (status & MSVR_RTS) ? */ TIOCM_RTS /* : 0) */ 
+                result  = /*   (status & MSVR_RTS) ? */ TIOCM_RTS /* : 0) */
                           |   ((status & MSVR_DTR) ? TIOCM_DTR : 0)
                           |   ((status & MSVR_CD)  ? TIOCM_CAR : 0)
                           |/* ((status & MSVR_DSR) ? */ TIOCM_DSR /* : 0) */
@@ -1955,7 +1953,7 @@ static inline void sx_send_break(struct specialix_port * port, unsigned long len
 {
         struct specialix_board *bp = port_Board(port);
         unsigned long flags;
-        
+
         func_enter();
 
         spin_lock_irqsave (&port->lock, flags);
@@ -1996,8 +1994,8 @@ static inline int sx_set_serial_info(struct specialix_port * port,
                 func_enter();
                 return -EFAULT;
         }
-        
-#if 0   
+
+#if 0
         if ((tmp.irq != bp->irq) ||
             (tmp.port != bp->base) ||
             (tmp.type != PORT_CIRRUS) ||
@@ -2008,12 +2006,12 @@ static inline int sx_set_serial_info(struct specialix_port * port,
                 func_exit();
                 return -EINVAL;
         }
-#endif  
+#endif
 
         change_speed = ((port->flags & ASYNC_SPD_MASK) !=
                         (tmp.flags & ASYNC_SPD_MASK));
         change_speed |= (tmp.custom_divisor != port->custom_divisor);
-        
+
         if (!capable(CAP_SYS_ADMIN)) {
                 if ((tmp.close_delay != port->close_delay) ||
                     (tmp.closing_wait != port->closing_wait) ||
@@ -2045,7 +2043,7 @@ static inline int sx_get_serial_info(struct specialix_port * port,
 {
         struct serial_struct tmp;
         struct specialix_board *bp = port_Board(port);
-        
+
         func_enter();
 
         /*
@@ -2074,7 +2072,7 @@ static inline int sx_get_serial_info(struct specialix_port * port,
 }
 
 
-static int sx_ioctl(struct tty_struct * tty, struct file * filp, 
+static int sx_ioctl(struct tty_struct * tty, struct file * filp,
                     unsigned int cmd, unsigned long arg)
 {
         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
@@ -2087,7 +2085,7 @@ static int sx_ioctl(struct tty_struct * tty, struct file * filp,
                 func_exit();
                 return -ENODEV;
         }
-        
+
         switch (cmd) {
          case TCSBRK:   /* SVID version: non-zero arg --> no break */
                 retval = tty_check_change(tty);
@@ -2129,7 +2127,7 @@ static int sx_ioctl(struct tty_struct * tty, struct file * filp,
          case TIOCGSERIAL:
                  func_exit();
                 return sx_get_serial_info(port, argp);
-         case TIOCSSERIAL:      
+         case TIOCSSERIAL:
                  func_exit();
                 return sx_set_serial_info(port, argp);
          default:
@@ -2153,16 +2151,16 @@ static void sx_throttle(struct tty_struct * tty)
                 func_exit();
                 return;
         }
-        
+
         bp = port_Board(port);
-        
+
         /* Use DTR instead of RTS ! */
-        if (SX_CRTSCTS (tty)) 
+        if (SX_CRTSCTS (tty))
                 port->MSVR &= ~MSVR_DTR;
         else {
                 /* Auch!!! I think the system shouldn't call this then. */
                 /* Or maybe we're supposed (allowed?) to do our side of hw
-                   handshake anyway, even when hardware handshake is off. 
+                   handshake anyway, even when hardware handshake is off.
                    When you see this in your logs, please report.... */
                 printk (KERN_ERR "sx%d: Need to throttle, but can't (hardware hs is off)\n",
                          port_No (port));
@@ -2193,14 +2191,14 @@ static void sx_unthrottle(struct tty_struct * tty)
         unsigned long flags;
 
         func_enter();
-                                
+
         if (sx_paranoia_check(port, tty->name, "sx_unthrottle")) {
                 func_exit();
                 return;
         }
-        
+
         bp = port_Board(port);
-        
+
         spin_lock_irqsave(&port->lock, flags);
         /* XXXX Use DTR INSTEAD???? */
         if (SX_CRTSCTS(tty)) {
@@ -2234,14 +2232,14 @@ static void sx_stop(struct tty_struct * tty)
         unsigned long flags;
 
         func_enter();
-        
+
         if (sx_paranoia_check(port, tty->name, "sx_stop")) {
                 func_exit();
                 return;
         }
 
         bp = port_Board(port);
-        
+
         spin_lock_irqsave(&port->lock, flags);
         port->IER &= ~IER_TXRDY;
         spin_lock_irqsave(&bp->lock, flags);
@@ -2261,14 +2259,14 @@ static void sx_start(struct tty_struct * tty)
         unsigned long flags;
 
         func_enter();
-                                
+
         if (sx_paranoia_check(port, tty->name, "sx_start")) {
                 func_exit();
                 return;
         }
-        
+
         bp = port_Board(port);
-        
+
         spin_lock_irqsave(&port->lock, flags);
         if (port->xmit_cnt && port->xmit_buf && !(port->IER & IER_TXRDY)) {
                 port->IER |= IER_TXRDY;
@@ -2290,13 +2288,13 @@ static void sx_start(struct tty_struct * tty)
  *
  *      serial interrupt routine -> (workqueue) ->
  *      do_sx_hangup() -> tty->hangup() -> sx_hangup()
- * 
+ *
  */
 static void do_sx_hangup(void *private_)
 {
         struct specialix_port   *port = (struct specialix_port *) private_;
         struct tty_struct       *tty;
-        
+
         func_enter();
 
         tty = port->tty;
@@ -2319,9 +2317,9 @@ static void sx_hangup(struct tty_struct * tty)
                 func_exit();
                 return;
         }
-        
+
         bp = port_Board(port);
-        
+
         sx_shutdown_port(bp, port);
         spin_lock_irqsave(&port->lock, flags);
         port->event = 0;
@@ -2346,10 +2344,10 @@ static void sx_set_termios(struct tty_struct * tty, struct termios * old_termios
         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
         unsigned long flags;
         struct specialix_board  * bp;
-                                
+
         if (sx_paranoia_check(port, tty->name, "sx_set_termios"))
                 return;
-        
+
         if (tty->termios->c_cflag == old_termios->c_cflag &&
             tty->termios->c_iflag == old_termios->c_iflag)
                 return;
@@ -2420,7 +2418,7 @@ static int sx_init_drivers(void)
                 func_exit();
                 return 1;
         }
-        
+
         if (!(tmp_buf = (unsigned char *) get_zeroed_page(GFP_KERNEL))) {
                 printk(KERN_ERR "sx: Couldn't get free page.\n");
                 put_tty_driver(specialix_driver);
@@ -2457,7 +2455,7 @@ static int sx_init_drivers(void)
                 init_waitqueue_head(&sx_port[i].close_wait);
                 spin_lock_init(&sx_port[i].lock);
         }
-        
+
         func_exit();
         return 0;
 }
@@ -2472,8 +2470,8 @@ static void sx_release_drivers(void)
         func_exit();
 }
 
-/* 
- * This routine must be called by kernel at boot time 
+/*
+ * This routine must be called by kernel at boot time
  */
 static int __init specialix_init(void)
 {
@@ -2489,7 +2487,7 @@ static int __init specialix_init(void)
 #else
         printk (KERN_INFO "sx: DTR/RTS pin is RTS when CRTSCTS is on.\n");
 #endif
-        
+
         for (i = 0; i < SX_NBOARD; i++)
                 sx_board[i].lock = SPIN_LOCK_UNLOCKED;
 
@@ -2498,7 +2496,7 @@ static int __init specialix_init(void)
                 return -EIO;
         }
 
-        for (i = 0; i < SX_NBOARD; i++) 
+        for (i = 0; i < SX_NBOARD; i++)
                 if (sx_board[i].base && !sx_probe(&sx_board[i]))
                         found++;
 
@@ -2512,8 +2510,8 @@ static int __init specialix_init(void)
                                 i++;
                                 continue;
                         }
-                        pdev = pci_find_device (PCI_VENDOR_ID_SPECIALIX, 
-                                                PCI_DEVICE_ID_SPECIALIX_IO8, 
+                        pdev = pci_find_device (PCI_VENDOR_ID_SPECIALIX,
+                                                PCI_DEVICE_ID_SPECIALIX_IO8,
                                                 pdev);
                         if (!pdev) break;
 
@@ -2557,10 +2555,10 @@ module_param(sx_poll, int, 0);
 /*
  * You can setup up to 4 boards.
  * by specifying "iobase=0xXXX,0xXXX ..." as insmod parameter.
- * You should specify the IRQs too in that case "irq=....,...". 
- * 
+ * You should specify the IRQs too in that case "irq=....,...".
+ *
  * More than 4 boards in one computer is not possible, as the card can
- * only use 4 different interrupts. 
+ * only use 4 different interrupts.
  *
  */
 static int __init specialix_init_module(void)
@@ -2583,16 +2581,16 @@ static int __init specialix_init_module(void)
 
         return specialix_init();
 }
-        
+
 static void __exit specialix_exit_module(void)
 {
         int i;
-        
+
         func_enter();
 
         sx_release_drivers();
         for (i = 0; i < SX_NBOARD; i++)
-                if (sx_board[i].flags & SX_BOARD_PRESENT) 
+                if (sx_board[i].flags & SX_BOARD_PRESENT)
                         sx_release_io_range(&sx_board[i]);
 #ifdef SPECIALIX_TIMER
         del_timer (&missed_irq_timer);
diff --git a/drivers/char/stallion.c b/drivers/char/stallion.c
index 951545a6ef2d..1c686414e0a1 100644
--- a/drivers/char/stallion.c
+++ b/drivers/char/stallion.c
@@ -3095,7 +3095,9 @@ static int __init stl_init(void)
                 devfs_mk_cdev(MKDEV(STL_SIOMEMMAJOR, i),
                                 S_IFCHR|S_IRUSR|S_IWUSR,
                                 "staliomem/%d", i);
-                class_device_create(stallion_class, MKDEV(STL_SIOMEMMAJOR, i), NULL, "staliomem%d", i);
+                class_device_create(stallion_class, NULL,
+                                    MKDEV(STL_SIOMEMMAJOR, i), NULL,
+                                    "staliomem%d", i);
         }
 
         stl_serial->owner = THIS_MODULE;
diff --git a/drivers/char/synclink.c b/drivers/char/synclink.c
index ea2d54be4843..0133dc0e25d0 100644
--- a/drivers/char/synclink.c
+++ b/drivers/char/synclink.c
@@ -912,6 +912,7 @@ MODULE_DEVICE_TABLE(pci, synclink_pci_tbl);
 MODULE_LICENSE("GPL");
 
 static struct pci_driver synclink_pci_driver = {
+        .owner          = THIS_MODULE,
         .name           = "synclink",
         .id_table       = synclink_pci_tbl,
         .probe          = synclink_init_one,
diff --git a/drivers/char/synclinkmp.c b/drivers/char/synclinkmp.c
index 6fb165cf8a61..f185724448b1 100644
--- a/drivers/char/synclinkmp.c
+++ b/drivers/char/synclinkmp.c
@@ -500,6 +500,7 @@ MODULE_DEVICE_TABLE(pci, synclinkmp_pci_tbl);
 MODULE_LICENSE("GPL");
 
 static struct pci_driver synclinkmp_pci_driver = {
+        .owner          = THIS_MODULE,
         .name           = "synclinkmp",
         .id_table       = synclinkmp_pci_tbl,
         .probe          = synclinkmp_init_one,
diff --git a/drivers/char/tb0219.c b/drivers/char/tb0219.c
index eb7058cbf015..24355b23b2ca 100644
--- a/drivers/char/tb0219.c
+++ b/drivers/char/tb0219.c
@@ -17,7 +17,7 @@
  *  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/device.h>
+#include <linux/platform_device.h>
 #include <linux/fs.h>
 #include <linux/init.h>
 #include <linux/module.h>
diff --git a/drivers/char/tipar.c b/drivers/char/tipar.c
index ec78d2f161f7..41a94bc79f67 100644
--- a/drivers/char/tipar.c
+++ b/drivers/char/tipar.c
@@ -436,7 +436,7 @@ tipar_register(int nr, struct parport *port)
                 goto out;
         }
 
-        class_device_create(tipar_class, MKDEV(TIPAR_MAJOR,
+        class_device_create(tipar_class, NULL, MKDEV(TIPAR_MAJOR,
                         TIPAR_MINOR + nr), NULL, "par%d", nr);
         /* Use devfs, tree: /dev/ticables/par/[0..2] */
         err = devfs_mk_cdev(MKDEV(TIPAR_MAJOR, TIPAR_MINOR + nr),
diff --git a/drivers/char/tlclk.c b/drivers/char/tlclk.c
new file mode 100644
index 000000000000..12167c04fa4c
--- /dev/null
+++ b/drivers/char/tlclk.c
@@ -0,0 +1,897 @@
+/*
+ * Telecom Clock driver for Intel NetStructure(tm) MPCBL0010
+ *
+ * Copyright (C) 2005 Kontron Canada
+ *
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * 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, GOOD TITLE or
+ * NON INFRINGEMENT.  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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Send feedback to <sebastien.bouchard@ca.kontron.com> and the current
+ * Maintainer  <mark.gross@intel.com>
+ *
+ * Description : This is the TELECOM CLOCK module driver for the ATCA
+ * MPCBL0010 ATCA computer.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>       /* printk() */
+#include <linux/fs.h>           /* everything... */
+#include <linux/errno.h>        /* error codes */
+#include <linux/delay.h>        /* udelay */
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/interrupt.h>
+#include <linux/spinlock.h>
+#include <linux/timer.h>
+#include <linux/sysfs.h>
+#include <linux/device.h>
+#include <linux/miscdevice.h>
+#include <linux/platform_device.h>
+#include <asm/io.h>             /* inb/outb */
+#include <asm/uaccess.h>
+
+MODULE_AUTHOR("Sebastien Bouchard <sebastien.bouchard@ca.kontron.com>");
+MODULE_LICENSE("GPL");
+
+/*Hardware Reset of the PLL */
+#define RESET_ON        0x00
+#define RESET_OFF       0x01
+
+/* MODE SELECT */
+#define NORMAL_MODE     0x00
+#define HOLDOVER_MODE   0x10
+#define FREERUN_MODE    0x20
+
+/* FILTER SELECT */
+#define FILTER_6HZ      0x04
+#define FILTER_12HZ     0x00
+
+/* SELECT REFERENCE FREQUENCY */
+#define REF_CLK1_8kHz           0x00
+#define REF_CLK2_19_44MHz       0x02
+
+/* Select primary or secondary redundant clock */
+#define PRIMARY_CLOCK   0x00
+#define SECONDARY_CLOCK 0x01
+
+/* CLOCK TRANSMISSION DEFINE */
+#define CLK_8kHz        0xff
+#define CLK_16_384MHz   0xfb
+
+#define CLK_1_544MHz    0x00
+#define CLK_2_048MHz    0x01
+#define CLK_4_096MHz    0x02
+#define CLK_6_312MHz    0x03
+#define CLK_8_192MHz    0x04
+#define CLK_19_440MHz   0x06
+
+#define CLK_8_592MHz    0x08
+#define CLK_11_184MHz   0x09
+#define CLK_34_368MHz   0x0b
+#define CLK_44_736MHz   0x0a
+
+/* RECEIVED REFERENCE */
+#define AMC_B1 0
+#define AMC_B2 1
+
+/* HARDWARE SWITCHING DEFINE */
+#define HW_ENABLE       0x80
+#define HW_DISABLE      0x00
+
+/* HARDWARE SWITCHING MODE DEFINE */
+#define PLL_HOLDOVER    0x40
+#define LOST_CLOCK      0x00
+
+/* ALARMS DEFINE */
+#define UNLOCK_MASK     0x10
+#define HOLDOVER_MASK   0x20
+#define SEC_LOST_MASK   0x40
+#define PRI_LOST_MASK   0x80
+
+/* INTERRUPT CAUSE DEFINE */
+
+#define PRI_LOS_01_MASK         0x01
+#define PRI_LOS_10_MASK         0x02
+
+#define SEC_LOS_01_MASK         0x04
+#define SEC_LOS_10_MASK         0x08
+
+#define HOLDOVER_01_MASK        0x10
+#define HOLDOVER_10_MASK        0x20
+
+#define UNLOCK_01_MASK          0x40
+#define UNLOCK_10_MASK          0x80
+
+struct tlclk_alarms {
+        __u32 lost_clocks;
+        __u32 lost_primary_clock;
+        __u32 lost_secondary_clock;
+        __u32 primary_clock_back;
+        __u32 secondary_clock_back;
+        __u32 switchover_primary;
+        __u32 switchover_secondary;
+        __u32 pll_holdover;
+        __u32 pll_end_holdover;
+        __u32 pll_lost_sync;
+        __u32 pll_sync;
+};
+/* Telecom clock I/O register definition */
+#define TLCLK_BASE 0xa08
+#define TLCLK_REG0 TLCLK_BASE
+#define TLCLK_REG1 (TLCLK_BASE+1)
+#define TLCLK_REG2 (TLCLK_BASE+2)
+#define TLCLK_REG3 (TLCLK_BASE+3)
+#define TLCLK_REG4 (TLCLK_BASE+4)
+#define TLCLK_REG5 (TLCLK_BASE+5)
+#define TLCLK_REG6 (TLCLK_BASE+6)
+#define TLCLK_REG7 (TLCLK_BASE+7)
+
+#define SET_PORT_BITS(port, mask, val) outb(((inb(port) & mask) | val), port)
+
+/* 0 = Dynamic allocation of the major device number */
+#define TLCLK_MAJOR 0
+
+/* sysfs interface definition:
+Upon loading the driver will create a sysfs directory under
+/sys/devices/platform/telco_clock.
+
+This directory exports the following interfaces.  There operation is
+documented in the MCPBL0010 TPS under the Telecom Clock API section, 11.4.
+alarms                          :
+current_ref                     :
+enable_clk3a_output             :
+enable_clk3b_output             :
+enable_clka0_output             :
+enable_clka1_output             :
+enable_clkb0_output             :
+enable_clkb1_output             :
+filter_select                   :
+hardware_switching              :
+hardware_switching_mode         :
+interrupt_switch                :
+mode_select                     :
+refalign                        :
+reset                           :
+select_amcb1_transmit_clock     :
+select_amcb2_transmit_clock     :
+select_redundant_clock          :
+select_ref_frequency            :
+test_mode                       :
+
+All sysfs interfaces are integers in hex format, i.e echo 99 > refalign
+has the same effect as echo 0x99 > refalign.
+*/
+
+static unsigned int telclk_interrupt;
+
+static int int_events;          /* Event that generate a interrupt */
+static int got_event;           /* if events processing have been done */
+
+static void switchover_timeout(unsigned long data);
+static struct timer_list switchover_timer =
+        TIMER_INITIALIZER(switchover_timeout , 0, 0);
+
+static struct tlclk_alarms *alarm_events;
+
+static DEFINE_SPINLOCK(event_lock);
+
+static int tlclk_major = TLCLK_MAJOR;
+
+static irqreturn_t tlclk_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+
+static DECLARE_WAIT_QUEUE_HEAD(wq);
+
+static int tlclk_open(struct inode *inode, struct file *filp)
+{
+        int result;
+
+        /* Make sure there is no interrupt pending while
+         * initialising interrupt handler */
+        inb(TLCLK_REG6);
+
+        /* This device is wired through the FPGA IO space of the ATCA blade
+         * we can't share this IRQ */
+        result = request_irq(telclk_interrupt, &tlclk_interrupt,
+                             SA_INTERRUPT, "telco_clock", tlclk_interrupt);
+        if (result == -EBUSY) {
+                printk(KERN_ERR "telco_clock: Interrupt can't be reserved!\n");
+                return -EBUSY;
+        }
+        inb(TLCLK_REG6);        /* Clear interrupt events */
+
+        return 0;
+}
+
+static int tlclk_release(struct inode *inode, struct file *filp)
+{
+        free_irq(telclk_interrupt, tlclk_interrupt);
+
+        return 0;
+}
+
+ssize_t tlclk_read(struct file *filp, char __user *buf, size_t count,
+                loff_t *f_pos)
+{
+        if (count < sizeof(struct tlclk_alarms))
+                return -EIO;
+
+        wait_event_interruptible(wq, got_event);
+        if (copy_to_user(buf, alarm_events, sizeof(struct tlclk_alarms)))
+                return -EFAULT;
+
+        memset(alarm_events, 0, sizeof(struct tlclk_alarms));
+        got_event = 0;
+
+        return  sizeof(struct tlclk_alarms);
+}
+
+ssize_t tlclk_write(struct file *filp, const char __user *buf, size_t count,
+            loff_t *f_pos)
+{
+        return 0;
+}
+
+static struct file_operations tlclk_fops = {
+        .read = tlclk_read,
+        .write = tlclk_write,
+        .open = tlclk_open,
+        .release = tlclk_release,
+
+};
+
+static struct miscdevice tlclk_miscdev = {
+        .minor = MISC_DYNAMIC_MINOR,
+        .name = "telco_clock",
+        .fops = &tlclk_fops,
+};
+
+static ssize_t show_current_ref(struct device *d,
+                struct device_attribute *attr, char *buf)
+{
+        unsigned long ret_val;
+        unsigned long flags;
+
+        spin_lock_irqsave(&event_lock, flags);
+        ret_val = ((inb(TLCLK_REG1) & 0x08) >> 3);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return sprintf(buf, "0x%lX\n", ret_val);
+}
+
+static DEVICE_ATTR(current_ref, S_IRUGO, show_current_ref, NULL);
+
+
+static ssize_t show_interrupt_switch(struct device *d,
+                struct device_attribute *attr, char *buf)
+{
+        unsigned long ret_val;
+        unsigned long flags;
+
+        spin_lock_irqsave(&event_lock, flags);
+        ret_val = inb(TLCLK_REG6);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return sprintf(buf, "0x%lX\n", ret_val);
+}
+
+static DEVICE_ATTR(interrupt_switch, S_IRUGO,
+                show_interrupt_switch, NULL);
+
+static ssize_t show_alarms(struct device *d,
+                struct device_attribute *attr,  char *buf)
+{
+        unsigned long ret_val;
+        unsigned long flags;
+
+        spin_lock_irqsave(&event_lock, flags);
+        ret_val = (inb(TLCLK_REG2) & 0xf0);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return sprintf(buf, "0x%lX\n", ret_val);
+}
+
+static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
+
+static ssize_t store_enable_clk3b_output(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, ": tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG3, 0x7f, val << 7);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(enable_clk3b_output, S_IWUGO, NULL,
+                store_enable_clk3b_output);
+
+static ssize_t store_enable_clk3a_output(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long flags;
+        unsigned long tmp;
+        unsigned char val;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG3, 0xbf, val << 6);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(enable_clk3a_output, S_IWUGO, NULL,
+                store_enable_clk3a_output);
+
+static ssize_t store_enable_clkb1_output(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long flags;
+        unsigned long tmp;
+        unsigned char val;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG2, 0xf7, val << 3);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(enable_clkb1_output, S_IWUGO, NULL,
+                store_enable_clkb1_output);
+
+
+static ssize_t store_enable_clka1_output(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long flags;
+        unsigned long tmp;
+        unsigned char val;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG2, 0xfb, val << 2);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(enable_clka1_output, S_IWUGO, NULL,
+                store_enable_clka1_output);
+
+static ssize_t store_enable_clkb0_output(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long flags;
+        unsigned long tmp;
+        unsigned char val;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG2, 0xfd, val << 1);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(enable_clkb0_output, S_IWUGO, NULL,
+                store_enable_clkb0_output);
+
+static ssize_t store_enable_clka0_output(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long flags;
+        unsigned long tmp;
+        unsigned char val;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG2, 0xfe, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(enable_clka0_output, S_IWUGO, NULL,
+                store_enable_clka0_output);
+
+static ssize_t store_test_mode(struct device *d,
+                struct device_attribute *attr,  const char *buf, size_t count)
+{
+        unsigned long flags;
+        unsigned long tmp;
+        unsigned char val;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG4, 0xfd, 2);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(test_mode, S_IWUGO, NULL, store_test_mode);
+
+static ssize_t store_select_amcb2_transmit_clock(struct device *d,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long flags;
+        unsigned long tmp;
+        unsigned char val;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+                if ((val == CLK_8kHz) || (val == CLK_16_384MHz)) {
+                        SET_PORT_BITS(TLCLK_REG3, 0xc7, 0x28);
+                        SET_PORT_BITS(TLCLK_REG1, 0xfb, ~val);
+                } else if (val >= CLK_8_592MHz) {
+                        SET_PORT_BITS(TLCLK_REG3, 0xc7, 0x38);
+                        switch (val) {
+                        case CLK_8_592MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 1);
+                                break;
+                        case CLK_11_184MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 0);
+                                break;
+                        case CLK_34_368MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 3);
+                                break;
+                        case CLK_44_736MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 2);
+                                break;
+                        }
+                } else
+                        SET_PORT_BITS(TLCLK_REG3, 0xc7, val << 3);
+
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(select_amcb2_transmit_clock, S_IWUGO, NULL,
+        store_select_amcb2_transmit_clock);
+
+static ssize_t store_select_amcb1_transmit_clock(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+                if ((val == CLK_8kHz) || (val == CLK_16_384MHz)) {
+                        SET_PORT_BITS(TLCLK_REG3, 0xf8, 0x5);
+                        SET_PORT_BITS(TLCLK_REG1, 0xfb, ~val);
+                } else if (val >= CLK_8_592MHz) {
+                        SET_PORT_BITS(TLCLK_REG3, 0xf8, 0x7);
+                        switch (val) {
+                        case CLK_8_592MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 1);
+                                break;
+                        case CLK_11_184MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 0);
+                                break;
+                        case CLK_34_368MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 3);
+                                break;
+                        case CLK_44_736MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 2);
+                                break;
+                        }
+                } else
+                        SET_PORT_BITS(TLCLK_REG3, 0xf8, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(select_amcb1_transmit_clock, S_IWUGO, NULL,
+                store_select_amcb1_transmit_clock);
+
+static ssize_t store_select_redundant_clock(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG1, 0xfe, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(select_redundant_clock, S_IWUGO, NULL,
+                store_select_redundant_clock);
+
+static ssize_t store_select_ref_frequency(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG1, 0xfd, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(select_ref_frequency, S_IWUGO, NULL,
+                store_select_ref_frequency);
+
+static ssize_t store_filter_select(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG0, 0xfb, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(filter_select, S_IWUGO, NULL, store_filter_select);
+
+static ssize_t store_hardware_switching_mode(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG0, 0xbf, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(hardware_switching_mode, S_IWUGO, NULL,
+                store_hardware_switching_mode);
+
+static ssize_t store_hardware_switching(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG0, 0x7f, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(hardware_switching, S_IWUGO, NULL,
+                store_hardware_switching);
+
+static ssize_t store_refalign (struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG0, 0xf7, 0);
+        udelay(2);
+        SET_PORT_BITS(TLCLK_REG0, 0xf7, 0x08);
+        udelay(2);
+        SET_PORT_BITS(TLCLK_REG0, 0xf7, 0);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(refalign, S_IWUGO, NULL, store_refalign);
+
+static ssize_t store_mode_select (struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG0, 0xcf, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(mode_select, S_IWUGO, NULL, store_mode_select);
+
+static ssize_t store_reset (struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG4, 0xfd, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(reset, S_IWUGO, NULL, store_reset);
+
+static struct attribute *tlclk_sysfs_entries[] = {
+        &dev_attr_current_ref.attr,
+        &dev_attr_interrupt_switch.attr,
+        &dev_attr_alarms.attr,
+        &dev_attr_enable_clk3a_output.attr,
+        &dev_attr_enable_clk3b_output.attr,
+        &dev_attr_enable_clkb1_output.attr,
+        &dev_attr_enable_clka1_output.attr,
+        &dev_attr_enable_clkb0_output.attr,
+        &dev_attr_enable_clka0_output.attr,
+        &dev_attr_test_mode.attr,
+        &dev_attr_select_amcb1_transmit_clock.attr,
+        &dev_attr_select_amcb2_transmit_clock.attr,
+        &dev_attr_select_redundant_clock.attr,
+        &dev_attr_select_ref_frequency.attr,
+        &dev_attr_filter_select.attr,
+        &dev_attr_hardware_switching_mode.attr,
+        &dev_attr_hardware_switching.attr,
+        &dev_attr_refalign.attr,
+        &dev_attr_mode_select.attr,
+        &dev_attr_reset.attr,
+        NULL
+};
+
+static struct attribute_group tlclk_attribute_group = {
+        .name = NULL,           /* put in device directory */
+        .attrs = tlclk_sysfs_entries,
+};
+
+static struct platform_device *tlclk_device;
+
+static int __init tlclk_init(void)
+{
+        int ret;
+
+        ret = register_chrdev(tlclk_major, "telco_clock", &tlclk_fops);
+        if (ret < 0) {
+                printk(KERN_ERR "telco_clock: can't get major! %d\n", tlclk_major);
+                return ret;
+        }
+        alarm_events = kzalloc( sizeof(struct tlclk_alarms), GFP_KERNEL);
+        if (!alarm_events)
+                goto out1;
+
+        /* Read telecom clock IRQ number (Set by BIOS) */
+        if (!request_region(TLCLK_BASE, 8, "telco_clock")) {
+                printk(KERN_ERR "tlclk: request_region failed! 0x%X\n",
+                        TLCLK_BASE);
+                ret = -EBUSY;
+                goto out2;
+        }
+        telclk_interrupt = (inb(TLCLK_REG7) & 0x0f);
+
+        if (0x0F == telclk_interrupt ) { /* not MCPBL0010 ? */
+                printk(KERN_ERR "telclk_interrup = 0x%x non-mcpbl0010 hw\n",
+                        telclk_interrupt);
+                ret = -ENXIO;
+                goto out3;
+        }
+
+        init_timer(&switchover_timer);
+
+        ret = misc_register(&tlclk_miscdev);
+        if (ret < 0) {
+                printk(KERN_ERR " misc_register retruns %d\n", ret);
+                ret = -EBUSY;
+                goto out3;
+        }
+
+        tlclk_device = platform_device_register_simple("telco_clock",
+                                -1, NULL, 0);
+        if (!tlclk_device) {
+                printk(KERN_ERR " platform_device_register retruns 0x%X\n",
+                        (unsigned int) tlclk_device);
+                ret = -EBUSY;
+                goto out4;
+        }
+
+        ret = sysfs_create_group(&tlclk_device->dev.kobj,
+                        &tlclk_attribute_group);
+        if (ret) {
+                printk(KERN_ERR "failed to create sysfs device attributes\n");
+                sysfs_remove_group(&tlclk_device->dev.kobj,
+                        &tlclk_attribute_group);
+                goto out5;
+        }
+
+        return 0;
+out5:
+        platform_device_unregister(tlclk_device);
+out4:
+        misc_deregister(&tlclk_miscdev);
+out3:
+        release_region(TLCLK_BASE, 8);
+out2:
+        kfree(alarm_events);
+out1:
+        unregister_chrdev(tlclk_major, "telco_clock");
+        return ret;
+}
+
+static void __exit tlclk_cleanup(void)
+{
+        sysfs_remove_group(&tlclk_device->dev.kobj, &tlclk_attribute_group);
+        platform_device_unregister(tlclk_device);
+        misc_deregister(&tlclk_miscdev);
+        unregister_chrdev(tlclk_major, "telco_clock");
+
+        release_region(TLCLK_BASE, 8);
+        del_timer_sync(&switchover_timer);
+        kfree(alarm_events);
+
+}
+
+static void switchover_timeout(unsigned long data)
+{
+        if ((data & 1)) {
+                if ((inb(TLCLK_REG1) & 0x08) != (data & 0x08))
+                        alarm_events->switchover_primary++;
+        } else {
+                if ((inb(TLCLK_REG1) & 0x08) != (data & 0x08))
+                        alarm_events->switchover_secondary++;
+        }
+
+        /* Alarm processing is done, wake up read task */
+        del_timer(&switchover_timer);
+        got_event = 1;
+        wake_up(&wq);
+}
+
+static irqreturn_t tlclk_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&event_lock, flags);
+        /* Read and clear interrupt events */
+        int_events = inb(TLCLK_REG6);
+
+        /* Primary_Los changed from 0 to 1 ? */
+        if (int_events & PRI_LOS_01_MASK) {
+                if (inb(TLCLK_REG2) & SEC_LOST_MASK)
+                        alarm_events->lost_clocks++;
+                else
+                        alarm_events->lost_primary_clock++;
+        }
+
+        /* Primary_Los changed from 1 to 0 ? */
+        if (int_events & PRI_LOS_10_MASK) {
+                alarm_events->primary_clock_back++;
+                SET_PORT_BITS(TLCLK_REG1, 0xFE, 1);
+        }
+        /* Secondary_Los changed from 0 to 1 ? */
+        if (int_events & SEC_LOS_01_MASK) {
+                if (inb(TLCLK_REG2) & PRI_LOST_MASK)
+                        alarm_events->lost_clocks++;
+                else
+                        alarm_events->lost_secondary_clock++;
+        }
+        /* Secondary_Los changed from 1 to 0 ? */
+        if (int_events & SEC_LOS_10_MASK) {
+                alarm_events->secondary_clock_back++;
+                SET_PORT_BITS(TLCLK_REG1, 0xFE, 0);
+        }
+        if (int_events & HOLDOVER_10_MASK)
+                alarm_events->pll_end_holdover++;
+
+        if (int_events & UNLOCK_01_MASK)
+                alarm_events->pll_lost_sync++;
+
+        if (int_events & UNLOCK_10_MASK)
+                alarm_events->pll_sync++;
+
+        /* Holdover changed from 0 to 1 ? */
+        if (int_events & HOLDOVER_01_MASK) {
+                alarm_events->pll_holdover++;
+
+                /* TIMEOUT in ~10ms */
+                switchover_timer.expires = jiffies + msecs_to_jiffies(10);
+                switchover_timer.data = inb(TLCLK_REG1);
+                add_timer(&switchover_timer);
+        } else {
+                got_event = 1;
+                wake_up(&wq);
+        }
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return IRQ_HANDLED;
+}
+
+module_init(tlclk_init);
+module_exit(tlclk_cleanup);
diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index 049d128ae7f0..303f15880466 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -64,7 +64,7 @@ static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
         if (count == 0)
                 return -ENODATA;
         if (count > bufsiz) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "invalid count value %x %zx \n", count, bufsiz);
                 return -E2BIG;
         }
@@ -72,21 +72,21 @@ static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
         down(&chip->tpm_mutex);
 
         if ((rc = chip->vendor->send(chip, (u8 *) buf, count)) < 0) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "tpm_transmit: tpm_send: error %zd\n", rc);
                 goto out;
         }
 
         stop = jiffies + 2 * 60 * HZ;
         do {
-                u8 status = inb(chip->vendor->base + 1);
+                u8 status = chip->vendor->status(chip);
                 if ((status & chip->vendor->req_complete_mask) ==
                     chip->vendor->req_complete_val) {
                         goto out_recv;
                 }
 
                 if ((status == chip->vendor->req_canceled)) {
-                        dev_err(&chip->pci_dev->dev, "Operation Canceled\n");
+                        dev_err(chip->dev, "Operation Canceled\n");
                         rc = -ECANCELED;
                         goto out;
                 }
@@ -97,14 +97,14 @@ static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
 
 
         chip->vendor->cancel(chip);
-        dev_err(&chip->pci_dev->dev, "Operation Timed out\n");
+        dev_err(chip->dev, "Operation Timed out\n");
         rc = -ETIME;
         goto out;
 
 out_recv:
         rc = chip->vendor->recv(chip, (u8 *) buf, bufsiz);
         if (rc < 0)
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "tpm_transmit: tpm_recv: error %zd\n", rc);
 out:
         up(&chip->tpm_mutex);
@@ -139,15 +139,14 @@ ssize_t tpm_show_pcrs(struct device *dev, struct device_attribute *attr,
         __be32 index;
         char *str = buf;
 
-        struct tpm_chip *chip =
-            pci_get_drvdata(to_pci_dev(dev));
+        struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
         memcpy(data, cap_pcr, sizeof(cap_pcr));
         if ((len = tpm_transmit(chip, data, sizeof(data)))
             < CAP_PCR_RESULT_SIZE) {
-                dev_dbg(&chip->pci_dev->dev, "A TPM error (%d) occurred "
+                dev_dbg(chip->dev, "A TPM error (%d) occurred "
                                 "attempting to determine the number of PCRS\n",
                         be32_to_cpu(*((__be32 *) (data + 6))));
                 return 0;
@@ -161,9 +160,10 @@ ssize_t tpm_show_pcrs(struct device *dev, struct device_attribute *attr,
                 memcpy(data + 10, &index, 4);
                 if ((len = tpm_transmit(chip, data, sizeof(data)))
                     < READ_PCR_RESULT_SIZE){
-                        dev_dbg(&chip->pci_dev->dev, "A TPM error (%d) occurred"
+                        dev_dbg(chip->dev, "A TPM error (%d) occurred"
                                 " attempting to read PCR %d of %d\n",
-                                be32_to_cpu(*((__be32 *) (data + 6))), i, num_pcrs);
+                                be32_to_cpu(*((__be32 *) (data + 6))),
+                                i, num_pcrs);
                         goto out;
                 }
                 str += sprintf(str, "PCR-%02d: ", i);
@@ -191,21 +191,19 @@ ssize_t tpm_show_pubek(struct device *dev, struct device_attribute *attr,
         int i, rc;
         char *str = buf;
 
-        struct tpm_chip *chip =
-            pci_get_drvdata(to_pci_dev(dev));
+        struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
-        data = kmalloc(READ_PUBEK_RESULT_SIZE, GFP_KERNEL);
+        data = kzalloc(READ_PUBEK_RESULT_SIZE, GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
 
         memcpy(data, readpubek, sizeof(readpubek));
-        memset(data + sizeof(readpubek), 0, 20);        /* zero nonce */
 
         if ((len = tpm_transmit(chip, data, READ_PUBEK_RESULT_SIZE)) <
             READ_PUBEK_RESULT_SIZE) {
-                dev_dbg(&chip->pci_dev->dev, "A TPM error (%d) occurred "
+                dev_dbg(chip->dev, "A TPM error (%d) occurred "
                                 "attempting to read the PUBEK\n",
                             be32_to_cpu(*((__be32 *) (data + 6))));
                 rc = 0;
@@ -245,7 +243,6 @@ out:
         kfree(data);
         return rc;
 }
-
 EXPORT_SYMBOL_GPL(tpm_show_pubek);
 
 #define CAP_VER_RESULT_SIZE 18
@@ -274,8 +271,7 @@ ssize_t tpm_show_caps(struct device *dev, struct device_attribute *attr,
         ssize_t len;
         char *str = buf;
 
-        struct tpm_chip *chip =
-            pci_get_drvdata(to_pci_dev(dev));
+        struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
@@ -315,7 +311,6 @@ ssize_t tpm_store_cancel(struct device *dev, struct device_attribute *attr,
 }
 EXPORT_SYMBOL_GPL(tpm_store_cancel);
 
-
 /*
  * Device file system interface to the TPM
  */
@@ -339,21 +334,20 @@ int tpm_open(struct inode *inode, struct file *file)
         }
 
         if (chip->num_opens) {
-                dev_dbg(&chip->pci_dev->dev,
-                        "Another process owns this TPM\n");
+                dev_dbg(chip->dev, "Another process owns this TPM\n");
                 rc = -EBUSY;
                 goto err_out;
         }
 
         chip->num_opens++;
-        pci_dev_get(chip->pci_dev);
+        get_device(chip->dev);
 
         spin_unlock(&driver_lock);
 
         chip->data_buffer = kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL);
         if (chip->data_buffer == NULL) {
                 chip->num_opens--;
-                pci_dev_put(chip->pci_dev);
+                put_device(chip->dev);
                 return -ENOMEM;
         }
 
@@ -366,7 +360,6 @@ err_out:
         spin_unlock(&driver_lock);
         return rc;
 }
-
 EXPORT_SYMBOL_GPL(tpm_open);
 
 int tpm_release(struct inode *inode, struct file *file)
@@ -378,15 +371,14 @@ int tpm_release(struct inode *inode, struct file *file)
         chip->num_opens--;
         del_singleshot_timer_sync(&chip->user_read_timer);
         atomic_set(&chip->data_pending, 0);
-        pci_dev_put(chip->pci_dev);
+        put_device(chip->dev);
         kfree(chip->data_buffer);
         spin_unlock(&driver_lock);
         return 0;
 }
-
 EXPORT_SYMBOL_GPL(tpm_release);
 
-ssize_t tpm_write(struct file * file, const char __user * buf,
+ssize_t tpm_write(struct file *file, const char __user *buf,
                   size_t size, loff_t * off)
 {
         struct tpm_chip *chip = file->private_data;
@@ -422,7 +414,7 @@ ssize_t tpm_write(struct file * file, const char __user * buf,
 
 EXPORT_SYMBOL_GPL(tpm_write);
 
-ssize_t tpm_read(struct file * file, char __user * buf,
+ssize_t tpm_read(struct file * file, char __user *buf,
                  size_t size, loff_t * off)
 {
         struct tpm_chip *chip = file->private_data;
@@ -444,15 +436,14 @@ ssize_t tpm_read(struct file * file, char __user * buf,
 
         return ret_size;
 }
-
 EXPORT_SYMBOL_GPL(tpm_read);
 
-void __devexit tpm_remove(struct pci_dev *pci_dev)
+void tpm_remove_hardware(struct device *dev)
 {
-        struct tpm_chip *chip = pci_get_drvdata(pci_dev);
+        struct tpm_chip *chip = dev_get_drvdata(dev);
 
         if (chip == NULL) {
-                dev_err(&pci_dev->dev, "No device data found\n");
+                dev_err(dev, "No device data found\n");
                 return;
         }
 
@@ -462,22 +453,20 @@ void __devexit tpm_remove(struct pci_dev *pci_dev)
 
         spin_unlock(&driver_lock);
 
-        pci_set_drvdata(pci_dev, NULL);
+        dev_set_drvdata(dev, NULL);
         misc_deregister(&chip->vendor->miscdev);
         kfree(chip->vendor->miscdev.name);
 
-        sysfs_remove_group(&pci_dev->dev.kobj, chip->vendor->attr_group);
+        sysfs_remove_group(&dev->kobj, chip->vendor->attr_group);
 
-        pci_disable_device(pci_dev);
-
-        dev_mask[chip->dev_num / TPM_NUM_MASK_ENTRIES ] &= !(1 << (chip->dev_num % TPM_NUM_MASK_ENTRIES));
+        dev_mask[chip->dev_num / TPM_NUM_MASK_ENTRIES ] &=
+                !(1 << (chip->dev_num % TPM_NUM_MASK_ENTRIES));
 
         kfree(chip);
 
-        pci_dev_put(pci_dev);
+        put_device(dev);
 }
-
-EXPORT_SYMBOL_GPL(tpm_remove);
+EXPORT_SYMBOL_GPL(tpm_remove_hardware);
 
 static u8 savestate[] = {
         0, 193,                 /* TPM_TAG_RQU_COMMAND */
@@ -489,32 +478,30 @@ static u8 savestate[] = {
  * We are about to suspend. Save the TPM state
  * so that it can be restored.
  */
-int tpm_pm_suspend(struct pci_dev *pci_dev, pm_message_t pm_state)
+int tpm_pm_suspend(struct device *dev, pm_message_t pm_state)
 {
-        struct tpm_chip *chip = pci_get_drvdata(pci_dev);
+        struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
         tpm_transmit(chip, savestate, sizeof(savestate));
         return 0;
 }
-
 EXPORT_SYMBOL_GPL(tpm_pm_suspend);
 
 /*
  * Resume from a power safe. The BIOS already restored
  * the TPM state.
  */
-int tpm_pm_resume(struct pci_dev *pci_dev)
+int tpm_pm_resume(struct device *dev)
 {
-        struct tpm_chip *chip = pci_get_drvdata(pci_dev);
+        struct tpm_chip *chip = dev_get_drvdata(dev);
 
         if (chip == NULL)
                 return -ENODEV;
 
         return 0;
 }
-
 EXPORT_SYMBOL_GPL(tpm_pm_resume);
 
 /*
@@ -524,8 +511,7 @@ EXPORT_SYMBOL_GPL(tpm_pm_resume);
  * upon errant exit from this function specific probe function should call
  * pci_disable_device
  */
-int tpm_register_hardware(struct pci_dev *pci_dev,
-                          struct tpm_vendor_specific *entry)
+int tpm_register_hardware(struct device *dev, struct tpm_vendor_specific *entry)
 {
 #define DEVNAME_SIZE 7
 
@@ -534,12 +520,10 @@ int tpm_register_hardware(struct pci_dev *pci_dev,
         int i, j;
 
         /* Driver specific per-device data */
-        chip = kmalloc(sizeof(*chip), GFP_KERNEL);
+        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
         if (chip == NULL)
                 return -ENOMEM;
 
-        memset(chip, 0, sizeof(struct tpm_chip));
-
         init_MUTEX(&chip->buffer_mutex);
         init_MUTEX(&chip->tpm_mutex);
         INIT_LIST_HEAD(&chip->list);
@@ -563,8 +547,7 @@ int tpm_register_hardware(struct pci_dev *pci_dev,
 
 dev_num_search_complete:
         if (chip->dev_num < 0) {
-                dev_err(&pci_dev->dev,
-                        "No available tpm device numbers\n");
+                dev_err(dev, "No available tpm device numbers\n");
                 kfree(chip);
                 return -ENODEV;
         } else if (chip->dev_num == 0)
@@ -576,15 +559,15 @@ dev_num_search_complete:
         scnprintf(devname, DEVNAME_SIZE, "%s%d", "tpm", chip->dev_num);
         chip->vendor->miscdev.name = devname;
 
-        chip->vendor->miscdev.dev = &(pci_dev->dev);
-        chip->pci_dev = pci_dev_get(pci_dev);
+        chip->vendor->miscdev.dev = dev;
+        chip->dev = get_device(dev);
 
         if (misc_register(&chip->vendor->miscdev)) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "unable to misc_register %s, minor %d\n",
                         chip->vendor->miscdev.name,
                         chip->vendor->miscdev.minor);
-                pci_dev_put(pci_dev);
+                put_device(dev);
                 kfree(chip);
                 dev_mask[i] &= !(1 << j);
                 return -ENODEV;
@@ -592,17 +575,16 @@ dev_num_search_complete:
 
         spin_lock(&driver_lock);
 
-        pci_set_drvdata(pci_dev, chip);
+        dev_set_drvdata(dev, chip);
 
         list_add(&chip->list, &tpm_chip_list);
 
         spin_unlock(&driver_lock);
 
-        sysfs_create_group(&pci_dev->dev.kobj, chip->vendor->attr_group);
+        sysfs_create_group(&dev->kobj, chip->vendor->attr_group);
 
         return 0;
 }
-
 EXPORT_SYMBOL_GPL(tpm_register_hardware);
 
 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h
index 373b41f6b460..024814b50c3c 100644
--- a/drivers/char/tpm/tpm.h
+++ b/drivers/char/tpm/tpm.h
@@ -55,12 +55,13 @@ struct tpm_vendor_specific {
         int (*recv) (struct tpm_chip *, u8 *, size_t);
         int (*send) (struct tpm_chip *, u8 *, size_t);
         void (*cancel) (struct tpm_chip *);
+        u8 (*status) (struct tpm_chip *);
         struct miscdevice miscdev;
         struct attribute_group *attr_group;
 };
 
 struct tpm_chip {
-        struct pci_dev *pci_dev;        /* PCI device stuff */
+        struct device *dev;     /* Device stuff */
 
         int dev_num;            /* /dev/tpm# */
         int num_opens;          /* only one allowed */
@@ -91,13 +92,13 @@ static inline void tpm_write_index(int base, int index, int value)
         outb(value & 0xFF, base+1);
 }
 
-extern int tpm_register_hardware(struct pci_dev *,
+extern int tpm_register_hardware(struct device *,
                                  struct tpm_vendor_specific *);
 extern int tpm_open(struct inode *, struct file *);
 extern int tpm_release(struct inode *, struct file *);
 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 __devexit tpm_remove(struct pci_dev *);
-extern int tpm_pm_suspend(struct pci_dev *, pm_message_t);
-extern int tpm_pm_resume(struct pci_dev *);
+extern void tpm_remove_hardware(struct device *);
+extern int tpm_pm_suspend(struct device *, pm_message_t);
+extern int tpm_pm_resume(struct device *);
diff --git a/drivers/char/tpm/tpm_atmel.c b/drivers/char/tpm/tpm_atmel.c
index c0d64914595f..32e01450c425 100644
--- a/drivers/char/tpm/tpm_atmel.c
+++ b/drivers/char/tpm/tpm_atmel.c
@@ -19,6 +19,7 @@
  * 
  */
 
+#include <linux/platform_device.h>
 #include "tpm.h"
 
 /* Atmel definitions */
@@ -40,7 +41,7 @@ enum tpm_atmel_read_status {
         ATML_STATUS_READY = 0x08
 };
 
-static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
+static int tpm_atml_recv(struct tpm_chip *chip, u8 *buf, size_t count)
 {
         u8 status, *hdr = buf;
         u32 size;
@@ -54,7 +55,7 @@ static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         for (i = 0; i < 6; i++) {
                 status = inb(chip->vendor->base + 1);
                 if ((status & ATML_STATUS_DATA_AVAIL) == 0) {
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "error reading header\n");
                         return -EIO;
                 }
@@ -66,12 +67,12 @@ static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         size = be32_to_cpu(*native_size);
 
         if (count < size) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "Recv size(%d) less than available space\n", size);
                 for (; i < size; i++) { /* clear the waiting data anyway */
                         status = inb(chip->vendor->base + 1);
                         if ((status & ATML_STATUS_DATA_AVAIL) == 0) {
-                                dev_err(&chip->pci_dev->dev,
+                                dev_err(chip->dev,
                                         "error reading data\n");
                                 return -EIO;
                         }
@@ -83,7 +84,7 @@ static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         for (; i < size; i++) {
                 status = inb(chip->vendor->base + 1);
                 if ((status & ATML_STATUS_DATA_AVAIL) == 0) {
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "error reading data\n");
                         return -EIO;
                 }
@@ -93,20 +94,20 @@ static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         /* make sure data available is gone */
         status = inb(chip->vendor->base + 1);
         if (status & ATML_STATUS_DATA_AVAIL) {
-                dev_err(&chip->pci_dev->dev, "data available is stuck\n");
+                dev_err(chip->dev, "data available is stuck\n");
                 return -EIO;
         }
 
         return size;
 }
 
-static int tpm_atml_send(struct tpm_chip *chip, u8 * buf, size_t count)
+static int tpm_atml_send(struct tpm_chip *chip, u8 *buf, size_t count)
 {
         int i;
 
-        dev_dbg(&chip->pci_dev->dev, "tpm_atml_send: ");
+        dev_dbg(chip->dev, "tpm_atml_send:\n");
         for (i = 0; i < count; i++) {
-                dev_dbg(&chip->pci_dev->dev, "0x%x(%d) ", buf[i], buf[i]);
+                dev_dbg(chip->dev, "%d 0x%x(%d)\n",  i, buf[i], buf[i]);
                 outb(buf[i], chip->vendor->base);
         }
 
@@ -118,6 +119,11 @@ static void tpm_atml_cancel(struct tpm_chip *chip)
         outb(ATML_STATUS_ABORT, chip->vendor->base + 1);
 }
 
+static u8 tpm_atml_status(struct tpm_chip *chip)
+{
+        return inb(chip->vendor->base + 1);
+}
+
 static struct file_operations atmel_ops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
@@ -137,7 +143,7 @@ static struct attribute* atmel_attrs[] = {
         &dev_attr_pcrs.attr,
         &dev_attr_caps.attr,
         &dev_attr_cancel.attr,
-        0,
+        NULL,
 };
 
 static struct attribute_group atmel_attr_grp = { .attrs = atmel_attrs };
@@ -146,6 +152,7 @@ static struct tpm_vendor_specific tpm_atmel = {
         .recv = tpm_atml_recv,
         .send = tpm_atml_send,
         .cancel = tpm_atml_cancel,
+        .status = tpm_atml_status,
         .req_complete_mask = ATML_STATUS_BUSY | ATML_STATUS_DATA_AVAIL,
         .req_complete_val = ATML_STATUS_DATA_AVAIL,
         .req_canceled = ATML_STATUS_READY,
@@ -153,86 +160,94 @@ static struct tpm_vendor_specific tpm_atmel = {
         .miscdev = { .fops = &atmel_ops, },
 };
 
-static int __devinit tpm_atml_init(struct pci_dev *pci_dev,
-                                   const struct pci_device_id *pci_id)
+static struct platform_device *pdev;
+
+static void __devexit tpm_atml_remove(struct device *dev)
+{
+        struct tpm_chip *chip = dev_get_drvdata(dev);
+        if (chip) {
+                release_region(chip->vendor->base, 2);
+                tpm_remove_hardware(chip->dev);
+        }
+}
+
+static struct device_driver atml_drv = {
+        .name = "tpm_atmel",
+        .bus = &platform_bus_type,
+        .owner = THIS_MODULE,
+        .suspend = tpm_pm_suspend,
+        .resume = tpm_pm_resume,
+};
+
+static int __init init_atmel(void)
 {
-        u8 version[4];
         int rc = 0;
         int lo, hi;
 
-        if (pci_enable_device(pci_dev))
-                return -EIO;
+        driver_register(&atml_drv);
 
         lo = tpm_read_index(TPM_ADDR, TPM_ATMEL_BASE_ADDR_LO);
         hi = tpm_read_index(TPM_ADDR, TPM_ATMEL_BASE_ADDR_HI);
 
         tpm_atmel.base = (hi<<8)|lo;
-        dev_dbg( &pci_dev->dev, "Operating with base: 0x%x\n", tpm_atmel.base);
 
         /* verify that it is an Atmel part */
         if (tpm_read_index(TPM_ADDR, 4) != 'A' || tpm_read_index(TPM_ADDR, 5) != 'T'
             || tpm_read_index(TPM_ADDR, 6) != 'M' || tpm_read_index(TPM_ADDR, 7) != 'L') {
-                rc = -ENODEV;
-                goto out_err;
+                return -ENODEV;
         }
 
-        /* query chip for its version number */
-        if ((version[0] = tpm_read_index(TPM_ADDR, 0x00)) != 0xFF) {
-                version[1] = tpm_read_index(TPM_ADDR, 0x01);
-                version[2] = tpm_read_index(TPM_ADDR, 0x02);
-                version[3] = tpm_read_index(TPM_ADDR, 0x03);
-        } else {
-                dev_info(&pci_dev->dev, "version query failed\n");
-                rc = -ENODEV;
-                goto out_err;
+        /* verify chip version number is 1.1 */
+        if (    (tpm_read_index(TPM_ADDR, 0x00) != 0x01) ||
+                (tpm_read_index(TPM_ADDR, 0x01) != 0x01 ))
+                return -ENODEV;
+
+        pdev = kzalloc(sizeof(struct platform_device), GFP_KERNEL);
+        if ( !pdev )
+                return -ENOMEM;
+
+        pdev->name = "tpm_atmel0";
+        pdev->id = -1;
+        pdev->num_resources = 0;
+        pdev->dev.release = tpm_atml_remove;
+        pdev->dev.driver = &atml_drv;
+
+        if ((rc = platform_device_register(pdev)) < 0) {
+                kfree(pdev);
+                pdev = NULL;
+                return rc;
         }
 
-        if ((rc = tpm_register_hardware(pci_dev, &tpm_atmel)) < 0)
-                goto out_err;
+        if (request_region(tpm_atmel.base, 2, "tpm_atmel0") == NULL ) {
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+                return -EBUSY;
+        }
 
-        dev_info(&pci_dev->dev,
-                 "Atmel TPM version %d.%d.%d.%d\n", version[0], version[1],
-                 version[2], version[3]);
+        if ((rc = tpm_register_hardware(&pdev->dev, &tpm_atmel)) < 0) {
+                release_region(tpm_atmel.base, 2);
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+                return rc;
+        }
 
+        dev_info(&pdev->dev, "Atmel TPM 1.1, Base Address: 0x%x\n",
+                        tpm_atmel.base);
         return 0;
-out_err:
-        pci_disable_device(pci_dev);
-        return rc;
-}
-
-static struct pci_device_id tpm_pci_tbl[] __devinitdata = {
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8111_LPC)},
-        {PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6LPC)},
-        {0,}
-};
-
-MODULE_DEVICE_TABLE(pci, tpm_pci_tbl);
-
-static struct pci_driver atmel_pci_driver = {
-        .name = "tpm_atmel",
-        .id_table = tpm_pci_tbl,
-        .probe = tpm_atml_init,
-        .remove = __devexit_p(tpm_remove),
-        .suspend = tpm_pm_suspend,
-        .resume = tpm_pm_resume,
-};
-
-static int __init init_atmel(void)
-{
-        return pci_register_driver(&atmel_pci_driver);
 }
 
 static void __exit cleanup_atmel(void)
 {
-        pci_unregister_driver(&atmel_pci_driver);
+        if (pdev) {
+                tpm_atml_remove(&pdev->dev);
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+        }
+
+        driver_unregister(&atml_drv);
 }
 
 module_init(init_atmel);
diff --git a/drivers/char/tpm/tpm_infineon.c b/drivers/char/tpm/tpm_infineon.c
index 939e51e119e6..8198dbb7370f 100644
--- a/drivers/char/tpm/tpm_infineon.c
+++ b/drivers/char/tpm/tpm_infineon.c
@@ -5,6 +5,7 @@
  * Specifications at www.trustedcomputinggroup.org
  *
  * Copyright (C) 2005, Marcel Selhorst <selhorst@crypto.rub.de>
+ * Sirrix AG - security technologies, http://www.sirrix.com and
  * Applied Data Security Group, Ruhr-University Bochum, Germany
  * Project-Homepage: http://www.prosec.rub.de/tpm
  *
@@ -29,9 +30,10 @@
 #define TPM_INFINEON_DEV_VEN_VALUE      0x15D1
 
 /* These values will be filled after PnP-call */
-static int TPM_INF_DATA = 0;
-static int TPM_INF_ADDR = 0;
-static int pnp_registered = 0;
+static int TPM_INF_DATA;
+static int TPM_INF_ADDR;
+static int TPM_INF_BASE;
+static int TPM_INF_PORT_LEN;
 
 /* TPM header definitions */
 enum infineon_tpm_header {
@@ -143,11 +145,9 @@ static int wait(struct tpm_chip *chip, int wait_for_bit)
         }
         if (i == TPM_MAX_TRIES) {       /* timeout occurs */
                 if (wait_for_bit == STAT_XFE)
-                        dev_err(&chip->pci_dev->dev,
-                                "Timeout in wait(STAT_XFE)\n");
+                        dev_err(chip->dev, "Timeout in wait(STAT_XFE)\n");
                 if (wait_for_bit == STAT_RDA)
-                        dev_err(&chip->pci_dev->dev,
-                                "Timeout in wait(STAT_RDA)\n");
+                        dev_err(chip->dev, "Timeout in wait(STAT_RDA)\n");
                 return -EIO;
         }
         return 0;
@@ -170,7 +170,7 @@ static void wait_and_send(struct tpm_chip *chip, u8 sendbyte)
 static void tpm_wtx(struct tpm_chip *chip)
 {
         number_of_wtx++;
-        dev_info(&chip->pci_dev->dev, "Granting WTX (%02d / %02d)\n",
+        dev_info(chip->dev, "Granting WTX (%02d / %02d)\n",
                  number_of_wtx, TPM_MAX_WTX_PACKAGES);
         wait_and_send(chip, TPM_VL_VER);
         wait_and_send(chip, TPM_CTRL_WTX);
@@ -181,7 +181,7 @@ static void tpm_wtx(struct tpm_chip *chip)
 
 static void tpm_wtx_abort(struct tpm_chip *chip)
 {
-        dev_info(&chip->pci_dev->dev, "Aborting WTX\n");
+        dev_info(chip->dev, "Aborting WTX\n");
         wait_and_send(chip, TPM_VL_VER);
         wait_and_send(chip, TPM_CTRL_WTX_ABORT);
         wait_and_send(chip, 0x00);
@@ -206,7 +206,7 @@ recv_begin:
         }
 
         if (buf[0] != TPM_VL_VER) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "Wrong transport protocol implementation!\n");
                 return -EIO;
         }
@@ -221,8 +221,7 @@ recv_begin:
                 }
 
                 if ((size == 0x6D00) && (buf[1] == 0x80)) {
-                        dev_err(&chip->pci_dev->dev,
-                                "Error handling on vendor layer!\n");
+                        dev_err(chip->dev, "Error handling on vendor layer!\n");
                         return -EIO;
                 }
 
@@ -234,7 +233,7 @@ recv_begin:
         }
 
         if (buf[1] == TPM_CTRL_WTX) {
-                dev_info(&chip->pci_dev->dev, "WTX-package received\n");
+                dev_info(chip->dev, "WTX-package received\n");
                 if (number_of_wtx < TPM_MAX_WTX_PACKAGES) {
                         tpm_wtx(chip);
                         goto recv_begin;
@@ -245,14 +244,14 @@ recv_begin:
         }
 
         if (buf[1] == TPM_CTRL_WTX_ABORT_ACK) {
-                dev_info(&chip->pci_dev->dev, "WTX-abort acknowledged\n");
+                dev_info(chip->dev, "WTX-abort acknowledged\n");
                 return size;
         }
 
         if (buf[1] == TPM_CTRL_ERROR) {
-                dev_err(&chip->pci_dev->dev, "ERROR-package received:\n");
+                dev_err(chip->dev, "ERROR-package received:\n");
                 if (buf[4] == TPM_INF_NAK)
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "-> Negative acknowledgement"
                                 " - retransmit command!\n");
                 return -EIO;
@@ -271,7 +270,7 @@ static int tpm_inf_send(struct tpm_chip *chip, u8 * buf, size_t count)
 
         ret = empty_fifo(chip, 1);
         if (ret) {
-                dev_err(&chip->pci_dev->dev, "Timeout while clearing FIFO\n");
+                dev_err(chip->dev, "Timeout while clearing FIFO\n");
                 return -EIO;
         }
 
@@ -316,6 +315,11 @@ static void tpm_inf_cancel(struct tpm_chip *chip)
          */
 }
 
+static u8 tpm_inf_status(struct tpm_chip *chip)
+{
+        return inb(chip->vendor->base + STAT);
+}
+
 static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
 static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL);
 static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps, NULL);
@@ -344,6 +348,7 @@ static struct tpm_vendor_specific tpm_inf = {
         .recv = tpm_inf_recv,
         .send = tpm_inf_send,
         .cancel = tpm_inf_cancel,
+        .status = tpm_inf_status,
         .req_complete_mask = 0,
         .req_complete_val = 0,
         .attr_group = &inf_attr_grp,
@@ -356,30 +361,11 @@ static const struct pnp_device_id tpm_pnp_tbl[] = {
         {"IFX0102", 0},
         {"", 0}
 };
+
 MODULE_DEVICE_TABLE(pnp, tpm_pnp_tbl);
 
 static int __devinit tpm_inf_pnp_probe(struct pnp_dev *dev,
-                                        const struct pnp_device_id *dev_id)
-{
-        if (pnp_port_valid(dev, 0)) {
-                TPM_INF_ADDR = (pnp_port_start(dev, 0) & 0xff);
-                TPM_INF_DATA = ((TPM_INF_ADDR + 1) & 0xff);
-                tpm_inf.base = pnp_port_start(dev, 1);
-                dev_info(&dev->dev, "Found %s with ID %s\n",
-                dev->name, dev_id->id);
-                return 0;
-        }
-        return -ENODEV;
-}
-
-static struct pnp_driver tpm_inf_pnp = {
-        .name = "tpm_inf_pnp",
-        .id_table = tpm_pnp_tbl,
-        .probe = tpm_inf_pnp_probe,
-};
-
-static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
-                                   const struct pci_device_id *pci_id)
+                                       const struct pnp_device_id *dev_id)
 {
         int rc = 0;
         u8 iol, ioh;
@@ -388,30 +374,28 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
         int productid[2];
         char chipname[20];
 
-        rc = pci_enable_device(pci_dev);
-        if (rc)
-                return rc;
-
-        dev_info(&pci_dev->dev, "LPC-bus found at 0x%x\n", pci_id->device);
-
-        /* read IO-ports from PnP */
-        rc = pnp_register_driver(&tpm_inf_pnp);
-        if (rc < 0) {
-                dev_err(&pci_dev->dev,
-                        "Error %x from pnp_register_driver!\n",rc);
-                goto error2;
-        }
-        if (!rc) {
-                dev_info(&pci_dev->dev, "No Infineon TPM found!\n");
-                goto error;
+        /* read IO-ports through PnP */
+        if (pnp_port_valid(dev, 0) && pnp_port_valid(dev, 1) &&
+            !(pnp_port_flags(dev, 0) & IORESOURCE_DISABLED)) {
+                TPM_INF_ADDR = pnp_port_start(dev, 0);
+                TPM_INF_DATA = (TPM_INF_ADDR + 1);
+                TPM_INF_BASE = pnp_port_start(dev, 1);
+                TPM_INF_PORT_LEN = pnp_port_len(dev, 1);
+                if (!TPM_INF_PORT_LEN)
+                        return -EINVAL;
+                dev_info(&dev->dev, "Found %s with ID %s\n",
+                         dev->name, dev_id->id);
+                if (!((TPM_INF_BASE >> 8) & 0xff))
+                        return -EINVAL;
+                /* publish my base address and request region */
+                tpm_inf.base = TPM_INF_BASE;
+                if (request_region
+                    (tpm_inf.base, TPM_INF_PORT_LEN, "tpm_infineon0") == NULL) {
+                        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
+                        return -EINVAL;
+                }
         } else {
-                pnp_registered = 1;
-        }
-
-        /* Make sure, we have received valid config ports */
-        if (!TPM_INF_ADDR) {
-                dev_err(&pci_dev->dev, "No valid IO-ports received!\n");
-                goto error;
+                return -EINVAL;
         }
 
         /* query chip for its vendor, its version number a.s.o. */
@@ -443,10 +427,6 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
 
         if ((vendorid[0] << 8 | vendorid[1]) == (TPM_INFINEON_DEV_VEN_VALUE)) {
 
-                if (tpm_inf.base == 0) {
-                        dev_err(&pci_dev->dev, "No IO-ports found!\n");
-                        goto error;
-                }
                 /* configure TPM with IO-ports */
                 outb(IOLIMH, TPM_INF_ADDR);
                 outb(((tpm_inf.base >> 8) & 0xff), TPM_INF_DATA);
@@ -460,10 +440,11 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
                 iol = inb(TPM_INF_DATA);
 
                 if ((ioh << 8 | iol) != tpm_inf.base) {
-                        dev_err(&pci_dev->dev,
+                        dev_err(&dev->dev,
                                 "Could not set IO-ports to %04x\n",
                                 tpm_inf.base);
-                        goto error;
+                        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
+                        return -EIO;
                 }
 
                 /* activate register */
@@ -475,7 +456,7 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
                 outb(RESET_LP_IRQC_DISABLE, tpm_inf.base + CMD);
 
                 /* Finally, we're done, print some infos */
-                dev_info(&pci_dev->dev, "TPM found: "
+                dev_info(&dev->dev, "TPM found: "
                          "config base 0x%x, "
                          "io base 0x%x, "
                          "chip version %02x%02x, "
@@ -483,59 +464,53 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
                          "product id %02x%02x"
                          "%s\n",
                          TPM_INF_ADDR,
-                         tpm_inf.base,
+                         TPM_INF_BASE,
                          version[0], version[1],
                          vendorid[0], vendorid[1],
                          productid[0], productid[1], chipname);
 
-                rc = tpm_register_hardware(pci_dev, &tpm_inf);
-                if (rc < 0)
-                        goto error;
+                rc = tpm_register_hardware(&dev->dev, &tpm_inf);
+                if (rc < 0) {
+                        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
+                        return -ENODEV;
+                }
                 return 0;
         } else {
-                dev_info(&pci_dev->dev, "No Infineon TPM found!\n");
-error:
-                pnp_unregister_driver(&tpm_inf_pnp);
-error2:
-                pci_disable_device(pci_dev);
-                pnp_registered = 0;
+                dev_info(&dev->dev, "No Infineon TPM found!\n");
                 return -ENODEV;
         }
 }
 
-static struct pci_device_id tpm_pci_tbl[] __devinitdata = {
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_2)},
-        {0,}
-};
+static __devexit void tpm_inf_pnp_remove(struct pnp_dev *dev)
+{
+        struct tpm_chip *chip = pnp_get_drvdata(dev);
 
-MODULE_DEVICE_TABLE(pci, tpm_pci_tbl);
+        if (chip) {
+                release_region(chip->vendor->base, TPM_INF_PORT_LEN);
+                tpm_remove_hardware(chip->dev);
+        }
+}
 
-static struct pci_driver inf_pci_driver = {
-        .name = "tpm_inf",
-        .id_table = tpm_pci_tbl,
-        .probe = tpm_inf_probe,
-        .remove = __devexit_p(tpm_remove),
-        .suspend = tpm_pm_suspend,
-        .resume = tpm_pm_resume,
+static struct pnp_driver tpm_inf_pnp = {
+        .name = "tpm_inf_pnp",
+        .driver = {
+                .owner = THIS_MODULE,
+                .suspend = tpm_pm_suspend,
+                .resume = tpm_pm_resume,
+        },
+        .id_table = tpm_pnp_tbl,
+        .probe = tpm_inf_pnp_probe,
+        .remove = tpm_inf_pnp_remove,
 };
 
 static int __init init_inf(void)
 {
-        return pci_register_driver(&inf_pci_driver);
+        return pnp_register_driver(&tpm_inf_pnp);
 }
 
 static void __exit cleanup_inf(void)
 {
-        if (pnp_registered)
-                pnp_unregister_driver(&tpm_inf_pnp);
-        pci_unregister_driver(&inf_pci_driver);
+        pnp_unregister_driver(&tpm_inf_pnp);
 }
 
 module_init(init_inf);
@@ -543,5 +518,5 @@ module_exit(cleanup_inf);
 
 MODULE_AUTHOR("Marcel Selhorst <selhorst@crypto.rub.de>");
 MODULE_DESCRIPTION("Driver for Infineon TPM SLD 9630 TT 1.1 / SLB 9635 TT 1.2");
-MODULE_VERSION("1.5");
+MODULE_VERSION("1.6");
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/tpm/tpm_nsc.c b/drivers/char/tpm/tpm_nsc.c
index b4127348c063..8d125c974a2d 100644
--- a/drivers/char/tpm/tpm_nsc.c
+++ b/drivers/char/tpm/tpm_nsc.c
@@ -19,6 +19,7 @@
  * 
  */
 
+#include <linux/platform_device.h>
 #include "tpm.h"
 
 /* National definitions */
@@ -111,7 +112,7 @@ static int nsc_wait_for_ready(struct tpm_chip *chip)
         }
         while (time_before(jiffies, stop));
 
-        dev_info(&chip->pci_dev->dev, "wait for ready failed\n");
+        dev_info(chip->dev, "wait for ready failed\n");
         return -EBUSY;
 }
 
@@ -127,12 +128,12 @@ static int tpm_nsc_recv(struct tpm_chip *chip, u8 * buf, size_t count)
                 return -EIO;
 
         if (wait_for_stat(chip, NSC_STATUS_F0, NSC_STATUS_F0, &data) < 0) {
-                dev_err(&chip->pci_dev->dev, "F0 timeout\n");
+                dev_err(chip->dev, "F0 timeout\n");
                 return -EIO;
         }
         if ((data =
              inb(chip->vendor->base + NSC_DATA)) != NSC_COMMAND_NORMAL) {
-                dev_err(&chip->pci_dev->dev, "not in normal mode (0x%x)\n",
+                dev_err(chip->dev, "not in normal mode (0x%x)\n",
                         data);
                 return -EIO;
         }
@@ -141,7 +142,7 @@ static int tpm_nsc_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         for (p = buffer; p < &buffer[count]; p++) {
                 if (wait_for_stat
                     (chip, NSC_STATUS_OBF, NSC_STATUS_OBF, &data) < 0) {
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "OBF timeout (while reading data)\n");
                         return -EIO;
                 }
@@ -152,11 +153,11 @@ static int tpm_nsc_recv(struct tpm_chip *chip, u8 * buf, size_t count)
 
         if ((data & NSC_STATUS_F0) == 0 &&
         (wait_for_stat(chip, NSC_STATUS_F0, NSC_STATUS_F0, &data) < 0)) {
-                dev_err(&chip->pci_dev->dev, "F0 not set\n");
+                dev_err(chip->dev, "F0 not set\n");
                 return -EIO;
         }
         if ((data = inb(chip->vendor->base + NSC_DATA)) != NSC_COMMAND_EOC) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "expected end of command(0x%x)\n", data);
                 return -EIO;
         }
@@ -187,19 +188,19 @@ static int tpm_nsc_send(struct tpm_chip *chip, u8 * buf, size_t count)
                 return -EIO;
 
         if (wait_for_stat(chip, NSC_STATUS_IBF, 0, &data) < 0) {
-                dev_err(&chip->pci_dev->dev, "IBF timeout\n");
+                dev_err(chip->dev, "IBF timeout\n");
                 return -EIO;
         }
 
         outb(NSC_COMMAND_NORMAL, chip->vendor->base + NSC_COMMAND);
         if (wait_for_stat(chip, NSC_STATUS_IBR, NSC_STATUS_IBR, &data) < 0) {
-                dev_err(&chip->pci_dev->dev, "IBR timeout\n");
+                dev_err(chip->dev, "IBR timeout\n");
                 return -EIO;
         }
 
         for (i = 0; i < count; i++) {
                 if (wait_for_stat(chip, NSC_STATUS_IBF, 0, &data) < 0) {
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "IBF timeout (while writing data)\n");
                         return -EIO;
                 }
@@ -207,7 +208,7 @@ static int tpm_nsc_send(struct tpm_chip *chip, u8 * buf, size_t count)
         }
 
         if (wait_for_stat(chip, NSC_STATUS_IBF, 0, &data) < 0) {
-                dev_err(&chip->pci_dev->dev, "IBF timeout\n");
+                dev_err(chip->dev, "IBF timeout\n");
                 return -EIO;
         }
         outb(NSC_COMMAND_EOC, chip->vendor->base + NSC_COMMAND);
@@ -220,6 +221,11 @@ static void tpm_nsc_cancel(struct tpm_chip *chip)
         outb(NSC_COMMAND_CANCEL, chip->vendor->base + NSC_COMMAND);
 }
 
+static u8 tpm_nsc_status(struct tpm_chip *chip)
+{
+        return inb(chip->vendor->base + NSC_STATUS);
+}
+
 static struct file_operations nsc_ops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
@@ -239,7 +245,7 @@ static struct attribute * nsc_attrs[] = {
         &dev_attr_pcrs.attr,
         &dev_attr_caps.attr,
         &dev_attr_cancel.attr,
-        0,
+        NULL,
 };
 
 static struct attribute_group nsc_attr_grp = { .attrs = nsc_attrs };
@@ -248,6 +254,7 @@ static struct tpm_vendor_specific tpm_nsc = {
         .recv = tpm_nsc_recv,
         .send = tpm_nsc_send,
         .cancel = tpm_nsc_cancel,
+        .status = tpm_nsc_status,
         .req_complete_mask = NSC_STATUS_OBF,
         .req_complete_val = NSC_STATUS_OBF,
         .req_canceled = NSC_STATUS_RDY,
@@ -255,16 +262,32 @@ static struct tpm_vendor_specific tpm_nsc = {
         .miscdev = { .fops = &nsc_ops, },
 };
 
-static int __devinit tpm_nsc_init(struct pci_dev *pci_dev,
-                                  const struct pci_device_id *pci_id)
+static struct platform_device *pdev = NULL;
+
+static void __devexit tpm_nsc_remove(struct device *dev)
+{
+        struct tpm_chip *chip = dev_get_drvdata(dev);
+        if ( chip ) {
+                release_region(chip->vendor->base, 2);
+                tpm_remove_hardware(chip->dev);
+        }
+}
+
+static struct device_driver nsc_drv = {
+        .name = "tpm_nsc",
+        .bus = &platform_bus_type,
+        .owner = THIS_MODULE,
+        .suspend = tpm_pm_suspend,
+        .resume = tpm_pm_resume,
+};
+
+static int __init init_nsc(void)
 {
         int rc = 0;
         int lo, hi;
         int nscAddrBase = TPM_ADDR;
 
-
-        if (pci_enable_device(pci_dev))
-                return -EIO;
+        driver_register(&nsc_drv);
 
         /* select PM channel 1 */
         tpm_write_index(nscAddrBase,NSC_LDN_INDEX, 0x12);
@@ -273,37 +296,71 @@ static int __devinit tpm_nsc_init(struct pci_dev *pci_dev,
         if (tpm_read_index(TPM_ADDR, NSC_SID_INDEX) != 0xEF) {
                 nscAddrBase = (tpm_read_index(TPM_SUPERIO_ADDR, 0x2C)<<8)|
                         (tpm_read_index(TPM_SUPERIO_ADDR, 0x2B)&0xFE);
-                if (tpm_read_index(nscAddrBase, NSC_SID_INDEX) != 0xF6) {
-                        rc = -ENODEV;
-                        goto out_err;
-                }
+                if (tpm_read_index(nscAddrBase, NSC_SID_INDEX) != 0xF6)
+                        return -ENODEV;
         }
 
         hi = tpm_read_index(nscAddrBase, TPM_NSC_BASE0_HI);
         lo = tpm_read_index(nscAddrBase, TPM_NSC_BASE0_LO);
         tpm_nsc.base = (hi<<8) | lo;
 
-        dev_dbg(&pci_dev->dev, "NSC TPM detected\n");
-        dev_dbg(&pci_dev->dev,
+        /* enable the DPM module */
+        tpm_write_index(nscAddrBase, NSC_LDC_INDEX, 0x01);
+
+        pdev = kmalloc(sizeof(struct platform_device), GFP_KERNEL);
+        if ( !pdev )
+                return -ENOMEM;
+
+        memset(pdev, 0, sizeof(struct platform_device));
+
+        pdev->name = "tpm_nscl0";
+        pdev->id = -1;
+        pdev->num_resources = 0;
+        pdev->dev.release = tpm_nsc_remove;
+        pdev->dev.driver = &nsc_drv;
+
+        if ((rc=platform_device_register(pdev)) < 0) {
+                kfree(pdev);
+                pdev = NULL;
+                return rc;
+        }
+
+        if (request_region(tpm_nsc.base, 2, "tpm_nsc0") == NULL ) {
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+                return -EBUSY;
+        }
+
+        if ((rc = tpm_register_hardware(&pdev->dev, &tpm_nsc)) < 0) {
+                release_region(tpm_nsc.base, 2);
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+                return rc;
+        }
+
+        dev_dbg(&pdev->dev, "NSC TPM detected\n");
+        dev_dbg(&pdev->dev,
                 "NSC LDN 0x%x, SID 0x%x, SRID 0x%x\n",
                 tpm_read_index(nscAddrBase,0x07), tpm_read_index(nscAddrBase,0x20),
                 tpm_read_index(nscAddrBase,0x27));
-        dev_dbg(&pci_dev->dev,
+        dev_dbg(&pdev->dev,
                 "NSC SIOCF1 0x%x SIOCF5 0x%x SIOCF6 0x%x SIOCF8 0x%x\n",
                 tpm_read_index(nscAddrBase,0x21), tpm_read_index(nscAddrBase,0x25),
                 tpm_read_index(nscAddrBase,0x26), tpm_read_index(nscAddrBase,0x28));
-        dev_dbg(&pci_dev->dev, "NSC IO Base0 0x%x\n",
+        dev_dbg(&pdev->dev, "NSC IO Base0 0x%x\n",
                 (tpm_read_index(nscAddrBase,0x60) << 8) | tpm_read_index(nscAddrBase,0x61));
-        dev_dbg(&pci_dev->dev, "NSC IO Base1 0x%x\n",
+        dev_dbg(&pdev->dev, "NSC IO Base1 0x%x\n",
                 (tpm_read_index(nscAddrBase,0x62) << 8) | tpm_read_index(nscAddrBase,0x63));
-        dev_dbg(&pci_dev->dev, "NSC Interrupt number and wakeup 0x%x\n",
+        dev_dbg(&pdev->dev, "NSC Interrupt number and wakeup 0x%x\n",
                 tpm_read_index(nscAddrBase,0x70));
-        dev_dbg(&pci_dev->dev, "NSC IRQ type select 0x%x\n",
+        dev_dbg(&pdev->dev, "NSC IRQ type select 0x%x\n",
                 tpm_read_index(nscAddrBase,0x71));
-        dev_dbg(&pci_dev->dev,
+        dev_dbg(&pdev->dev,
                 "NSC DMA channel select0 0x%x, select1 0x%x\n",
                 tpm_read_index(nscAddrBase,0x74), tpm_read_index(nscAddrBase,0x75));
-        dev_dbg(&pci_dev->dev,
+        dev_dbg(&pdev->dev,
                 "NSC Config "
                 "0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
                 tpm_read_index(nscAddrBase,0xF0), tpm_read_index(nscAddrBase,0xF1),
@@ -312,55 +369,23 @@ static int __devinit tpm_nsc_init(struct pci_dev *pci_dev,
                 tpm_read_index(nscAddrBase,0xF6), tpm_read_index(nscAddrBase,0xF7),
                 tpm_read_index(nscAddrBase,0xF8), tpm_read_index(nscAddrBase,0xF9));
 
-        dev_info(&pci_dev->dev,
+        dev_info(&pdev->dev,
                  "NSC TPM revision %d\n",
                  tpm_read_index(nscAddrBase, 0x27) & 0x1F);
 
-        /* enable the DPM module */
-        tpm_write_index(nscAddrBase, NSC_LDC_INDEX, 0x01);
-
-        if ((rc = tpm_register_hardware(pci_dev, &tpm_nsc)) < 0)
-                goto out_err;
-
         return 0;
-
-out_err:
-        pci_disable_device(pci_dev);
-        return rc;
-}
-
-static struct pci_device_id tpm_pci_tbl[] __devinitdata = {
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8111_LPC)},
-        {0,}
-};
-
-MODULE_DEVICE_TABLE(pci, tpm_pci_tbl);
-
-static struct pci_driver nsc_pci_driver = {
-        .name = "tpm_nsc",
-        .id_table = tpm_pci_tbl,
-        .probe = tpm_nsc_init,
-        .remove = __devexit_p(tpm_remove),
-        .suspend = tpm_pm_suspend,
-        .resume = tpm_pm_resume,
-};
-
-static int __init init_nsc(void)
-{
-        return pci_register_driver(&nsc_pci_driver);
 }
 
 static void __exit cleanup_nsc(void)
 {
-        pci_unregister_driver(&nsc_pci_driver);
+        if (pdev) {
+                tpm_nsc_remove(&pdev->dev);
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+        }
+
+        driver_unregister(&nsc_drv);
 }
 
 module_init(init_nsc);
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index e5953f3433f3..c586bfa852ee 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -809,7 +809,7 @@ static void do_tty_hangup(void *data)
         check_tty_count(tty, "do_tty_hangup");
         file_list_lock();
         /* This breaks for file handles being sent over AF_UNIX sockets ? */
-        list_for_each_entry(filp, &tty->tty_files, f_list) {
+        list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
                 if (filp->f_op->write == redirected_tty_write)
                         cons_filp = filp;
                 if (filp->f_op->write != tty_write)
@@ -2728,7 +2728,7 @@ void tty_register_device(struct tty_driver *driver, unsigned index,
                 pty_line_name(driver, index, name);
         else
                 tty_line_name(driver, index, name);
-        class_device_create(tty_class, dev, device, name);
+        class_device_create(tty_class, NULL, dev, device, "%s", name);
 }
 
 /**
@@ -2983,14 +2983,14 @@ static int __init tty_init(void)
             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
                 panic("Couldn't register /dev/tty driver\n");
         devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
-        class_device_create(tty_class, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
+        class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
 
         cdev_init(&console_cdev, &console_fops);
         if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
                 panic("Couldn't register /dev/console driver\n");
         devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
-        class_device_create(tty_class, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
+        class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
 
 #ifdef CONFIG_UNIX98_PTYS
         cdev_init(&ptmx_cdev, &ptmx_fops);
@@ -2998,7 +2998,7 @@ static int __init tty_init(void)
             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
                 panic("Couldn't register /dev/ptmx driver\n");
         devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
-        class_device_create(tty_class, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
+        class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
 #endif
 
 #ifdef CONFIG_VT
@@ -3007,7 +3007,7 @@ static int __init tty_init(void)
             register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
                 panic("Couldn't register /dev/tty0 driver\n");
         devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
-        class_device_create(tty_class, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
+        class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
 
         vty_init();
 #endif
diff --git a/drivers/char/vc_screen.c b/drivers/char/vc_screen.c
index 79c2928a8817..f66c7ad6fd38 100644
--- a/drivers/char/vc_screen.c
+++ b/drivers/char/vc_screen.c
@@ -484,8 +484,10 @@ void vcs_make_devfs(struct tty_struct *tty)
         devfs_mk_cdev(MKDEV(VCS_MAJOR, tty->index + 129),
                         S_IFCHR|S_IRUSR|S_IWUSR,
                         "vcc/a%u", tty->index + 1);
-        class_device_create(vc_class, MKDEV(VCS_MAJOR, tty->index + 1), NULL, "vcs%u", tty->index + 1);
-        class_device_create(vc_class, MKDEV(VCS_MAJOR, tty->index + 129), NULL, "vcsa%u", tty->index + 1);
+        class_device_create(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 1),
+                        NULL, "vcs%u", tty->index + 1);
+        class_device_create(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 129),
+                        NULL, "vcsa%u", tty->index + 1);
 }
 void vcs_remove_devfs(struct tty_struct *tty)
 {
@@ -503,7 +505,7 @@ int __init vcs_init(void)
 
         devfs_mk_cdev(MKDEV(VCS_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vcc/0");
         devfs_mk_cdev(MKDEV(VCS_MAJOR, 128), S_IFCHR|S_IRUSR|S_IWUSR, "vcc/a0");
-        class_device_create(vc_class, MKDEV(VCS_MAJOR, 0), NULL, "vcs");
-        class_device_create(vc_class, MKDEV(VCS_MAJOR, 128), NULL, "vcsa");
+        class_device_create(vc_class, NULL, MKDEV(VCS_MAJOR, 0), NULL, "vcs");
+        class_device_create(vc_class, NULL, MKDEV(VCS_MAJOR, 128), NULL, "vcsa");
         return 0;
 }
diff --git a/drivers/char/viotape.c b/drivers/char/viotape.c
index 0aff45fac2e6..51abd3defc1c 100644
--- a/drivers/char/viotape.c
+++ b/drivers/char/viotape.c
@@ -956,9 +956,9 @@ static int viotape_probe(struct vio_dev *vdev, const struct vio_device_id *id)
         state[i].cur_part = 0;
         for (j = 0; j < MAX_PARTITIONS; ++j)
                 state[i].part_stat_rwi[j] = VIOT_IDLE;
-        class_device_create(tape_class, MKDEV(VIOTAPE_MAJOR, i), NULL,
+        class_device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i), NULL,
                         "iseries!vt%d", i);
-        class_device_create(tape_class, MKDEV(VIOTAPE_MAJOR, i | 0x80),
+        class_device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i | 0x80),
                         NULL, "iseries!nvt%d", i);
         devfs_mk_cdev(MKDEV(VIOTAPE_MAJOR, i), S_IFCHR | S_IRUSR | S_IWUSR,
                         "iseries/vt%d", i);
@@ -993,13 +993,16 @@ static struct vio_device_id viotape_device_table[] __devinitdata = {
         { "viotape", "" },
         { "", "" }
 };
-
 MODULE_DEVICE_TABLE(vio, viotape_device_table);
+
 static struct vio_driver viotape_driver = {
-        .name = "viotape",
         .id_table = viotape_device_table,
         .probe = viotape_probe,
-        .remove = viotape_remove
+        .remove = viotape_remove,
+        .driver = {
+                .name = "viotape",
+                .owner = THIS_MODULE,
+        }
 };
 
 
diff --git a/drivers/char/vr41xx_giu.c b/drivers/char/vr41xx_giu.c
index 683278bc5241..94641085faf8 100644
--- a/drivers/char/vr41xx_giu.c
+++ b/drivers/char/vr41xx_giu.c
@@ -19,7 +19,7 @@
  *  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/device.h>
+#include <linux/platform_device.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
 #include <linux/init.h>
diff --git a/drivers/char/vr41xx_rtc.c b/drivers/char/vr41xx_rtc.c
index a6dbe4da030c..5e3292df69d8 100644
--- a/drivers/char/vr41xx_rtc.c
+++ b/drivers/char/vr41xx_rtc.c
@@ -17,7 +17,7 @@
  *  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/device.h>
+#include <linux/platform_device.h>
 #include <linux/fs.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
diff --git a/drivers/char/vt_ioctl.c b/drivers/char/vt_ioctl.c
index 1d44f69e1fda..003dda147cd0 100644
--- a/drivers/char/vt_ioctl.c
+++ b/drivers/char/vt_ioctl.c
@@ -192,6 +192,9 @@ do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
         int i, j, k;
         int ret;
 
+        if (!capable(CAP_SYS_TTY_CONFIG))
+                return -EPERM;
+
         kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
         if (!kbs) {
                 ret = -ENOMEM;
diff --git a/drivers/char/watchdog/cpu5wdt.c b/drivers/char/watchdog/cpu5wdt.c
index 2865dac0a813..e75045fe2641 100644
--- a/drivers/char/watchdog/cpu5wdt.c
+++ b/drivers/char/watchdog/cpu5wdt.c
@@ -28,6 +28,7 @@
 #include <linux/init.h>
 #include <linux/ioport.h>
 #include <linux/timer.h>
+#include <linux/jiffies.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
 
diff --git a/drivers/char/watchdog/mixcomwd.c b/drivers/char/watchdog/mixcomwd.c
index 7fc2188386d9..d8dede575402 100644
--- a/drivers/char/watchdog/mixcomwd.c
+++ b/drivers/char/watchdog/mixcomwd.c
@@ -45,6 +45,8 @@
 #include <linux/fs.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
+#include <linux/jiffies.h>
+#include <linux/timer.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 
diff --git a/drivers/char/watchdog/mpcore_wdt.c b/drivers/char/watchdog/mpcore_wdt.c
index 75ca84ed4adf..da631c114fd1 100644
--- a/drivers/char/watchdog/mpcore_wdt.c
+++ b/drivers/char/watchdog/mpcore_wdt.c
@@ -29,7 +29,7 @@
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <linux/device.h>
+#include <linux/platform_device.h>
 
 #include <asm/hardware/arm_twd.h>
 #include <asm/uaccess.h>
@@ -396,6 +396,7 @@ static int __devexit mpcore_wdt_remove(struct device *dev)
 }
 
 static struct device_driver mpcore_wdt_driver = {
+        .owner          = THIS_MODULE,
         .name           = "mpcore_wdt",
         .bus            = &platform_bus_type,
         .probe          = mpcore_wdt_probe,
diff --git a/drivers/char/watchdog/mv64x60_wdt.c b/drivers/char/watchdog/mv64x60_wdt.c
index 6d3ff0836c44..119b3c541d95 100644
--- a/drivers/char/watchdog/mv64x60_wdt.c
+++ b/drivers/char/watchdog/mv64x60_wdt.c
@@ -22,6 +22,8 @@
 #include <linux/miscdevice.h>
 #include <linux/module.h>
 #include <linux/watchdog.h>
+#include <linux/platform_device.h>
+
 #include <asm/mv64x60.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
@@ -211,6 +213,7 @@ static int __devexit mv64x60_wdt_remove(struct device *dev)
 }
 
 static struct device_driver mv64x60_wdt_driver = {
+        .owner = THIS_MODULE,
         .name = MV64x60_WDT_NAME,
         .bus = &platform_bus_type,
         .probe = mv64x60_wdt_probe,
diff --git a/drivers/char/watchdog/pcwd.c b/drivers/char/watchdog/pcwd.c
index 427ad51b7a35..37c9e13ad3ac 100644
--- a/drivers/char/watchdog/pcwd.c
+++ b/drivers/char/watchdog/pcwd.c
@@ -66,7 +66,7 @@
 #include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/reboot.h>
-
+#include <linux/sched.h>        /* TASK_INTERRUPTIBLE, set_current_state() and friends */
 #include <asm/uaccess.h>
 #include <asm/io.h>
 
diff --git a/drivers/char/watchdog/pcwd_pci.c b/drivers/char/watchdog/pcwd_pci.c
index 0b8e493be045..d9ef55bdf88a 100644
--- a/drivers/char/watchdog/pcwd_pci.c
+++ b/drivers/char/watchdog/pcwd_pci.c
@@ -1,7 +1,7 @@
 /*
  *      Berkshire PCI-PC Watchdog Card Driver
  *
- *      (c) Copyright 2003 Wim Van Sebroeck <wim@iguana.be>.
+ *      (c) Copyright 2003-2005 Wim Van Sebroeck <wim@iguana.be>.
  *
  *      Based on source code of the following authors:
  *        Ken Hollis <kenji@bitgate.com>,
@@ -21,7 +21,9 @@
  */
 
 /*
- *      A bells and whistles driver is available from http://www.pcwd.de/
+ *      A bells and whistles driver is available from: 
+ *      http://www.kernel.org/pub/linux/kernel/people/wim/pcwd/pcwd_pci/
+ *
  *      More info available at http://www.berkprod.com/ or http://www.pcwatchdog.com/
  */
 
@@ -753,6 +755,7 @@ static struct pci_device_id pcipcwd_pci_tbl[] = {
 MODULE_DEVICE_TABLE(pci, pcipcwd_pci_tbl);
 
 static struct pci_driver pcipcwd_driver = {
+        .owner          = THIS_MODULE,
         .name           = WATCHDOG_NAME,
         .id_table       = pcipcwd_pci_tbl,
         .probe          = pcipcwd_card_init,
diff --git a/drivers/char/watchdog/s3c2410_wdt.c b/drivers/char/watchdog/s3c2410_wdt.c
index 3625b2601b42..751cb77b0715 100644
--- a/drivers/char/watchdog/s3c2410_wdt.c
+++ b/drivers/char/watchdog/s3c2410_wdt.c
@@ -44,7 +44,7 @@
 #include <linux/watchdog.h>
 #include <linux/fs.h>
 #include <linux/init.h>
-#include <linux/device.h>
+#include <linux/platform_device.h>
 #include <linux/interrupt.h>
 
 #include <asm/uaccess.h>
@@ -464,32 +464,28 @@ static void s3c2410wdt_shutdown(struct device *dev)
 static unsigned long wtcon_save;
 static unsigned long wtdat_save;
 
-static int s3c2410wdt_suspend(struct device *dev, pm_message_t state, u32 level)
+static int s3c2410wdt_suspend(struct device *dev, pm_message_t state)
 {
-        if (level == SUSPEND_POWER_DOWN) {
-                /* Save watchdog state, and turn it off. */
-                wtcon_save = readl(wdt_base + S3C2410_WTCON);
-                wtdat_save = readl(wdt_base + S3C2410_WTDAT);
+        /* Save watchdog state, and turn it off. */
+        wtcon_save = readl(wdt_base + S3C2410_WTCON);
+        wtdat_save = readl(wdt_base + S3C2410_WTDAT);
 
-                /* Note that WTCNT doesn't need to be saved. */
-                s3c2410wdt_stop();
-        }
+        /* Note that WTCNT doesn't need to be saved. */
+        s3c2410wdt_stop();
 
         return 0;
 }
 
-static int s3c2410wdt_resume(struct device *dev, u32 level)
+static int s3c2410wdt_resume(struct device *dev)
 {
-        if (level == RESUME_POWER_ON) {
-                /* Restore watchdog state. */
+        /* Restore watchdog state. */
 
-                writel(wtdat_save, wdt_base + S3C2410_WTDAT);
-                writel(wtdat_save, wdt_base + S3C2410_WTCNT); /* Reset count */
-                writel(wtcon_save, wdt_base + S3C2410_WTCON);
+        writel(wtdat_save, wdt_base + S3C2410_WTDAT);
+        writel(wtdat_save, wdt_base + S3C2410_WTCNT); /* Reset count */
+        writel(wtcon_save, wdt_base + S3C2410_WTCON);
 
-                printk(KERN_INFO PFX "watchdog %sabled\n",
-                       (wtcon_save & S3C2410_WTCON_ENABLE) ? "en" : "dis");
-        }
+        printk(KERN_INFO PFX "watchdog %sabled\n",
+               (wtcon_save & S3C2410_WTCON_ENABLE) ? "en" : "dis");
 
         return 0;
 }
@@ -501,6 +497,7 @@ static int s3c2410wdt_resume(struct device *dev, u32 level)
 
 
 static struct device_driver s3c2410wdt_driver = {
+        .owner          = THIS_MODULE,
         .name           = "s3c2410-wdt",
         .bus            = &platform_bus_type,
         .probe          = s3c2410wdt_probe,
diff --git a/drivers/char/watchdog/sc520_wdt.c b/drivers/char/watchdog/sc520_wdt.c
index 72501be79b0c..4ee9974ad8cb 100644
--- a/drivers/char/watchdog/sc520_wdt.c
+++ b/drivers/char/watchdog/sc520_wdt.c
@@ -63,6 +63,7 @@
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
+#include <linux/jiffies.h>
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
diff --git a/drivers/char/watchdog/softdog.c b/drivers/char/watchdog/softdog.c
index 20e5eb8667f2..a91edaf3a350 100644
--- a/drivers/char/watchdog/softdog.c
+++ b/drivers/char/watchdog/softdog.c
@@ -47,6 +47,8 @@
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
+#include <linux/jiffies.h>
+
 #include <asm/uaccess.h>
 
 #define PFX "SoftDog: "
diff --git a/drivers/char/watchdog/w83627hf_wdt.c b/drivers/char/watchdog/w83627hf_wdt.c
index b5d821015421..d15ca9a3986f 100644
--- a/drivers/char/watchdog/w83627hf_wdt.c
+++ b/drivers/char/watchdog/w83627hf_wdt.c
@@ -359,5 +359,5 @@ module_exit(wdt_exit);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Pádraig Brady <P@draigBrady.com>");
-MODULE_DESCRIPTION("w38627hf WDT driver");
+MODULE_DESCRIPTION("w83627hf WDT driver");
 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/char/watchdog/wdt_pci.c b/drivers/char/watchdog/wdt_pci.c
index 4b3311993d48..dc9370f6c348 100644
--- a/drivers/char/watchdog/wdt_pci.c
+++ b/drivers/char/watchdog/wdt_pci.c
@@ -711,6 +711,7 @@ MODULE_DEVICE_TABLE(pci, wdtpci_pci_tbl);
 
 
 static struct pci_driver wdtpci_driver = {
+        .owner          = THIS_MODULE,
         .name           = "wdt_pci",
         .id_table       = wdtpci_pci_tbl,
         .probe          = wdtpci_init_one,