78 files changed, 948 insertions, 1374 deletions

diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 4135d8c5bcae..05ba410682a3 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -222,7 +222,7 @@ config SYNCLINKMP
 
 config SYNCLINK_GT
         tristate "SyncLink GT/AC support"
-        depends on SERIAL_NONSTANDARD
+        depends on SERIAL_NONSTANDARD && PCI
         help
           Support for SyncLink GT and SyncLink AC families of
           synchronous and asynchronous serial adapters
@@ -992,7 +992,7 @@ config HPET_MMAP
 
 config HANGCHECK_TIMER
         tristate "Hangcheck timer"
-        depends on X86 || IA64 || PPC64 || S390
+        depends on X86 || IA64 || PPC64
         help
           The hangcheck-timer module detects when the system has gone
           out to lunch past a certain margin.  It can reboot the system
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 810679dcbbb0..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;
 
@@ -600,6 +602,26 @@ static void __devexit agp_amd64_remove(struct pci_dev *pdev)
         agp_put_bridge(bridge);
 }
 
+#ifdef CONFIG_PM
+
+static int agp_amd64_suspend(struct pci_dev *pdev, pm_message_t state)
+{
+        pci_save_state(pdev);
+        pci_set_power_state(pdev, pci_choose_state(pdev, state));
+
+        return 0;
+}
+
+static int agp_amd64_resume(struct pci_dev *pdev)
+{
+        pci_set_power_state(pdev, PCI_D0);
+        pci_restore_state(pdev);
+
+        return amd_8151_configure();
+}
+
+#endif /* CONFIG_PM */
+
 static struct pci_device_id agp_amd64_pci_table[] = {
         {
         .class          = (PCI_CLASS_BRIDGE_HOST << 8),
@@ -718,6 +740,10 @@ static struct pci_driver agp_amd64_pci_driver = {
         .id_table       = agp_amd64_pci_table,
         .probe          = agp_amd64_probe,
         .remove         = agp_amd64_remove,
+#ifdef CONFIG_PM
+        .suspend        = agp_amd64_suspend,
+        .resume         = agp_amd64_resume,
+#endif
 };
 
 
diff --git a/drivers/char/agp/ati-agp.c b/drivers/char/agp/ati-agp.c
index 53372a83b675..5b74c36c116c 100644
--- a/drivers/char/agp/ati-agp.c
+++ b/drivers/char/agp/ati-agp.c
@@ -244,6 +244,22 @@ static int ati_configure(void)
 }
 
 
+#ifdef CONFIG_PM
+static int agp_ati_resume(struct pci_dev *dev)
+{
+        pci_restore_state(dev);
+
+        return ati_configure();
+}
+
+static int agp_ati_suspend(struct pci_dev *dev, pm_message_t state)
+{
+        pci_save_state(dev);
+
+        return 0;
+}
+#endif
+
 /*
  *Since we don't need contigious memory we just try
  * to get the gatt table once
@@ -525,6 +541,10 @@ static struct pci_driver agp_ati_pci_driver = {
         .id_table       = agp_ati_pci_table,
         .probe          = agp_ati_probe,
         .remove         = agp_ati_remove,
+#ifdef CONFIG_PM
+        .resume         = agp_ati_resume,
+        .suspend        = agp_ati_suspend,
+#endif
 };
 
 static int __init agp_ati_init(void)
diff --git a/drivers/char/agp/frontend.c b/drivers/char/agp/frontend.c
index 17f520c9d471..97eeb2345b18 100644
--- a/drivers/char/agp/frontend.c
+++ b/drivers/char/agp/frontend.c
@@ -592,7 +592,7 @@ static int agp_mmap(struct file *file, struct vm_area_struct *vma)
         struct agp_file_private *priv = file->private_data;
         struct agp_kern_info kerninfo;
 
-        down(&(agp_fe.agp_mutex));
+        mutex_lock(&(agp_fe.agp_mutex));
 
         if (agp_fe.backend_acquired != TRUE)
                 goto out_eperm;
@@ -627,7 +627,7 @@ static int agp_mmap(struct file *file, struct vm_area_struct *vma)
                                             size, vma->vm_page_prot)) {
                         goto out_again;
                 }
-                up(&(agp_fe.agp_mutex));
+                mutex_unlock(&(agp_fe.agp_mutex));
                 return 0;
         }
 
@@ -643,20 +643,20 @@ static int agp_mmap(struct file *file, struct vm_area_struct *vma)
                                             size, vma->vm_page_prot)) {
                         goto out_again;
                 }
-                up(&(agp_fe.agp_mutex));
+                mutex_unlock(&(agp_fe.agp_mutex));
                 return 0;
         }
 
 out_eperm:
-        up(&(agp_fe.agp_mutex));
+        mutex_unlock(&(agp_fe.agp_mutex));
         return -EPERM;
 
 out_inval:
-        up(&(agp_fe.agp_mutex));
+        mutex_unlock(&(agp_fe.agp_mutex));
         return -EINVAL;
 
 out_again:
-        up(&(agp_fe.agp_mutex));
+        mutex_unlock(&(agp_fe.agp_mutex));
         return -EAGAIN;
 }
 
@@ -664,7 +664,7 @@ static int agp_release(struct inode *inode, struct file *file)
 {
         struct agp_file_private *priv = file->private_data;
 
-        down(&(agp_fe.agp_mutex));
+        mutex_lock(&(agp_fe.agp_mutex));
 
         DBG("priv=%p", priv);
 
@@ -687,7 +687,7 @@ static int agp_release(struct inode *inode, struct file *file)
         agp_remove_file_private(priv);
         kfree(priv);
         file->private_data = NULL;
-        up(&(agp_fe.agp_mutex));
+        mutex_unlock(&(agp_fe.agp_mutex));
         return 0;
 }
 
@@ -698,7 +698,7 @@ static int agp_open(struct inode *inode, struct file *file)
         struct agp_client *client;
         int rc = -ENXIO;
 
-        down(&(agp_fe.agp_mutex));
+        mutex_lock(&(agp_fe.agp_mutex));
 
         if (minor != AGPGART_MINOR)
                 goto err_out;
@@ -723,13 +723,13 @@ static int agp_open(struct inode *inode, struct file *file)
         file->private_data = (void *) priv;
         agp_insert_file_private(priv);
         DBG("private=%p, client=%p", priv, client);
-        up(&(agp_fe.agp_mutex));
+        mutex_unlock(&(agp_fe.agp_mutex));
         return 0;
 
 err_out_nomem:
         rc = -ENOMEM;
 err_out:
-        up(&(agp_fe.agp_mutex));
+        mutex_unlock(&(agp_fe.agp_mutex));
         return rc;
 }
 
@@ -985,7 +985,7 @@ static int agp_ioctl(struct inode *inode, struct file *file,
         int ret_val = -ENOTTY;
 
         DBG("priv=%p, cmd=%x", curr_priv, cmd);
-        down(&(agp_fe.agp_mutex));
+        mutex_lock(&(agp_fe.agp_mutex));
 
         if ((agp_fe.current_controller == NULL) &&
             (cmd != AGPIOC_ACQUIRE)) {
@@ -1055,7 +1055,7 @@ static int agp_ioctl(struct inode *inode, struct file *file,
 
 ioctl_out:
         DBG("ioctl returns %d\n", ret_val);
-        up(&(agp_fe.agp_mutex));
+        mutex_unlock(&(agp_fe.agp_mutex));
         return ret_val;
 }
 
@@ -1081,7 +1081,7 @@ static struct miscdevice agp_miscdev =
 int agp_frontend_initialize(void)
 {
         memset(&agp_fe, 0, sizeof(struct agp_front_data));
-        sema_init(&(agp_fe.agp_mutex), 1);
+        mutex_init(&(agp_fe.agp_mutex));
 
         if (misc_register(&agp_miscdev)) {
                 printk(KERN_ERR PFX "unable to get minor: %d\n", AGPGART_MINOR);
diff --git a/drivers/char/agp/intel-agp.c b/drivers/char/agp/intel-agp.c
index e7bed5047dcc..631531fd97a5 100644
--- a/drivers/char/agp/intel-agp.c
+++ b/drivers/char/agp/intel-agp.c
@@ -422,7 +422,8 @@ static void intel_i830_init_gtt_entries(void)
                         /* Check it's really I915G */
                         if (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915G_HB ||
                             agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915GM_HB ||
-                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945G_HB)
+                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945G_HB ||
+                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945GM_HB)
                                 gtt_entries = MB(48) - KB(size);
                         else
                                 gtt_entries = 0;
@@ -431,7 +432,8 @@ static void intel_i830_init_gtt_entries(void)
                         /* Check it's really I915G */
                         if (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915G_HB ||
                             agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915GM_HB ||
-                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945G_HB)
+                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945G_HB ||
+                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945GM_HB)
                                 gtt_entries = MB(64) - KB(size);
                         else
                                 gtt_entries = 0;
@@ -1681,6 +1683,14 @@ static int __devinit agp_intel_probe(struct pci_dev *pdev,
                 }
                 name = "945G";
                 break;
+        case PCI_DEVICE_ID_INTEL_82945GM_HB:
+                if (find_i830(PCI_DEVICE_ID_INTEL_82945GM_IG)) {
+                        bridge->driver = &intel_915_driver;
+                } else {
+                        bridge->driver = &intel_845_driver;
+                }
+                name = "945GM";
+                break;
         case PCI_DEVICE_ID_INTEL_7505_0:
                 bridge->driver = &intel_7505_driver;
                 name = "E7505";
@@ -1821,6 +1831,7 @@ static struct pci_device_id agp_intel_pci_table[] = {
         ID(PCI_DEVICE_ID_INTEL_82915G_HB),
         ID(PCI_DEVICE_ID_INTEL_82915GM_HB),
         ID(PCI_DEVICE_ID_INTEL_82945G_HB),
+        ID(PCI_DEVICE_ID_INTEL_82945GM_HB),
         { }
 };
 
diff --git a/drivers/char/agp/isoch.c b/drivers/char/agp/isoch.c
index 40083241804e..7c14a096b85e 100644
--- a/drivers/char/agp/isoch.c
+++ b/drivers/char/agp/isoch.c
@@ -218,10 +218,8 @@ static int agp_3_5_isochronous_node_enable(struct agp_bridge_data *bridge,
                         master[cdev].rq *= (1 << (master[cdev].y - 1));
 
                 tot_rq += master[cdev].rq;
-
-                if (cdev == ndevs-1)
-                        master[cdev].n += rem;
         }
+        master[ndevs-1].n += rem;
 
         /* Figure the number of isochronous and asynchronous RQ slots the
          * target is providing. */
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/cyclades.c b/drivers/char/cyclades.c
index 39c61a71176e..cc7acf877dc0 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -1233,7 +1233,7 @@ cyy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                             }
                              info->idle_stats.recv_idle = jiffies;
                         }
-                        schedule_delayed_work(&tty->buf.work, 1);
+                        tty_schedule_flip(tty);
                     }
                     /* end of service */
                     cy_writeb(base_addr+(CyRIR<<index), (save_xir & 0x3f));
@@ -1606,7 +1606,7 @@ cyz_handle_rx(struct cyclades_port *info,
             }
 #endif
             info->idle_stats.recv_idle = jiffies;
-            schedule_delayed_work(&tty->buf.work, 1);
+            tty_schedule_flip(tty);
         }
         /* Update rx_get */
         cy_writel(&buf_ctrl->rx_get, new_rx_get);
@@ -1809,7 +1809,7 @@ cyz_handle_cmd(struct cyclades_card *cinfo)
         if(delta_count)
             cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
         if(special_count)
-            schedule_delayed_work(&tty->buf.work, 1);
+            tty_schedule_flip(tty);
     }
 }
 
diff --git a/drivers/char/drm/ati_pcigart.c b/drivers/char/drm/ati_pcigart.c
index 5485382cadec..bd7be09ea53d 100644
--- a/drivers/char/drm/ati_pcigart.c
+++ b/drivers/char/drm/ati_pcigart.c
@@ -59,17 +59,16 @@ static void *drm_ati_alloc_pcigart_table(void)
         int i;
         DRM_DEBUG("%s\n", __FUNCTION__);
 
-        address = __get_free_pages(GFP_KERNEL, ATI_PCIGART_TABLE_ORDER);
+        address = __get_free_pages(GFP_KERNEL | __GFP_COMP,
+                                   ATI_PCIGART_TABLE_ORDER);
         if (address == 0UL) {
-                return 0;
+                return NULL;
         }
 
         page = virt_to_page(address);
 
-        for (i = 0; i < ATI_PCIGART_TABLE_PAGES; i++, page++) {
-                get_page(page);
+        for (i = 0; i < ATI_PCIGART_TABLE_PAGES; i++, page++)
                 SetPageReserved(page);
-        }
 
         DRM_DEBUG("%s: returning 0x%08lx\n", __FUNCTION__, address);
         return (void *)address;
@@ -83,10 +82,8 @@ static void drm_ati_free_pcigart_table(void *address)
 
         page = virt_to_page((unsigned long)address);
 
-        for (i = 0; i < ATI_PCIGART_TABLE_PAGES; i++, page++) {
-                __put_page(page);
+        for (i = 0; i < ATI_PCIGART_TABLE_PAGES; i++, page++)
                 ClearPageReserved(page);
-        }
 
         free_pages((unsigned long)address, ATI_PCIGART_TABLE_ORDER);
 }
@@ -127,7 +124,7 @@ int drm_ati_pcigart_cleanup(drm_device_t *dev, drm_ati_pcigart_info *gart_info)
         if (gart_info->gart_table_location == DRM_ATI_GART_MAIN
             && gart_info->addr) {
                 drm_ati_free_pcigart_table(gart_info->addr);
-                gart_info->addr = 0;
+                gart_info->addr = NULL;
         }
 
         return 1;
@@ -168,7 +165,7 @@ int drm_ati_pcigart_init(drm_device_t *dev, drm_ati_pcigart_info *gart_info)
                 if (bus_address == 0) {
                         DRM_ERROR("unable to map PCIGART pages!\n");
                         drm_ati_free_pcigart_table(address);
-                        address = 0;
+                        address = NULL;
                         goto done;
                 }
         } else {
diff --git a/drivers/char/drm/drmP.h b/drivers/char/drm/drmP.h
index 54b561e69486..107df9fdba4e 100644
--- a/drivers/char/drm/drmP.h
+++ b/drivers/char/drm/drmP.h
@@ -57,6 +57,7 @@
 #include <linux/smp_lock.h>     /* For (un)lock_kernel */
 #include <linux/mm.h>
 #include <linux/cdev.h>
+#include <linux/mutex.h>
 #if defined(__alpha__) || defined(__powerpc__)
 #include <asm/pgtable.h>        /* For pte_wrprotect */
 #endif
@@ -623,7 +624,7 @@ typedef struct drm_device {
         /** \name Locks */
         /*@{ */
         spinlock_t count_lock;          /**< For inuse, drm_device::open_count, drm_device::buf_use */
-        struct semaphore struct_sem;    /**< For others */
+        struct mutex struct_mutex;      /**< For others */
         /*@} */
 
         /** \name Usage Counters */
@@ -658,7 +659,7 @@ typedef struct drm_device {
         /*@{ */
         drm_ctx_list_t *ctxlist;        /**< Linked list of context handles */
         int ctx_count;                  /**< Number of context handles */
-        struct semaphore ctxlist_sem;   /**< For ctxlist */
+        struct mutex ctxlist_mutex;     /**< For ctxlist */
 
         drm_map_t **context_sareas;         /**< per-context SAREA's */
         int max_context;
@@ -979,7 +980,7 @@ extern int drm_put_head(drm_head_t * head);
 extern unsigned int drm_debug;
 extern unsigned int drm_cards_limit;
 extern drm_head_t **drm_heads;
-extern struct drm_sysfs_class *drm_class;
+extern struct class *drm_class;
 extern struct proc_dir_entry *drm_proc_root;
 
                                 /* Proc support (drm_proc.h) */
@@ -1010,11 +1011,9 @@ extern void __drm_pci_free(drm_device_t * dev, drm_dma_handle_t * dmah);
 extern void drm_pci_free(drm_device_t * dev, drm_dma_handle_t * dmah);
 
                                /* sysfs support (drm_sysfs.c) */
-struct drm_sysfs_class;
-extern struct drm_sysfs_class *drm_sysfs_create(struct module *owner,
-                                                char *name);
-extern void drm_sysfs_destroy(struct drm_sysfs_class *cs);
-extern struct class_device *drm_sysfs_device_add(struct drm_sysfs_class *cs,
+extern struct class *drm_sysfs_create(struct module *owner, char *name);
+extern void drm_sysfs_destroy(struct class *cs);
+extern struct class_device *drm_sysfs_device_add(struct class *cs,
                                                  drm_head_t *head);
 extern void drm_sysfs_device_remove(struct class_device *class_dev);
 
diff --git a/drivers/char/drm/drm_auth.c b/drivers/char/drm/drm_auth.c
index a47b502bc7cc..2a37586a7ee8 100644
--- a/drivers/char/drm/drm_auth.c
+++ b/drivers/char/drm/drm_auth.c
@@ -56,7 +56,7 @@ static int drm_hash_magic(drm_magic_t magic)
  * \param magic magic number.
  *
  * Searches in drm_device::magiclist within all files with the same hash key
- * the one with matching magic number, while holding the drm_device::struct_sem
+ * the one with matching magic number, while holding the drm_device::struct_mutex
  * lock.
  */
 static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
@@ -65,14 +65,14 @@ static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
         drm_magic_entry_t *pt;
         int hash = drm_hash_magic(magic);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         for (pt = dev->magiclist[hash].head; pt; pt = pt->next) {
                 if (pt->magic == magic) {
                         retval = pt->priv;
                         break;
                 }
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return retval;
 }
 
@@ -85,7 +85,7 @@ static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
  *
  * Creates a drm_magic_entry structure and appends to the linked list
  * associated the magic number hash key in drm_device::magiclist, while holding
- * the drm_device::struct_sem lock.
+ * the drm_device::struct_mutex lock.
  */
 static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
                          drm_magic_t magic)
@@ -104,7 +104,7 @@ static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
         entry->priv = priv;
         entry->next = NULL;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         if (dev->magiclist[hash].tail) {
                 dev->magiclist[hash].tail->next = entry;
                 dev->magiclist[hash].tail = entry;
@@ -112,7 +112,7 @@ static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
                 dev->magiclist[hash].head = entry;
                 dev->magiclist[hash].tail = entry;
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         return 0;
 }
@@ -124,7 +124,7 @@ static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
  * \param magic magic number.
  *
  * Searches and unlinks the entry in drm_device::magiclist with the magic
- * number hash key, while holding the drm_device::struct_sem lock.
+ * number hash key, while holding the drm_device::struct_mutex lock.
  */
 static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
 {
@@ -135,7 +135,7 @@ static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
         DRM_DEBUG("%d\n", magic);
         hash = drm_hash_magic(magic);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         for (pt = dev->magiclist[hash].head; pt; prev = pt, pt = pt->next) {
                 if (pt->magic == magic) {
                         if (dev->magiclist[hash].head == pt) {
@@ -147,11 +147,11 @@ static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
                         if (prev) {
                                 prev->next = pt->next;
                         }
-                        up(&dev->struct_sem);
+                        mutex_unlock(&dev->struct_mutex);
                         return 0;
                 }
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
 
diff --git a/drivers/char/drm/drm_bufs.c b/drivers/char/drm/drm_bufs.c
index 1db12dcb6802..e2637b4d51de 100644
--- a/drivers/char/drm/drm_bufs.c
+++ b/drivers/char/drm/drm_bufs.c
@@ -255,14 +255,14 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
         memset(list, 0, sizeof(*list));
         list->map = map;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         list_add(&list->head, &dev->maplist->head);
         /* Assign a 32-bit handle */
-        /* We do it here so that dev->struct_sem protects the increment */
+        /* We do it here so that dev->struct_mutex protects the increment */
         list->user_token = HandleID(map->type == _DRM_SHM
                                     ? (unsigned long)map->handle
                                     : map->offset, dev);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         *maplist = list;
         return 0;
@@ -392,9 +392,9 @@ int drm_rmmap(drm_device_t *dev, drm_local_map_t *map)
 {
         int ret;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         ret = drm_rmmap_locked(dev, map);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         return ret;
 }
@@ -423,7 +423,7 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
                 return -EFAULT;
         }
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         list_for_each(list, &dev->maplist->head) {
                 drm_map_list_t *r_list = list_entry(list, drm_map_list_t, head);
 
@@ -439,7 +439,7 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
          * find anything.
          */
         if (list == (&dev->maplist->head)) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
 
@@ -448,13 +448,13 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
 
         /* Register and framebuffer maps are permanent */
         if ((map->type == _DRM_REGISTERS) || (map->type == _DRM_FRAME_BUFFER)) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return 0;
         }
 
         ret = drm_rmmap_locked(dev, map);
 
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         return ret;
 }
@@ -566,16 +566,16 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
         atomic_inc(&dev->buf_alloc);
         spin_unlock(&dev->count_lock);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         entry = &dma->bufs[order];
         if (entry->buf_count) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM; /* May only call once for each order */
         }
 
         if (count < 0 || count > 4096) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -EINVAL;
         }
@@ -583,7 +583,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
         entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
                                    DRM_MEM_BUFS);
         if (!entry->buflist) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -616,7 +616,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
                         /* Set count correctly so we free the proper amount. */
                         entry->buf_count = count;
                         drm_cleanup_buf_error(dev, entry);
-                        up(&dev->struct_sem);
+                        mutex_unlock(&dev->struct_mutex);
                         atomic_dec(&dev->buf_alloc);
                         return -ENOMEM;
                 }
@@ -638,7 +638,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
         if (!temp_buflist) {
                 /* Free the entry because it isn't valid */
                 drm_cleanup_buf_error(dev, entry);
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -656,7 +656,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
         DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
         DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
 
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         request->count = entry->buf_count;
         request->size = size;
@@ -722,16 +722,16 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
         atomic_inc(&dev->buf_alloc);
         spin_unlock(&dev->count_lock);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         entry = &dma->bufs[order];
         if (entry->buf_count) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM; /* May only call once for each order */
         }
 
         if (count < 0 || count > 4096) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -EINVAL;
         }
@@ -739,7 +739,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
         entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
                                    DRM_MEM_BUFS);
         if (!entry->buflist) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -750,7 +750,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
         if (!entry->seglist) {
                 drm_free(entry->buflist,
                          count * sizeof(*entry->buflist), DRM_MEM_BUFS);
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -766,7 +766,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
                          count * sizeof(*entry->buflist), DRM_MEM_BUFS);
                 drm_free(entry->seglist,
                          count * sizeof(*entry->seglist), DRM_MEM_SEGS);
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -790,7 +790,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
                         drm_free(temp_pagelist,
                                  (dma->page_count + (count << page_order))
                                  * sizeof(*dma->pagelist), DRM_MEM_PAGES);
-                        up(&dev->struct_sem);
+                        mutex_unlock(&dev->struct_mutex);
                         atomic_dec(&dev->buf_alloc);
                         return -ENOMEM;
                 }
@@ -831,7 +831,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
                                           (count << page_order))
                                          * sizeof(*dma->pagelist),
                                          DRM_MEM_PAGES);
-                                up(&dev->struct_sem);
+                                mutex_unlock(&dev->struct_mutex);
                                 atomic_dec(&dev->buf_alloc);
                                 return -ENOMEM;
                         }
@@ -853,7 +853,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
                 drm_free(temp_pagelist,
                          (dma->page_count + (count << page_order))
                          * sizeof(*dma->pagelist), DRM_MEM_PAGES);
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -878,7 +878,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
         dma->page_count += entry->seg_count << page_order;
         dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order);
 
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         request->count = entry->buf_count;
         request->size = size;
@@ -948,16 +948,16 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
         atomic_inc(&dev->buf_alloc);
         spin_unlock(&dev->count_lock);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         entry = &dma->bufs[order];
         if (entry->buf_count) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM; /* May only call once for each order */
         }
 
         if (count < 0 || count > 4096) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -EINVAL;
         }
@@ -965,7 +965,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
         entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
                                    DRM_MEM_BUFS);
         if (!entry->buflist) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -999,7 +999,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
                         /* Set count correctly so we free the proper amount. */
                         entry->buf_count = count;
                         drm_cleanup_buf_error(dev, entry);
-                        up(&dev->struct_sem);
+                        mutex_unlock(&dev->struct_mutex);
                         atomic_dec(&dev->buf_alloc);
                         return -ENOMEM;
                 }
@@ -1022,7 +1022,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
         if (!temp_buflist) {
                 /* Free the entry because it isn't valid */
                 drm_cleanup_buf_error(dev, entry);
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -1040,7 +1040,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
         DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
         DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
 
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         request->count = entry->buf_count;
         request->size = size;
@@ -1110,16 +1110,16 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
         atomic_inc(&dev->buf_alloc);
         spin_unlock(&dev->count_lock);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         entry = &dma->bufs[order];
         if (entry->buf_count) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM; /* May only call once for each order */
         }
 
         if (count < 0 || count > 4096) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -EINVAL;
         }
@@ -1127,7 +1127,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
         entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
                                    DRM_MEM_BUFS);
         if (!entry->buflist) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -1160,7 +1160,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
                         /* Set count correctly so we free the proper amount. */
                         entry->buf_count = count;
                         drm_cleanup_buf_error(dev, entry);
-                        up(&dev->struct_sem);
+                        mutex_unlock(&dev->struct_mutex);
                         atomic_dec(&dev->buf_alloc);
                         return -ENOMEM;
                 }
@@ -1182,7 +1182,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
         if (!temp_buflist) {
                 /* Free the entry because it isn't valid */
                 drm_cleanup_buf_error(dev, entry);
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -1200,7 +1200,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
         DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
         DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
 
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         request->count = entry->buf_count;
         request->size = size;
diff --git a/drivers/char/drm/drm_context.c b/drivers/char/drm/drm_context.c
index f84254526949..83094c73da67 100644
--- a/drivers/char/drm/drm_context.c
+++ b/drivers/char/drm/drm_context.c
@@ -53,7 +53,7 @@
  * \param ctx_handle context handle.
  *
  * Clears the bit specified by \p ctx_handle in drm_device::ctx_bitmap and the entry
- * in drm_device::context_sareas, while holding the drm_device::struct_sem
+ * in drm_device::context_sareas, while holding the drm_device::struct_mutex
  * lock.
  */
 void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle)
@@ -64,10 +64,10 @@ void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle)
                 goto failed;
 
         if (ctx_handle < DRM_MAX_CTXBITMAP) {
-                down(&dev->struct_sem);
+                mutex_lock(&dev->struct_mutex);
                 clear_bit(ctx_handle, dev->ctx_bitmap);
                 dev->context_sareas[ctx_handle] = NULL;
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return;
         }
       failed:
@@ -83,7 +83,7 @@ void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle)
  *
  * Find the first zero bit in drm_device::ctx_bitmap and (re)allocates
  * drm_device::context_sareas to accommodate the new entry while holding the
- * drm_device::struct_sem lock.
+ * drm_device::struct_mutex lock.
  */
 static int drm_ctxbitmap_next(drm_device_t * dev)
 {
@@ -92,7 +92,7 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
         if (!dev->ctx_bitmap)
                 return -1;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         bit = find_first_zero_bit(dev->ctx_bitmap, DRM_MAX_CTXBITMAP);
         if (bit < DRM_MAX_CTXBITMAP) {
                 set_bit(bit, dev->ctx_bitmap);
@@ -113,7 +113,7 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
                                                          DRM_MEM_MAPS);
                                 if (!ctx_sareas) {
                                         clear_bit(bit, dev->ctx_bitmap);
-                                        up(&dev->struct_sem);
+                                        mutex_unlock(&dev->struct_mutex);
                                         return -1;
                                 }
                                 dev->context_sareas = ctx_sareas;
@@ -126,16 +126,16 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
                                               DRM_MEM_MAPS);
                                 if (!dev->context_sareas) {
                                         clear_bit(bit, dev->ctx_bitmap);
-                                        up(&dev->struct_sem);
+                                        mutex_unlock(&dev->struct_mutex);
                                         return -1;
                                 }
                                 dev->context_sareas[bit] = NULL;
                         }
                 }
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return bit;
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return -1;
 }
 
@@ -145,24 +145,24 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
  * \param dev DRM device.
  *
  * Allocates and initialize drm_device::ctx_bitmap and drm_device::context_sareas, while holding
- * the drm_device::struct_sem lock.
+ * the drm_device::struct_mutex lock.
  */
 int drm_ctxbitmap_init(drm_device_t * dev)
 {
         int i;
         int temp;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         dev->ctx_bitmap = (unsigned long *)drm_alloc(PAGE_SIZE,
                                                      DRM_MEM_CTXBITMAP);
         if (dev->ctx_bitmap == NULL) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -ENOMEM;
         }
         memset((void *)dev->ctx_bitmap, 0, PAGE_SIZE);
         dev->context_sareas = NULL;
         dev->max_context = -1;
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
                 temp = drm_ctxbitmap_next(dev);
@@ -178,17 +178,17 @@ int drm_ctxbitmap_init(drm_device_t * dev)
  * \param dev DRM device.
  *
  * Frees drm_device::ctx_bitmap and drm_device::context_sareas, while holding
- * the drm_device::struct_sem lock.
+ * the drm_device::struct_mutex lock.
  */
 void drm_ctxbitmap_cleanup(drm_device_t * dev)
 {
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         if (dev->context_sareas)
                 drm_free(dev->context_sareas,
                          sizeof(*dev->context_sareas) *
                          dev->max_context, DRM_MEM_MAPS);
         drm_free((void *)dev->ctx_bitmap, PAGE_SIZE, DRM_MEM_CTXBITMAP);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 }
 
 /*@}*/
@@ -222,15 +222,15 @@ int drm_getsareactx(struct inode *inode, struct file *filp,
         if (copy_from_user(&request, argp, sizeof(request)))
                 return -EFAULT;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         if (dev->max_context < 0
             || request.ctx_id >= (unsigned)dev->max_context) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
 
         map = dev->context_sareas[request.ctx_id];
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         request.handle = NULL;
         list_for_each_entry(_entry, &dev->maplist->head, head) {
@@ -274,7 +274,7 @@ int drm_setsareactx(struct inode *inode, struct file *filp,
                            (drm_ctx_priv_map_t __user *) arg, sizeof(request)))
                 return -EFAULT;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         list_for_each(list, &dev->maplist->head) {
                 r_list = list_entry(list, drm_map_list_t, head);
                 if (r_list->map
@@ -282,7 +282,7 @@ int drm_setsareactx(struct inode *inode, struct file *filp,
                         goto found;
         }
       bad:
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return -EINVAL;
 
       found:
@@ -294,7 +294,7 @@ int drm_setsareactx(struct inode *inode, struct file *filp,
         if (request.ctx_id >= (unsigned)dev->max_context)
                 goto bad;
         dev->context_sareas[request.ctx_id] = map;
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return 0;
 }
 
@@ -448,10 +448,10 @@ int drm_addctx(struct inode *inode, struct file *filp,
         ctx_entry->handle = ctx.handle;
         ctx_entry->tag = priv;
 
-        down(&dev->ctxlist_sem);
+        mutex_lock(&dev->ctxlist_mutex);
         list_add(&ctx_entry->head, &dev->ctxlist->head);
         ++dev->ctx_count;
-        up(&dev->ctxlist_sem);
+        mutex_unlock(&dev->ctxlist_mutex);
 
         if (copy_to_user(argp, &ctx, sizeof(ctx)))
                 return -EFAULT;
@@ -574,7 +574,7 @@ int drm_rmctx(struct inode *inode, struct file *filp,
                 drm_ctxbitmap_free(dev, ctx.handle);
         }
 
-        down(&dev->ctxlist_sem);
+        mutex_lock(&dev->ctxlist_mutex);
         if (!list_empty(&dev->ctxlist->head)) {
                 drm_ctx_list_t *pos, *n;
 
@@ -586,7 +586,7 @@ int drm_rmctx(struct inode *inode, struct file *filp,
                         }
                 }
         }
-        up(&dev->ctxlist_sem);
+        mutex_unlock(&dev->ctxlist_mutex);
 
         return 0;
 }
diff --git a/drivers/char/drm/drm_drv.c b/drivers/char/drm/drm_drv.c
index c4fa5a29582b..dc6bbe8a18dc 100644
--- a/drivers/char/drm/drm_drv.c
+++ b/drivers/char/drm/drm_drv.c
@@ -151,7 +151,7 @@ int drm_lastclose(drm_device_t * dev)
         if (dev->irq_enabled)
                 drm_irq_uninstall(dev);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         del_timer(&dev->timer);
 
         /* Clear pid list */
@@ -231,7 +231,7 @@ int drm_lastclose(drm_device_t * dev)
                 dev->lock.filp = NULL;
                 wake_up_interruptible(&dev->lock.lock_queue);
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         DRM_DEBUG("lastclose completed\n");
         return 0;
diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c
index 403f44a1bf01..641f7633878c 100644
--- a/drivers/char/drm/drm_fops.c
+++ b/drivers/char/drm/drm_fops.c
@@ -262,7 +262,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
                         goto out_free;
         }
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         if (!dev->file_last) {
                 priv->next = NULL;
                 priv->prev = NULL;
@@ -276,7 +276,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
                 dev->file_last->next = priv;
                 dev->file_last = priv;
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
 #ifdef __alpha__
         /*
@@ -413,7 +413,7 @@ int drm_release(struct inode *inode, struct file *filp)
 
         drm_fasync(-1, filp, 0);
 
-        down(&dev->ctxlist_sem);
+        mutex_lock(&dev->ctxlist_mutex);
         if (dev->ctxlist && (!list_empty(&dev->ctxlist->head))) {
                 drm_ctx_list_t *pos, *n;
 
@@ -432,9 +432,9 @@ int drm_release(struct inode *inode, struct file *filp)
                         }
                 }
         }
-        up(&dev->ctxlist_sem);
+        mutex_unlock(&dev->ctxlist_mutex);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         if (priv->remove_auth_on_close == 1) {
                 drm_file_t *temp = dev->file_first;
                 while (temp) {
@@ -452,7 +452,7 @@ int drm_release(struct inode *inode, struct file *filp)
         } else {
                 dev->file_last = priv->prev;
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         if (dev->driver->postclose)
                 dev->driver->postclose(dev, priv);
diff --git a/drivers/char/drm/drm_ioctl.c b/drivers/char/drm/drm_ioctl.c
index bcd4e604d3ec..555f323b8a32 100644
--- a/drivers/char/drm/drm_ioctl.c
+++ b/drivers/char/drm/drm_ioctl.c
@@ -194,9 +194,9 @@ int drm_getmap(struct inode *inode, struct file *filp,
                 return -EFAULT;
         idx = map.offset;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         if (idx < 0) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
 
@@ -209,7 +209,7 @@ int drm_getmap(struct inode *inode, struct file *filp,
                 i++;
         }
         if (!r_list || !r_list->map) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
 
@@ -219,7 +219,7 @@ int drm_getmap(struct inode *inode, struct file *filp,
         map.flags = r_list->map->flags;
         map.handle = (void *)(unsigned long)r_list->user_token;
         map.mtrr = r_list->map->mtrr;
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         if (copy_to_user(argp, &map, sizeof(map)))
                 return -EFAULT;
@@ -253,11 +253,11 @@ int drm_getclient(struct inode *inode, struct file *filp,
         if (copy_from_user(&client, argp, sizeof(client)))
                 return -EFAULT;
         idx = client.idx;
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         for (i = 0, pt = dev->file_first; i < idx && pt; i++, pt = pt->next) ;
 
         if (!pt) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
         client.auth = pt->authenticated;
@@ -265,7 +265,7 @@ int drm_getclient(struct inode *inode, struct file *filp,
         client.uid = pt->uid;
         client.magic = pt->magic;
         client.iocs = pt->ioctl_count;
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         if (copy_to_user(argp, &client, sizeof(client)))
                 return -EFAULT;
@@ -292,7 +292,7 @@ int drm_getstats(struct inode *inode, struct file *filp,
 
         memset(&stats, 0, sizeof(stats));
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
 
         for (i = 0; i < dev->counters; i++) {
                 if (dev->types[i] == _DRM_STAT_LOCK)
@@ -305,7 +305,7 @@ int drm_getstats(struct inode *inode, struct file *filp,
 
         stats.count = dev->counters;
 
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         if (copy_to_user((drm_stats_t __user *) arg, &stats, sizeof(stats)))
                 return -EFAULT;
diff --git a/drivers/char/drm/drm_irq.c b/drivers/char/drm/drm_irq.c
index b0d4b236e837..611a1173091d 100644
--- a/drivers/char/drm/drm_irq.c
+++ b/drivers/char/drm/drm_irq.c
@@ -98,20 +98,20 @@ static int drm_irq_install(drm_device_t * dev)
         if (dev->irq == 0)
                 return -EINVAL;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
 
         /* Driver must have been initialized */
         if (!dev->dev_private) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
 
         if (dev->irq_enabled) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -EBUSY;
         }
         dev->irq_enabled = 1;
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         DRM_DEBUG("%s: irq=%d\n", __FUNCTION__, dev->irq);
 
@@ -135,9 +135,9 @@ static int drm_irq_install(drm_device_t * dev)
         ret = request_irq(dev->irq, dev->driver->irq_handler,
                           sh_flags, dev->devname, dev);
         if (ret < 0) {
-                down(&dev->struct_sem);
+                mutex_lock(&dev->struct_mutex);
                 dev->irq_enabled = 0;
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return ret;
         }
 
@@ -161,10 +161,10 @@ int drm_irq_uninstall(drm_device_t * dev)
         if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
                 return -EINVAL;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         irq_enabled = dev->irq_enabled;
         dev->irq_enabled = 0;
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         if (!irq_enabled)
                 return -EINVAL;
diff --git a/drivers/char/drm/drm_pciids.h b/drivers/char/drm/drm_pciids.h
index 5b1d3a04458d..2c17e88a8847 100644
--- a/drivers/char/drm/drm_pciids.h
+++ b/drivers/char/drm/drm_pciids.h
@@ -3,6 +3,7 @@
    Please contact dri-devel@lists.sf.net to add new cards to this list
 */
 #define radeon_PCI_IDS \
+        {0x1002, 0x3150, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350},\
         {0x1002, 0x4136, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS100|CHIP_IS_IGP}, \
         {0x1002, 0x4137, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|CHIP_IS_IGP}, \
         {0x1002, 0x4144, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \
@@ -84,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}, \
@@ -242,5 +242,6 @@
         {0x8086, 0x2582, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
         {0x8086, 0x2592, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
         {0x8086, 0x2772, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x8086, 0x27a2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
         {0, 0, 0}
 
diff --git a/drivers/char/drm/drm_proc.c b/drivers/char/drm/drm_proc.c
index 6f943e3309ef..362a270af0f1 100644
--- a/drivers/char/drm/drm_proc.c
+++ b/drivers/char/drm/drm_proc.c
@@ -258,7 +258,7 @@ static int drm__vm_info(char *buf, char **start, off_t offset, int request,
 }
 
 /**
- * Simply calls _vm_info() while holding the drm_device::struct_sem lock.
+ * Simply calls _vm_info() while holding the drm_device::struct_mutex lock.
  */
 static int drm_vm_info(char *buf, char **start, off_t offset, int request,
                        int *eof, void *data)
@@ -266,9 +266,9 @@ static int drm_vm_info(char *buf, char **start, off_t offset, int request,
         drm_device_t *dev = (drm_device_t *) data;
         int ret;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         ret = drm__vm_info(buf, start, offset, request, eof, data);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return ret;
 }
 
@@ -331,7 +331,7 @@ static int drm__queues_info(char *buf, char **start, off_t offset,
 }
 
 /**
- * Simply calls _queues_info() while holding the drm_device::struct_sem lock.
+ * Simply calls _queues_info() while holding the drm_device::struct_mutex lock.
  */
 static int drm_queues_info(char *buf, char **start, off_t offset, int request,
                            int *eof, void *data)
@@ -339,9 +339,9 @@ static int drm_queues_info(char *buf, char **start, off_t offset, int request,
         drm_device_t *dev = (drm_device_t *) data;
         int ret;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         ret = drm__queues_info(buf, start, offset, request, eof, data);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return ret;
 }
 
@@ -403,7 +403,7 @@ static int drm__bufs_info(char *buf, char **start, off_t offset, int request,
 }
 
 /**
- * Simply calls _bufs_info() while holding the drm_device::struct_sem lock.
+ * Simply calls _bufs_info() while holding the drm_device::struct_mutex lock.
  */
 static int drm_bufs_info(char *buf, char **start, off_t offset, int request,
                          int *eof, void *data)
@@ -411,9 +411,9 @@ static int drm_bufs_info(char *buf, char **start, off_t offset, int request,
         drm_device_t *dev = (drm_device_t *) data;
         int ret;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         ret = drm__bufs_info(buf, start, offset, request, eof, data);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return ret;
 }
 
@@ -459,7 +459,7 @@ static int drm__clients_info(char *buf, char **start, off_t offset,
 }
 
 /**
- * Simply calls _clients_info() while holding the drm_device::struct_sem lock.
+ * Simply calls _clients_info() while holding the drm_device::struct_mutex lock.
  */
 static int drm_clients_info(char *buf, char **start, off_t offset,
                             int request, int *eof, void *data)
@@ -467,9 +467,9 @@ static int drm_clients_info(char *buf, char **start, off_t offset,
         drm_device_t *dev = (drm_device_t *) data;
         int ret;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         ret = drm__clients_info(buf, start, offset, request, eof, data);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return ret;
 }
 
@@ -540,9 +540,9 @@ static int drm_vma_info(char *buf, char **start, off_t offset, int request,
         drm_device_t *dev = (drm_device_t *) data;
         int ret;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         ret = drm__vma_info(buf, start, offset, request, eof, data);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return ret;
 }
 #endif
diff --git a/drivers/char/drm/drm_stub.c b/drivers/char/drm/drm_stub.c
index 42d766359caa..68073e14fdec 100644
--- a/drivers/char/drm/drm_stub.c
+++ b/drivers/char/drm/drm_stub.c
@@ -50,7 +50,7 @@ module_param_named(cards_limit, drm_cards_limit, int, 0444);
 module_param_named(debug, drm_debug, int, 0600);
 
 drm_head_t **drm_heads;
-struct drm_sysfs_class *drm_class;
+struct class *drm_class;
 struct proc_dir_entry *drm_proc_root;
 
 static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
@@ -61,8 +61,8 @@ static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
 
         spin_lock_init(&dev->count_lock);
         init_timer(&dev->timer);
-        sema_init(&dev->struct_sem, 1);
-        sema_init(&dev->ctxlist_sem, 1);
+        mutex_init(&dev->struct_mutex);
+        mutex_init(&dev->ctxlist_mutex);
 
         dev->pdev = pdev;
 
diff --git a/drivers/char/drm/drm_sysfs.c b/drivers/char/drm/drm_sysfs.c
index 68e43ddc16ae..0b9f98a7eb10 100644
--- a/drivers/char/drm/drm_sysfs.c
+++ b/drivers/char/drm/drm_sysfs.c
@@ -1,3 +1,4 @@
+
 /*
  * drm_sysfs.c - Modifications to drm_sysfs_class.c to support
  *               extra sysfs attribute from DRM. Normal drm_sysfs_class
@@ -19,36 +20,6 @@
 #include "drm_core.h"
 #include "drmP.h"
 
-struct drm_sysfs_class {
-        struct class_device_attribute attr;
-        struct class class;
-};
-#define to_drm_sysfs_class(d) container_of(d, struct drm_sysfs_class, class)
-
-struct simple_dev {
-        dev_t dev;
-        struct class_device class_dev;
-};
-#define to_simple_dev(d) container_of(d, struct simple_dev, class_dev)
-
-static void release_simple_dev(struct class_device *class_dev)
-{
-        struct simple_dev *s_dev = to_simple_dev(class_dev);
-        kfree(s_dev);
-}
-
-static ssize_t show_dev(struct class_device *class_dev, char *buf)
-{
-        struct simple_dev *s_dev = to_simple_dev(class_dev);
-        return print_dev_t(buf, s_dev->dev);
-}
-
-static void drm_sysfs_class_release(struct class *class)
-{
-        struct drm_sysfs_class *cs = to_drm_sysfs_class(class);
-        kfree(cs);
-}
-
 /* Display the version of drm_core. This doesn't work right in current design */
 static ssize_t version_show(struct class *dev, char *buf)
 {
@@ -69,38 +40,16 @@ static CLASS_ATTR(version, S_IRUGO, version_show, NULL);
  * Note, the pointer created here is to be destroyed when finished by making a
  * call to drm_sysfs_destroy().
  */
-struct drm_sysfs_class *drm_sysfs_create(struct module *owner, char *name)
+struct class *drm_sysfs_create(struct module *owner, char *name)
 {
-        struct drm_sysfs_class *cs;
-        int retval;
-
-        cs = kmalloc(sizeof(*cs), GFP_KERNEL);
-        if (!cs) {
-                retval = -ENOMEM;
-                goto error;
-        }
-        memset(cs, 0x00, sizeof(*cs));
-
-        cs->class.name = name;
-        cs->class.class_release = drm_sysfs_class_release;
-        cs->class.release = release_simple_dev;
-
-        cs->attr.attr.name = "dev";
-        cs->attr.attr.mode = S_IRUGO;
-        cs->attr.attr.owner = owner;
-        cs->attr.show = show_dev;
-        cs->attr.store = NULL;
-
-        retval = class_register(&cs->class);
-        if (retval)
-                goto error;
-        class_create_file(&cs->class, &class_attr_version);
-
-        return cs;
-
-      error:
-        kfree(cs);
-        return ERR_PTR(retval);
+        struct class *class;
+
+        class = class_create(owner, name);
+        if (!class)
+                return class;
+
+        class_create_file(class, &class_attr_version);
+        return class;
 }
 
 /**
@@ -110,12 +59,13 @@ struct drm_sysfs_class *drm_sysfs_create(struct module *owner, char *name)
  * Note, the pointer to be destroyed must have been created with a call to
  * drm_sysfs_create().
  */
-void drm_sysfs_destroy(struct drm_sysfs_class *cs)
+void drm_sysfs_destroy(struct class *class)
 {
-        if ((cs == NULL) || (IS_ERR(cs)))
+        if ((class == NULL) || (IS_ERR(class)))
                 return;
 
-        class_unregister(&cs->class);
+        class_remove_file(class, &class_attr_version);
+        class_destroy(class);
 }
 
 static ssize_t show_dri(struct class_device *class_device, char *buf)
@@ -132,7 +82,7 @@ static struct class_device_attribute class_device_attrs[] = {
 
 /**
  * drm_sysfs_device_add - adds a class device to sysfs for a character driver
- * @cs: pointer to the struct drm_sysfs_class that this device should be registered to.
+ * @cs: pointer to the struct class that this device should be registered to.
  * @dev: the dev_t for the device to be added.
  * @device: a pointer to a struct device that is assiociated with this class device.
  * @fmt: string for the class device's name
@@ -141,46 +91,26 @@ static struct class_device_attribute class_device_attrs[] = {
  * class.  A "dev" file will be created, showing the dev_t for the device.  The
  * pointer to the struct class_device will be returned from the call.  Any further
  * sysfs files that might be required can be created using this pointer.
- * Note: the struct drm_sysfs_class passed to this function must have previously been
+ * Note: the struct class passed to this function must have previously been
  * created with a call to drm_sysfs_create().
  */
-struct class_device *drm_sysfs_device_add(struct drm_sysfs_class *cs,
-                                          drm_head_t *head)
+struct class_device *drm_sysfs_device_add(struct class *cs, drm_head_t *head)
 {
-        struct simple_dev *s_dev = NULL;
-        int i, retval;
-
-        if ((cs == NULL) || (IS_ERR(cs))) {
-                retval = -ENODEV;
-                goto error;
-        }
-
-        s_dev = kmalloc(sizeof(*s_dev), GFP_KERNEL);
-        if (!s_dev) {
-                retval = -ENOMEM;
-                goto error;
-        }
-        memset(s_dev, 0x00, sizeof(*s_dev));
-
-        s_dev->dev = MKDEV(DRM_MAJOR, head->minor);
-        s_dev->class_dev.dev = &(head->dev->pdev)->dev;
-        s_dev->class_dev.class = &cs->class;
+        struct class_device *class_dev;
+        int i;
 
-        snprintf(s_dev->class_dev.class_id, BUS_ID_SIZE, "card%d", head->minor);
-        retval = class_device_register(&s_dev->class_dev);
-        if (retval)
-                goto error;
+        class_dev = class_device_create(cs, NULL,
+                                        MKDEV(DRM_MAJOR, head->minor),
+                                        &(head->dev->pdev)->dev,
+                                        "card%d", head->minor);
+        if (!class_dev)
+                return NULL;
 
-        class_device_create_file(&s_dev->class_dev, &cs->attr);
-        class_set_devdata(&s_dev->class_dev, head);
+        class_set_devdata(class_dev, head);
 
         for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++)
-                class_device_create_file(&s_dev->class_dev, &class_device_attrs[i]);
-        return &s_dev->class_dev;
-
-error:
-        kfree(s_dev);
-        return ERR_PTR(retval);
+                class_device_create_file(class_dev, &class_device_attrs[i]);
+        return class_dev;
 }
 
 /**
@@ -192,10 +122,9 @@ error:
  */
 void drm_sysfs_device_remove(struct class_device *class_dev)
 {
-        struct simple_dev *s_dev = to_simple_dev(class_dev);
         int i;
 
         for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++)
-                class_device_remove_file(&s_dev->class_dev, &class_device_attrs[i]);
-        class_device_unregister(&s_dev->class_dev);
+                class_device_remove_file(class_dev, &class_device_attrs[i]);
+        class_device_unregister(class_dev);
 }
diff --git a/drivers/char/drm/drm_vm.c b/drivers/char/drm/drm_vm.c
index 3f73aa774c80..0291cd62c69f 100644
--- a/drivers/char/drm/drm_vm.c
+++ b/drivers/char/drm/drm_vm.c
@@ -188,7 +188,7 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
 
         map = vma->vm_private_data;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         for (pt = dev->vmalist, prev = NULL; pt; pt = next) {
                 next = pt->next;
                 if (pt->vma->vm_private_data == map)
@@ -248,7 +248,7 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
                         drm_free(map, sizeof(*map), DRM_MEM_MAPS);
                 }
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 }
 
 /**
@@ -404,12 +404,12 @@ static void drm_vm_open(struct vm_area_struct *vma)
 
         vma_entry = drm_alloc(sizeof(*vma_entry), DRM_MEM_VMAS);
         if (vma_entry) {
-                down(&dev->struct_sem);
+                mutex_lock(&dev->struct_mutex);
                 vma_entry->vma = vma;
                 vma_entry->next = dev->vmalist;
                 vma_entry->pid = current->pid;
                 dev->vmalist = vma_entry;
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
         }
 }
 
@@ -431,7 +431,7 @@ static void drm_vm_close(struct vm_area_struct *vma)
                   vma->vm_start, vma->vm_end - vma->vm_start);
         atomic_dec(&dev->vma_count);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         for (pt = dev->vmalist, prev = NULL; pt; prev = pt, pt = pt->next) {
                 if (pt->vma == vma) {
                         if (prev) {
@@ -443,7 +443,7 @@ static void drm_vm_close(struct vm_area_struct *vma)
                         break;
                 }
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 }
 
 /**
diff --git a/drivers/char/drm/i810_dma.c b/drivers/char/drm/i810_dma.c
index cc1b89086876..ae0aa6d7e0bb 100644
--- a/drivers/char/drm/i810_dma.c
+++ b/drivers/char/drm/i810_dma.c
@@ -958,7 +958,7 @@ static int i810_flush_queue(drm_device_t * dev)
 }
 
 /* Must be called with the lock held */
-void i810_reclaim_buffers(drm_device_t * dev, struct file *filp)
+static void i810_reclaim_buffers(drm_device_t * dev, struct file *filp)
 {
         drm_device_dma_t *dma = dev->dma;
         int i;
diff --git a/drivers/char/drm/i810_drv.h b/drivers/char/drm/i810_drv.h
index a18b80d91920..e8cf3ff606f0 100644
--- a/drivers/char/drm/i810_drv.h
+++ b/drivers/char/drm/i810_drv.h
@@ -113,8 +113,6 @@ typedef struct drm_i810_private {
 } drm_i810_private_t;
 
                                 /* i810_dma.c */
-extern void i810_reclaim_buffers(drm_device_t * dev, struct file *filp);
-
 extern int i810_driver_dma_quiescent(drm_device_t * dev);
 extern void i810_driver_reclaim_buffers_locked(drm_device_t * dev,
                                                struct file *filp);
diff --git a/drivers/char/drm/i830_dma.c b/drivers/char/drm/i830_dma.c
index 4fea32aed6d2..163f2cbfe60d 100644
--- a/drivers/char/drm/i830_dma.c
+++ b/drivers/char/drm/i830_dma.c
@@ -1239,7 +1239,7 @@ static int i830_flush_queue(drm_device_t * dev)
 }
 
 /* Must be called with the lock held */
-void i830_reclaim_buffers(drm_device_t * dev, struct file *filp)
+static void i830_reclaim_buffers(drm_device_t * dev, struct file *filp)
 {
         drm_device_dma_t *dma = dev->dma;
         int i;
diff --git a/drivers/char/drm/i830_drv.h b/drivers/char/drm/i830_drv.h
index bf9075b576bd..85bc5be6f916 100644
--- a/drivers/char/drm/i830_drv.h
+++ b/drivers/char/drm/i830_drv.h
@@ -123,9 +123,6 @@ typedef struct drm_i830_private {
 extern drm_ioctl_desc_t i830_ioctls[];
 extern int i830_max_ioctl;
 
-/* i830_dma.c */
-extern void i830_reclaim_buffers(drm_device_t * dev, struct file *filp);
-
 /* i830_irq.c */
 extern int i830_irq_emit(struct inode *inode, struct file *filp,
                          unsigned int cmd, unsigned long arg);
diff --git a/drivers/char/drm/i915_dma.c b/drivers/char/drm/i915_dma.c
index 9140703da1ba..1ff4c7ca0bff 100644
--- a/drivers/char/drm/i915_dma.c
+++ b/drivers/char/drm/i915_dma.c
@@ -344,18 +344,20 @@ static int i915_emit_cmds(drm_device_t * dev, int __user * buffer, int dwords)
         int i;
         RING_LOCALS;
 
+        if ((dwords+1) * sizeof(int) >= dev_priv->ring.Size - 8)
+                return DRM_ERR(EINVAL);
+
+        BEGIN_LP_RING(((dwords+1)&~1));
+
         for (i = 0; i < dwords;) {
                 int cmd, sz;
 
                 if (DRM_COPY_FROM_USER_UNCHECKED(&cmd, &buffer[i], sizeof(cmd)))
                         return DRM_ERR(EINVAL);
 
-/*              printk("%d/%d ", i, dwords); */
-
                 if ((sz = validate_cmd(cmd)) == 0 || i + sz > dwords)
                         return DRM_ERR(EINVAL);
 
-                BEGIN_LP_RING(sz);
                 OUT_RING(cmd);
 
                 while (++i, --sz) {
@@ -365,9 +367,13 @@ static int i915_emit_cmds(drm_device_t * dev, int __user * buffer, int dwords)
                         }
                         OUT_RING(cmd);
                 }
-                ADVANCE_LP_RING();
         }
 
+        if (dwords & 1)
+                OUT_RING(0);
+
+        ADVANCE_LP_RING();
+
         return 0;
 }
 
@@ -401,6 +407,21 @@ static int i915_emit_box(drm_device_t * dev,
         return 0;
 }
 
+static void i915_emit_breadcrumb(drm_device_t *dev)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        RING_LOCALS;
+
+        dev_priv->sarea_priv->last_enqueue = dev_priv->counter++;
+
+        BEGIN_LP_RING(4);
+        OUT_RING(CMD_STORE_DWORD_IDX);
+        OUT_RING(20);
+        OUT_RING(dev_priv->counter);
+        OUT_RING(0);
+        ADVANCE_LP_RING();
+}
+
 static int i915_dispatch_cmdbuffer(drm_device_t * dev,
                                    drm_i915_cmdbuffer_t * cmd)
 {
@@ -429,6 +450,7 @@ static int i915_dispatch_cmdbuffer(drm_device_t * dev,
                         return ret;
         }
 
+        i915_emit_breadcrumb(dev);
         return 0;
 }
 
@@ -475,12 +497,7 @@ static int i915_dispatch_batchbuffer(drm_device_t * dev,
 
         dev_priv->sarea_priv->last_enqueue = dev_priv->counter++;
 
-        BEGIN_LP_RING(4);
-        OUT_RING(CMD_STORE_DWORD_IDX);
-        OUT_RING(20);
-        OUT_RING(dev_priv->counter);
-        OUT_RING(0);
-        ADVANCE_LP_RING();
+        i915_emit_breadcrumb(dev);
 
         return 0;
 }
@@ -657,7 +674,7 @@ static int i915_getparam(DRM_IOCTL_ARGS)
                 value = READ_BREADCRUMB(dev_priv);
                 break;
         default:
-                DRM_ERROR("Unkown parameter %d\n", param.param);
+                DRM_ERROR("Unknown parameter %d\n", param.param);
                 return DRM_ERR(EINVAL);
         }
 
@@ -742,7 +759,8 @@ drm_ioctl_desc_t i915_ioctls[] = {
         [DRM_IOCTL_NR(DRM_I915_ALLOC)] = {i915_mem_alloc, DRM_AUTH},
         [DRM_IOCTL_NR(DRM_I915_FREE)] = {i915_mem_free, DRM_AUTH},
         [DRM_IOCTL_NR(DRM_I915_INIT_HEAP)] = {i915_mem_init_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
-        [DRM_IOCTL_NR(DRM_I915_CMDBUFFER)] = {i915_cmdbuffer, DRM_AUTH}
+        [DRM_IOCTL_NR(DRM_I915_CMDBUFFER)] = {i915_cmdbuffer, DRM_AUTH},
+        [DRM_IOCTL_NR(DRM_I915_DESTROY_HEAP)] = { i915_mem_destroy_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY }
 };
 
 int i915_max_ioctl = DRM_ARRAY_SIZE(i915_ioctls);
diff --git a/drivers/char/drm/i915_drm.h b/drivers/char/drm/i915_drm.h
index 77412ddac007..4cb3da578330 100644
--- a/drivers/char/drm/i915_drm.h
+++ b/drivers/char/drm/i915_drm.h
@@ -74,6 +74,30 @@ typedef struct _drm_i915_sarea {
         int pf_active;
         int pf_current_page;    /* which buffer is being displayed? */
         int perf_boxes;         /* performance boxes to be displayed */
+        int width, height;      /* screen size in pixels */
+
+        drm_handle_t front_handle;
+        int front_offset;
+        int front_size;
+
+        drm_handle_t back_handle;
+        int back_offset;
+        int back_size;
+
+        drm_handle_t depth_handle;
+        int depth_offset;
+        int depth_size;
+
+        drm_handle_t tex_handle;
+        int tex_offset;
+        int tex_size;
+        int log_tex_granularity;
+        int pitch;
+        int rotation;           /* 0, 90, 180 or 270 */
+        int rotated_offset;
+        int rotated_size;
+        int rotated_pitch;
+        int virtualX, virtualY;
 } drm_i915_sarea_t;
 
 /* Flags for perf_boxes
@@ -99,6 +123,7 @@ typedef struct _drm_i915_sarea {
 #define DRM_I915_FREE           0x09
 #define DRM_I915_INIT_HEAP      0x0a
 #define DRM_I915_CMDBUFFER      0x0b
+#define DRM_I915_DESTROY_HEAP   0x0c
 
 #define DRM_IOCTL_I915_INIT             DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT, drm_i915_init_t)
 #define DRM_IOCTL_I915_FLUSH            DRM_IO ( DRM_COMMAND_BASE + DRM_I915_FLUSH)
@@ -112,6 +137,7 @@ typedef struct _drm_i915_sarea {
 #define DRM_IOCTL_I915_FREE             DRM_IOW( DRM_COMMAND_BASE + DRM_I915_FREE, drm_i915_mem_free_t)
 #define DRM_IOCTL_I915_INIT_HEAP        DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT_HEAP, drm_i915_mem_init_heap_t)
 #define DRM_IOCTL_I915_CMDBUFFER        DRM_IOW( DRM_COMMAND_BASE + DRM_I915_CMDBUFFER, drm_i915_cmdbuffer_t)
+#define DRM_IOCTL_I915_DESTROY_HEAP     DRM_IOW( DRM_COMMAND_BASE + DRM_I915_DESTROY_HEAP, drm_i915_mem_destroy_heap_t)
 
 /* Allow drivers to submit batchbuffers directly to hardware, relying
  * on the security mechanisms provided by hardware.
@@ -191,4 +217,11 @@ typedef struct drm_i915_mem_init_heap {
         int start;
 } drm_i915_mem_init_heap_t;
 
+/* Allow memory manager to be torn down and re-initialized (eg on
+ * rotate):
+ */
+typedef struct drm_i915_mem_destroy_heap {
+        int region;
+} drm_i915_mem_destroy_heap_t;
+
 #endif                          /* _I915_DRM_H_ */
diff --git a/drivers/char/drm/i915_drv.h b/drivers/char/drm/i915_drv.h
index c6c71b45f101..7a65666899e4 100644
--- a/drivers/char/drm/i915_drv.h
+++ b/drivers/char/drm/i915_drv.h
@@ -37,16 +37,17 @@
 
 #define DRIVER_NAME             "i915"
 #define DRIVER_DESC             "Intel Graphics"
-#define DRIVER_DATE             "20051209"
+#define DRIVER_DATE             "20060119"
 
 /* Interface history:
  *
  * 1.1: Original.
  * 1.2: Add Power Management
  * 1.3: Add vblank support
+ * 1.4: Fix cmdbuffer path, add heap destroy
  */
 #define DRIVER_MAJOR            1
-#define DRIVER_MINOR            3
+#define DRIVER_MINOR            4
 #define DRIVER_PATCHLEVEL       0
 
 typedef struct _drm_i915_ring_buffer {
@@ -123,6 +124,7 @@ extern void i915_driver_irq_uninstall(drm_device_t * dev);
 extern int i915_mem_alloc(DRM_IOCTL_ARGS);
 extern int i915_mem_free(DRM_IOCTL_ARGS);
 extern int i915_mem_init_heap(DRM_IOCTL_ARGS);
+extern int i915_mem_destroy_heap(DRM_IOCTL_ARGS);
 extern void i915_mem_takedown(struct mem_block **heap);
 extern void i915_mem_release(drm_device_t * dev,
                              DRMFILE filp, struct mem_block *heap);
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/i915_mem.c b/drivers/char/drm/i915_mem.c
index ba87ff17ff64..52c67324df58 100644
--- a/drivers/char/drm/i915_mem.c
+++ b/drivers/char/drm/i915_mem.c
@@ -365,3 +365,34 @@ int i915_mem_init_heap(DRM_IOCTL_ARGS)
 
         return init_heap(heap, initheap.start, initheap.size);
 }
+
+int i915_mem_destroy_heap( DRM_IOCTL_ARGS )
+{
+        DRM_DEVICE;
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        drm_i915_mem_destroy_heap_t destroyheap;
+        struct mem_block **heap;
+
+        if ( !dev_priv ) {
+                DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
+                return DRM_ERR(EINVAL);
+        }
+
+        DRM_COPY_FROM_USER_IOCTL( destroyheap, (drm_i915_mem_destroy_heap_t *)data,
+                                  sizeof(destroyheap) );
+
+        heap = get_heap( dev_priv, destroyheap.region );
+        if (!heap) {
+                DRM_ERROR("get_heap failed");
+                return DRM_ERR(EFAULT);
+        }
+        
+        if (!*heap) {
+                DRM_ERROR("heap not initialized?");
+                return DRM_ERR(EFAULT);
+        }
+
+        i915_mem_takedown( heap );
+        return 0;
+}
+
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_cp.c b/drivers/char/drm/radeon_cp.c
index 915665c7fe7c..9bb8ae0c1c27 100644
--- a/drivers/char/drm/radeon_cp.c
+++ b/drivers/char/drm/radeon_cp.c
@@ -1640,7 +1640,7 @@ static int radeon_do_cleanup_cp(drm_device_t * dev)
                 if (dev_priv->gart_info.gart_table_location == DRM_ATI_GART_FB)
                 {
                         drm_core_ioremapfree(&dev_priv->gart_info.mapping, dev);
-                        dev_priv->gart_info.addr = 0;
+                        dev_priv->gart_info.addr = NULL;
                 }
         }
         /* only clear to the start of flags */
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/drm/savage_bci.c b/drivers/char/drm/savage_bci.c
index 0d426deeefec..59c7520bf9a2 100644
--- a/drivers/char/drm/savage_bci.c
+++ b/drivers/char/drm/savage_bci.c
@@ -32,6 +32,8 @@
 #define SAVAGE_EVENT_USEC_TIMEOUT       5000000 /* 5s */
 #define SAVAGE_FREELIST_DEBUG           0
 
+static int savage_do_cleanup_bci(drm_device_t *dev);
+
 static int
 savage_bci_wait_fifo_shadow(drm_savage_private_t * dev_priv, unsigned int n)
 {
@@ -895,7 +897,7 @@ static int savage_do_init_bci(drm_device_t * dev, drm_savage_init_t * init)
         return 0;
 }
 
-int savage_do_cleanup_bci(drm_device_t * dev)
+static int savage_do_cleanup_bci(drm_device_t * dev)
 {
         drm_savage_private_t *dev_priv = dev->dev_private;
 
diff --git a/drivers/char/drm/savage_drv.h b/drivers/char/drm/savage_drv.h
index dd46cb85439c..8f04b3d82292 100644
--- a/drivers/char/drm/savage_drv.h
+++ b/drivers/char/drm/savage_drv.h
@@ -212,7 +212,6 @@ extern int savage_driver_load(drm_device_t *dev, unsigned long chipset);
 extern int savage_driver_firstopen(drm_device_t *dev);
 extern void savage_driver_lastclose(drm_device_t *dev);
 extern int savage_driver_unload(drm_device_t *dev);
-extern int savage_do_cleanup_bci(drm_device_t * dev);
 extern void savage_reclaim_buffers(drm_device_t * dev, DRMFILE filp);
 
 /* state functions */
diff --git a/drivers/char/drm/via_dma.c b/drivers/char/drm/via_dma.c
index 593c0b8f650a..a691ae74129d 100644
--- a/drivers/char/drm/via_dma.c
+++ b/drivers/char/drm/via_dma.c
@@ -222,7 +222,7 @@ static int via_initialize(drm_device_t * dev,
         return 0;
 }
 
-int via_dma_init(DRM_IOCTL_ARGS)
+static int via_dma_init(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
@@ -321,7 +321,7 @@ int via_driver_dma_quiescent(drm_device_t * dev)
         return 0;
 }
 
-int via_flush_ioctl(DRM_IOCTL_ARGS)
+static int via_flush_ioctl(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
 
@@ -330,7 +330,7 @@ int via_flush_ioctl(DRM_IOCTL_ARGS)
         return via_driver_dma_quiescent(dev);
 }
 
-int via_cmdbuffer(DRM_IOCTL_ARGS)
+static int via_cmdbuffer(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_via_cmdbuffer_t cmdbuf;
@@ -375,7 +375,7 @@ static int via_dispatch_pci_cmdbuffer(drm_device_t * dev,
         return ret;
 }
 
-int via_pci_cmdbuffer(DRM_IOCTL_ARGS)
+static int via_pci_cmdbuffer(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_via_cmdbuffer_t cmdbuf;
@@ -665,7 +665,7 @@ static void via_cmdbuf_reset(drm_via_private_t * dev_priv)
  * User interface to the space and lag functions.
  */
 
-int via_cmdbuf_size(DRM_IOCTL_ARGS)
+static int via_cmdbuf_size(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_via_cmdbuf_size_t d_siz;
diff --git a/drivers/char/drm/via_dmablit.c b/drivers/char/drm/via_dmablit.c
index 9d5e027dae0e..b7f17457b424 100644
--- a/drivers/char/drm/via_dmablit.c
+++ b/drivers/char/drm/via_dmablit.c
@@ -108,7 +108,7 @@ via_map_blit_for_device(struct pci_dev *pdev,
         int num_desc = 0;
         int cur_line;
         dma_addr_t next = 0 | VIA_DMA_DPR_EC;
-        drm_via_descriptor_t *desc_ptr = 0;
+        drm_via_descriptor_t *desc_ptr = NULL;
 
         if (mode == 1) 
                 desc_ptr = vsg->desc_pages[cur_descriptor_page];
@@ -167,7 +167,7 @@ via_map_blit_for_device(struct pci_dev *pdev,
  */
 
 
-void
+static void
 via_free_sg_info(struct pci_dev *pdev, drm_via_sg_info_t *vsg) 
 {
         struct page *page;
@@ -581,7 +581,7 @@ via_build_sg_info(drm_device_t *dev, drm_via_sg_info_t *vsg, drm_via_dmablit_t *
         int ret = 0;
         
         vsg->direction = (draw) ? DMA_TO_DEVICE : DMA_FROM_DEVICE;
-        vsg->bounce_buffer = 0;
+        vsg->bounce_buffer = NULL;
 
         vsg->state = dr_via_sg_init;
 
diff --git a/drivers/char/drm/via_drv.h b/drivers/char/drm/via_drv.h
index aad4f99f5405..52bcc7b1ba45 100644
--- a/drivers/char/drm/via_drv.h
+++ b/drivers/char/drm/via_drv.h
@@ -110,11 +110,6 @@ extern int via_mem_free(DRM_IOCTL_ARGS);
 extern int via_agp_init(DRM_IOCTL_ARGS);
 extern int via_map_init(DRM_IOCTL_ARGS);
 extern int via_decoder_futex(DRM_IOCTL_ARGS);
-extern int via_dma_init(DRM_IOCTL_ARGS);
-extern int via_cmdbuffer(DRM_IOCTL_ARGS);
-extern int via_flush_ioctl(DRM_IOCTL_ARGS);
-extern int via_pci_cmdbuffer(DRM_IOCTL_ARGS);
-extern int via_cmdbuf_size(DRM_IOCTL_ARGS);
 extern int via_wait_irq(DRM_IOCTL_ARGS);
 extern int via_dma_blit_sync( DRM_IOCTL_ARGS );
 extern int via_dma_blit( DRM_IOCTL_ARGS );
@@ -139,8 +134,6 @@ extern int via_driver_dma_quiescent(drm_device_t * dev);
 extern void via_init_futex(drm_via_private_t * dev_priv);
 extern void via_cleanup_futex(drm_via_private_t * dev_priv);
 extern void via_release_futex(drm_via_private_t * dev_priv, int context);
-extern int via_driver_irq_wait(drm_device_t * dev, unsigned int irq,
-                               int force_sequence, unsigned int *sequence);
 
 extern void via_dmablit_handler(drm_device_t *dev, int engine, int from_irq);
 extern void via_init_dmablit(drm_device_t *dev);
diff --git a/drivers/char/drm/via_irq.c b/drivers/char/drm/via_irq.c
index 56d7e3daea12..6152415644e9 100644
--- a/drivers/char/drm/via_irq.c
+++ b/drivers/char/drm/via_irq.c
@@ -190,7 +190,7 @@ int via_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence)
         return ret;
 }
 
-int
+static int
 via_driver_irq_wait(drm_device_t * dev, unsigned int irq, int force_sequence,
                     unsigned int *sequence)
 {
diff --git a/drivers/char/esp.c b/drivers/char/esp.c
index 3f3ac039f4d9..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)
 {
@@ -359,7 +348,7 @@ static inline void receive_chars_pio(struct esp_struct *info, int num_bytes)
                 }
         }
 
-        schedule_delayed_work(&tty->buf.work, 1);
+        tty_schedule_flip(tty);
 
         info->stat_flags &= ~ESP_STAT_RX_TIMEOUT;
         release_pio_buffer(pio_buf);
@@ -426,7 +415,7 @@ static inline void receive_chars_dma_done(struct esp_struct *info,
                         }
                         tty_insert_flip_char(tty, dma_buffer[num_bytes - 1], statflag);
                 }
-                schedule_delayed_work(&tty->buf.work, 1);
+                tty_schedule_flip(tty);
         }
 
         if (dma_bytes != num_bytes) {
@@ -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/hangcheck-timer.c b/drivers/char/hangcheck-timer.c
index 40a67c86420c..ac626418b329 100644
--- a/drivers/char/hangcheck-timer.c
+++ b/drivers/char/hangcheck-timer.c
@@ -117,12 +117,9 @@ __setup("hcheck_reboot", hangcheck_parse_reboot);
 __setup("hcheck_dump_tasks", hangcheck_parse_dump_tasks);
 #endif /* not MODULE */
 
-#if defined(CONFIG_X86)
+#if defined(CONFIG_X86) || defined(CONFIG_S390)
 # define HAVE_MONOTONIC
 # define TIMER_FREQ 1000000000ULL
-#elif defined(CONFIG_S390)
-/* FA240000 is 1 Second in the IBM time universe (Page 4-38 Principles of Op for zSeries */
-# define TIMER_FREQ 0xFA240000ULL
 #elif defined(CONFIG_IA64)
 # define TIMER_FREQ ((unsigned long long)local_cpu_data->itc_freq)
 #elif defined(CONFIG_PPC64)
@@ -134,12 +131,7 @@ extern unsigned long long monotonic_clock(void);
 #else
 static inline unsigned long long monotonic_clock(void)
 {
-# ifdef __s390__
-        /* returns the TOD.  see 4-38 Principles of Op of zSeries */
-        return get_clock();
-# else
         return get_cycles();
-# endif  /* __s390__ */
 }
 #endif  /* HAVE_MONOTONIC */
 
@@ -188,8 +180,6 @@ static int __init hangcheck_init(void)
                VERSION_STR, hangcheck_tick, hangcheck_margin);
 #if defined (HAVE_MONOTONIC)
         printk("Hangcheck: Using monotonic_clock().\n");
-#elif defined(__s390__)
-        printk("Hangcheck: Using TOD.\n");
 #else
         printk("Hangcheck: Using get_cycles().\n");
 #endif  /* HAVE_MONOTONIC */
diff --git a/drivers/char/hpet.c b/drivers/char/hpet.c
index 3808d9572619..ef140ebde117 100644
--- a/drivers/char/hpet.c
+++ b/drivers/char/hpet.c
@@ -927,9 +927,9 @@ static acpi_status hpet_resources(struct acpi_resource *res, void *data)
         if (ACPI_SUCCESS(status)) {
                 unsigned long size;
 
-                size = addr.max_address_range - addr.min_address_range + 1;
-                hdp->hd_phys_address = addr.min_address_range;
-                hdp->hd_address = ioremap(addr.min_address_range, size);
+                size = addr.maximum - addr.minimum + 1;
+                hdp->hd_phys_address = addr.minimum;
+                hdp->hd_address = ioremap(addr.minimum, size);
 
                 if (hpet_is_known(hdp)) {
                         printk(KERN_DEBUG "%s: 0x%lx is busy\n",
@@ -937,15 +937,15 @@ static acpi_status hpet_resources(struct acpi_resource *res, void *data)
                         iounmap(hdp->hd_address);
                         return -EBUSY;
                 }
-        } else if (res->id == ACPI_RSTYPE_FIXED_MEM32) {
-                struct acpi_resource_fixed_mem32 *fixmem32;
+        } else if (res->type == ACPI_RESOURCE_TYPE_FIXED_MEMORY32) {
+                struct acpi_resource_fixed_memory32 *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,
+                hdp->hd_phys_address = fixmem32->address;
+                hdp->hd_address = ioremap(fixmem32->address,
                                                 HPET_RANGE_SIZE);
 
                 if (hpet_is_known(hdp)) {
@@ -954,24 +954,20 @@ static acpi_status hpet_resources(struct acpi_resource *res, void *data)
                         iounmap(hdp->hd_address);
                         return -EBUSY;
                 }
-        } else if (res->id == ACPI_RSTYPE_EXT_IRQ) {
-                struct acpi_resource_ext_irq *irqp;
-                int i;
+        } else if (res->type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) {
+                struct acpi_resource_extended_irq *irqp;
+                int i, irq;
 
                 irqp = &res->data.extended_irq;
 
-                if (irqp->number_of_interrupts > 0) {
-                        hdp->hd_nirqs = irqp->number_of_interrupts;
-
-                        for (i = 0; i < hdp->hd_nirqs; i++) {
-                                int rc =
-                                    acpi_register_gsi(irqp->interrupts[i],
-                                                      irqp->edge_level,
-                                                      irqp->active_high_low);
-                                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/hw_random.c b/drivers/char/hw_random.c
index b3bc2e37e616..29dc87e59020 100644
--- a/drivers/char/hw_random.c
+++ b/drivers/char/hw_random.c
@@ -131,7 +131,9 @@ enum {
         rng_hw_none,
         rng_hw_intel,
         rng_hw_amd,
+#ifdef __i386__
         rng_hw_via,
+#endif
         rng_hw_geode,
 };
 
diff --git a/drivers/char/ip2/i2cmd.c b/drivers/char/ip2/i2cmd.c
index cb8f4198e9a3..e7af647800b6 100644
--- a/drivers/char/ip2/i2cmd.c
+++ b/drivers/char/ip2/i2cmd.c
@@ -139,7 +139,6 @@ static UCHAR ct79[] = { 2, BYP,     0x4F,0                   }; // XMIT_NOW
 //static UCHAR ct86[]={ 2, BTH,     0x56,0                   }; // RCV_ENABLE
 static UCHAR ct87[] = { 1, BYP,     0x57                     }; // HW_TEST
 //static UCHAR ct88[]={ 3, BTH,     0x58,0,0                 }; // RCV_THRESHOLD
-static UCHAR ct89[]={ 1, BYP,     0x59                     }; // DSS_NOW
 //static UCHAR ct90[]={ 3, BYP,     0x5A,0,0                 }; // Set SILO
 //static UCHAR ct91[]={ 2, BYP,     0x5B,0                   }; // timed break
 
diff --git a/drivers/char/ip2main.c b/drivers/char/ip2main.c
index 56e93a5a1e24..48fcfba37bfa 100644
--- a/drivers/char/ip2main.c
+++ b/drivers/char/ip2main.c
@@ -2906,65 +2906,16 @@ ip2_ipl_ioctl ( struct inode *pInode, struct file *pFile, UINT cmd, ULONG arg )
                 rc = -EINVAL;
                 break;
         case 3:     // Trace device
-                if ( cmd == 1 ) {
-                        rc = put_user(iiSendPendingMail, pIndex++ );
-                        rc = put_user(i2InitChannels, pIndex++ );
-                        rc = put_user(i2QueueNeeds, pIndex++ );
-                        rc = put_user(i2QueueCommands, pIndex++ );
-                        rc = put_user(i2GetStatus, pIndex++ );
-                        rc = put_user(i2Input, pIndex++ );
-                        rc = put_user(i2InputFlush, pIndex++ );
-                        rc = put_user(i2Output, pIndex++ );
-                        rc = put_user(i2FlushOutput, pIndex++ );
-                        rc = put_user(i2DrainWakeup, pIndex++ );
-                        rc = put_user(i2DrainOutput, pIndex++ );
-                        rc = put_user(i2OutputFree, pIndex++ );
-                        rc = put_user(i2StripFifo, pIndex++ );
-                        rc = put_user(i2StuffFifoBypass, pIndex++ );
-                        rc = put_user(i2StuffFifoFlow, pIndex++ );
-                        rc = put_user(i2StuffFifoInline, pIndex++ );
-                        rc = put_user(i2ServiceBoard, pIndex++ );
-                        rc = put_user(serviceOutgoingFifo, pIndex++ );
-                        // rc = put_user(ip2_init, pIndex++ );
-                        rc = put_user(ip2_init_board, pIndex++ );
-                        rc = put_user(find_eisa_board, pIndex++ );
-                        rc = put_user(set_irq, pIndex++ );
-                        rc = put_user(ip2_interrupt, pIndex++ );
-                        rc = put_user(ip2_poll, pIndex++ );
-                        rc = put_user(service_all_boards, pIndex++ );
-                        rc = put_user(do_input, pIndex++ );
-                        rc = put_user(do_status, pIndex++ );
-#ifndef IP2DEBUG_OPEN
-                        rc = put_user(0, pIndex++ );
-#else
-                        rc = put_user(open_sanity_check, pIndex++ );
-#endif
-                        rc = put_user(ip2_open, pIndex++ );
-                        rc = put_user(ip2_close, pIndex++ );
-                        rc = put_user(ip2_hangup, pIndex++ );
-                        rc = put_user(ip2_write, pIndex++ );
-                        rc = put_user(ip2_putchar, pIndex++ );
-                        rc = put_user(ip2_flush_chars, pIndex++ );
-                        rc = put_user(ip2_write_room, pIndex++ );
-                        rc = put_user(ip2_chars_in_buf, pIndex++ );
-                        rc = put_user(ip2_flush_buffer, pIndex++ );
-
-                        //rc = put_user(ip2_wait_until_sent, pIndex++ );
-                        rc = put_user(0, pIndex++ );
-
-                        rc = put_user(ip2_throttle, pIndex++ );
-                        rc = put_user(ip2_unthrottle, pIndex++ );
-                        rc = put_user(ip2_ioctl, pIndex++ );
-                        rc = put_user(0, pIndex++ );
-                        rc = put_user(get_serial_info, pIndex++ );
-                        rc = put_user(set_serial_info, pIndex++ );
-                        rc = put_user(ip2_set_termios, pIndex++ );
-                        rc = put_user(ip2_set_line_discipline, pIndex++ );
-                        rc = put_user(set_params, pIndex++ );
-                } else {
+                /*
+                 * akpm: This used to write a whole bunch of function addresses
+                 * to userspace, which generated lots of put_user() warnings.
+                 * I killed it all.  Just return "success" and don't do
+                 * anything.
+                 */
+                if (cmd == 1)
+                        rc = 0;
+                else
                         rc = -EINVAL;
-                }
-
                 break;
 
         default:
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index 0097f06fa67b..d745004281d0 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -481,7 +481,7 @@ int ipmi_validate_addr(struct ipmi_addr *addr, int len)
         }
 
         if ((addr->channel == IPMI_BMC_CHANNEL)
-            || (addr->channel >= IPMI_NUM_CHANNELS)
+            || (addr->channel >= IPMI_MAX_CHANNELS)
             || (addr->channel < 0))
                 return -EINVAL;
 
@@ -1321,7 +1321,7 @@ static int i_ipmi_request(ipmi_user_t          user,
                 unsigned char         ipmb_seq;
                 long                  seqid;
 
-                if (addr->channel >= IPMI_NUM_CHANNELS) {
+                if (addr->channel >= IPMI_MAX_CHANNELS) {
                         spin_lock_irqsave(&intf->counter_lock, flags);
                         intf->sent_invalid_commands++;
                         spin_unlock_irqrestore(&intf->counter_lock, flags);
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index c67ef3e47ad5..e59b638766ef 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -1270,36 +1270,36 @@ static int try_init_port(int intf_num, struct smi_info **new_info)
         return 0;
 }
 
-static unsigned char mem_inb(struct si_sm_io *io, unsigned int offset)
+static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
 {
         return readb((io->addr)+(offset * io->regspacing));
 }
 
-static void mem_outb(struct si_sm_io *io, unsigned int offset,
+static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
                      unsigned char b)
 {
         writeb(b, (io->addr)+(offset * io->regspacing));
 }
 
-static unsigned char mem_inw(struct si_sm_io *io, unsigned int offset)
+static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
 {
         return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
                 && 0xff;
 }
 
-static void mem_outw(struct si_sm_io *io, unsigned int offset,
+static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
                      unsigned char b)
 {
         writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
 }
 
-static unsigned char mem_inl(struct si_sm_io *io, unsigned int offset)
+static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
 {
         return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
                 && 0xff;
 }
 
-static void mem_outl(struct si_sm_io *io, unsigned int offset,
+static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
                      unsigned char b)
 {
         writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
@@ -1349,16 +1349,16 @@ static int mem_setup(struct smi_info *info)
            upon the register size. */
         switch (info->io.regsize) {
         case 1:
-                info->io.inputb = mem_inb;
-                info->io.outputb = mem_outb;
+                info->io.inputb = intf_mem_inb;
+                info->io.outputb = intf_mem_outb;
                 break;
         case 2:
-                info->io.inputb = mem_inw;
-                info->io.outputb = mem_outw;
+                info->io.inputb = intf_mem_inw;
+                info->io.outputb = intf_mem_outw;
                 break;
         case 4:
-                info->io.inputb = mem_inl;
-                info->io.outputb = mem_outl;
+                info->io.inputb = intf_mem_inl;
+                info->io.outputb = intf_mem_outl;
                 break;
 #ifdef readq
         case 8:
@@ -1580,11 +1580,6 @@ static int try_init_acpi(int intf_num, struct smi_info **new_info)
         if (! is_new_interface(-1, addr_space, spmi->addr.address))
                 return -ENODEV;
 
-        if (! spmi->addr.register_bit_width) {
-                acpi_failure = 1;
-                return -ENODEV;
-        }
-
         /* Figure out the interface type. */
         switch (spmi->InterfaceType)
         {
@@ -1634,9 +1629,6 @@ static int try_init_acpi(int intf_num, struct smi_info **new_info)
                 regspacings[intf_num] = spmi->addr.register_bit_width / 8;
                 info->io.regspacing = spmi->addr.register_bit_width / 8;
         } else {
-                /* Some broken systems get this wrong and set the value
-                 * to zero.  Assume it is the default spacing.  If that
-                 * is wrong, too bad, the vendor should fix the tables. */
                 regspacings[intf_num] = DEFAULT_REGSPACING;
                 info->io.regspacing = DEFAULT_REGSPACING;
         }
diff --git a/drivers/char/mmtimer.c b/drivers/char/mmtimer.c
index c92378121b4c..1b05fa688996 100644
--- a/drivers/char/mmtimer.c
+++ b/drivers/char/mmtimer.c
@@ -675,7 +675,7 @@ static int __init mmtimer_init(void)
         cnodeid_t node, maxn = -1;
 
         if (!ia64_platform_is("sn2"))
-                return -1;
+                return 0;
 
         /*
          * Sanity check the cycles/sec variable
diff --git a/drivers/char/pcmcia/cm4000_cs.c b/drivers/char/pcmcia/cm4000_cs.c
index 649677b5dc36..5fdf18515433 100644
--- a/drivers/char/pcmcia/cm4000_cs.c
+++ b/drivers/char/pcmcia/cm4000_cs.c
@@ -13,11 +13,12 @@
   *
   * (C) 2000,2001,2002,2003,2004 Omnikey AG
   *
-  * (C) 2005 Harald Welte <laforge@gnumonks.org>
+  * (C) 2005-2006 Harald Welte <laforge@gnumonks.org>
   *     - Adhere to Kernel CodingStyle
   *     - Port to 2.6.13 "new" style PCMCIA
   *     - Check for copy_{from,to}_user return values
   *     - Use nonseekable_open()
+  *     - add class interface for udev device creation
   *
   * All rights reserved. Licensed under dual BSD/GPL license.
   */
@@ -56,7 +57,7 @@ module_param(pc_debug, int, 0600);
 #else
 #define DEBUGP(n, rdr, x, args...)
 #endif
-static char *version = "cm4000_cs.c v2.4.0gm5 - All bugs added by Harald Welte";
+static char *version = "cm4000_cs.c v2.4.0gm6 - All bugs added by Harald Welte";
 
 #define T_1SEC          (HZ)
 #define T_10MSEC        msecs_to_jiffies(10)
@@ -156,6 +157,7 @@ struct cm4000_dev {
                 /*queue*/ 4*sizeof(wait_queue_head_t))
 
 static dev_link_t *dev_table[CM4000_MAX_DEV];
+static struct class *cmm_class;
 
 /* This table doesn't use spaces after the comma between fields and thus
  * violates CodingStyle.  However, I don't really think wrapping it around will
@@ -1937,6 +1939,9 @@ static int cm4000_attach(struct pcmcia_device *p_dev)
         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
         cm4000_config(link, i);
 
+        class_device_create(cmm_class, NULL, MKDEV(major, i), NULL,
+                            "cmm%d", i);
+
         return 0;
 }
 
@@ -1962,6 +1967,8 @@ static void cm4000_detach(struct pcmcia_device *p_dev)
         dev_table[devno] = NULL;
         kfree(dev);
 
+        class_device_destroy(cmm_class, MKDEV(major, devno));
+
         return;
 }
 
@@ -1995,8 +2002,18 @@ static struct pcmcia_driver cm4000_driver = {
 
 static int __init cmm_init(void)
 {
+        int rc;
+
         printk(KERN_INFO "%s\n", version);
-        pcmcia_register_driver(&cm4000_driver);
+
+        cmm_class = class_create(THIS_MODULE, "cardman_4000");
+        if (!cmm_class)
+                return -1;
+
+        rc = pcmcia_register_driver(&cm4000_driver);
+        if (rc < 0)
+                return rc;
+
         major = register_chrdev(0, DEVICE_NAME, &cm4000_fops);
         if (major < 0) {
                 printk(KERN_WARNING MODULE_NAME
@@ -2012,6 +2029,7 @@ static void __exit cmm_exit(void)
         printk(KERN_INFO MODULE_NAME ": unloading\n");
         pcmcia_unregister_driver(&cm4000_driver);
         unregister_chrdev(major, DEVICE_NAME);
+        class_destroy(cmm_class);
 };
 
 module_init(cmm_init);
diff --git a/drivers/char/pcmcia/cm4040_cs.c b/drivers/char/pcmcia/cm4040_cs.c
index 46eb371bf17e..466e33bab029 100644
--- a/drivers/char/pcmcia/cm4040_cs.c
+++ b/drivers/char/pcmcia/cm4040_cs.c
@@ -3,12 +3,13 @@
  *
  * (c) 2000-2004 Omnikey AG (http://www.omnikey.com/)
  *
- * (C) 2005 Harald Welte <laforge@gnumonks.org>
+ * (C) 2005-2006 Harald Welte <laforge@gnumonks.org>
  *      - add support for poll()
  *      - driver cleanup
  *      - add waitqueues
  *      - adhere to linux kernel coding style and policies
  *      - support 2.6.13 "new style" pcmcia interface
+ *      - add class interface for udev device creation
  *
  * The device basically is a USB CCID compliant device that has been
  * attached to an I/O-Mapped FIFO.
@@ -53,7 +54,7 @@ module_param(pc_debug, int, 0600);
 #endif
 
 static char *version =
-"OMNIKEY CardMan 4040 v1.1.0gm4 - All bugs added by Harald Welte";
+"OMNIKEY CardMan 4040 v1.1.0gm5 - All bugs added by Harald Welte";
 
 #define CCID_DRIVER_BULK_DEFAULT_TIMEOUT        (150*HZ)
 #define CCID_DRIVER_ASYNC_POWERUP_TIMEOUT       (35*HZ)
@@ -67,6 +68,7 @@ static char *version =
 static void reader_release(dev_link_t *link);
 
 static int major;
+static struct class *cmx_class;
 
 #define         BS_READABLE     0x01
 #define         BS_WRITABLE     0x02
@@ -696,6 +698,9 @@ static int reader_attach(struct pcmcia_device *p_dev)
         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
         reader_config(link, i);
 
+        class_device_create(cmx_class, NULL, MKDEV(major, i), NULL,
+                            "cmx%d", i);
+
         return 0;
 }
 
@@ -721,6 +726,8 @@ static void reader_detach(struct pcmcia_device *p_dev)
         dev_table[devno] = NULL;
         kfree(dev);
 
+        class_device_destroy(cmx_class, MKDEV(major, devno));
+
         return;
 }
 
@@ -755,8 +762,17 @@ static struct pcmcia_driver reader_driver = {
 
 static int __init cm4040_init(void)
 {
+        int rc;
+
         printk(KERN_INFO "%s\n", version);
-        pcmcia_register_driver(&reader_driver);
+        cmx_class = class_create(THIS_MODULE, "cardman_4040");
+        if (!cmx_class)
+                return -1;
+
+        rc = pcmcia_register_driver(&reader_driver);
+        if (rc < 0)
+                return rc;
+
         major = register_chrdev(0, DEVICE_NAME, &reader_fops);
         if (major < 0) {
                 printk(KERN_WARNING MODULE_NAME
@@ -771,6 +787,7 @@ static void __exit cm4040_exit(void)
         printk(KERN_INFO MODULE_NAME ": unloading\n");
         pcmcia_unregister_driver(&reader_driver);
         unregister_chrdev(major, DEVICE_NAME);
+        class_destroy(cmx_class);
 }
 
 module_init(cm4040_init);
diff --git a/drivers/char/rio/cirrus.h b/drivers/char/rio/cirrus.h
index 217ff09f2fa1..89bd94eb45be 100644
--- a/drivers/char/rio/cirrus.h
+++ b/drivers/char/rio/cirrus.h
@@ -40,148 +40,6 @@
 #endif
 #define _cirrus_h 1
 
-#ifdef RTA
-#define TO_UART RX
-#define TO_DRIVER TX
-#endif
-
-#ifdef HOST
-#define TO_UART TX
-#define TO_DRIVER RX
-#endif
-#ifdef RTA
-/* Miscellaneous defines for CIRRUS addresses and related logic for
-   interrupts etc.
-*/
-#define MAP(a)          ((short *)(cirrus_base + (a)))
-#define outp(a,b)       (*MAP (a) =(b))
-#define inp(a)          ((*MAP (a)) & 0xff)
-#define CIRRUS_FIRST    (short*)0x7300
-#define CIRRUS_SECOND   (short*)0x7200
-#define CIRRUS_THIRD    (short*)0x7100
-#define CIRRUS_FOURTH   (short*)0x7000
-#define PORTS_ON_CIRRUS 4
-#define CIRRUS_FIFO_SIZE        12
-#define SPACE           0x20
-#define TAB             0x09
-#define LINE_FEED       0x0a
-#define CARRIAGE_RETURN 0x0d
-#define BACKSPACE       0x08
-#define SPACES_IN_TABS  8
-#define SEND_ESCAPE     0x00
-#define START_BREAK     0x81
-#define TIMER_TICK      0x82
-#define STOP_BREAK      0x83
-#define BASE(a) ((a) < 4 ? (short*)CIRRUS_FIRST : ((a) < 8 ? (short *)CIRRUS_SECOND : ((a) < 12 ? (short*)CIRRUS_THIRD : (short *)CIRRUS_FOURTH)))
-#define txack1  ((short *)0x7104)
-#define rxack1  ((short *)0x7102)
-#define mdack1  ((short *)0x7106)
-#define txack2  ((short *)0x7006)
-#define rxack2  ((short *)0x7004)
-#define mdack2  ((short *)0x7100)
-#define int_latch       ((short *) 0x7800)
-#define int_status      ((short *) 0x7c00)
-#define tx1_pending     0x20
-#define rx1_pending     0x10
-#define md1_pending     0x40
-#define tx2_pending     0x02
-#define rx2_pending     0x01
-#define md2_pending     0x40
-#define module1_bits    0x07
-#define module1_modern  0x08
-#define module2_bits    0x70
-#define module2_modern  0x80
-#define module_blank    0xf
-#define rs232_d25       0x0
-#define rs232_rj45      0x1
-#define rs422_d25       0x3
-#define parallel        0x5
-
-#define CLK0    0x00
-#define CLK1    0x01
-#define CLK2    0x02
-#define CLK3    0x03
-#define CLK4    0x04
-
-#define CIRRUS_REVC    0x42
-#define CIRRUS_REVE    0x44
-
-#define TURNON  1
-#define TURNOFF 0
-
-/* The list of CIRRUS registers. 
-   NB. These registers are relative values on 8 bit boundaries whereas
-   on the RTA's the CIRRUS registers are on word boundaries. Use pointer
-   arithmetic (short *) to obtain the real addresses required */
-#define ccr     0x05            /* Channel Command Register     */
-#define ier     0x06            /* Interrupt Enable Register    */
-#define cor1    0x08            /* Channel Option Register 1    */
-#define cor2    0x09            /* Channel Option Register 2    */
-#define cor3    0x0a            /* Channel Option Register 3    */
-#define cor4    0x1e            /* Channel Option Register 4    */
-#define cor5    0x1f            /* Channel Option Register 5    */
-
-#define ccsr    0x0b            /* Channel Control Status Register */
-#define rdcr    0x0e            /* Receive Data Count Register  */
-#define tdcr    0x12            /* Transmit Data Count Register */
-#define mcor1   0x15            /* Modem Change Option Register 1 */
-#define mcor2   0x16            /* Modem Change Option Regsiter 2 */
-
-#define livr    0x18            /* Local Interrupt Vector Register */
-#define schr1   0x1a            /* Special Character Register 1 */
-#define schr2   0x1b            /* Special Character Register 2 */
-#define schr3   0x1c            /* Special Character Register 3 */
-#define schr4   0x1d            /* Special Character Register 4 */
-
-#define rtr     0x20            /* Receive Timer Register */
-#define rtpr    0x21            /* Receive Timeout Period Register */
-#define lnc     0x24            /* Lnext character */
-
-#define rivr    0x43            /* Receive Interrupt Vector Register    */
-#define tivr    0x42            /* Transmit Interrupt Vector Register   */
-#define mivr    0x41            /* Modem Interrupt Vector Register      */
-#define gfrcr   0x40            /* Global Firmware Revision code Reg    */
-#define ricr    0x44            /* Receive Interrupting Channel Reg     */
-#define ticr    0x45            /* Transmit Interrupting Channel Reg    */
-#define micr    0x46            /* Modem Interrupting Channel Register  */
-
-#define gcr     0x4b            /* Global configuration register */
-#define misr    0x4c            /* Modem interrupt status register */
-
-#define rbusr   0x59
-#define tbusr   0x5a
-#define mbusr   0x5b
-
-#define eoir    0x60            /* End Of Interrupt Register */
-#define rdsr    0x62            /* Receive Data / Status Register */
-#define tdr     0x63            /* Transmit Data Register */
-#define svrr    0x67            /* Service Request Register */
-
-#define car     0x68            /* Channel Access Register */
-#define mir     0x69            /* Modem Interrupt Register */
-#define tir     0x6a            /* Transmit Interrupt Register */
-#define rir     0x6b            /* Receive Interrupt Register */
-#define msvr1   0x6c            /* Modem Signal Value Register 1 */
-#define msvr2   0x6d            /* Modem Signal Value Register 2 */
-#define psvr    0x6f            /* Printer Signal Value Register */
-
-#define tbpr    0x72            /* Transmit Baud Rate Period Register */
-#define tcor    0x76            /* Transmit Clock Option Register */
-
-#define rbpr    0x78            /* Receive Baud Rate Period Register */
-#define rber    0x7a            /* Receive Baud Rate Extension Register */
-#define rcor    0x7c            /* Receive Clock Option Register */
-#define ppr     0x7e            /* Prescalar Period Register    */
-
-/* Misc registers used for forcing the 1400 out of its reset woes */
-#define airl    0x6d
-#define airm    0x6e
-#define airh    0x6f
-#define btcr    0x66
-#define mtcr    0x6c
-#define tber    0x74
-
-#endif                          /* #ifdef RTA */
 
 
 /* Bit fields for particular registers */
diff --git a/drivers/char/rio/defaults.h b/drivers/char/rio/defaults.h
index 5b600c32ac02..d55c2f6a9877 100644
--- a/drivers/char/rio/defaults.h
+++ b/drivers/char/rio/defaults.h
@@ -45,13 +45,6 @@ static char *_rio_defaults_h_sccs = "@(#)defaults.h	1.1";
 #define MILLISECOND           (int) (1000/64)   /* 15.625 low ticks */
 #define SECOND                (int) 15625       /* Low priority ticks */
 
-#ifdef RTA
-#define RX_LIMIT       (ushort) 3
-#endif
-#ifdef HOST
-#define RX_LIMIT       (ushort) 1
-#endif
-
 #define LINK_TIMEOUT          (int) (POLL_PERIOD / 2)
 
 
diff --git a/drivers/char/rio/link.h b/drivers/char/rio/link.h
index bfba5b0c033e..48d68ca7f825 100644
--- a/drivers/char/rio/link.h
+++ b/drivers/char/rio/link.h
@@ -102,30 +102,14 @@
 /*
 ** LED stuff
 */
-#if defined(RTA)
-#define LED_OFF            ((ushort) 0) /* LED off */
-#define LED_RED            ((ushort) 1) /* LED Red */
-#define LED_GREEN          ((ushort) 2) /* LED Green */
-#define LED_ORANGE         ((ushort) 4) /* LED Orange */
-#define LED_1TO8_OPEN      ((ushort) 1) /* Port 1->8 LED on */
-#define LED_9TO16_OPEN     ((ushort) 2) /* Port 9->16 LED on */
-#define LED_SET_COLOUR(colour)  (link->led = (colour))
-#define LED_OR_COLOUR(colour)   (link->led |= (colour))
-#define LED_TIMEOUT(time)    (link->led_timeout = RioTimePlus(RioTime(),(time)))
-#else
 #define LED_SET_COLOUR(colour)
 #define LED_OR_COLOUR(colour)
 #define LED_TIMEOUT(time)
-#endif                          /* RTA */
 
 struct LPB {
         WORD link_number;       /* Link Number */
         Channel_ptr in_ch;      /* Link In Channel */
         Channel_ptr out_ch;     /* Link Out Channel */
-#ifdef RTA
-        uchar stat_led;         /* Port open leds */
-        uchar led;              /* True, light led! */
-#endif
         BYTE attached_serial[4];        /* Attached serial number */
         BYTE attached_host_serial[4];
         /* Serial number of Host who
@@ -144,30 +128,12 @@ struct LPB {
         WORD WaitNoBoot;        /* Secs to hold off booting */
         PKT_ptr add_packet_list;        /* Add packets to here */
         PKT_ptr remove_packet_list;     /* Send packets from here */
-#ifdef RTA
-#ifdef DCIRRUS
-#define    QBUFS_PER_REDIRECT (4 / PKTS_PER_BUFFER + 1)
-#else
-#define    QBUFS_PER_REDIRECT (8 / PKTS_PER_BUFFER + 1)
-#endif
-        PKT_ptr_ptr rd_add;     /* Add a new Packet here */
-        Q_BUF_ptr rd_add_qb;    /* Pointer to the add Q buf */
-        PKT_ptr_ptr rd_add_st_qbb;      /* Pointer to start of the Q's buf */
-        PKT_ptr_ptr rd_add_end_qbb;     /* Pointer to the end of the Q's buf */
-        PKT_ptr_ptr rd_remove;  /* Remove a Packet here */
-        Q_BUF_ptr rd_remove_qb; /* Pointer to the remove Q buf */
-        PKT_ptr_ptr rd_remove_st_qbb;   /* Pointer to the start of the Q buf */
-        PKT_ptr_ptr rd_remove_end_qbb;  /* Pointer to the end of the Q buf */
-        ushort pkts_in_q;       /* Packets in queue */
-#endif
 
         Channel_ptr lrt_fail_chan;      /* Lrt's failure channel */
         Channel_ptr ltt_fail_chan;      /* Ltt's failure channel */
 
-#if defined (HOST) || defined (INKERNEL)
         /* RUP structure for HOST to driver communications */
         struct RUP rup;
-#endif
         struct RUP link_rup;    /* RUP for the link (POLL,
                                    topology etc.) */
         WORD attached_link;     /* Number of attached link */
diff --git a/drivers/char/rio/list.h b/drivers/char/rio/list.h
index 36aad4c9cb3a..79b853140ae5 100644
--- a/drivers/char/rio/list.h
+++ b/drivers/char/rio/list.h
@@ -44,8 +44,6 @@ static char *_rio_list_h_sccs = "@(#)list.h	1.9";
 
 #define PKT_IN_USE    0x1
 
-#ifdef INKERNEL
-
 #define ZERO_PTR (ushort) 0x8000
 #define CaD     PortP->Caddr
 
@@ -54,143 +52,5 @@ static char *_rio_list_h_sccs = "@(#)list.h	1.9";
 ** to by the TxAdd pointer has PKT_IN_USE clear in its address.
 */
 
-#ifndef linux
-#if defined( MIPS ) && !defined( MIPSEISA )
-/* May the shoes of the Devil dance on your grave for creating this */
-#define   can_add_transmit(PacketP,PortP) \
-          (!((uint)(PacketP = (struct PKT *)RIO_PTR(CaD,RINDW(PortP->TxAdd))) \
-          & (PKT_IN_USE<<2)))
-
-#elif  defined(MIPSEISA) || defined(nx6000) || \
-       defined(drs6000)  || defined(UWsparc)
-
-#define   can_add_transmit(PacketP,PortP) \
-          (!((uint)(PacketP = (struct PKT *)RIO_PTR(CaD,RINDW(PortP->TxAdd))) \
-          & PKT_IN_USE))
-
-#else
-#define   can_add_transmit(PacketP,PortP) \
-          (!((uint)(PacketP = (struct PKT *)RIO_PTR(CaD,*PortP->TxAdd)) \
-          & PKT_IN_USE))
-#endif
-
-/*
-** To add a packet to the queue, you set the PKT_IN_USE bit in the address,
-** and then move the TxAdd pointer along one position to point to the next
-** packet pointer. You must wrap the pointer from the end back to the start.
-*/
-#if defined(MIPS) || defined(nx6000) || defined(drs6000) || defined(UWsparc)
-#   define add_transmit(PortP)  \
-        WINDW(PortP->TxAdd,RINDW(PortP->TxAdd) | PKT_IN_USE);\
-        if (PortP->TxAdd == PortP->TxEnd)\
-            PortP->TxAdd = PortP->TxStart;\
-        else\
-            PortP->TxAdd++;\
-        WWORD(PortP->PhbP->tx_add , RIO_OFF(CaD,PortP->TxAdd));
-#elif defined(AIX)
-#   define add_transmit(PortP)  \
-        {\
-            register ushort *TxAddP = (ushort *)RIO_PTR(Cad,PortP->TxAddO);\
-            WINDW( TxAddP, RINDW( TxAddP ) | PKT_IN_USE );\
-            if (PortP->TxAddO == PortP->TxEndO )\
-                PortP->TxAddO = PortP->TxStartO;\
-            else\
-                PortP->TxAddO += sizeof(ushort);\
-            WWORD(((PHB *)RIO_PTR(Cad,PortP->PhbO))->tx_add , PortP->TxAddO );\
-        }
-#else
-#   define add_transmit(PortP)  \
-        *PortP->TxAdd |= PKT_IN_USE;\
-        if (PortP->TxAdd == PortP->TxEnd)\
-            PortP->TxAdd = PortP->TxStart;\
-        else\
-            PortP->TxAdd++;\
-        PortP->PhbP->tx_add = RIO_OFF(CaD,PortP->TxAdd);
-#endif
-
-/*
-** can_remove_receive( PacketP, PortP ) returns non-zero if PKT_IN_USE is set
-** for the next packet on the queue. It will also set PacketP to point to the
-** relevant packet, [having cleared the PKT_IN_USE bit]. If PKT_IN_USE is clear,
-** then can_remove_receive() returns 0.
-*/
-#if defined(MIPS) || defined(nx6000) || defined(drs6000) || defined(UWsparc)
-#   define can_remove_receive(PacketP,PortP) \
-        ((RINDW(PortP->RxRemove) & PKT_IN_USE) ? \
-        (PacketP=(struct PKT *)RIO_PTR(CaD,(RINDW(PortP->RxRemove) & ~PKT_IN_USE))):0)
-#elif defined(AIX)
-#   define can_remove_receive(PacketP,PortP) \
-        ((RINDW((ushort *)RIO_PTR(Cad,PortP->RxRemoveO)) & PKT_IN_USE) ? \
-        (PacketP=(struct PKT *)RIO_PTR(Cad,RINDW((ushort *)RIO_PTR(Cad,PortP->RxRemoveO)) & ~PKT_IN_USE)):0)
-#else
-#   define can_remove_receive(PacketP,PortP) \
-        ((*PortP->RxRemove & PKT_IN_USE) ? \
-        (PacketP=(struct PKT *)RIO_PTR(CaD,(*PortP->RxRemove & ~PKT_IN_USE))):0)
-#endif
-
-
-/*
-** Will God see it within his heart to forgive us for this thing that
-** we have created? To remove a packet from the receive queue you clear
-** its PKT_IN_USE bit, and then bump the pointers. Once the pointers
-** get to the end, they must be wrapped back to the start.
-*/
-#if defined(MIPS) || defined(nx6000) || defined(drs6000) || defined(UWsparc)
-#   define remove_receive(PortP) \
-        WINDW(PortP->RxRemove, (RINDW(PortP->RxRemove) & ~PKT_IN_USE));\
-        if (PortP->RxRemove == PortP->RxEnd)\
-            PortP->RxRemove = PortP->RxStart;\
-        else\
-            PortP->RxRemove++;\
-        WWORD(PortP->PhbP->rx_remove , RIO_OFF(CaD,PortP->RxRemove));
-#elif defined(AIX)
-#   define remove_receive(PortP) \
-    {\
-        register ushort *RxRemoveP = (ushort *)RIO_PTR(Cad,PortP->RxRemoveO);\
-        WINDW( RxRemoveP, RINDW( RxRemoveP ) & ~PKT_IN_USE );\
-        if (PortP->RxRemoveO == PortP->RxEndO)\
-            PortP->RxRemoveO = PortP->RxStartO;\
-        else\
-            PortP->RxRemoveO += sizeof(ushort);\
-        WWORD(((PHB *)RIO_PTR(Cad,PortP->PhbO))->rx_remove, PortP->RxRemoveO );\
-    }
-#else
-#   define remove_receive(PortP) \
-        *PortP->RxRemove &= ~PKT_IN_USE;\
-        if (PortP->RxRemove == PortP->RxEnd)\
-            PortP->RxRemove = PortP->RxStart;\
-        else\
-            PortP->RxRemove++;\
-        PortP->PhbP->rx_remove = RIO_OFF(CaD,PortP->RxRemove);
-#endif
-#endif
-
-
-#else                           /* !IN_KERNEL */
-
-#define ZERO_PTR NULL
-
-
-#ifdef HOST
-/* #define can_remove_transmit(pkt,phb) ((((char*)pkt = (*(char**)(phb->tx_remove))-1) || 1)) && (*phb->u3.s2.tx_remove_ptr & PKT_IN_USE))   */
-#define remove_transmit(phb) *phb->u3.s2.tx_remove_ptr &= ~(ushort)PKT_IN_USE;\
-                             if (phb->tx_remove == phb->tx_end)\
-                                phb->tx_remove = phb->tx_start;\
-                             else\
-                                phb->tx_remove++;
-#define can_add_receive(phb) !(*phb->u4.s2.rx_add_ptr & PKT_IN_USE)
-#define add_receive(pkt,phb) *phb->rx_add = pkt;\
-                             *phb->u4.s2.rx_add_ptr |= PKT_IN_USE;\
-                             if (phb->rx_add == phb->rx_end)\
-                                phb->rx_add = phb->rx_start;\
-                             else\
-                                phb->rx_add++;
-#endif
-#endif
-
-#ifdef RTA
-#define splx(oldspl)    if ((oldspl) == 0) spl0()
-#endif
-
 #endif                          /* ifndef _list.h */
 /*********** end of file ***********/
diff --git a/drivers/char/rio/parmmap.h b/drivers/char/rio/parmmap.h
index fe4e00567065..e24acc1d1844 100644
--- a/drivers/char/rio/parmmap.h
+++ b/drivers/char/rio/parmmap.h
@@ -78,14 +78,9 @@ struct PARM_MAP {
         WORD idle_count;        /* Idle time counter */
         WORD busy_count;        /* Busy counter */
         WORD idle_control;      /* Control Idle Process */
-#if defined(HOST) || defined(INKERNEL)
         WORD tx_intr;           /* TX interrupt pending */
         WORD rx_intr;           /* RX interrupt pending */
         WORD rup_intr;          /* RUP interrupt pending */
-#endif
-#if defined(RTA)
-        WORD dying_count;       /* Count of processes dead */
-#endif
 };
 
 #endif
diff --git a/drivers/char/rio/phb.h b/drivers/char/rio/phb.h
index 3baebf8513af..2663ca0306e2 100644
--- a/drivers/char/rio/phb.h
+++ b/drivers/char/rio/phb.h
@@ -44,17 +44,6 @@
 #endif
 
 
- /*************************************************
-  * Set the LIMIT values.
-  ************************************************/
-#ifdef RTA
-#define RX_LIMIT       (ushort) 3
-#endif
-#ifdef HOST
-#define RX_LIMIT       (ushort) 1
-#endif
-
-
 /*************************************************
  * Handshake asserted. Deasserted by the LTT(s)
  ************************************************/
@@ -69,11 +58,7 @@
 /*************************************************
  * Maximum number of PHB's
  ************************************************/
-#if defined (HOST) || defined (INKERNEL)
 #define MAX_PHB               ((ushort) 128)    /* range 0-127 */
-#else
-#define MAX_PHB               ((ushort) 8)      /* range 0-7 */
-#endif
 
 /*************************************************
  * Defines for the mode fields
@@ -139,141 +124,23 @@
  * the start. The pointer tx_add points to a SPACE to put a Packet.
  * The pointer tx_remove points to the next Packet to remove
  *************************************************************************/
-#ifndef INKERNEL
-#define src_unit     u2.s2.unit
-#define src_port     u2.s2.port
-#define dest_unit    u1.s1.unit
-#define dest_port    u1.s1.port
-#endif
-#ifdef HOST
-#define tx_start     u3.s1.tx_start_ptr_ptr
-#define tx_add       u3.s1.tx_add_ptr_ptr
-#define tx_end       u3.s1.tx_end_ptr_ptr
-#define tx_remove    u3.s1.tx_remove_ptr_ptr
-#define rx_start     u4.s1.rx_start_ptr_ptr
-#define rx_add       u4.s1.rx_add_ptr_ptr
-#define rx_end       u4.s1.rx_end_ptr_ptr
-#define rx_remove    u4.s1.rx_remove_ptr_ptr
-#endif
 typedef struct PHB PHB;
 struct PHB {
-#ifdef RTA
-        ushort port;
-#endif
-#ifdef INKERNEL
         WORD source;
-#else
-        union {
-                ushort source;  /* Complete source */
-                struct {
-                        unsigned char unit;     /* Source unit */
-                        unsigned char port;     /* Source port */
-                } s2;
-        } u2;
-#endif
         WORD handshake;
         WORD status;
         NUMBER timeout;         /* Maximum of 1.9 seconds */
         WORD link;              /* Send down this link */
-#ifdef INKERNEL
         WORD destination;
-#else
-        union {
-                ushort destination;     /* Complete destination */
-                struct {
-                        unsigned char unit;     /* Destination unit */
-                        unsigned char port;     /* Destination port */
-                } s1;
-        } u1;
-#endif
-#ifdef RTA
-        ushort tx_pkts_added;
-        ushort tx_pkts_removed;
-        Q_BUF_ptr tx_q_start;   /* Start of the Q list chain */
-        short num_tx_q_bufs;    /* Number of Q buffers in the chain */
-        PKT_ptr_ptr tx_add;     /* Add a new Packet here */
-        Q_BUF_ptr tx_add_qb;    /* Pointer to the add Q buf */
-        PKT_ptr_ptr tx_add_st_qbb;      /* Pointer to start of the Q's buf */
-        PKT_ptr_ptr tx_add_end_qbb;     /* Pointer to the end of the Q's buf */
-        PKT_ptr_ptr tx_remove;  /* Remove a Packet here */
-        Q_BUF_ptr tx_remove_qb; /* Pointer to the remove Q buf */
-        PKT_ptr_ptr tx_remove_st_qbb;   /* Pointer to the start of the Q buf */
-        PKT_ptr_ptr tx_remove_end_qbb;  /* Pointer to the end of the Q buf */
-#endif
-#ifdef INKERNEL
         PKT_ptr_ptr tx_start;
         PKT_ptr_ptr tx_end;
         PKT_ptr_ptr tx_add;
         PKT_ptr_ptr tx_remove;
-#endif
-#ifdef HOST
-        union {
-                struct {
-                        PKT_ptr_ptr tx_start_ptr_ptr;
-                        PKT_ptr_ptr tx_end_ptr_ptr;
-                        PKT_ptr_ptr tx_add_ptr_ptr;
-                        PKT_ptr_ptr tx_remove_ptr_ptr;
-                } s1;
-                struct {
-                        ushort *tx_start_ptr;
-                        ushort *tx_end_ptr;
-                        ushort *tx_add_ptr;
-                        ushort *tx_remove_ptr;
-                } s2;
-        } u3;
-#endif
 
-#ifdef  RTA
-        ushort rx_pkts_added;
-        ushort rx_pkts_removed;
-        Q_BUF_ptr rx_q_start;   /* Start of the Q list chain */
-        short num_rx_q_bufs;    /* Number of Q buffers in the chain */
-        PKT_ptr_ptr rx_add;     /* Add a new Packet here */
-        Q_BUF_ptr rx_add_qb;    /* Pointer to the add Q buf */
-        PKT_ptr_ptr rx_add_st_qbb;      /* Pointer to start of the Q's buf */
-        PKT_ptr_ptr rx_add_end_qbb;     /* Pointer to the end of the Q's buf */
-        PKT_ptr_ptr rx_remove;  /* Remove a Packet here */
-        Q_BUF_ptr rx_remove_qb; /* Pointer to the remove Q buf */
-        PKT_ptr_ptr rx_remove_st_qbb;   /* Pointer to the start of the Q buf */
-        PKT_ptr_ptr rx_remove_end_qbb;  /* Pointer to the end of the Q buf */
-#endif
-#ifdef INKERNEL
         PKT_ptr_ptr rx_start;
         PKT_ptr_ptr rx_end;
         PKT_ptr_ptr rx_add;
         PKT_ptr_ptr rx_remove;
-#endif
-#ifdef HOST
-        union {
-                struct {
-                        PKT_ptr_ptr rx_start_ptr_ptr;
-                        PKT_ptr_ptr rx_end_ptr_ptr;
-                        PKT_ptr_ptr rx_add_ptr_ptr;
-                        PKT_ptr_ptr rx_remove_ptr_ptr;
-                } s1;
-                struct {
-                        ushort *rx_start_ptr;
-                        ushort *rx_end_ptr;
-                        ushort *rx_add_ptr;
-                        ushort *rx_remove_ptr;
-                } s2;
-        } u4;
-#endif
-
-#ifdef RTA                      /* some fields for the remotes */
-        ushort flush_count;     /* Count of write flushes */
-        ushort txmode;          /* Modes for tx */
-        ushort rxmode;          /* Modes for rx */
-        ushort portmode;        /* Generic modes */
-        ushort column;          /* TAB3 column count */
-        ushort tx_subscript;    /* (TX) Subscript into data field */
-        ushort rx_subscript;    /* (RX) Subscript into data field */
-        PKT_ptr rx_incomplete;  /* Hold an incomplete packet here */
-        ushort modem_bits;      /* Modem bits to mask */
-        ushort lastModem;       /* Modem control lines. */
-        ushort addr;            /* Address for sub commands */
-        ushort MonitorTstate;   /* TRUE if monitoring tstop */
-#endif
 
 };
 
diff --git a/drivers/char/rio/pkt.h b/drivers/char/rio/pkt.h
index 882fd429ac2e..7011e52e82db 100644
--- a/drivers/char/rio/pkt.h
+++ b/drivers/char/rio/pkt.h
@@ -70,39 +70,12 @@
 #define CONTROL_DATA_WNDW  (DATA_WNDW << 8)
 
 struct PKT {
-#ifdef INKERNEL
         BYTE dest_unit;         /* Destination Unit Id */
         BYTE dest_port;         /* Destination POrt */
         BYTE src_unit;          /* Source Unit Id */
         BYTE src_port;          /* Source POrt */
-#else
-        union {
-                ushort destination;     /* Complete destination */
-                struct {
-                        unsigned char unit;     /* Destination unit */
-                        unsigned char port;     /* Destination port */
-                } s1;
-        } u1;
-        union {
-                ushort source;  /* Complete source */
-                struct {
-                        unsigned char unit;     /* Source unit */
-                        unsigned char port;     /* Source port */
-                } s2;
-        } u2;
-#endif
-#ifdef INKERNEL
         BYTE len;
         BYTE control;
-#else
-        union {
-                ushort control;
-                struct {
-                        unsigned char len;
-                        unsigned char control;
-                } s3;
-        } u3;
-#endif
         BYTE data[PKT_MAX_DATA_LEN];
         /* Actual data :-) */
         WORD csum;              /* C-SUM */
diff --git a/drivers/char/rio/qbuf.h b/drivers/char/rio/qbuf.h
index acd9e8e5307d..391ffc335535 100644
--- a/drivers/char/rio/qbuf.h
+++ b/drivers/char/rio/qbuf.h
@@ -46,11 +46,7 @@ static char *_rio_qbuf_h_sccs = "@(#)qbuf.h	1.1";
 
 
 
-#ifdef HOST
-#define PKTS_PER_BUFFER    1
-#else
 #define PKTS_PER_BUFFER    (220 / PKT_LENGTH)
-#endif
 
 typedef struct Q_BUF Q_BUF;
 struct Q_BUF {
diff --git a/drivers/char/rio/riotypes.h b/drivers/char/rio/riotypes.h
index 9b67e2468bec..46084d5c7e98 100644
--- a/drivers/char/rio/riotypes.h
+++ b/drivers/char/rio/riotypes.h
@@ -43,9 +43,6 @@
 #endif
 #endif
 
-#ifdef INKERNEL
-
-#if !defined(MIPSAT)
 typedef unsigned short NUMBER_ptr;
 typedef unsigned short WORD_ptr;
 typedef unsigned short BYTE_ptr;
@@ -65,69 +62,6 @@ typedef unsigned short RUP_ptr;
 typedef unsigned short short_ptr;
 typedef unsigned short u_short_ptr;
 typedef unsigned short ushort_ptr;
-#else
-/* MIPSAT types */
-typedef char RIO_POINTER[8];
-typedef RIO_POINTER NUMBER_ptr;
-typedef RIO_POINTER WORD_ptr;
-typedef RIO_POINTER BYTE_ptr;
-typedef RIO_POINTER char_ptr;
-typedef RIO_POINTER Channel_ptr;
-typedef RIO_POINTER FREE_LIST_ptr_ptr;
-typedef RIO_POINTER FREE_LIST_ptr;
-typedef RIO_POINTER LPB_ptr;
-typedef RIO_POINTER Process_ptr;
-typedef RIO_POINTER PHB_ptr;
-typedef RIO_POINTER PKT_ptr;
-typedef RIO_POINTER PKT_ptr_ptr;
-typedef RIO_POINTER Q_BUF_ptr;
-typedef RIO_POINTER Q_BUF_ptr_ptr;
-typedef RIO_POINTER ROUTE_STR_ptr;
-typedef RIO_POINTER RUP_ptr;
-typedef RIO_POINTER short_ptr;
-typedef RIO_POINTER u_short_ptr;
-typedef RIO_POINTER ushort_ptr;
-#endif
-
-#else                           /* not INKERNEL */
-typedef unsigned char BYTE;
-typedef unsigned short WORD;
-typedef unsigned long DWORD;
-typedef short NUMBER;
-typedef short *NUMBER_ptr;
-typedef unsigned short *WORD_ptr;
-typedef unsigned char *BYTE_ptr;
-typedef unsigned char uchar;
-typedef unsigned short ushort;
-typedef unsigned int uint;
-typedef unsigned long ulong;
-typedef unsigned char u_char;
-typedef unsigned short u_short;
-typedef unsigned int u_int;
-typedef unsigned long u_long;
-typedef unsigned short ERROR;
-typedef unsigned long ID;
-typedef char *char_ptr;
-typedef Channel *Channel_ptr;
-typedef struct FREE_LIST *FREE_LIST_ptr;
-typedef struct FREE_LIST **FREE_LIST_ptr_ptr;
-typedef struct LPB *LPB_ptr;
-typedef struct Process *Process_ptr;
-typedef struct PHB *PHB_ptr;
-typedef struct PKT *PKT_ptr;
-typedef struct PKT **PKT_ptr_ptr;
-typedef struct Q_BUF *Q_BUF_ptr;
-typedef struct Q_BUF **Q_BUF_ptr_ptr;
-typedef struct ROUTE_STR *ROUTE_STR_ptr;
-typedef struct RUP *RUP_ptr;
-typedef short *short_ptr;
-typedef u_short *u_short_ptr;
-typedef ushort *ushort_ptr;
-typedef struct PKT PKT;
-typedef struct LPB LPB;
-typedef struct RUP RUP;
-#endif
-
 
 #endif                          /* __riotypes__ */
 
diff --git a/drivers/char/rio/rup.h b/drivers/char/rio/rup.h
index 8d44fec91dd5..f74f67c6f702 100644
--- a/drivers/char/rio/rup.h
+++ b/drivers/char/rio/rup.h
@@ -43,12 +43,7 @@
 #endif
 #endif
 
-#if defined( HOST ) || defined( INKERNEL )
 #define MAX_RUP          ((short) 16)
-#endif
-#ifdef RTA
-#define MAX_RUP          ((short) 1)
-#endif
 
 #define PKTS_PER_RUP     ((short) 2)    /* They are always used in pairs */
 
diff --git a/drivers/char/rio/sam.h b/drivers/char/rio/sam.h
index 31494054b213..6f754e19015d 100644
--- a/drivers/char/rio/sam.h
+++ b/drivers/char/rio/sam.h
@@ -43,10 +43,6 @@
 #endif
 
 
-#if !defined( HOST ) && !defined( INKERNEL )
-#define RTA 1
-#endif
-
 #define NUM_FREE_LIST_UNITS     500
 
 #ifndef FALSE
diff --git a/drivers/char/rocket.c b/drivers/char/rocket.c
index 0949dcef0697..7edc6a4dbdc4 100644
--- a/drivers/char/rocket.c
+++ b/drivers/char/rocket.c
@@ -433,7 +433,7 @@ static void rp_do_receive(struct r_port *info,
                 count += ToRecv;
         }
         /*  Push the data up to the tty layer */
-        ld->receive_buf(tty, cbuf, fbuf, count);
+        ld->receive_buf(tty, chead, fhead, count);
 done:
         tty_ldisc_deref(ld);
 }
diff --git a/drivers/char/ser_a2232.c b/drivers/char/ser_a2232.c
index 80a5b840e22f..fee68cc895f8 100644
--- a/drivers/char/ser_a2232.c
+++ b/drivers/char/ser_a2232.c
@@ -103,6 +103,7 @@
 
 #include <linux/serial.h>
 #include <linux/generic_serial.h>
+#include <linux/tty_flip.h>
 
 #include "ser_a2232.h"
 #include "ser_a2232fw.h"
diff --git a/drivers/char/sx.c b/drivers/char/sx.c
index 64bf89cb574f..a6b4f02bdceb 100644
--- a/drivers/char/sx.c
+++ b/drivers/char/sx.c
@@ -931,7 +931,7 @@ static int sx_set_real_termios (void *ptr)
         case CS6:sx_write_channel_byte (port, hi_mask, 0x3f);break;
         case CS5:sx_write_channel_byte (port, hi_mask, 0x1f);break;
         default:
-                printk (KERN_INFO "sx: Invalid wordsize: %d\n", CFLAG & CSIZE);
+                printk (KERN_INFO "sx: Invalid wordsize: %u\n", CFLAG & CSIZE);
                 break;
         }
 
@@ -958,7 +958,7 @@ static int sx_set_real_termios (void *ptr)
         } else {
                 set_bit(TTY_HW_COOK_IN, &port->gs.tty->flags);
         }
-        sx_dprintk (SX_DEBUG_TERMIOS, "iflags: %x(%d) ", 
+        sx_dprintk (SX_DEBUG_TERMIOS, "iflags: %x(%d) ",
                     port->gs.tty->termios->c_iflag, 
                     I_OTHER(port->gs.tty));
 
@@ -973,7 +973,7 @@ static int sx_set_real_termios (void *ptr)
         } else {
                 clear_bit(TTY_HW_COOK_OUT, &port->gs.tty->flags);
         }
-        sx_dprintk (SX_DEBUG_TERMIOS, "oflags: %x(%d)\n", 
+        sx_dprintk (SX_DEBUG_TERMIOS, "oflags: %x(%d)\n",
                     port->gs.tty->termios->c_oflag, 
                     O_OTHER(port->gs.tty));
         /* port->c_dcd = sx_get_CD (port); */
@@ -1095,17 +1095,17 @@ static inline void sx_receive_chars (struct sx_port *port)
 
                 sx_dprintk (SX_DEBUG_RECEIVE, "rxop=%d, c = %d.\n", rx_op, c); 
 
+                /* Don't copy past the end of the hardware receive buffer */
+                if (rx_op + c > 0x100) c = 0x100 - rx_op;
+
+                sx_dprintk (SX_DEBUG_RECEIVE, "c = %d.\n", c);
+
                 /* Don't copy more bytes than there is room for in the buffer */
 
                 c = tty_prepare_flip_string(tty, &rp, c);
 
                 sx_dprintk (SX_DEBUG_RECEIVE, "c = %d.\n", c); 
 
-                /* Don't copy past the end of the hardware receive buffer */
-                if (rx_op + c > 0x100) c = 0x100 - rx_op;
-
-                sx_dprintk (SX_DEBUG_RECEIVE, "c = %d.\n", c);
-
                 /* If for one reason or another, we can't copy more data, we're done! */
                 if (c == 0) break;
 
@@ -2173,15 +2173,17 @@ static int probe_si (struct sx_board *board)
         if ( IS_SI1_BOARD(board)) {
                 /* This should be an SI1 board, which has this
                    location writable... */
-                if (read_sx_byte (board, SI2_ISA_ID_BASE) != 0x10)
+                if (read_sx_byte (board, SI2_ISA_ID_BASE) != 0x10) {
                         func_exit ();
                         return 0; 
+                }
         } else {
                 /* This should be an SI2 board, which has the bottom
                    3 bits non-writable... */
-                if (read_sx_byte (board, SI2_ISA_ID_BASE) == 0x10)
+                if (read_sx_byte (board, SI2_ISA_ID_BASE) == 0x10) {
                         func_exit ();
                         return 0; 
+                }
         }
 
         /* Now we're pretty much convinced that there is an SI board here, 
@@ -2192,15 +2194,17 @@ static int probe_si (struct sx_board *board)
         if ( IS_SI1_BOARD(board)) {
                 /* This should be an SI1 board, which has this
                    location writable... */
-                if (read_sx_byte (board, SI2_ISA_ID_BASE) != 0x10)
+                if (read_sx_byte (board, SI2_ISA_ID_BASE) != 0x10) {
                         func_exit();
                         return 0; 
+                }
         } else {
                 /* This should be an SI2 board, which has the bottom
                    3 bits non-writable... */
-                if (read_sx_byte (board, SI2_ISA_ID_BASE) == 0x10)
+                if (read_sx_byte (board, SI2_ISA_ID_BASE) == 0x10) {
                         func_exit ();
                         return 0; 
+                }
         }
 
         printheader ();
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index a85a60a93deb..b046390cd256 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -306,7 +306,7 @@ struct slgt_info {
         int tx_active;
 
         unsigned char signals;    /* serial signal states */
-        unsigned int init_error;  /* initialization error */
+        int init_error;  /* initialization error */
 
         unsigned char *tx_buf;
         int tx_count;
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_bios.c b/drivers/char/tpm/tpm_bios.c
index aedf7a8e6da7..537aa45d8c67 100644
--- a/drivers/char/tpm/tpm_bios.c
+++ b/drivers/char/tpm/tpm_bios.c
@@ -191,7 +191,7 @@ static int get_event_name(char *dest, struct tcpa_event *event,
         const char *name = "";
         char data[40] = "";
         int i, n_len = 0, d_len = 0;
-        u32 event_id, event_data_size;
+        u32 event_id;
 
         switch(event->event_type) {
         case PREBOOT:
@@ -220,8 +220,7 @@ static int get_event_name(char *dest, struct tcpa_event *event,
                 }
                 break;
         case EVENT_TAG:
-                event_id = be32_to_cpu(event_entry);
-                event_data_size = be32_to_cpu(&event_entry[4]);
+                event_id = be32_to_cpu(*((u32 *)event_entry));
 
                 /* ToDo Row data -> Base64 */
 
@@ -376,7 +375,7 @@ static int read_log(struct tpm_bios_log *log)
 {
         struct acpi_tcpa *buff;
         acpi_status status;
-        void *virt;
+        struct acpi_table_header *virt;
 
         if (log->bios_event_log != NULL) {
                 printk(KERN_ERR
@@ -413,7 +412,7 @@ static int read_log(struct tpm_bios_log *log)
 
         log->bios_event_log_end = log->bios_event_log + buff->log_max_len;
 
-        acpi_os_map_memory(buff->log_start_addr, buff->log_max_len, &virt);
+        acpi_os_map_memory(buff->log_start_addr, buff->log_max_len, (void *) &virt);
 
         memcpy(log->bios_event_log, virt, buff->log_max_len);
 
@@ -487,26 +486,35 @@ struct file_operations tpm_binary_bios_measurements_ops = {
         .release = tpm_bios_measurements_release,
 };
 
+static int is_bad(void *p)
+{
+        if (!p)
+                return 1;
+        if (IS_ERR(p) && (PTR_ERR(p) != -ENODEV))
+                return 1;
+        return 0;
+}
+
 struct dentry **tpm_bios_log_setup(char *name)
 {
         struct dentry **ret = NULL, *tpm_dir, *bin_file, *ascii_file;
 
         tpm_dir = securityfs_create_dir(name, NULL);
-        if (!tpm_dir)
+        if (is_bad(tpm_dir))
                 goto out;
 
         bin_file =
             securityfs_create_file("binary_bios_measurements",
                                    S_IRUSR | S_IRGRP, tpm_dir, NULL,
                                    &tpm_binary_bios_measurements_ops);
-        if (!bin_file)
+        if (is_bad(bin_file))
                 goto out_tpm;
 
         ascii_file =
             securityfs_create_file("ascii_bios_measurements",
                                    S_IRUSR | S_IRGRP, tpm_dir, NULL,
                                    &tpm_ascii_bios_measurements_ops);
-        if (!ascii_file)
+        if (is_bad(ascii_file))
                 goto out_bin;
 
         ret = kmalloc(3 * sizeof(struct dentry *), GFP_KERNEL);
@@ -538,3 +546,4 @@ void tpm_bios_log_teardown(struct dentry **lst)
                 securityfs_remove(lst[i]);
 }
 EXPORT_SYMBOL_GPL(tpm_bios_log_teardown);
+MODULE_LICENSE("GPL");
diff --git a/drivers/char/tpm/tpm_infineon.c b/drivers/char/tpm/tpm_infineon.c
index 8198dbb7370f..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. */
@@ -441,10 +454,10 @@ static int __devinit tpm_inf_pnp_probe(struct pnp_dev *dev,
 
                 if ((ioh << 8 | iol) != tpm_inf.base) {
                         dev_err(&dev->dev,
-                                "Could not set IO-ports to %04x\n",
+                                "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 eb8b5be4e249..53d3d066554e 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -253,6 +253,7 @@ static void tty_buffer_free_all(struct tty_struct *tty)
 
 static void tty_buffer_init(struct tty_struct *tty)
 {
+        spin_lock_init(&tty->buf.lock);
         tty->buf.head = NULL;
         tty->buf.tail = NULL;
         tty->buf.free = NULL;
@@ -266,6 +267,9 @@ static struct tty_buffer *tty_buffer_alloc(size_t size)
         p->used = 0;
         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); */
@@ -296,8 +300,10 @@ 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);
+/*                      memset(t->data, '*', size); */
 /*                      printk("Flip recycle %p\n", t); */
                         return t;
                 }
@@ -312,25 +318,37 @@ static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
 
 int tty_buffer_request_room(struct tty_struct *tty, size_t size)
 {
-        struct tty_buffer *b = tty->buf.tail, *n;
-        int left = 0;
+        struct tty_buffer *b, *n;
+        int left;
+        unsigned long flags;
+
+        spin_lock_irqsave(&tty->buf.lock, flags);
 
         /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
            remove this conditional if its worth it. This would be invisible
            to the callers */
-        if(b != NULL)
+        if ((b = tty->buf.tail) != NULL) {
                 left = b->size - b->used;
-        if(left >= size)
-                return size;
-        /* This is the slow path - looking for new buffers to use */
-        n = tty_buffer_find(tty, size);
-        if(n == NULL)
-                return left;
-        if(b != NULL)
-                b->next = n;
-        else
-                tty->buf.head = n;
-        tty->buf.tail = n;
+                b->active = 1;
+        } else
+                left = 0;
+
+        if (left < size) {
+                /* This is the slow path - looking for new buffers to use */
+                if ((n = tty_buffer_find(tty, size)) != NULL) {
+                        if (b != NULL) {
+                                b->next = n;
+                                b->active = 0;
+                                b->commit = b->used;
+                        } else
+                                tty->buf.head = n;
+                        tty->buf.tail = n;
+                        n->active = 1;
+                } else
+                        size = left;
+        }
+
+        spin_unlock_irqrestore(&tty->buf.lock, flags);
         return size;
 }
 
@@ -396,10 +414,12 @@ EXPORT_SYMBOL_GPL(tty_insert_flip_string_flags);
 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
 {
         int space = tty_buffer_request_room(tty, size);
-        struct tty_buffer *tb = tty->buf.tail;
-        *chars = tb->char_buf_ptr + tb->used;
-        memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
-        tb->used += space;
+        if (likely(space)) {
+                struct tty_buffer *tb = tty->buf.tail;
+                *chars = tb->char_buf_ptr + tb->used;
+                memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
+                tb->used += space;
+        }
         return space;
 }
 
@@ -416,10 +436,12 @@ EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
 int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
 {
         int space = tty_buffer_request_room(tty, size);
-        struct tty_buffer *tb = tty->buf.tail;
-        *chars = tb->char_buf_ptr + tb->used;
-        *flags = tb->flag_buf_ptr + tb->used;
-        tb->used += space;
+        if (likely(space)) {
+                struct tty_buffer *tb = tty->buf.tail;
+                *chars = tb->char_buf_ptr + tb->used;
+                *flags = tb->flag_buf_ptr + tb->used;
+                tb->used += space;
+        }
         return space;
 }
 
@@ -1819,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) {
@@ -1847,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();
         }       
 
@@ -1855,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 "
@@ -1870,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
@@ -1915,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;
@@ -2735,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 */
@@ -2747,20 +2771,24 @@ static void flush_to_ldisc(void *private_)
                 schedule_delayed_work(&tty->buf.work, 1);
                 goto out;
         }
-        spin_lock_irqsave(&tty->read_lock, flags);
+        spin_lock_irqsave(&tty->buf.lock, flags);
         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->read_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->read_lock, flags);
                 tty_buffer_free(tty, tbuf);
         }
-        spin_unlock_irqrestore(&tty->read_lock, flags);
+        spin_unlock_irqrestore(&tty->buf.lock, flags);
 out:
         tty_ldisc_deref(disc);
 }
@@ -2852,6 +2880,14 @@ EXPORT_SYMBOL(tty_get_baud_rate);
 
 void tty_flip_buffer_push(struct tty_struct *tty)
 {
+        unsigned long flags;
+        spin_lock_irqsave(&tty->buf.lock, flags);
+        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)
                 flush_to_ldisc((void *) tty);
         else
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index f1d9cb7feae6..0900d1dbee59 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -3213,6 +3213,7 @@ void getconsxy(struct vc_data *vc, unsigned char *p)
 
 void putconsxy(struct vc_data *vc, unsigned char *p)
 {
+        hide_cursor(vc);
         gotoxy(vc, p[0], p[1]);
         set_cursor(vc);
 }
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:
diff --git a/drivers/char/watchdog/sbc_epx_c3.c b/drivers/char/watchdog/sbc_epx_c3.c
index 951764614ebf..837b1ec3ffe3 100644
--- a/drivers/char/watchdog/sbc_epx_c3.c
+++ b/drivers/char/watchdog/sbc_epx_c3.c
@@ -25,6 +25,7 @@
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
+#include <linux/ioport.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 
@@ -91,7 +92,7 @@ static int epx_c3_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static ssize_t epx_c3_write(struct file *file, const char *data,
+static ssize_t epx_c3_write(struct file *file, const char __user *data,
                         size_t len, loff_t *ppos)
 {
         /* Refresh the timer. */
@@ -104,6 +105,7 @@ static int epx_c3_ioctl(struct inode *inode, struct file *file,
                         unsigned int cmd, unsigned long arg)
 {
         int options, retval = -EINVAL;
+        int __user *argp = (void __user *)arg;
         static struct watchdog_info ident = {
                 .options                = WDIOF_KEEPALIVEPING |
                                           WDIOF_MAGICCLOSE,
@@ -113,20 +115,19 @@ static int epx_c3_ioctl(struct inode *inode, struct file *file,
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-                if (copy_to_user((struct watchdog_info *)arg,
-                                 &ident, sizeof(ident)))
+                if (copy_to_user(argp, &ident, sizeof(ident)))
                         return -EFAULT;
                 return 0;
         case WDIOC_GETSTATUS:
         case WDIOC_GETBOOTSTATUS:
-                return put_user(0,(int *)arg);
+                return put_user(0, argp);
         case WDIOC_KEEPALIVE:
                 epx_c3_pet();
                 return 0;
         case WDIOC_GETTIMEOUT:
-                return put_user(WATCHDOG_TIMEOUT,(int *)arg);
-        case WDIOC_SETOPTIONS: {
-                if (get_user(options, (int *)arg))
+                return put_user(WATCHDOG_TIMEOUT, argp);
+        case WDIOC_SETOPTIONS:
+                if (get_user(options, argp))
                         return -EFAULT;
 
                 if (options & WDIOS_DISABLECARD) {
@@ -140,7 +141,6 @@ static int epx_c3_ioctl(struct inode *inode, struct file *file,
                 }
 
                 return retval;
-        }
         default:
                 return -ENOIOCTLCMD;
         }
@@ -181,11 +181,14 @@ static int __init watchdog_init(void)
 {
         int ret;
 
+        if (!request_region(EPXC3_WATCHDOG_CTL_REG, 2, "epxc3_watchdog"))
+                return -EBUSY;
+
         ret = register_reboot_notifier(&epx_c3_notifier);
         if (ret) {
                 printk(KERN_ERR PFX "cannot register reboot notifier "
                         "(err=%d)\n", ret);
-                return ret;
+                goto out;
         }
 
         ret = misc_register(&epx_c3_miscdev);
@@ -193,18 +196,23 @@ static int __init watchdog_init(void)
                 printk(KERN_ERR PFX "cannot register miscdev on minor=%d "
                         "(err=%d)\n", WATCHDOG_MINOR, ret);
                 unregister_reboot_notifier(&epx_c3_notifier);
-                return ret;
+                goto out;
         }
 
         printk(banner);
 
         return 0;
+
+out:
+        release_region(EPXC3_WATCHDOG_CTL_REG, 2);
+        return ret;
 }
 
 static void __exit watchdog_exit(void)
 {
         misc_deregister(&epx_c3_miscdev);
         unregister_reboot_notifier(&epx_c3_notifier);
+        release_region(EPXC3_WATCHDOG_CTL_REG, 2);
 }
 
 module_init(watchdog_init);