17 files changed, 407 insertions, 334 deletions

diff --git a/drivers/char/agp/Kconfig b/drivers/char/agp/Kconfig
index 486ed8a11b59..a4d425d2dce2 100644
--- a/drivers/char/agp/Kconfig
+++ b/drivers/char/agp/Kconfig
@@ -15,22 +15,23 @@ config AGP
           due to kernel allocation issues), you could use PCI accesses
           and have up to a couple gigs of texture space.
 
-          Note that this is the only means to have XFree4/GLX use
+          Note that this is the only means to have X/GLX use
           write-combining with MTRR support on the AGP bus. Without it, OpenGL
           direct rendering will be a lot slower but still faster than PIO.
 
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI.  If unsure, say N.
-
           To compile this driver as a module, choose M here: the
           module will be called agpgart.
 
+          You should say Y here if you want to use GLX or DRI.
+
+          If unsure, say N.
+
 config AGP_ALI
         tristate "ALI chipset support"
         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
+          X on the following ALi chipsets.  The supported chipsets
           include M1541, M1621, M1631, M1632, M1641,M1647,and M1651.
           For the ALi-chipset question, ALi suggests you refer to
           <http://www.ali.com.tw/eng/support/index.shtml>.
@@ -40,28 +41,19 @@ config AGP_ALI
           timing issues, this chipset cannot do AGP 2x with the G200.
           This is a hardware limitation. AGP 1x seems to be fine, though.
 
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI.  If unsure, say N.
-
 config AGP_ATI
         tristate "ATI chipset support"
         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.
-
-      You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-      use GLX or DRI.  If unsure, say N.
+          This option gives you AGP support for the GLX component of
+          X on the ATI RadeonIGP family of chipsets.
 
 config AGP_AMD
         tristate "AMD Irongate, 761, and 762 chipset support"
         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.
-
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI.  If unsure, say N.
+          X on AMD Irongate, 761, and 762 chipsets.
 
 config AGP_AMD64
         tristate "AMD Opteron/Athlon64 on-CPU GART support" if !GART_IOMMU
@@ -69,45 +61,38 @@ config AGP_AMD64
         default y if GART_IOMMU
         help
           This option gives you AGP support for the GLX component of
-          XFree86 4.x using the on-CPU northbridge of the AMD Athlon64/Opteron CPUs.
+          X using the on-CPU northbridge of the AMD Athlon64/Opteron CPUs.
           You still need an external AGP bridge like the AMD 8151, VIA
           K8T400M, SiS755. It may also support other AGP bridges when loaded
           with agp_try_unsupported=1.
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI.  If unsure, say Y
 
 config AGP_INTEL
         tristate "Intel 440LX/BX/GX, I8xx and E7x05 chipset support"
         depends on AGP && X86
         help
-          This option gives you AGP support for the GLX component of XFree86 4.x
+          This option gives you AGP support for the GLX component of X
           on Intel 440LX/BX/GX, 815, 820, 830, 840, 845, 850, 860, 875,
-          E7205 and E7505 chipsets and full support for the 810, 815, 830M, 845G,
-          852GM, 855GM, 865G and I915 integrated graphics chipsets.
+          E7205 and E7505 chipsets and full support for the 810, 815, 830M,
+          845G, 852GM, 855GM, 865G and I915 integrated graphics chipsets.
+
 
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI, or if you have any Intel integrated graphics
-          chipsets.  If unsure, say Y.
 
 config AGP_NVIDIA
         tristate "NVIDIA nForce/nForce2 chipset support"
         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
-          include nForce and nForce2
+          X on NVIDIA chipsets including nForce and nForce2
 
 config AGP_SIS
         tristate "SiS chipset support"
         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.
+          X on Silicon Integrated Systems [SiS] chipsets.
 
           Note that 5591/5592 AGP chipsets are NOT supported.
 
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI.  If unsure, say N.
 
 config AGP_SWORKS
         tristate "Serverworks LE/HE chipset support"
@@ -121,10 +106,7 @@ config AGP_VIA
         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.
-
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI.  If unsure, say N.
+          X on VIA MVP3/Apollo Pro chipsets.
 
 config AGP_I460
         tristate "Intel 460GX chipset support"
@@ -159,9 +141,6 @@ config AGP_EFFICEON
           This option gives you AGP support for the Transmeta Efficeon
           series processors with integrated northbridges.
 
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI.  If unsure, say Y.
-
 config AGP_SGI_TIOCA
         tristate "SGI TIO chipset AGP support"
         depends on AGP && (IA64_SGI_SN2 || IA64_GENERIC)
diff --git a/drivers/char/agp/amd64-agp.c b/drivers/char/agp/amd64-agp.c
index 9964c508c111..1251b2515bbe 100644
--- a/drivers/char/agp/amd64-agp.c
+++ b/drivers/char/agp/amd64-agp.c
@@ -516,8 +516,10 @@ static int __devinit nforce3_agp_init(struct pci_dev *pdev)
         pci_read_config_dword (hammers[0], AMD64_GARTAPERTUREBASE, &apbase);
 
         /* if x86-64 aperture base is beyond 4G, exit here */
-        if ( (apbase & 0x7fff) >> (32 - 25) )
-                 return -ENODEV;
+        if ( (apbase & 0x7fff) >> (32 - 25) ) {
+                printk(KERN_INFO PFX "aperture base > 4G\n");
+                return -ENODEV;
+        }
 
         apbase = (apbase & 0x7fff) << 25;
 
diff --git a/drivers/char/agp/sworks-agp.c b/drivers/char/agp/sworks-agp.c
index 268f78d926d3..efef9999f1cf 100644
--- a/drivers/char/agp/sworks-agp.c
+++ b/drivers/char/agp/sworks-agp.c
@@ -468,9 +468,7 @@ static int __devinit agp_serverworks_probe(struct pci_dev *pdev,
 
         switch (pdev->device) {
         case 0x0006:
-                /* ServerWorks CNB20HE
-                Fail silently.*/
-                printk (KERN_ERR PFX "Detected ServerWorks CNB20HE chipset: No AGP present.\n");
+                printk (KERN_ERR PFX "ServerWorks CNB20HE is unsupported due to lack of documentation.\n");
                 return -ENODEV;
 
         case PCI_DEVICE_ID_SERVERWORKS_HE:
diff --git a/drivers/char/drm/drm_pciids.h b/drivers/char/drm/drm_pciids.h
index 8fd6357a48da..2c17e88a8847 100644
--- a/drivers/char/drm/drm_pciids.h
+++ b/drivers/char/drm/drm_pciids.h
@@ -85,7 +85,6 @@
         {0x1002, 0x5969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \
         {0x1002, 0x596A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \
         {0x1002, 0x596B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \
-        {0x1002, 0x5b60, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350}, \
         {0x1002, 0x5c61, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|CHIP_IS_MOBILITY}, \
         {0x1002, 0x5c62, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \
         {0x1002, 0x5c63, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|CHIP_IS_MOBILITY}, \
diff --git a/drivers/char/drm/i915_irq.c b/drivers/char/drm/i915_irq.c
index a1381c61aa63..d3879ac9970f 100644
--- a/drivers/char/drm/i915_irq.c
+++ b/drivers/char/drm/i915_irq.c
@@ -202,10 +202,15 @@ void i915_driver_irq_postinstall(drm_device_t * dev)
 void i915_driver_irq_uninstall(drm_device_t * dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+        u16 temp;
+
         if (!dev_priv)
                 return;
 
         I915_WRITE16(I915REG_HWSTAM, 0xffff);
         I915_WRITE16(I915REG_INT_MASK_R, 0xffff);
         I915_WRITE16(I915REG_INT_ENABLE_R, 0x0);
+
+        temp = I915_READ16(I915REG_INT_IDENTITY_R);
+        I915_WRITE16(I915REG_INT_IDENTITY_R, temp);
 }
diff --git a/drivers/char/drm/r300_cmdbuf.c b/drivers/char/drm/r300_cmdbuf.c
index 291dbf4c8186..c08fa5076f05 100644
--- a/drivers/char/drm/r300_cmdbuf.c
+++ b/drivers/char/drm/r300_cmdbuf.c
@@ -161,6 +161,7 @@ void r300_init_reg_flags(void)
         ADD_RANGE(R300_VAP_PVS_CNTL_1, 3);
         ADD_RANGE(R300_GB_ENABLE, 1);
         ADD_RANGE(R300_GB_MSPOS0, 5);
+        ADD_RANGE(R300_TX_CNTL, 1);
         ADD_RANGE(R300_TX_ENABLE, 1);
         ADD_RANGE(0x4200, 4);
         ADD_RANGE(0x4214, 1);
@@ -489,6 +490,50 @@ static __inline__ int r300_emit_3d_load_vbpntr(drm_radeon_private_t *dev_priv,
 
         return 0;
 }
+static __inline__ int r300_emit_bitblt_multi(drm_radeon_private_t *dev_priv,
+                                             drm_radeon_kcmd_buffer_t *cmdbuf)
+{
+        u32 *cmd = (u32 *) cmdbuf->buf;
+        int count, ret;
+        RING_LOCALS;
+
+        count=(cmd[0]>>16) & 0x3fff;
+
+        if (cmd[0] & 0x8000) {
+                u32 offset;
+
+                if (cmd[1] & (RADEON_GMC_SRC_PITCH_OFFSET_CNTL 
+                              | RADEON_GMC_DST_PITCH_OFFSET_CNTL)) {
+                        offset = cmd[2] << 10;
+                        ret = r300_check_offset(dev_priv, offset);
+                        if (ret) {
+                                DRM_ERROR("Invalid bitblt first offset is %08X\n", offset);
+                                return DRM_ERR(EINVAL);
+                        }
+                }
+
+                if ((cmd[1] & RADEON_GMC_SRC_PITCH_OFFSET_CNTL) &&
+                    (cmd[1] & RADEON_GMC_DST_PITCH_OFFSET_CNTL)) {
+                        offset = cmd[3] << 10;
+                        ret = r300_check_offset(dev_priv, offset);
+                        if (ret) {
+                                DRM_ERROR("Invalid bitblt second offset is %08X\n", offset);
+                                return DRM_ERR(EINVAL);
+                        }
+                        
+                }
+        }
+
+        BEGIN_RING(count+2);
+        OUT_RING(cmd[0]);
+        OUT_RING_TABLE((int *)(cmdbuf->buf + 4), count + 1);
+        ADVANCE_RING();
+
+        cmdbuf->buf += (count+2)*4;
+        cmdbuf->bufsz -= (count+2)*4;
+
+        return 0;
+}
 
 static __inline__ int r300_emit_raw_packet3(drm_radeon_private_t *dev_priv,
                                             drm_radeon_kcmd_buffer_t *cmdbuf)
@@ -527,6 +572,9 @@ static __inline__ int r300_emit_raw_packet3(drm_radeon_private_t *dev_priv,
         case RADEON_3D_LOAD_VBPNTR:     /* load vertex array pointers */
                 return r300_emit_3d_load_vbpntr(dev_priv, cmdbuf, header);
 
+        case RADEON_CNTL_BITBLT_MULTI:
+                return r300_emit_bitblt_multi(dev_priv, cmdbuf);
+
         case RADEON_CP_3D_DRAW_IMMD_2:  /* triggers drawing using in-packet vertex data */
         case RADEON_CP_3D_DRAW_VBUF_2:  /* triggers drawing of vertex buffers setup elsewhere */
         case RADEON_CP_3D_DRAW_INDX_2:  /* triggers drawing using indices to vertex buffer */
diff --git a/drivers/char/drm/r300_reg.h b/drivers/char/drm/r300_reg.h
index a0ed20e25221..d1e19954406b 100644
--- a/drivers/char/drm/r300_reg.h
+++ b/drivers/char/drm/r300_reg.h
@@ -451,6 +451,9 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 /* END */
 
 /* gap */
+/* Zero to flush caches. */
+#define R300_TX_CNTL                        0x4100
+
 /* The upper enable bits are guessed, based on fglrx reported limits. */
 #define R300_TX_ENABLE                      0x4104
 #       define R300_TX_ENABLE_0                  (1 << 0)
diff --git a/drivers/char/drm/radeon_drv.h b/drivers/char/drm/radeon_drv.h
index 498b19b1d641..1f7d2ab8c4fc 100644
--- a/drivers/char/drm/radeon_drv.h
+++ b/drivers/char/drm/radeon_drv.h
@@ -90,9 +90,10 @@
  * 1.19- Add support for gart table in FB memory and PCIE r300
  * 1.20- Add support for r300 texrect
  * 1.21- Add support for card type getparam
+ * 1.22- Add support for texture cache flushes (R300_TX_CNTL)
  */
 #define DRIVER_MAJOR            1
-#define DRIVER_MINOR            21
+#define DRIVER_MINOR            22
 #define DRIVER_PATCHLEVEL       0
 
 /*
diff --git a/drivers/char/esp.c b/drivers/char/esp.c
index 57539d8f9f7c..09dc4b01232c 100644
--- a/drivers/char/esp.c
+++ b/drivers/char/esp.c
@@ -150,17 +150,6 @@ static void rs_wait_until_sent(struct tty_struct *, int);
 /* Standard COM flags (except for COM4, because of the 8514 problem) */
 #define STD_COM_FLAGS (ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST)
 
-/*
- * tmp_buf is used as a temporary buffer by serial_write.  We need to
- * lock it in case the memcpy_fromfs blocks while swapping in a page,
- * and some other program tries to do a serial write at the same time.
- * Since the lock will only come under contention when the system is
- * swapping and available memory is low, it makes sense to share one
- * buffer across all the serial ports, since it significantly saves
- * memory if large numbers of serial ports are open.
- */
-static unsigned char *tmp_buf;
-
 static inline int serial_paranoia_check(struct esp_struct *info,
                                         char *name, const char *routine)
 {
@@ -1267,7 +1256,7 @@ static int rs_write(struct tty_struct * tty,
         if (serial_paranoia_check(info, tty->name, "rs_write"))
                 return 0;
 
-        if (!tty || !info->xmit_buf || !tmp_buf)
+        if (!tty || !info->xmit_buf)
                 return 0;
             
         while (1) {
@@ -2291,11 +2280,7 @@ static int esp_open(struct tty_struct *tty, struct file * filp)
         tty->driver_data = info;
         info->tty = tty;
 
-        if (!tmp_buf) {
-                tmp_buf = (unsigned char *) get_zeroed_page(GFP_KERNEL);
-                if (!tmp_buf)
-                        return -ENOMEM;
-        }
+        spin_unlock_irqrestore(&info->lock, flags);
         
         /*
          * Start up serial port
@@ -2602,9 +2587,6 @@ static void __exit espserial_exit(void)
                 free_pages((unsigned long)dma_buffer,
                         get_order(DMA_BUFFER_SZ));
 
-        if (tmp_buf)
-                free_page((unsigned long)tmp_buf);
-
         while (free_pio_buf) {
                 pio_buf = free_pio_buf->next;
                 kfree(free_pio_buf);
diff --git a/drivers/char/hpet.c b/drivers/char/hpet.c
index 66a2fee06eb9..ef140ebde117 100644
--- a/drivers/char/hpet.c
+++ b/drivers/char/hpet.c
@@ -956,22 +956,18 @@ static acpi_status hpet_resources(struct acpi_resource *res, void *data)
                 }
         } else if (res->type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) {
                 struct acpi_resource_extended_irq *irqp;
-                int i;
+                int i, irq;
 
                 irqp = &res->data.extended_irq;
 
-                if (irqp->interrupt_count > 0) {
-                        hdp->hd_nirqs = irqp->interrupt_count;
-
-                        for (i = 0; i < hdp->hd_nirqs; i++) {
-                                int rc =
-                                    acpi_register_gsi(irqp->interrupts[i],
-                                                      irqp->triggering,
-                                                      irqp->polarity);
-                                if (rc < 0)
-                                        return AE_ERROR;
-                                hdp->hd_irq[i] = rc;
-                        }
+                for (i = 0; i < irqp->interrupt_count; i++) {
+                        irq = acpi_register_gsi(irqp->interrupts[i],
+                                      irqp->triggering, irqp->polarity);
+                        if (irq < 0)
+                                return AE_ERROR;
+
+                        hdp->hd_irq[hdp->hd_nirqs] = irq;
+                        hdp->hd_nirqs++;
                 }
         }
 
diff --git a/drivers/char/hvc_console.c b/drivers/char/hvc_console.c
index 1994a92d4733..f65b2e14a485 100644
--- a/drivers/char/hvc_console.c
+++ b/drivers/char/hvc_console.c
@@ -335,6 +335,8 @@ static int hvc_open(struct tty_struct *tty, struct file * filp)
         } /* else count == 0 */
 
         tty->driver_data = hp;
+        tty->low_latency = 1; /* Makes flushes to ldisc synchronous. */
+
         hp->tty = tty;
         /* Save for request_irq outside of spin_lock. */
         irq = hp->irq;
@@ -633,9 +635,6 @@ static int hvc_poll(struct hvc_struct *hp)
                         tty_insert_flip_char(tty, buf[i], 0);
                 }
 
-                if (count)
-                        tty_schedule_flip(tty);
-
                 /*
                  * Account for the total amount read in one loop, and if above
                  * 64 bytes, we do a quick schedule loop to let the tty grok
@@ -656,6 +655,9 @@ static int hvc_poll(struct hvc_struct *hp)
  bail:
         spin_unlock_irqrestore(&hp->lock, flags);
 
+        if (read_total)
+                tty_flip_buffer_push(tty);
+        
         return poll_mask;
 }
 
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index 5765f672e853..d58f82318853 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -243,7 +243,7 @@ static struct sysrq_key_op sysrq_term_op = {
 
 static void moom_callback(void *ignored)
 {
-        out_of_memory(GFP_KERNEL, 0);
+        out_of_memory(&NODE_DATA(0)->node_zonelists[ZONE_NORMAL], GFP_KERNEL, 0);
 }
 
 static DECLARE_WORK(moom_work, moom_callback, NULL);
diff --git a/drivers/char/tipar.c b/drivers/char/tipar.c
index 41a94bc79f67..eb2eb3e12d6a 100644
--- a/drivers/char/tipar.c
+++ b/drivers/char/tipar.c
@@ -250,12 +250,17 @@ tipar_open(struct inode *inode, struct file *file)
 {
         unsigned int minor = iminor(inode) - TIPAR_MINOR;
 
-        if (minor > tp_count - 1)
+        if (tp_count == 0 || minor > tp_count - 1)
                 return -ENXIO;
 
         if (test_and_set_bit(minor, &opened))
                 return -EBUSY;
 
+        if (!table[minor].dev) {
+                printk(KERN_ERR "%s: NULL device for minor %u\n",
+                                __FUNCTION__, minor);
+                return -ENXIO;
+        }
         parport_claim_or_block(table[minor].dev);
         init_ti_parallel(minor);
         parport_release(table[minor].dev);
@@ -510,16 +515,20 @@ tipar_init_module(void)
                 err = PTR_ERR(tipar_class);
                 goto out_chrdev;
         }
-        if (parport_register_driver(&tipar_driver)) {
+        if (parport_register_driver(&tipar_driver) || tp_count == 0) {
                 printk(KERN_ERR "tipar: unable to register with parport\n");
                 err = -EIO;
-                goto out;
+                goto out_class;
         }
 
         err = 0;
         goto out;
 
+out_class:
+        class_destroy(tipar_class);
+
 out_chrdev:
+        devfs_remove("ticables/par");
         unregister_chrdev(TIPAR_MAJOR, "tipar");
 out:
         return err;     
diff --git a/drivers/char/tpm/tpm_infineon.c b/drivers/char/tpm/tpm_infineon.c
index ec7590951af5..24095f6ee6da 100644
--- a/drivers/char/tpm/tpm_infineon.c
+++ b/drivers/char/tpm/tpm_infineon.c
@@ -33,6 +33,7 @@
 static int TPM_INF_DATA;
 static int TPM_INF_ADDR;
 static int TPM_INF_BASE;
+static int TPM_INF_ADDR_LEN;
 static int TPM_INF_PORT_LEN;
 
 /* TPM header definitions */
@@ -195,6 +196,7 @@ static int tpm_inf_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         int i;
         int ret;
         u32 size = 0;
+        number_of_wtx = 0;
 
 recv_begin:
         /* start receiving header */
@@ -378,24 +380,35 @@ static int __devinit tpm_inf_pnp_probe(struct pnp_dev *dev,
         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_ADDR_LEN = pnp_port_len(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;
+                if ((TPM_INF_PORT_LEN < 4) || (TPM_INF_ADDR_LEN < 2)) {
+                        rc = -EINVAL;
+                        goto err_last;
+                }
                 dev_info(&dev->dev, "Found %s with ID %s\n",
                          dev->name, dev_id->id);
-                if (!((TPM_INF_BASE >> 8) & 0xff))
-                        return -EINVAL;
+                if (!((TPM_INF_BASE >> 8) & 0xff)) {
+                        rc = -EINVAL;
+                        goto err_last;
+                }
                 /* 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;
+                        rc = -EINVAL;
+                        goto err_last;
+                }
+                if (request_region(TPM_INF_ADDR, TPM_INF_ADDR_LEN,
+                                "tpm_infineon0") == NULL) {
+                        rc = -EINVAL;
+                        goto err_last;
                 }
         } else {
-                return -EINVAL;
+                rc = -EINVAL;
+                goto err_last;
         }
 
         /* query chip for its vendor, its version number a.s.o. */
@@ -443,8 +456,8 @@ static int __devinit tpm_inf_pnp_probe(struct pnp_dev *dev,
                         dev_err(&dev->dev,
                                 "Could not set IO-ports to 0x%lx\n",
                                 tpm_inf.base);
-                        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
-                        return -EIO;
+                        rc = -EIO;
+                        goto err_release_region;
                 }
 
                 /* activate register */
@@ -471,14 +484,21 @@ static int __devinit tpm_inf_pnp_probe(struct pnp_dev *dev,
 
                 rc = tpm_register_hardware(&dev->dev, &tpm_inf);
                 if (rc < 0) {
-                        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
-                        return -ENODEV;
+                        rc = -ENODEV;
+                        goto err_release_region;
                 }
                 return 0;
         } else {
-                dev_info(&dev->dev, "No Infineon TPM found!\n");
-                return -ENODEV;
+                rc = -ENODEV;
+                goto err_release_region;
         }
+
+err_release_region:
+        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
+        release_region(TPM_INF_ADDR, TPM_INF_ADDR_LEN);
+
+err_last:
+        return rc;
 }
 
 static __devexit void tpm_inf_pnp_remove(struct pnp_dev *dev)
@@ -518,5 +538,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.6");
+MODULE_VERSION("1.7");
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 076e07c1da38..e9bba94fc898 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -268,6 +268,8 @@ static struct tty_buffer *tty_buffer_alloc(size_t size)
         p->size = size;
         p->next = NULL;
         p->active = 0;
+        p->commit = 0;
+        p->read = 0;
         p->char_buf_ptr = (char *)(p->data);
         p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
 /*      printk("Flip create %p\n", p); */
@@ -298,6 +300,8 @@ static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
                         *tbh = t->next;
                         t->next = NULL;
                         t->used = 0;
+                        t->commit = 0;
+                        t->read = 0;
                         /* DEBUG ONLY */
                         memset(t->data, '*', size);
 /*                      printk("Flip recycle %p\n", t); */
@@ -335,6 +339,7 @@ int tty_buffer_request_room(struct tty_struct *tty, size_t size)
                         if (b != NULL) {
                                 b->next = n;
                                 b->active = 0;
+                                b->commit = b->used;
                         } else
                                 tty->buf.head = n;
                         tty->buf.tail = n;
@@ -1836,7 +1841,6 @@ static void release_dev(struct file * filp)
                 tty_closing = tty->count <= 1;
                 o_tty_closing = o_tty &&
                         (o_tty->count <= (pty_master ? 1 : 0));
-                up(&tty_sem);
                 do_sleep = 0;
 
                 if (tty_closing) {
@@ -1864,6 +1868,7 @@ static void release_dev(struct file * filp)
 
                 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
                                     "active!\n", tty_name(tty, buf));
+                up(&tty_sem);
                 schedule();
         }       
 
@@ -1872,8 +1877,6 @@ static void release_dev(struct file * filp)
          * both sides, and we've completed the last operation that could 
          * block, so it's safe to proceed with closing.
          */
-         
-        down(&tty_sem);
         if (pty_master) {
                 if (--o_tty->count < 0) {
                         printk(KERN_WARNING "release_dev: bad pty slave count "
@@ -1887,7 +1890,6 @@ static void release_dev(struct file * filp)
                        tty->count, tty_name(tty, buf));
                 tty->count = 0;
         }
-        up(&tty_sem);
         
         /*
          * We've decremented tty->count, so we need to remove this file
@@ -1932,6 +1934,8 @@ static void release_dev(struct file * filp)
                 read_unlock(&tasklist_lock);
         }
 
+        up(&tty_sem);
+
         /* check whether both sides are closing ... */
         if (!tty_closing || (o_tty && !o_tty_closing))
                 return;
@@ -2752,6 +2756,9 @@ static void flush_to_ldisc(void *private_)
         unsigned long   flags;
         struct tty_ldisc *disc;
         struct tty_buffer *tbuf;
+        int count;
+        char *char_buf;
+        unsigned char *flag_buf;
 
         disc = tty_ldisc_ref(tty);
         if (disc == NULL)       /*  !TTY_LDISC */
@@ -2765,16 +2772,20 @@ static void flush_to_ldisc(void *private_)
                 goto out;
         }
         spin_lock_irqsave(&tty->buf.lock, flags);
-        while((tbuf = tty->buf.head) != NULL && !tbuf->active) {
+        while((tbuf = tty->buf.head) != NULL) {
+                while ((count = tbuf->commit - tbuf->read) != 0) {
+                        char_buf = tbuf->char_buf_ptr + tbuf->read;
+                        flag_buf = tbuf->flag_buf_ptr + tbuf->read;
+                        tbuf->read += count;
+                        spin_unlock_irqrestore(&tty->buf.lock, flags);
+                        disc->receive_buf(tty, char_buf, flag_buf, count);
+                        spin_lock_irqsave(&tty->buf.lock, flags);
+                }
+                if (tbuf->active)
+                        break;
                 tty->buf.head = tbuf->next;
                 if (tty->buf.head == NULL)
                         tty->buf.tail = NULL;
-                spin_unlock_irqrestore(&tty->buf.lock, flags);
-                /* printk("Process buffer %p for %d\n", tbuf, tbuf->used); */
-                disc->receive_buf(tty, tbuf->char_buf_ptr,
-                                       tbuf->flag_buf_ptr,
-                                       tbuf->used);
-                spin_lock_irqsave(&tty->buf.lock, flags);
                 tty_buffer_free(tty, tbuf);
         }
         spin_unlock_irqrestore(&tty->buf.lock, flags);
@@ -2871,8 +2882,10 @@ void tty_flip_buffer_push(struct tty_struct *tty)
 {
         unsigned long flags;
         spin_lock_irqsave(&tty->buf.lock, flags);
-        if (tty->buf.tail != NULL)
+        if (tty->buf.tail != NULL) {
                 tty->buf.tail->active = 0;
+                tty->buf.tail->commit = tty->buf.tail->used;
+        }
         spin_unlock_irqrestore(&tty->buf.lock, flags);
 
         if (tty->low_latency)
diff --git a/drivers/char/watchdog/pcwd.c b/drivers/char/watchdog/pcwd.c
index 37c9e13ad3ac..8d6b249ad66b 100644
--- a/drivers/char/watchdog/pcwd.c
+++ b/drivers/char/watchdog/pcwd.c
@@ -49,29 +49,37 @@
  *      More info available at http://www.berkprod.com/ or http://www.pcwatchdog.com/
  */
 
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/types.h>
-#include <linux/timer.h>
-#include <linux/jiffies.h>
-#include <linux/config.h>
-#include <linux/wait.h>
-#include <linux/slab.h>
-#include <linux/ioport.h>
-#include <linux/delay.h>
-#include <linux/fs.h>
-#include <linux/miscdevice.h>
-#include <linux/watchdog.h>
-#include <linux/notifier.h>
-#include <linux/init.h>
-#include <linux/spinlock.h>
-#include <linux/reboot.h>
+#include <linux/config.h>       /* For CONFIG_WATCHDOG_NOWAYOUT/... */
+#include <linux/module.h>       /* For module specific items */
+#include <linux/moduleparam.h>  /* For new moduleparam's */
+#include <linux/types.h>        /* For standard types (like size_t) */
+#include <linux/errno.h>        /* For the -ENODEV/... values */
+#include <linux/kernel.h>       /* For printk/panic/... */
+#include <linux/delay.h>        /* For mdelay function */
+#include <linux/timer.h>        /* For timer related operations */
+#include <linux/jiffies.h>      /* For jiffies stuff */
+#include <linux/miscdevice.h>   /* For MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR) */
+#include <linux/watchdog.h>     /* For the watchdog specific items */
+#include <linux/notifier.h>     /* For notifier support */
+#include <linux/reboot.h>       /* For reboot_notifier stuff */
+#include <linux/init.h>         /* For __init/__exit/... */
+#include <linux/fs.h>           /* For file operations */
+#include <linux/ioport.h>       /* For io-port access */
+#include <linux/spinlock.h>     /* For spin_lock/spin_unlock/... */
 #include <linux/sched.h>        /* TASK_INTERRUPTIBLE, set_current_state() and friends */
-#include <asm/uaccess.h>
-#include <asm/io.h>
+#include <linux/slab.h>         /* For kmalloc */
 
-#define WD_VER                  "1.16 (06/12/2004)"
-#define PFX                     "pcwd: "
+#include <asm/uaccess.h>        /* For copy_to_user/put_user/... */
+#include <asm/io.h>             /* For inb/outb/... */
+
+/* Module and version information */
+#define WATCHDOG_VERSION "1.16"
+#define WATCHDOG_DATE "03 Jan 2006"
+#define WATCHDOG_DRIVER_NAME "ISA-PC Watchdog"
+#define WATCHDOG_NAME "pcwd"
+#define PFX WATCHDOG_NAME ": "
+#define DRIVER_VERSION WATCHDOG_DRIVER_NAME " driver, v" WATCHDOG_VERSION " (" WATCHDOG_DATE ")\n"
+#define WD_VER WATCHDOG_VERSION " (" WATCHDOG_DATE ")"
 
 /*
  * It should be noted that PCWD_REVISION_B was removed because A and B
@@ -85,36 +93,38 @@
 
 /*
  * These are the defines that describe the control status bits for the
- * PC Watchdog card, revision A.
- */
+ * PCI-PC Watchdog card.
+*/
+/* Port 1 : Control Status #1 for the PC Watchdog card, revision A. */
 #define WD_WDRST                0x01    /* Previously reset state */
 #define WD_T110                 0x02    /* Temperature overheat sense */
 #define WD_HRTBT                0x04    /* Heartbeat sense */
 #define WD_RLY2                 0x08    /* External relay triggered */
 #define WD_SRLY2                0x80    /* Software external relay triggered */
-
-/*
- * These are the defines that describe the control status bits for the
- * PC Watchdog card, revision C.
- */
+/* Port 1 : Control Status #1 for the PC Watchdog card, revision C. */
 #define WD_REVC_WTRP            0x01    /* Watchdog Trip status */
 #define WD_REVC_HRBT            0x02    /* Watchdog Heartbeat */
 #define WD_REVC_TTRP            0x04    /* Temperature Trip status */
+/* Port 2 : Control Status #2 */
+#define WD_WDIS                 0x10    /* Watchdog Disabled */
+#define WD_ENTP                 0x20    /* Watchdog Enable Temperature Trip */
+#define WD_SSEL                 0x40    /* Watchdog Switch Select (1:SW1 <-> 0:SW2) */
+#define WD_WCMD                 0x80    /* Watchdog Command Mode */
 
 /* max. time we give an ISA watchdog card to process a command */
 /* 500ms for each 4 bit response (according to spec.) */
 #define ISA_COMMAND_TIMEOUT     1000
 
 /* Watchdog's internal commands */
-#define CMD_ISA_IDLE                    0x00
-#define CMD_ISA_VERSION_INTEGER         0x01
-#define CMD_ISA_VERSION_TENTH           0x02
-#define CMD_ISA_VERSION_HUNDRETH        0x03
-#define CMD_ISA_VERSION_MINOR           0x04
-#define CMD_ISA_SWITCH_SETTINGS         0x05
-#define CMD_ISA_DELAY_TIME_2SECS        0x0A
-#define CMD_ISA_DELAY_TIME_4SECS        0x0B
-#define CMD_ISA_DELAY_TIME_8SECS        0x0C
+#define CMD_ISA_IDLE                    0x00
+#define CMD_ISA_VERSION_INTEGER         0x01
+#define CMD_ISA_VERSION_TENTH           0x02
+#define CMD_ISA_VERSION_HUNDRETH        0x03
+#define CMD_ISA_VERSION_MINOR           0x04
+#define CMD_ISA_SWITCH_SETTINGS         0x05
+#define CMD_ISA_DELAY_TIME_2SECS        0x0A
+#define CMD_ISA_DELAY_TIME_4SECS        0x0B
+#define CMD_ISA_DELAY_TIME_8SECS        0x0C
 
 /*
  * We are using an kernel timer to do the pinging of the watchdog
@@ -130,15 +140,17 @@ static int cards_found;
 /* internal variables */
 static atomic_t open_allowed = ATOMIC_INIT(1);
 static char expect_close;
-static struct timer_list timer;
-static unsigned long next_heartbeat;
 static int temp_panic;
-static int revision;                    /* The card's revision */
-static int supports_temp;               /* Wether or not the card has a temperature device */
-static int command_mode;                /* Wether or not the card is in command mode */
-static int initial_status;              /* The card's boot status */
-static int current_readport;            /* The cards I/O address */
-static spinlock_t io_lock;
+static struct {                         /* this is private data for each ISA-PC watchdog card */
+        int revision;                   /* The card's revision */
+        int supports_temp;              /* Wether or not the card has a temperature device */
+        int command_mode;               /* Wether or not the card is in command mode */
+        int boot_status;                /* The card's boot status */
+        int io_addr;                    /* The cards I/O address */
+        spinlock_t io_lock;             /* the lock for io operations */
+        struct timer_list timer;        /* The timer that pings the watchdog */
+        unsigned long next_heartbeat;   /* the next_heartbeat for the timer */
+} pcwd_private;
 
 /* module parameters */
 #define WATCHDOG_HEARTBEAT 60           /* 60 sec default heartbeat */
@@ -161,14 +173,14 @@ static int send_isa_command(int cmd)
         int port0, last_port0;  /* Double read for stabilising */
 
         /* The WCMD bit must be 1 and the command is only 4 bits in size */
-        control_status = (cmd & 0x0F) | 0x80;
-        outb_p(control_status, current_readport + 2);
+        control_status = (cmd & 0x0F) | WD_WCMD;
+        outb_p(control_status, pcwd_private.io_addr + 2);
         udelay(ISA_COMMAND_TIMEOUT);
 
-        port0 = inb_p(current_readport);
+        port0 = inb_p(pcwd_private.io_addr);
         for (i = 0; i < 25; ++i) {
                 last_port0 = port0;
-                port0 = inb_p(current_readport);
+                port0 = inb_p(pcwd_private.io_addr);
 
                 if (port0 == last_port0)
                         break;  /* Data is stable */
@@ -184,7 +196,7 @@ static int set_command_mode(void)
         int i, found=0, count=0;
 
         /* Set the card into command mode */
-        spin_lock(&io_lock);
+        spin_lock(&pcwd_private.io_lock);
         while ((!found) && (count < 3)) {
                 i = send_isa_command(CMD_ISA_IDLE);
 
@@ -192,15 +204,15 @@ static int set_command_mode(void)
                         found = 1;
                 else if (i == 0xF3) {
                         /* Card does not like what we've done to it */
-                        outb_p(0x00, current_readport + 2);
+                        outb_p(0x00, pcwd_private.io_addr + 2);
                         udelay(1200);   /* Spec says wait 1ms */
-                        outb_p(0x00, current_readport + 2);
+                        outb_p(0x00, pcwd_private.io_addr + 2);
                         udelay(ISA_COMMAND_TIMEOUT);
                 }
                 count++;
         }
-        spin_unlock(&io_lock);
-        command_mode = found;
+        spin_unlock(&pcwd_private.io_lock);
+        pcwd_private.command_mode = found;
 
         return(found);
 }
@@ -208,12 +220,95 @@ static int set_command_mode(void)
 static void unset_command_mode(void)
 {
         /* Set the card into normal mode */
-        spin_lock(&io_lock);
-        outb_p(0x00, current_readport + 2);
+        spin_lock(&pcwd_private.io_lock);
+        outb_p(0x00, pcwd_private.io_addr + 2);
         udelay(ISA_COMMAND_TIMEOUT);
-        spin_unlock(&io_lock);
+        spin_unlock(&pcwd_private.io_lock);
+
+        pcwd_private.command_mode = 0;
+}
+
+static inline void pcwd_check_temperature_support(void)
+{
+        if (inb(pcwd_private.io_addr) != 0xF0)
+                pcwd_private.supports_temp = 1;
+}
+
+static inline char *get_firmware(void)
+{
+        int one, ten, hund, minor;
+        char *ret;
+
+        ret = kmalloc(6, GFP_KERNEL);
+        if(ret == NULL)
+                return NULL;
+
+        if (set_command_mode()) {
+                one = send_isa_command(CMD_ISA_VERSION_INTEGER);
+                ten = send_isa_command(CMD_ISA_VERSION_TENTH);
+                hund = send_isa_command(CMD_ISA_VERSION_HUNDRETH);
+                minor = send_isa_command(CMD_ISA_VERSION_MINOR);
+                sprintf(ret, "%c.%c%c%c", one, ten, hund, minor);
+        }
+        else
+                sprintf(ret, "ERROR");
+
+        unset_command_mode();
+        return(ret);
+}
+
+static inline int pcwd_get_option_switches(void)
+{
+        int option_switches=0;
+
+        if (set_command_mode()) {
+                /* Get switch settings */
+                option_switches = send_isa_command(CMD_ISA_SWITCH_SETTINGS);
+        }
+
+        unset_command_mode();
+        return(option_switches);
+}
+
+static void pcwd_show_card_info(void)
+{
+        char *firmware;
+        int option_switches;
+
+        /* Get some extra info from the hardware (in command/debug/diag mode) */
+        if (pcwd_private.revision == PCWD_REVISION_A)
+                printk(KERN_INFO PFX "ISA-PC Watchdog (REV.A) detected at port 0x%04x\n", pcwd_private.io_addr);
+        else if (pcwd_private.revision == PCWD_REVISION_C) {
+                firmware = get_firmware();
+                printk(KERN_INFO PFX "ISA-PC Watchdog (REV.C) detected at port 0x%04x (Firmware version: %s)\n",
+                        pcwd_private.io_addr, firmware);
+                kfree(firmware);
+                option_switches = pcwd_get_option_switches();
+                printk(KERN_INFO PFX "Option switches (0x%02x): Temperature Reset Enable=%s, Power On Delay=%s\n",
+                        option_switches,
+                        ((option_switches & 0x10) ? "ON" : "OFF"),
+                        ((option_switches & 0x08) ? "ON" : "OFF"));
+
+                /* Reprogram internal heartbeat to 2 seconds */
+                if (set_command_mode()) {
+                        send_isa_command(CMD_ISA_DELAY_TIME_2SECS);
+                        unset_command_mode();
+                }
+        }
+
+        if (pcwd_private.supports_temp)
+                printk(KERN_INFO PFX "Temperature Option Detected\n");
+
+        if (pcwd_private.boot_status & WDIOF_CARDRESET)
+                printk(KERN_INFO PFX "Previous reboot was caused by the card\n");
+
+        if (pcwd_private.boot_status & WDIOF_OVERHEAT) {
+                printk(KERN_EMERG PFX "Card senses a CPU Overheat. Panicking!\n");
+                printk(KERN_EMERG PFX "CPU Overheat\n");
+        }
 
-        command_mode = 0;
+        if (pcwd_private.boot_status == 0)
+                printk(KERN_INFO PFX "No previous trip detected - Cold boot or reset\n");
 }
 
 static void pcwd_timer_ping(unsigned long data)
@@ -222,25 +317,25 @@ static void pcwd_timer_ping(unsigned long data)
 
         /* If we got a heartbeat pulse within the WDT_INTERVAL
          * we agree to ping the WDT */
-        if(time_before(jiffies, next_heartbeat)) {
+        if(time_before(jiffies, pcwd_private.next_heartbeat)) {
                 /* Ping the watchdog */
-                spin_lock(&io_lock);
-                if (revision == PCWD_REVISION_A) {
+                spin_lock(&pcwd_private.io_lock);
+                if (pcwd_private.revision == PCWD_REVISION_A) {
                         /*  Rev A cards are reset by setting the WD_WDRST bit in register 1 */
-                        wdrst_stat = inb_p(current_readport);
+                        wdrst_stat = inb_p(pcwd_private.io_addr);
                         wdrst_stat &= 0x0F;
                         wdrst_stat |= WD_WDRST;
 
-                        outb_p(wdrst_stat, current_readport + 1);
+                        outb_p(wdrst_stat, pcwd_private.io_addr + 1);
                 } else {
                         /* Re-trigger watchdog by writing to port 0 */
-                        outb_p(0x00, current_readport);
+                        outb_p(0x00, pcwd_private.io_addr);
                 }
 
                 /* Re-set the timer interval */
-                mod_timer(&timer, jiffies + WDT_INTERVAL);
+                mod_timer(&pcwd_private.timer, jiffies + WDT_INTERVAL);
 
-                spin_unlock(&io_lock);
+                spin_unlock(&pcwd_private.io_lock);
         } else {
                 printk(KERN_WARNING PFX "Heartbeat lost! Will not ping the watchdog\n");
         }
@@ -250,19 +345,19 @@ static int pcwd_start(void)
 {
         int stat_reg;
 
-        next_heartbeat = jiffies + (heartbeat * HZ);
+        pcwd_private.next_heartbeat = jiffies + (heartbeat * HZ);
 
         /* Start the timer */
-        mod_timer(&timer, jiffies + WDT_INTERVAL);
+        mod_timer(&pcwd_private.timer, jiffies + WDT_INTERVAL);
 
         /* Enable the port */
-        if (revision == PCWD_REVISION_C) {
-                spin_lock(&io_lock);
-                outb_p(0x00, current_readport + 3);
+        if (pcwd_private.revision == PCWD_REVISION_C) {
+                spin_lock(&pcwd_private.io_lock);
+                outb_p(0x00, pcwd_private.io_addr + 3);
                 udelay(ISA_COMMAND_TIMEOUT);
-                stat_reg = inb_p(current_readport + 2);
-                spin_unlock(&io_lock);
-                if (stat_reg & 0x10) {
+                stat_reg = inb_p(pcwd_private.io_addr + 2);
+                spin_unlock(&pcwd_private.io_lock);
+                if (stat_reg & WD_WDIS) {
                         printk(KERN_INFO PFX "Could not start watchdog\n");
                         return -EIO;
                 }
@@ -275,18 +370,18 @@ static int pcwd_stop(void)
         int stat_reg;
 
         /* Stop the timer */
-        del_timer(&timer);
+        del_timer(&pcwd_private.timer);
 
         /*  Disable the board  */
-        if (revision == PCWD_REVISION_C) {
-                spin_lock(&io_lock);
-                outb_p(0xA5, current_readport + 3);
+        if (pcwd_private.revision == PCWD_REVISION_C) {
+                spin_lock(&pcwd_private.io_lock);
+                outb_p(0xA5, pcwd_private.io_addr + 3);
                 udelay(ISA_COMMAND_TIMEOUT);
-                outb_p(0xA5, current_readport + 3);
+                outb_p(0xA5, pcwd_private.io_addr + 3);
                 udelay(ISA_COMMAND_TIMEOUT);
-                stat_reg = inb_p(current_readport + 2);
-                spin_unlock(&io_lock);
-                if ((stat_reg & 0x10) == 0) {
+                stat_reg = inb_p(pcwd_private.io_addr + 2);
+                spin_unlock(&pcwd_private.io_lock);
+                if ((stat_reg & WD_WDIS) == 0) {
                         printk(KERN_INFO PFX "Could not stop watchdog\n");
                         return -EIO;
                 }
@@ -297,7 +392,7 @@ static int pcwd_stop(void)
 static int pcwd_keepalive(void)
 {
         /* user land ping */
-        next_heartbeat = jiffies + (heartbeat * HZ);
+        pcwd_private.next_heartbeat = jiffies + (heartbeat * HZ);
         return 0;
 }
 
@@ -315,23 +410,23 @@ static int pcwd_get_status(int *status)
         int card_status;
 
         *status=0;
-        spin_lock(&io_lock);
-        if (revision == PCWD_REVISION_A)
+        spin_lock(&pcwd_private.io_lock);
+        if (pcwd_private.revision == PCWD_REVISION_A)
                 /* Rev A cards return status information from
                  * the base register, which is used for the
                  * temperature in other cards. */
-                card_status = inb(current_readport);
+                card_status = inb(pcwd_private.io_addr);
         else {
                 /* Rev C cards return card status in the base
                  * address + 1 register. And use different bits
                  * to indicate a card initiated reset, and an
                  * over-temperature condition. And the reboot
                  * status can be reset. */
-                card_status = inb(current_readport + 1);
+                card_status = inb(pcwd_private.io_addr + 1);
         }
-        spin_unlock(&io_lock);
+        spin_unlock(&pcwd_private.io_lock);
 
-        if (revision == PCWD_REVISION_A) {
+        if (pcwd_private.revision == PCWD_REVISION_A) {
                 if (card_status & WD_WDRST)
                         *status |= WDIOF_CARDRESET;
 
@@ -360,10 +455,10 @@ static int pcwd_get_status(int *status)
 
 static int pcwd_clear_status(void)
 {
-        if (revision == PCWD_REVISION_C) {
-                spin_lock(&io_lock);
-                outb_p(0x00, current_readport + 1); /* clear reset status */
-                spin_unlock(&io_lock);
+        if (pcwd_private.revision == PCWD_REVISION_C) {
+                spin_lock(&pcwd_private.io_lock);
+                outb_p(0x00, pcwd_private.io_addr + 1); /* clear reset status */
+                spin_unlock(&pcwd_private.io_lock);
         }
         return 0;
 }
@@ -371,20 +466,20 @@ static int pcwd_clear_status(void)
 static int pcwd_get_temperature(int *temperature)
 {
         /* check that port 0 gives temperature info and no command results */
-        if (command_mode)
+        if (pcwd_private.command_mode)
                 return -1;
 
         *temperature = 0;
-        if (!supports_temp)
+        if (!pcwd_private.supports_temp)
                 return -ENODEV;
 
         /*
          * Convert celsius to fahrenheit, since this was
          * the decided 'standard' for this return value.
          */
-        spin_lock(&io_lock);
-        *temperature = ((inb(current_readport)) * 9 / 5) + 32;
-        spin_unlock(&io_lock);
+        spin_lock(&pcwd_private.io_lock);
+        *temperature = ((inb(pcwd_private.io_addr)) * 9 / 5) + 32;
+        spin_unlock(&pcwd_private.io_lock);
 
         return 0;
 }
@@ -425,7 +520,7 @@ static int pcwd_ioctl(struct inode *inode, struct file *file,
                 return put_user(status, argp);
 
         case WDIOC_GETBOOTSTATUS:
-                return put_user(initial_status, argp);
+                return put_user(pcwd_private.boot_status, argp);
 
         case WDIOC_GETTEMP:
                 if (pcwd_get_temperature(&temperature))
@@ -434,7 +529,7 @@ static int pcwd_ioctl(struct inode *inode, struct file *file,
                 return put_user(temperature, argp);
 
         case WDIOC_SETOPTIONS:
-                if (revision == PCWD_REVISION_C)
+                if (pcwd_private.revision == PCWD_REVISION_C)
                 {
                         if(copy_from_user(&rv, argp, sizeof(int)))
                                 return -EFAULT;
@@ -550,7 +645,7 @@ static ssize_t pcwd_temp_read(struct file *file, char __user *buf, size_t count,
 
 static int pcwd_temp_open(struct inode *inode, struct file *file)
 {
-        if (!supports_temp)
+        if (!pcwd_private.supports_temp)
                 return -ENODEV;
 
         return nonseekable_open(inode, file);
@@ -616,68 +711,24 @@ static struct notifier_block pcwd_notifier = {
  *      Init & exit routines
  */
 
-static inline void get_support(void)
-{
-        if (inb(current_readport) != 0xF0)
-                supports_temp = 1;
-}
-
 static inline int get_revision(void)
 {
         int r = PCWD_REVISION_C;
 
-        spin_lock(&io_lock);
+        spin_lock(&pcwd_private.io_lock);
         /* REV A cards use only 2 io ports; test
          * presumes a floating bus reads as 0xff. */
-        if ((inb(current_readport + 2) == 0xFF) ||
-            (inb(current_readport + 3) == 0xFF))
+        if ((inb(pcwd_private.io_addr + 2) == 0xFF) ||
+            (inb(pcwd_private.io_addr + 3) == 0xFF))
                 r=PCWD_REVISION_A;
-        spin_unlock(&io_lock);
+        spin_unlock(&pcwd_private.io_lock);
 
         return r;
 }
 
-static inline char *get_firmware(void)
-{
-        int one, ten, hund, minor;
-        char *ret;
-
-        ret = kmalloc(6, GFP_KERNEL);
-        if(ret == NULL)
-                return NULL;
-
-        if (set_command_mode()) {
-                one = send_isa_command(CMD_ISA_VERSION_INTEGER);
-                ten = send_isa_command(CMD_ISA_VERSION_TENTH);
-                hund = send_isa_command(CMD_ISA_VERSION_HUNDRETH);
-                minor = send_isa_command(CMD_ISA_VERSION_MINOR);
-                sprintf(ret, "%c.%c%c%c", one, ten, hund, minor);
-        }
-        else
-                sprintf(ret, "ERROR");
-
-        unset_command_mode();
-        return(ret);
-}
-
-static inline int get_option_switches(void)
-{
-        int rv=0;
-
-        if (set_command_mode()) {
-                /* Get switch settings */
-                rv = send_isa_command(CMD_ISA_SWITCH_SETTINGS);
-        }
-
-        unset_command_mode();
-        return(rv);
-}
-
 static int __devinit pcwatchdog_init(int base_addr)
 {
         int ret;
-        char *firmware;
-        int option_switches;
 
         cards_found++;
         if (cards_found == 1)
@@ -692,104 +743,66 @@ static int __devinit pcwatchdog_init(int base_addr)
                 printk(KERN_ERR PFX "No I/O-Address for card detected\n");
                 return -ENODEV;
         }
-        current_readport = base_addr;
+        pcwd_private.io_addr = base_addr;
 
         /* Check card's revision */
-        revision = get_revision();
+        pcwd_private.revision = get_revision();
 
-        if (!request_region(current_readport, (revision == PCWD_REVISION_A) ? 2 : 4, "PCWD")) {
+        if (!request_region(pcwd_private.io_addr, (pcwd_private.revision == PCWD_REVISION_A) ? 2 : 4, "PCWD")) {
                 printk(KERN_ERR PFX "I/O address 0x%04x already in use\n",
-                        current_readport);
-                current_readport = 0x0000;
+                        pcwd_private.io_addr);
+                pcwd_private.io_addr = 0x0000;
                 return -EIO;
         }
 
         /* Initial variables */
-        supports_temp = 0;
+        pcwd_private.supports_temp = 0;
         temp_panic = 0;
-        initial_status = 0x0000;
+        pcwd_private.boot_status = 0x0000;
 
         /* get the boot_status */
-        pcwd_get_status(&initial_status);
+        pcwd_get_status(&pcwd_private.boot_status);
 
         /* clear the "card caused reboot" flag */
         pcwd_clear_status();
 
-        init_timer(&timer);
-        timer.function = pcwd_timer_ping;
-        timer.data = 0;
+        init_timer(&pcwd_private.timer);
+        pcwd_private.timer.function = pcwd_timer_ping;
+        pcwd_private.timer.data = 0;
 
         /*  Disable the board  */
         pcwd_stop();
 
         /*  Check whether or not the card supports the temperature device */
-        get_support();
-
-        /* Get some extra info from the hardware (in command/debug/diag mode) */
-        if (revision == PCWD_REVISION_A)
-                printk(KERN_INFO PFX "ISA-PC Watchdog (REV.A) detected at port 0x%04x\n", current_readport);
-        else if (revision == PCWD_REVISION_C) {
-                firmware = get_firmware();
-                printk(KERN_INFO PFX "ISA-PC Watchdog (REV.C) detected at port 0x%04x (Firmware version: %s)\n",
-                        current_readport, firmware);
-                kfree(firmware);
-                option_switches = get_option_switches();
-                printk(KERN_INFO PFX "Option switches (0x%02x): Temperature Reset Enable=%s, Power On Delay=%s\n",
-                        option_switches,
-                        ((option_switches & 0x10) ? "ON" : "OFF"),
-                        ((option_switches & 0x08) ? "ON" : "OFF"));
-
-                /* Reprogram internal heartbeat to 2 seconds */
-                if (set_command_mode()) {
-                        send_isa_command(CMD_ISA_DELAY_TIME_2SECS);
-                        unset_command_mode();
-                }
-        } else {
-                /* Should NEVER happen, unless get_revision() fails. */
-                printk(KERN_INFO PFX "Unable to get revision\n");
-                release_region(current_readport, (revision == PCWD_REVISION_A) ? 2 : 4);
-                current_readport = 0x0000;
-                return -1;
-        }
+        pcwd_check_temperature_support();
 
-        if (supports_temp)
-                printk(KERN_INFO PFX "Temperature Option Detected\n");
-
-        if (initial_status & WDIOF_CARDRESET)
-                printk(KERN_INFO PFX "Previous reboot was caused by the card\n");
-
-        if (initial_status & WDIOF_OVERHEAT) {
-                printk(KERN_EMERG PFX "Card senses a CPU Overheat. Panicking!\n");
-                printk(KERN_EMERG PFX "CPU Overheat\n");
-        }
-
-        if (initial_status == 0)
-                printk(KERN_INFO PFX "No previous trip detected - Cold boot or reset\n");
+        /* Show info about the card itself */
+        pcwd_show_card_info();
 
         /* Check that the heartbeat value is within it's range ; if not reset to the default */
-        if (pcwd_set_heartbeat(heartbeat)) {
-                pcwd_set_heartbeat(WATCHDOG_HEARTBEAT);
-                printk(KERN_INFO PFX "heartbeat value must be 2<=heartbeat<=7200, using %d\n",
-                        WATCHDOG_HEARTBEAT);
+        if (pcwd_set_heartbeat(heartbeat)) {
+                pcwd_set_heartbeat(WATCHDOG_HEARTBEAT);
+                printk(KERN_INFO PFX "heartbeat value must be 2<=heartbeat<=7200, using %d\n",
+                        WATCHDOG_HEARTBEAT);
         }
 
         ret = register_reboot_notifier(&pcwd_notifier);
         if (ret) {
                 printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
                         ret);
-                release_region(current_readport, (revision == PCWD_REVISION_A) ? 2 : 4);
-                current_readport = 0x0000;
+                release_region(pcwd_private.io_addr, (pcwd_private.revision == PCWD_REVISION_A) ? 2 : 4);
+                pcwd_private.io_addr = 0x0000;
                 return ret;
         }
 
-        if (supports_temp) {
+        if (pcwd_private.supports_temp) {
                 ret = misc_register(&temp_miscdev);
                 if (ret) {
                         printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
                                 TEMP_MINOR, ret);
                         unregister_reboot_notifier(&pcwd_notifier);
-                        release_region(current_readport, (revision == PCWD_REVISION_A) ? 2 : 4);
-                        current_readport = 0x0000;
+                        release_region(pcwd_private.io_addr, (pcwd_private.revision == PCWD_REVISION_A) ? 2 : 4);
+                        pcwd_private.io_addr = 0x0000;
                         return ret;
                 }
         }
@@ -798,11 +811,11 @@ static int __devinit pcwatchdog_init(int base_addr)
         if (ret) {
                 printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
                         WATCHDOG_MINOR, ret);
-                if (supports_temp)
+                if (pcwd_private.supports_temp)
                         misc_deregister(&temp_miscdev);
                 unregister_reboot_notifier(&pcwd_notifier);
-                release_region(current_readport, (revision == PCWD_REVISION_A) ? 2 : 4);
-                current_readport = 0x0000;
+                release_region(pcwd_private.io_addr, (pcwd_private.revision == PCWD_REVISION_A) ? 2 : 4);
+                pcwd_private.io_addr = 0x0000;
                 return ret;
         }
 
@@ -820,11 +833,12 @@ static void __devexit pcwatchdog_exit(void)
 
         /* Deregister */
         misc_deregister(&pcwd_miscdev);
-        if (supports_temp)
+        if (pcwd_private.supports_temp)
                 misc_deregister(&temp_miscdev);
         unregister_reboot_notifier(&pcwd_notifier);
-        release_region(current_readport, (revision == PCWD_REVISION_A) ? 2 : 4);
-        current_readport = 0x0000;
+        release_region(pcwd_private.io_addr, (pcwd_private.revision == PCWD_REVISION_A) ? 2 : 4);
+        pcwd_private.io_addr = 0x0000;
+        cards_found--;
 }
 
 /*
@@ -887,7 +901,7 @@ static int __init pcwd_init_module(void)
 {
         int i, found = 0;
 
-        spin_lock_init(&io_lock);
+        spin_lock_init(&pcwd_private.io_lock);
 
         for (i = 0; pcwd_ioports[i] != 0; i++) {
                 if (pcwd_checkcard(pcwd_ioports[i])) {
@@ -906,7 +920,7 @@ static int __init pcwd_init_module(void)
 
 static void __exit pcwd_cleanup_module(void)
 {
-        if (current_readport)
+        if (pcwd_private.io_addr)
                 pcwatchdog_exit();
         return;
 }
diff --git a/drivers/char/watchdog/sa1100_wdt.c b/drivers/char/watchdog/sa1100_wdt.c
index b474ea52d6e8..522a9370db94 100644
--- a/drivers/char/watchdog/sa1100_wdt.c
+++ b/drivers/char/watchdog/sa1100_wdt.c
@@ -93,23 +93,25 @@ static int sa1100dog_ioctl(struct inode *inode, struct file *file,
 {
         int ret = -ENOIOCTLCMD;
         int time;
+        void __user *argp = (void __user *)arg;
+        int __user *p = argp;
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-                ret = copy_to_user((struct watchdog_info __user *)arg, &ident,
+                ret = copy_to_user(argp, &ident,
                                    sizeof(ident)) ? -EFAULT : 0;
                 break;
 
         case WDIOC_GETSTATUS:
-                ret = put_user(0, (int __user *)arg);
+                ret = put_user(0, p);
                 break;
 
         case WDIOC_GETBOOTSTATUS:
-                ret = put_user(boot_status, (int __user *)arg);
+                ret = put_user(boot_status, p);
                 break;
 
         case WDIOC_SETTIMEOUT:
-                ret = get_user(time, (int __user *)arg);
+                ret = get_user(time, p);
                 if (ret)
                         break;
 
@@ -123,7 +125,7 @@ static int sa1100dog_ioctl(struct inode *inode, struct file *file,
                 /*fall through*/
 
         case WDIOC_GETTIMEOUT:
-                ret = put_user(pre_margin / OSCR_FREQ, (int __user *)arg);
+                ret = put_user(pre_margin / OSCR_FREQ, p);
                 break;
 
         case WDIOC_KEEPALIVE: